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

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