github.com/fastly/cli@v1.7.2-0.20240304164155-9d0f1d77c3bf/pkg/commands/tls/custom/activation/activation_test.go (about)

     1  package activation_test
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io"
     7  	"testing"
     8  
     9  	"github.com/fastly/go-fastly/v9/fastly"
    10  
    11  	"github.com/fastly/cli/pkg/app"
    12  	"github.com/fastly/cli/pkg/global"
    13  	"github.com/fastly/cli/pkg/mock"
    14  	"github.com/fastly/cli/pkg/testutil"
    15  )
    16  
    17  const (
    18  	mockResponseID        = "123"
    19  	mockResponseCertID    = "456"
    20  	validateAPIError      = "validate API error"
    21  	validateAPISuccess    = "validate API success"
    22  	validateMissingIDFlag = "validate missing --id flag"
    23  )
    24  
    25  func TestTLSCustomActivationCreate(t *testing.T) {
    26  	args := testutil.Args
    27  	scenarios := []testutil.TestScenario{
    28  		{
    29  			Name:      validateMissingIDFlag,
    30  			Args:      args("tls-custom activation enable --cert-id example"),
    31  			WantError: "required flag --id not provided",
    32  		},
    33  		{
    34  			Name:      validateMissingIDFlag,
    35  			Args:      args("tls-custom activation enable --id example"),
    36  			WantError: "required flag --cert-id not provided",
    37  		},
    38  		{
    39  			Name: validateAPIError,
    40  			API: mock.API{
    41  				CreateTLSActivationFn: func(_ *fastly.CreateTLSActivationInput) (*fastly.TLSActivation, error) {
    42  					return nil, testutil.Err
    43  				},
    44  			},
    45  			Args:      args("tls-custom activation enable --cert-id example --id example"),
    46  			WantError: testutil.Err.Error(),
    47  		},
    48  		{
    49  			Name: validateAPISuccess,
    50  			API: mock.API{
    51  				CreateTLSActivationFn: func(_ *fastly.CreateTLSActivationInput) (*fastly.TLSActivation, error) {
    52  					return &fastly.TLSActivation{
    53  						ID: mockResponseID,
    54  						Certificate: &fastly.CustomTLSCertificate{
    55  							ID: mockResponseCertID,
    56  						},
    57  					}, nil
    58  				},
    59  			},
    60  			Args:       args("tls-custom activation enable --cert-id example --id example"),
    61  			WantOutput: fmt.Sprintf("Enabled TLS Activation '%s' (Certificate '%s')", mockResponseID, mockResponseCertID),
    62  		},
    63  	}
    64  
    65  	for testcaseIdx := range scenarios {
    66  		testcase := &scenarios[testcaseIdx]
    67  		t.Run(testcase.Name, func(t *testing.T) {
    68  			var stdout bytes.Buffer
    69  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
    70  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
    71  				opts.APIClientFactory = mock.APIClient(testcase.API)
    72  				return opts, nil
    73  			}
    74  			err := app.Run(testcase.Args, nil)
    75  			testutil.AssertErrorContains(t, err, testcase.WantError)
    76  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
    77  		})
    78  	}
    79  }
    80  
    81  func TestTLSCustomActivationDelete(t *testing.T) {
    82  	args := testutil.Args
    83  	scenarios := []testutil.TestScenario{
    84  		{
    85  			Name:      validateMissingIDFlag,
    86  			Args:      args("tls-custom activation disable"),
    87  			WantError: "error parsing arguments: required flag --id not provided",
    88  		},
    89  		{
    90  			Name: validateAPIError,
    91  			API: mock.API{
    92  				DeleteTLSActivationFn: func(_ *fastly.DeleteTLSActivationInput) error {
    93  					return testutil.Err
    94  				},
    95  			},
    96  			Args:      args("tls-custom activation disable --id example"),
    97  			WantError: testutil.Err.Error(),
    98  		},
    99  		{
   100  			Name: validateAPISuccess,
   101  			API: mock.API{
   102  				DeleteTLSActivationFn: func(_ *fastly.DeleteTLSActivationInput) error {
   103  					return nil
   104  				},
   105  			},
   106  			Args:       args("tls-custom activation disable --id example"),
   107  			WantOutput: "Disabled TLS Activation 'example'",
   108  		},
   109  	}
   110  
   111  	for testcaseIdx := range scenarios {
   112  		testcase := &scenarios[testcaseIdx]
   113  		t.Run(testcase.Name, func(t *testing.T) {
   114  			var stdout bytes.Buffer
   115  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   116  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   117  				opts.APIClientFactory = mock.APIClient(testcase.API)
   118  				return opts, nil
   119  			}
   120  			err := app.Run(testcase.Args, nil)
   121  			testutil.AssertErrorContains(t, err, testcase.WantError)
   122  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   123  		})
   124  	}
   125  }
   126  
   127  func TestTLSCustomActivationDescribe(t *testing.T) {
   128  	args := testutil.Args
   129  	scenarios := []testutil.TestScenario{
   130  		{
   131  			Name:      validateMissingIDFlag,
   132  			Args:      args("tls-custom activation describe"),
   133  			WantError: "error parsing arguments: required flag --id not provided",
   134  		},
   135  		{
   136  			Name: validateAPIError,
   137  			API: mock.API{
   138  				GetTLSActivationFn: func(_ *fastly.GetTLSActivationInput) (*fastly.TLSActivation, error) {
   139  					return nil, testutil.Err
   140  				},
   141  			},
   142  			Args:      args("tls-custom activation describe --id example"),
   143  			WantError: testutil.Err.Error(),
   144  		},
   145  		{
   146  			Name: validateAPISuccess,
   147  			API: mock.API{
   148  				GetTLSActivationFn: func(_ *fastly.GetTLSActivationInput) (*fastly.TLSActivation, error) {
   149  					t := testutil.Date
   150  					return &fastly.TLSActivation{
   151  						ID:        mockResponseID,
   152  						CreatedAt: &t,
   153  					}, nil
   154  				},
   155  			},
   156  			Args:       args("tls-custom activation describe --id example"),
   157  			WantOutput: "\nID: " + mockResponseID + "\nCreated at: 2021-06-15 23:00:00 +0000 UTC\n",
   158  		},
   159  	}
   160  
   161  	for testcaseIdx := range scenarios {
   162  		testcase := &scenarios[testcaseIdx]
   163  		t.Run(testcase.Name, func(t *testing.T) {
   164  			var stdout bytes.Buffer
   165  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   166  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   167  				opts.APIClientFactory = mock.APIClient(testcase.API)
   168  				return opts, nil
   169  			}
   170  			err := app.Run(testcase.Args, nil)
   171  			testutil.AssertErrorContains(t, err, testcase.WantError)
   172  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   173  		})
   174  	}
   175  }
   176  
   177  func TestTLSCustomActivationList(t *testing.T) {
   178  	args := testutil.Args
   179  	scenarios := []testutil.TestScenario{
   180  		{
   181  			Name: validateAPIError,
   182  			API: mock.API{
   183  				ListTLSActivationsFn: func(_ *fastly.ListTLSActivationsInput) ([]*fastly.TLSActivation, error) {
   184  					return nil, testutil.Err
   185  				},
   186  			},
   187  			Args:      args("tls-custom activation list"),
   188  			WantError: testutil.Err.Error(),
   189  		},
   190  		{
   191  			Name: validateAPISuccess,
   192  			API: mock.API{
   193  				ListTLSActivationsFn: func(_ *fastly.ListTLSActivationsInput) ([]*fastly.TLSActivation, error) {
   194  					t := testutil.Date
   195  					return []*fastly.TLSActivation{
   196  						{
   197  							ID:        mockResponseID,
   198  							CreatedAt: &t,
   199  						},
   200  					}, nil
   201  				},
   202  			},
   203  			Args:       args("tls-custom activation list --verbose"),
   204  			WantOutput: "\nID: " + mockResponseID + "\nCreated at: 2021-06-15 23:00:00 +0000 UTC\n",
   205  		},
   206  	}
   207  
   208  	for testcaseIdx := range scenarios {
   209  		testcase := &scenarios[testcaseIdx]
   210  		t.Run(testcase.Name, func(t *testing.T) {
   211  			var stdout bytes.Buffer
   212  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   213  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   214  				opts.APIClientFactory = mock.APIClient(testcase.API)
   215  				return opts, nil
   216  			}
   217  			err := app.Run(testcase.Args, nil)
   218  			testutil.AssertErrorContains(t, err, testcase.WantError)
   219  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   220  		})
   221  	}
   222  }
   223  
   224  func TestTLSCustomActivationUpdate(t *testing.T) {
   225  	args := testutil.Args
   226  	scenarios := []testutil.TestScenario{
   227  		{
   228  			Name:      validateMissingIDFlag,
   229  			Args:      args("tls-custom activation update --cert-id example"),
   230  			WantError: "required flag --id not provided",
   231  		},
   232  		{
   233  			Name:      validateMissingIDFlag,
   234  			Args:      args("tls-custom activation update --id example"),
   235  			WantError: "required flag --cert-id not provided",
   236  		},
   237  		{
   238  			Name: validateAPIError,
   239  			API: mock.API{
   240  				UpdateTLSActivationFn: func(_ *fastly.UpdateTLSActivationInput) (*fastly.TLSActivation, error) {
   241  					return nil, testutil.Err
   242  				},
   243  			},
   244  			Args:      args("tls-custom activation update --cert-id example --id example"),
   245  			WantError: testutil.Err.Error(),
   246  		},
   247  		{
   248  			Name: validateAPISuccess,
   249  			API: mock.API{
   250  				UpdateTLSActivationFn: func(_ *fastly.UpdateTLSActivationInput) (*fastly.TLSActivation, error) {
   251  					return &fastly.TLSActivation{
   252  						ID: mockResponseID,
   253  						Certificate: &fastly.CustomTLSCertificate{
   254  							ID: mockResponseCertID,
   255  						},
   256  					}, nil
   257  				},
   258  			},
   259  			Args:       args("tls-custom activation update --cert-id example --id example"),
   260  			WantOutput: fmt.Sprintf("Updated TLS Activation Certificate '%s' (previously: 'example')", mockResponseCertID),
   261  		},
   262  	}
   263  
   264  	for testcaseIdx := range scenarios {
   265  		testcase := &scenarios[testcaseIdx]
   266  		t.Run(testcase.Name, func(t *testing.T) {
   267  			var stdout bytes.Buffer
   268  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   269  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   270  				opts.APIClientFactory = mock.APIClient(testcase.API)
   271  				return opts, nil
   272  			}
   273  			err := app.Run(testcase.Args, nil)
   274  			testutil.AssertErrorContains(t, err, testcase.WantError)
   275  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   276  		})
   277  	}
   278  }