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

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