github.com/fastly/cli@v1.7.2-0.20240304164155-9d0f1d77c3bf/pkg/commands/logging/kinesis/kinesis_test.go (about)

     1  package kinesis_test
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/fastly/go-fastly/v9/fastly"
     8  
     9  	"github.com/fastly/cli/pkg/argparser"
    10  	"github.com/fastly/cli/pkg/commands/logging/kinesis"
    11  	"github.com/fastly/cli/pkg/config"
    12  	"github.com/fastly/cli/pkg/errors"
    13  	"github.com/fastly/cli/pkg/global"
    14  	"github.com/fastly/cli/pkg/manifest"
    15  	"github.com/fastly/cli/pkg/mock"
    16  	"github.com/fastly/cli/pkg/testutil"
    17  )
    18  
    19  func TestCreateKinesisInput(t *testing.T) {
    20  	for _, testcase := range []struct {
    21  		name      string
    22  		cmd       *kinesis.CreateCommand
    23  		want      *fastly.CreateKinesisInput
    24  		wantError string
    25  	}{
    26  		{
    27  			name: "required values set flag serviceID",
    28  			cmd:  createCommandRequired(),
    29  			want: &fastly.CreateKinesisInput{
    30  				ServiceID:      "123",
    31  				ServiceVersion: 4,
    32  				Name:           fastly.ToPointer("log"),
    33  				StreamName:     fastly.ToPointer("stream"),
    34  				Region:         fastly.ToPointer("us-east-1"),
    35  				AccessKey:      fastly.ToPointer("access"),
    36  				SecretKey:      fastly.ToPointer("secret"),
    37  			},
    38  		},
    39  		{
    40  			name: "required values set flag serviceID using IAM role",
    41  			cmd:  createCommandRequiredIAMRole(),
    42  			want: &fastly.CreateKinesisInput{
    43  				ServiceID:      "123",
    44  				ServiceVersion: 4,
    45  				Name:           fastly.ToPointer("log"),
    46  				Region:         fastly.ToPointer("us-east-1"),
    47  				StreamName:     fastly.ToPointer("stream"),
    48  				IAMRole:        fastly.ToPointer("arn:aws:iam::123456789012:role/KinesisAccess"),
    49  			},
    50  		},
    51  		{
    52  			name: "all values set flag serviceID",
    53  			cmd:  createCommandAll(),
    54  			want: &fastly.CreateKinesisInput{
    55  				ServiceID:         "123",
    56  				ServiceVersion:    4,
    57  				Name:              fastly.ToPointer("logs"),
    58  				StreamName:        fastly.ToPointer("stream"),
    59  				Region:            fastly.ToPointer("us-east-1"),
    60  				AccessKey:         fastly.ToPointer("access"),
    61  				SecretKey:         fastly.ToPointer("secret"),
    62  				Format:            fastly.ToPointer(`%h %l %u %t "%r" %>s %b`),
    63  				FormatVersion:     fastly.ToPointer(2),
    64  				ResponseCondition: fastly.ToPointer("Prevent default logging"),
    65  				Placement:         fastly.ToPointer("none"),
    66  			},
    67  		},
    68  		{
    69  			name:      "error missing serviceID",
    70  			cmd:       createCommandMissingServiceID(),
    71  			want:      nil,
    72  			wantError: errors.ErrNoServiceID.Error(),
    73  		},
    74  	} {
    75  		t.Run(testcase.name, func(t *testing.T) {
    76  			var bs []byte
    77  			out := bytes.NewBuffer(bs)
    78  			verboseMode := true
    79  
    80  			serviceID, serviceVersion, err := argparser.ServiceDetails(argparser.ServiceDetailsOpts{
    81  				AutoCloneFlag:      testcase.cmd.AutoClone,
    82  				APIClient:          testcase.cmd.Globals.APIClient,
    83  				Manifest:           testcase.cmd.Manifest,
    84  				Out:                out,
    85  				ServiceVersionFlag: testcase.cmd.ServiceVersion,
    86  				VerboseMode:        verboseMode,
    87  			})
    88  
    89  			switch {
    90  			case err != nil && testcase.wantError == "":
    91  				t.Fatalf("unexpected error getting service details: %v", err)
    92  				return
    93  			case err != nil && testcase.wantError != "":
    94  				testutil.AssertErrorContains(t, err, testcase.wantError)
    95  				return
    96  			case err == nil && testcase.wantError != "":
    97  				t.Fatalf("expected error, have nil (service details: %s, %d)", serviceID, serviceVersion.Number)
    98  			case err == nil && testcase.wantError == "":
    99  				have, err := testcase.cmd.ConstructInput(serviceID, fastly.ToValue(serviceVersion.Number))
   100  				testutil.AssertErrorContains(t, err, testcase.wantError)
   101  				testutil.AssertEqual(t, testcase.want, have)
   102  			}
   103  		})
   104  	}
   105  }
   106  
   107  func TestUpdateKinesisInput(t *testing.T) {
   108  	scenarios := []struct {
   109  		name      string
   110  		cmd       *kinesis.UpdateCommand
   111  		api       mock.API
   112  		want      *fastly.UpdateKinesisInput
   113  		wantError string
   114  	}{
   115  		{
   116  			name: "no updates",
   117  			cmd:  updateCommandNoUpdates(),
   118  			api: mock.API{
   119  				ListVersionsFn: testutil.ListVersions,
   120  				CloneVersionFn: testutil.CloneVersionResult(4),
   121  				GetKinesisFn:   getKinesisOK,
   122  			},
   123  			want: &fastly.UpdateKinesisInput{
   124  				ServiceID:      "123",
   125  				ServiceVersion: 4,
   126  				Name:           "log",
   127  			},
   128  		},
   129  		{
   130  			name: "all values set flag serviceID",
   131  			cmd:  updateCommandAll(),
   132  			api: mock.API{
   133  				ListVersionsFn: testutil.ListVersions,
   134  				CloneVersionFn: testutil.CloneVersionResult(4),
   135  				GetKinesisFn:   getKinesisOK,
   136  			},
   137  			want: &fastly.UpdateKinesisInput{
   138  				ServiceID:         "123",
   139  				ServiceVersion:    4,
   140  				Name:              "log",
   141  				NewName:           fastly.ToPointer("new1"),
   142  				StreamName:        fastly.ToPointer("new2"),
   143  				AccessKey:         fastly.ToPointer("new3"),
   144  				SecretKey:         fastly.ToPointer("new4"),
   145  				IAMRole:           fastly.ToPointer(""),
   146  				Region:            fastly.ToPointer("new5"),
   147  				Format:            fastly.ToPointer("new7"),
   148  				FormatVersion:     fastly.ToPointer(3),
   149  				ResponseCondition: fastly.ToPointer("new9"),
   150  				Placement:         fastly.ToPointer("new11"),
   151  			},
   152  		},
   153  		{
   154  			name:      "error missing serviceID",
   155  			cmd:       updateCommandMissingServiceID(),
   156  			want:      nil,
   157  			wantError: errors.ErrNoServiceID.Error(),
   158  		},
   159  	}
   160  	for testcaseIdx := range scenarios {
   161  		testcase := &scenarios[testcaseIdx]
   162  		t.Run(testcase.name, func(t *testing.T) {
   163  			testcase.cmd.Globals.APIClient = testcase.api
   164  
   165  			var bs []byte
   166  			out := bytes.NewBuffer(bs)
   167  			verboseMode := true
   168  
   169  			serviceID, serviceVersion, err := argparser.ServiceDetails(argparser.ServiceDetailsOpts{
   170  				AutoCloneFlag:      testcase.cmd.AutoClone,
   171  				APIClient:          testcase.api,
   172  				Manifest:           testcase.cmd.Manifest,
   173  				Out:                out,
   174  				ServiceVersionFlag: testcase.cmd.ServiceVersion,
   175  				VerboseMode:        verboseMode,
   176  			})
   177  
   178  			switch {
   179  			case err != nil && testcase.wantError == "":
   180  				t.Fatalf("unexpected error getting service details: %v", err)
   181  				return
   182  			case err != nil && testcase.wantError != "":
   183  				testutil.AssertErrorContains(t, err, testcase.wantError)
   184  				return
   185  			case err == nil && testcase.wantError != "":
   186  				t.Fatalf("expected error, have nil (service details: %s, %d)", serviceID, serviceVersion.Number)
   187  			case err == nil && testcase.wantError == "":
   188  				have, err := testcase.cmd.ConstructInput(serviceID, fastly.ToValue(serviceVersion.Number))
   189  				testutil.AssertErrorContains(t, err, testcase.wantError)
   190  				testutil.AssertEqual(t, testcase.want, have)
   191  			}
   192  		})
   193  	}
   194  }
   195  
   196  func createCommandRequired() *kinesis.CreateCommand {
   197  	var b bytes.Buffer
   198  
   199  	g := global.Data{
   200  		Config: config.File{},
   201  		Env:    config.Environment{},
   202  		Output: &b,
   203  	}
   204  	g.APIClient, _ = mock.APIClient(mock.API{
   205  		ListVersionsFn: testutil.ListVersions,
   206  		CloneVersionFn: testutil.CloneVersionResult(4),
   207  	})("token", "endpoint", false)
   208  
   209  	return &kinesis.CreateCommand{
   210  		Base: argparser.Base{
   211  			Globals: &g,
   212  		},
   213  		Manifest: manifest.Data{
   214  			Flag: manifest.Flag{
   215  				ServiceID: "123",
   216  			},
   217  		},
   218  		ServiceVersion: argparser.OptionalServiceVersion{
   219  			OptionalString: argparser.OptionalString{Value: "1"},
   220  		},
   221  		AutoClone: argparser.OptionalAutoClone{
   222  			OptionalBool: argparser.OptionalBool{
   223  				Optional: argparser.Optional{
   224  					WasSet: true,
   225  				},
   226  				Value: true,
   227  			},
   228  		},
   229  		EndpointName: argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "log"},
   230  		Region:       argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "us-east-1"},
   231  		StreamName:   argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "stream"},
   232  		AccessKey:    argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "access"},
   233  		SecretKey:    argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "secret"},
   234  	}
   235  }
   236  
   237  func createCommandRequiredIAMRole() *kinesis.CreateCommand {
   238  	var b bytes.Buffer
   239  
   240  	g := global.Data{
   241  		Config: config.File{},
   242  		Env:    config.Environment{},
   243  		Output: &b,
   244  	}
   245  	g.APIClient, _ = mock.APIClient(mock.API{
   246  		ListVersionsFn: testutil.ListVersions,
   247  		CloneVersionFn: testutil.CloneVersionResult(4),
   248  	})("token", "endpoint", false)
   249  
   250  	return &kinesis.CreateCommand{
   251  		Base: argparser.Base{
   252  			Globals: &g,
   253  		},
   254  		Manifest: manifest.Data{
   255  			Flag: manifest.Flag{
   256  				ServiceID: "123",
   257  			},
   258  		},
   259  		ServiceVersion: argparser.OptionalServiceVersion{
   260  			OptionalString: argparser.OptionalString{Value: "1"},
   261  		},
   262  		EndpointName: argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "log"},
   263  		Region:       argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "us-east-1"},
   264  		StreamName:   argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "stream"},
   265  		AutoClone: argparser.OptionalAutoClone{
   266  			OptionalBool: argparser.OptionalBool{
   267  				Optional: argparser.Optional{
   268  					WasSet: true,
   269  				},
   270  				Value: true,
   271  			},
   272  		},
   273  		IAMRole: argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "arn:aws:iam::123456789012:role/KinesisAccess"},
   274  	}
   275  }
   276  
   277  func createCommandAll() *kinesis.CreateCommand {
   278  	var b bytes.Buffer
   279  
   280  	g := global.Data{
   281  		Config: config.File{},
   282  		Env:    config.Environment{},
   283  		Output: &b,
   284  	}
   285  	g.APIClient, _ = mock.APIClient(mock.API{
   286  		ListVersionsFn: testutil.ListVersions,
   287  		CloneVersionFn: testutil.CloneVersionResult(4),
   288  	})("token", "endpoint", false)
   289  
   290  	return &kinesis.CreateCommand{
   291  		Base: argparser.Base{
   292  			Globals: &g,
   293  		},
   294  		Manifest: manifest.Data{
   295  			Flag: manifest.Flag{
   296  				ServiceID: "123",
   297  			},
   298  		},
   299  		ServiceVersion: argparser.OptionalServiceVersion{
   300  			OptionalString: argparser.OptionalString{Value: "1"},
   301  		},
   302  		AutoClone: argparser.OptionalAutoClone{
   303  			OptionalBool: argparser.OptionalBool{
   304  				Optional: argparser.Optional{
   305  					WasSet: true,
   306  				},
   307  				Value: true,
   308  			},
   309  		},
   310  		EndpointName:      argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "logs"},
   311  		StreamName:        argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "stream"},
   312  		Region:            argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "us-east-1"},
   313  		AccessKey:         argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "access"},
   314  		SecretKey:         argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "secret"},
   315  		Format:            argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: `%h %l %u %t "%r" %>s %b`},
   316  		FormatVersion:     argparser.OptionalInt{Optional: argparser.Optional{WasSet: true}, Value: 2},
   317  		ResponseCondition: argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "Prevent default logging"},
   318  		Placement:         argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "none"},
   319  	}
   320  }
   321  
   322  func createCommandMissingServiceID() *kinesis.CreateCommand {
   323  	res := createCommandAll()
   324  	res.Manifest = manifest.Data{}
   325  	return res
   326  }
   327  
   328  func updateCommandNoUpdates() *kinesis.UpdateCommand {
   329  	var b bytes.Buffer
   330  
   331  	g := global.Data{
   332  		Config: config.File{},
   333  		Env:    config.Environment{},
   334  		Output: &b,
   335  	}
   336  
   337  	return &kinesis.UpdateCommand{
   338  		Base: argparser.Base{
   339  			Globals: &g,
   340  		},
   341  		Manifest: manifest.Data{
   342  			Flag: manifest.Flag{
   343  				ServiceID: "123",
   344  			},
   345  		},
   346  		EndpointName: "log",
   347  		ServiceVersion: argparser.OptionalServiceVersion{
   348  			OptionalString: argparser.OptionalString{Value: "1"},
   349  		},
   350  		AutoClone: argparser.OptionalAutoClone{
   351  			OptionalBool: argparser.OptionalBool{
   352  				Optional: argparser.Optional{
   353  					WasSet: true,
   354  				},
   355  				Value: true,
   356  			},
   357  		},
   358  	}
   359  }
   360  
   361  func updateCommandAll() *kinesis.UpdateCommand {
   362  	var b bytes.Buffer
   363  
   364  	g := global.Data{
   365  		Config: config.File{},
   366  		Env:    config.Environment{},
   367  		Output: &b,
   368  	}
   369  
   370  	return &kinesis.UpdateCommand{
   371  		Base: argparser.Base{
   372  			Globals: &g,
   373  		},
   374  		Manifest: manifest.Data{
   375  			Flag: manifest.Flag{
   376  				ServiceID: "123",
   377  			},
   378  		},
   379  		EndpointName: "log",
   380  		ServiceVersion: argparser.OptionalServiceVersion{
   381  			OptionalString: argparser.OptionalString{Value: "1"},
   382  		},
   383  		AutoClone: argparser.OptionalAutoClone{
   384  			OptionalBool: argparser.OptionalBool{
   385  				Optional: argparser.Optional{
   386  					WasSet: true,
   387  				},
   388  				Value: true,
   389  			},
   390  		},
   391  		NewName:           argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new1"},
   392  		StreamName:        argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new2"},
   393  		AccessKey:         argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new3"},
   394  		SecretKey:         argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new4"},
   395  		IAMRole:           argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: ""},
   396  		Region:            argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new5"},
   397  		Format:            argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new7"},
   398  		FormatVersion:     argparser.OptionalInt{Optional: argparser.Optional{WasSet: true}, Value: 3},
   399  		ResponseCondition: argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new9"},
   400  		Placement:         argparser.OptionalString{Optional: argparser.Optional{WasSet: true}, Value: "new11"},
   401  	}
   402  }
   403  
   404  func updateCommandMissingServiceID() *kinesis.UpdateCommand {
   405  	res := updateCommandAll()
   406  	res.Manifest = manifest.Data{}
   407  	return res
   408  }