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

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