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

     1  package datadog_test
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"io"
     7  	"strings"
     8  	"testing"
     9  
    10  	"github.com/fastly/go-fastly/v9/fastly"
    11  
    12  	"github.com/fastly/cli/pkg/app"
    13  	"github.com/fastly/cli/pkg/global"
    14  	"github.com/fastly/cli/pkg/mock"
    15  	"github.com/fastly/cli/pkg/testutil"
    16  )
    17  
    18  func TestDatadogCreate(t *testing.T) {
    19  	args := testutil.Args
    20  	scenarios := []struct {
    21  		args       []string
    22  		api        mock.API
    23  		wantError  string
    24  		wantOutput string
    25  	}{
    26  		{
    27  			args: args("logging datadog create --service-id 123 --version 1 --name log --auth-token abc --autoclone"),
    28  			api: mock.API{
    29  				ListVersionsFn:  testutil.ListVersions,
    30  				CloneVersionFn:  testutil.CloneVersionResult(4),
    31  				CreateDatadogFn: createDatadogOK,
    32  			},
    33  			wantOutput: "Created Datadog logging endpoint log (service 123 version 4)",
    34  		},
    35  		{
    36  			args: args("logging datadog create --service-id 123 --version 1 --name log --auth-token abc --autoclone"),
    37  			api: mock.API{
    38  				ListVersionsFn:  testutil.ListVersions,
    39  				CloneVersionFn:  testutil.CloneVersionResult(4),
    40  				CreateDatadogFn: createDatadogError,
    41  			},
    42  			wantError: errTest.Error(),
    43  		},
    44  	}
    45  	for testcaseIdx := range scenarios {
    46  		testcase := &scenarios[testcaseIdx]
    47  		t.Run(strings.Join(testcase.args, " "), func(t *testing.T) {
    48  			var stdout bytes.Buffer
    49  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
    50  				opts := testutil.MockGlobalData(testcase.args, &stdout)
    51  				opts.APIClientFactory = mock.APIClient(testcase.api)
    52  				return opts, nil
    53  			}
    54  			err := app.Run(testcase.args, nil)
    55  			testutil.AssertErrorContains(t, err, testcase.wantError)
    56  			testutil.AssertStringContains(t, stdout.String(), testcase.wantOutput)
    57  		})
    58  	}
    59  }
    60  
    61  func TestDatadogList(t *testing.T) {
    62  	args := testutil.Args
    63  	scenarios := []struct {
    64  		args       []string
    65  		api        mock.API
    66  		wantError  string
    67  		wantOutput string
    68  	}{
    69  		{
    70  			args: args("logging datadog list --service-id 123 --version 1"),
    71  			api: mock.API{
    72  				ListVersionsFn: testutil.ListVersions,
    73  				ListDatadogFn:  listDatadogsOK,
    74  			},
    75  			wantOutput: listDatadogsShortOutput,
    76  		},
    77  		{
    78  			args: args("logging datadog list --service-id 123 --version 1 --verbose"),
    79  			api: mock.API{
    80  				ListVersionsFn: testutil.ListVersions,
    81  				ListDatadogFn:  listDatadogsOK,
    82  			},
    83  			wantOutput: listDatadogsVerboseOutput,
    84  		},
    85  		{
    86  			args: args("logging datadog list --service-id 123 --version 1 -v"),
    87  			api: mock.API{
    88  				ListVersionsFn: testutil.ListVersions,
    89  				ListDatadogFn:  listDatadogsOK,
    90  			},
    91  			wantOutput: listDatadogsVerboseOutput,
    92  		},
    93  		{
    94  			args: args("logging datadog --verbose list --service-id 123 --version 1"),
    95  			api: mock.API{
    96  				ListVersionsFn: testutil.ListVersions,
    97  				ListDatadogFn:  listDatadogsOK,
    98  			},
    99  			wantOutput: listDatadogsVerboseOutput,
   100  		},
   101  		{
   102  			args: args("logging -v datadog list --service-id 123 --version 1"),
   103  			api: mock.API{
   104  				ListVersionsFn: testutil.ListVersions,
   105  				ListDatadogFn:  listDatadogsOK,
   106  			},
   107  			wantOutput: listDatadogsVerboseOutput,
   108  		},
   109  		{
   110  			args: args("logging datadog list --service-id 123 --version 1"),
   111  			api: mock.API{
   112  				ListVersionsFn: testutil.ListVersions,
   113  				ListDatadogFn:  listDatadogsError,
   114  			},
   115  			wantError: errTest.Error(),
   116  		},
   117  	}
   118  	for testcaseIdx := range scenarios {
   119  		testcase := &scenarios[testcaseIdx]
   120  		t.Run(strings.Join(testcase.args, " "), func(t *testing.T) {
   121  			var stdout bytes.Buffer
   122  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   123  				opts := testutil.MockGlobalData(testcase.args, &stdout)
   124  				opts.APIClientFactory = mock.APIClient(testcase.api)
   125  				return opts, nil
   126  			}
   127  			err := app.Run(testcase.args, nil)
   128  			testutil.AssertErrorContains(t, err, testcase.wantError)
   129  			testutil.AssertString(t, testcase.wantOutput, stdout.String())
   130  		})
   131  	}
   132  }
   133  
   134  func TestDatadogDescribe(t *testing.T) {
   135  	args := testutil.Args
   136  	scenarios := []struct {
   137  		args       []string
   138  		api        mock.API
   139  		wantError  string
   140  		wantOutput string
   141  	}{
   142  		{
   143  			args:      args("logging datadog describe --service-id 123 --version 1"),
   144  			wantError: "error parsing arguments: required flag --name not provided",
   145  		},
   146  		{
   147  			args: args("logging datadog describe --service-id 123 --version 1 --name logs"),
   148  			api: mock.API{
   149  				ListVersionsFn: testutil.ListVersions,
   150  				GetDatadogFn:   getDatadogError,
   151  			},
   152  			wantError: errTest.Error(),
   153  		},
   154  		{
   155  			args: args("logging datadog describe --service-id 123 --version 1 --name logs"),
   156  			api: mock.API{
   157  				ListVersionsFn: testutil.ListVersions,
   158  				GetDatadogFn:   getDatadogOK,
   159  			},
   160  			wantOutput: describeDatadogOutput,
   161  		},
   162  	}
   163  	for testcaseIdx := range scenarios {
   164  		testcase := &scenarios[testcaseIdx]
   165  		t.Run(strings.Join(testcase.args, " "), func(t *testing.T) {
   166  			var stdout bytes.Buffer
   167  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   168  				opts := testutil.MockGlobalData(testcase.args, &stdout)
   169  				opts.APIClientFactory = mock.APIClient(testcase.api)
   170  				return opts, nil
   171  			}
   172  			err := app.Run(testcase.args, nil)
   173  			testutil.AssertErrorContains(t, err, testcase.wantError)
   174  			testutil.AssertString(t, testcase.wantOutput, stdout.String())
   175  		})
   176  	}
   177  }
   178  
   179  func TestDatadogUpdate(t *testing.T) {
   180  	args := testutil.Args
   181  	scenarios := []struct {
   182  		args       []string
   183  		api        mock.API
   184  		wantError  string
   185  		wantOutput string
   186  	}{
   187  		{
   188  			args:      args("logging datadog update --service-id 123 --version 1 --new-name log"),
   189  			wantError: "error parsing arguments: required flag --name not provided",
   190  		},
   191  		{
   192  			args: args("logging datadog update --service-id 123 --version 1 --name logs --new-name log --autoclone"),
   193  			api: mock.API{
   194  				ListVersionsFn:  testutil.ListVersions,
   195  				CloneVersionFn:  testutil.CloneVersionResult(4),
   196  				UpdateDatadogFn: updateDatadogError,
   197  			},
   198  			wantError: errTest.Error(),
   199  		},
   200  		{
   201  			args: args("logging datadog update --service-id 123 --version 1 --name logs --new-name log --autoclone"),
   202  			api: mock.API{
   203  				ListVersionsFn:  testutil.ListVersions,
   204  				CloneVersionFn:  testutil.CloneVersionResult(4),
   205  				UpdateDatadogFn: updateDatadogOK,
   206  			},
   207  			wantOutput: "Updated Datadog logging endpoint log (service 123 version 4)",
   208  		},
   209  	}
   210  	for testcaseIdx := range scenarios {
   211  		testcase := &scenarios[testcaseIdx]
   212  		t.Run(strings.Join(testcase.args, " "), func(t *testing.T) {
   213  			var stdout bytes.Buffer
   214  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   215  				opts := testutil.MockGlobalData(testcase.args, &stdout)
   216  				opts.APIClientFactory = mock.APIClient(testcase.api)
   217  				return opts, nil
   218  			}
   219  			err := app.Run(testcase.args, nil)
   220  			testutil.AssertErrorContains(t, err, testcase.wantError)
   221  			testutil.AssertStringContains(t, stdout.String(), testcase.wantOutput)
   222  		})
   223  	}
   224  }
   225  
   226  func TestDatadogDelete(t *testing.T) {
   227  	args := testutil.Args
   228  	scenarios := []struct {
   229  		args       []string
   230  		api        mock.API
   231  		wantError  string
   232  		wantOutput string
   233  	}{
   234  		{
   235  			args:      args("logging datadog delete --service-id 123 --version 1"),
   236  			wantError: "error parsing arguments: required flag --name not provided",
   237  		},
   238  		{
   239  			args: args("logging datadog delete --service-id 123 --version 1 --name logs --autoclone"),
   240  			api: mock.API{
   241  				ListVersionsFn:  testutil.ListVersions,
   242  				CloneVersionFn:  testutil.CloneVersionResult(4),
   243  				DeleteDatadogFn: deleteDatadogError,
   244  			},
   245  			wantError: errTest.Error(),
   246  		},
   247  		{
   248  			args: args("logging datadog delete --service-id 123 --version 1 --name logs --autoclone"),
   249  			api: mock.API{
   250  				ListVersionsFn:  testutil.ListVersions,
   251  				CloneVersionFn:  testutil.CloneVersionResult(4),
   252  				DeleteDatadogFn: deleteDatadogOK,
   253  			},
   254  			wantOutput: "Deleted Datadog logging endpoint logs (service 123 version 4)",
   255  		},
   256  	}
   257  	for testcaseIdx := range scenarios {
   258  		testcase := &scenarios[testcaseIdx]
   259  		t.Run(strings.Join(testcase.args, " "), func(t *testing.T) {
   260  			var stdout bytes.Buffer
   261  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   262  				opts := testutil.MockGlobalData(testcase.args, &stdout)
   263  				opts.APIClientFactory = mock.APIClient(testcase.api)
   264  				return opts, nil
   265  			}
   266  			err := app.Run(testcase.args, nil)
   267  			testutil.AssertErrorContains(t, err, testcase.wantError)
   268  			testutil.AssertStringContains(t, stdout.String(), testcase.wantOutput)
   269  		})
   270  	}
   271  }
   272  
   273  var errTest = errors.New("fixture error")
   274  
   275  func createDatadogOK(i *fastly.CreateDatadogInput) (*fastly.Datadog, error) {
   276  	s := fastly.Datadog{
   277  		ServiceID:      fastly.ToPointer(i.ServiceID),
   278  		ServiceVersion: fastly.ToPointer(i.ServiceVersion),
   279  	}
   280  
   281  	if i.Name != nil {
   282  		s.Name = i.Name
   283  	}
   284  
   285  	return &s, nil
   286  }
   287  
   288  func createDatadogError(_ *fastly.CreateDatadogInput) (*fastly.Datadog, error) {
   289  	return nil, errTest
   290  }
   291  
   292  func listDatadogsOK(i *fastly.ListDatadogInput) ([]*fastly.Datadog, error) {
   293  	return []*fastly.Datadog{
   294  		{
   295  			ServiceID:         fastly.ToPointer(i.ServiceID),
   296  			ServiceVersion:    fastly.ToPointer(i.ServiceVersion),
   297  			Name:              fastly.ToPointer("logs"),
   298  			Token:             fastly.ToPointer("abc"),
   299  			Region:            fastly.ToPointer("US"),
   300  			Format:            fastly.ToPointer(`%h %l %u %t "%r" %>s %b`),
   301  			FormatVersion:     fastly.ToPointer(2),
   302  			ResponseCondition: fastly.ToPointer("Prevent default logging"),
   303  			Placement:         fastly.ToPointer("none"),
   304  		},
   305  		{
   306  			ServiceID:         fastly.ToPointer(i.ServiceID),
   307  			ServiceVersion:    fastly.ToPointer(i.ServiceVersion),
   308  			Name:              fastly.ToPointer("analytics"),
   309  			Token:             fastly.ToPointer("abc"),
   310  			Region:            fastly.ToPointer("US"),
   311  			Format:            fastly.ToPointer(`%h %l %u %t "%r" %>s %b`),
   312  			FormatVersion:     fastly.ToPointer(2),
   313  			ResponseCondition: fastly.ToPointer("Prevent default logging"),
   314  			Placement:         fastly.ToPointer("none"),
   315  		},
   316  	}, nil
   317  }
   318  
   319  func listDatadogsError(_ *fastly.ListDatadogInput) ([]*fastly.Datadog, error) {
   320  	return nil, errTest
   321  }
   322  
   323  var listDatadogsShortOutput = strings.TrimSpace(`
   324  SERVICE  VERSION  NAME
   325  123      1        logs
   326  123      1        analytics
   327  `) + "\n"
   328  
   329  var listDatadogsVerboseOutput = strings.TrimSpace(`
   330  Fastly API endpoint: https://api.fastly.com
   331  Fastly API token provided via config file (profile: user)
   332  
   333  Service ID (via --service-id): 123
   334  
   335  Version: 1
   336  	Datadog 1/2
   337  		Service ID: 123
   338  		Version: 1
   339  		Name: logs
   340  		Token: abc
   341  		Region: US
   342  		Format: %h %l %u %t "%r" %>s %b
   343  		Format version: 2
   344  		Response condition: Prevent default logging
   345  		Placement: none
   346  	Datadog 2/2
   347  		Service ID: 123
   348  		Version: 1
   349  		Name: analytics
   350  		Token: abc
   351  		Region: US
   352  		Format: %h %l %u %t "%r" %>s %b
   353  		Format version: 2
   354  		Response condition: Prevent default logging
   355  		Placement: none
   356  `) + "\n\n"
   357  
   358  func getDatadogOK(i *fastly.GetDatadogInput) (*fastly.Datadog, error) {
   359  	return &fastly.Datadog{
   360  		ServiceID:         fastly.ToPointer(i.ServiceID),
   361  		ServiceVersion:    fastly.ToPointer(i.ServiceVersion),
   362  		Name:              fastly.ToPointer("logs"),
   363  		Token:             fastly.ToPointer("abc"),
   364  		Region:            fastly.ToPointer("US"),
   365  		Format:            fastly.ToPointer(`%h %l %u %t "%r" %>s %b`),
   366  		FormatVersion:     fastly.ToPointer(2),
   367  		ResponseCondition: fastly.ToPointer("Prevent default logging"),
   368  		Placement:         fastly.ToPointer("none"),
   369  	}, nil
   370  }
   371  
   372  func getDatadogError(_ *fastly.GetDatadogInput) (*fastly.Datadog, error) {
   373  	return nil, errTest
   374  }
   375  
   376  var describeDatadogOutput = "\n" + strings.TrimSpace(`
   377  Format: %h %l %u %t "%r" %>s %b
   378  Format version: 2
   379  Name: logs
   380  Placement: none
   381  Region: US
   382  Response condition: Prevent default logging
   383  Service ID: 123
   384  Token: abc
   385  Version: 1
   386  `) + "\n"
   387  
   388  func updateDatadogOK(i *fastly.UpdateDatadogInput) (*fastly.Datadog, error) {
   389  	return &fastly.Datadog{
   390  		ServiceID:         fastly.ToPointer(i.ServiceID),
   391  		ServiceVersion:    fastly.ToPointer(i.ServiceVersion),
   392  		Name:              fastly.ToPointer("log"),
   393  		Token:             fastly.ToPointer("abc"),
   394  		Region:            fastly.ToPointer("US"),
   395  		Format:            fastly.ToPointer(`%h %l %u %t "%r" %>s %b`),
   396  		FormatVersion:     fastly.ToPointer(2),
   397  		ResponseCondition: fastly.ToPointer("Prevent default logging"),
   398  	}, nil
   399  }
   400  
   401  func updateDatadogError(_ *fastly.UpdateDatadogInput) (*fastly.Datadog, error) {
   402  	return nil, errTest
   403  }
   404  
   405  func deleteDatadogOK(_ *fastly.DeleteDatadogInput) error {
   406  	return nil
   407  }
   408  
   409  func deleteDatadogError(_ *fastly.DeleteDatadogInput) error {
   410  	return errTest
   411  }