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

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