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

     1  package certificate_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  	mockFieldValue        = "example"
    20  	validateAPIError      = "validate API error"
    21  	validateAPISuccess    = "validate API success"
    22  	validateMissingIDFlag = "validate missing --id flag"
    23  )
    24  
    25  func TestTLSCustomCertCreate(t *testing.T) {
    26  	args := testutil.Args
    27  	scenarios := []testutil.TestScenario{
    28  		{
    29  			Name:      "validate missing --cert-blob flag",
    30  			Args:      args("tls-custom certificate create"),
    31  			WantError: "required flag --cert-blob not provided",
    32  		},
    33  		{
    34  			Name: validateAPIError,
    35  			API: mock.API{
    36  				CreateCustomTLSCertificateFn: func(_ *fastly.CreateCustomTLSCertificateInput) (*fastly.CustomTLSCertificate, error) {
    37  					return nil, testutil.Err
    38  				},
    39  			},
    40  			Args:      args("tls-custom certificate create --cert-blob example"),
    41  			WantError: testutil.Err.Error(),
    42  		},
    43  		{
    44  			Name: validateAPISuccess,
    45  			API: mock.API{
    46  				CreateCustomTLSCertificateFn: func(_ *fastly.CreateCustomTLSCertificateInput) (*fastly.CustomTLSCertificate, error) {
    47  					return &fastly.CustomTLSCertificate{
    48  						ID: mockResponseID,
    49  					}, nil
    50  				},
    51  			},
    52  			Args:       args("tls-custom certificate create --cert-blob example"),
    53  			WantOutput: fmt.Sprintf("Created TLS Certificate '%s'", mockResponseID),
    54  		},
    55  	}
    56  
    57  	for testcaseIdx := range scenarios {
    58  		testcase := &scenarios[testcaseIdx]
    59  		t.Run(testcase.Name, func(t *testing.T) {
    60  			var stdout bytes.Buffer
    61  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
    62  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
    63  				opts.APIClientFactory = mock.APIClient(testcase.API)
    64  				return opts, nil
    65  			}
    66  			err := app.Run(testcase.Args, nil)
    67  			testutil.AssertErrorContains(t, err, testcase.WantError)
    68  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
    69  		})
    70  	}
    71  }
    72  
    73  func TestTLSCustomCertDelete(t *testing.T) {
    74  	args := testutil.Args
    75  	scenarios := []testutil.TestScenario{
    76  		{
    77  			Name:      validateMissingIDFlag,
    78  			Args:      args("tls-custom certificate delete"),
    79  			WantError: "error parsing arguments: required flag --id not provided",
    80  		},
    81  		{
    82  			Name: validateAPIError,
    83  			API: mock.API{
    84  				DeleteCustomTLSCertificateFn: func(_ *fastly.DeleteCustomTLSCertificateInput) error {
    85  					return testutil.Err
    86  				},
    87  			},
    88  			Args:      args("tls-custom certificate delete --id example"),
    89  			WantError: testutil.Err.Error(),
    90  		},
    91  		{
    92  			Name: validateAPISuccess,
    93  			API: mock.API{
    94  				DeleteCustomTLSCertificateFn: func(_ *fastly.DeleteCustomTLSCertificateInput) error {
    95  					return nil
    96  				},
    97  			},
    98  			Args:       args("tls-custom certificate delete --id example"),
    99  			WantOutput: "Deleted TLS Certificate 'example'",
   100  		},
   101  	}
   102  
   103  	for testcaseIdx := range scenarios {
   104  		testcase := &scenarios[testcaseIdx]
   105  		t.Run(testcase.Name, func(t *testing.T) {
   106  			var stdout bytes.Buffer
   107  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   108  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   109  				opts.APIClientFactory = mock.APIClient(testcase.API)
   110  				return opts, nil
   111  			}
   112  			err := app.Run(testcase.Args, nil)
   113  			testutil.AssertErrorContains(t, err, testcase.WantError)
   114  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   115  		})
   116  	}
   117  }
   118  
   119  func TestTLSCustomCertDescribe(t *testing.T) {
   120  	args := testutil.Args
   121  	scenarios := []testutil.TestScenario{
   122  		{
   123  			Name:      validateMissingIDFlag,
   124  			Args:      args("tls-custom certificate describe"),
   125  			WantError: "error parsing arguments: required flag --id not provided",
   126  		},
   127  		{
   128  			Name: validateAPIError,
   129  			API: mock.API{
   130  				GetCustomTLSCertificateFn: func(_ *fastly.GetCustomTLSCertificateInput) (*fastly.CustomTLSCertificate, error) {
   131  					return nil, testutil.Err
   132  				},
   133  			},
   134  			Args:      args("tls-custom certificate describe --id example"),
   135  			WantError: testutil.Err.Error(),
   136  		},
   137  		{
   138  			Name: validateAPISuccess,
   139  			API: mock.API{
   140  				GetCustomTLSCertificateFn: func(_ *fastly.GetCustomTLSCertificateInput) (*fastly.CustomTLSCertificate, error) {
   141  					t := testutil.Date
   142  					return &fastly.CustomTLSCertificate{
   143  						ID:                 mockResponseID,
   144  						IssuedTo:           mockFieldValue,
   145  						Issuer:             mockFieldValue,
   146  						Name:               mockFieldValue,
   147  						Replace:            true,
   148  						SerialNumber:       mockFieldValue,
   149  						SignatureAlgorithm: mockFieldValue,
   150  						CreatedAt:          &t,
   151  						UpdatedAt:          &t,
   152  					}, nil
   153  				},
   154  			},
   155  			Args:       args("tls-custom certificate describe --id example"),
   156  			WantOutput: "\nID: " + mockResponseID + "\nIssued to: " + mockFieldValue + "\nIssuer: " + mockFieldValue + "\nName: " + mockFieldValue + "\nReplace: true\nSerial number: " + mockFieldValue + "\nSignature algorithm: " + mockFieldValue + "\nCreated at: 2021-06-15 23:00:00 +0000 UTC\nUpdated at: 2021-06-15 23:00:00 +0000 UTC\n",
   157  		},
   158  	}
   159  
   160  	for testcaseIdx := range scenarios {
   161  		testcase := &scenarios[testcaseIdx]
   162  		t.Run(testcase.Name, func(t *testing.T) {
   163  			var stdout bytes.Buffer
   164  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   165  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   166  				opts.APIClientFactory = mock.APIClient(testcase.API)
   167  				return opts, nil
   168  			}
   169  			err := app.Run(testcase.Args, nil)
   170  			testutil.AssertErrorContains(t, err, testcase.WantError)
   171  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   172  		})
   173  	}
   174  }
   175  
   176  func TestTLSCustomCertList(t *testing.T) {
   177  	args := testutil.Args
   178  	scenarios := []testutil.TestScenario{
   179  		{
   180  			Name: validateAPIError,
   181  			API: mock.API{
   182  				ListCustomTLSCertificatesFn: func(_ *fastly.ListCustomTLSCertificatesInput) ([]*fastly.CustomTLSCertificate, error) {
   183  					return nil, testutil.Err
   184  				},
   185  			},
   186  			Args:      args("tls-custom certificate list"),
   187  			WantError: testutil.Err.Error(),
   188  		},
   189  		{
   190  			Name: validateAPISuccess,
   191  			API: mock.API{
   192  				ListCustomTLSCertificatesFn: func(_ *fastly.ListCustomTLSCertificatesInput) ([]*fastly.CustomTLSCertificate, error) {
   193  					t := testutil.Date
   194  					return []*fastly.CustomTLSCertificate{
   195  						{
   196  							ID:                 mockResponseID,
   197  							IssuedTo:           mockFieldValue,
   198  							Issuer:             mockFieldValue,
   199  							Name:               mockFieldValue,
   200  							Replace:            true,
   201  							SerialNumber:       mockFieldValue,
   202  							SignatureAlgorithm: mockFieldValue,
   203  							CreatedAt:          &t,
   204  							UpdatedAt:          &t,
   205  						},
   206  					}, nil
   207  				},
   208  			},
   209  			Args:       args("tls-custom certificate list --verbose"),
   210  			WantOutput: "Fastly API endpoint: https://api.fastly.com\nFastly API token provided via config file (profile: user)\n\nID: " + mockResponseID + "\nIssued to: " + mockFieldValue + "\nIssuer: " + mockFieldValue + "\nName: " + mockFieldValue + "\nReplace: true\nSerial number: " + mockFieldValue + "\nSignature algorithm: " + mockFieldValue + "\nCreated at: 2021-06-15 23:00:00 +0000 UTC\nUpdated at: 2021-06-15 23:00:00 +0000 UTC\n",
   211  		},
   212  	}
   213  
   214  	for testcaseIdx := range scenarios {
   215  		testcase := &scenarios[testcaseIdx]
   216  		t.Run(testcase.Name, func(t *testing.T) {
   217  			var stdout bytes.Buffer
   218  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   219  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   220  				opts.APIClientFactory = mock.APIClient(testcase.API)
   221  				return opts, nil
   222  			}
   223  			err := app.Run(testcase.Args, nil)
   224  			testutil.AssertErrorContains(t, err, testcase.WantError)
   225  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   226  		})
   227  	}
   228  }
   229  
   230  func TestTLSCustomCertUpdate(t *testing.T) {
   231  	args := testutil.Args
   232  	scenarios := []testutil.TestScenario{
   233  		{
   234  			Name:      "validate missing --cert-blob flag",
   235  			Args:      args("tls-custom certificate update --id example"),
   236  			WantError: "required flag --cert-blob not provided",
   237  		},
   238  		{
   239  			Name:      validateMissingIDFlag,
   240  			Args:      args("tls-custom certificate update --cert-blob example"),
   241  			WantError: "required flag --id not provided",
   242  		},
   243  		{
   244  			Name: validateAPIError,
   245  			API: mock.API{
   246  				UpdateCustomTLSCertificateFn: func(_ *fastly.UpdateCustomTLSCertificateInput) (*fastly.CustomTLSCertificate, error) {
   247  					return nil, testutil.Err
   248  				},
   249  			},
   250  			Args:      args("tls-custom certificate update --cert-blob example --id example"),
   251  			WantError: testutil.Err.Error(),
   252  		},
   253  		{
   254  			Name: validateAPISuccess,
   255  			API: mock.API{
   256  				UpdateCustomTLSCertificateFn: func(_ *fastly.UpdateCustomTLSCertificateInput) (*fastly.CustomTLSCertificate, error) {
   257  					return &fastly.CustomTLSCertificate{
   258  						ID: mockResponseID,
   259  					}, nil
   260  				},
   261  			},
   262  			Args:       args("tls-custom certificate update --cert-blob example --id example"),
   263  			WantOutput: fmt.Sprintf("Updated TLS Certificate '%s'", mockResponseID),
   264  		},
   265  		{
   266  			Name: validateAPISuccess + " with --name for different output",
   267  			API: mock.API{
   268  				UpdateCustomTLSCertificateFn: func(_ *fastly.UpdateCustomTLSCertificateInput) (*fastly.CustomTLSCertificate, error) {
   269  					return &fastly.CustomTLSCertificate{
   270  						ID:   mockResponseID,
   271  						Name: "Updated",
   272  					}, nil
   273  				},
   274  			},
   275  			Args:       args("tls-custom certificate update --cert-blob example --id example --name example"),
   276  			WantOutput: "Updated TLS Certificate 'Updated' (previously: 'example')",
   277  		},
   278  	}
   279  
   280  	for testcaseIdx := range scenarios {
   281  		testcase := &scenarios[testcaseIdx]
   282  		t.Run(testcase.Name, func(t *testing.T) {
   283  			var stdout bytes.Buffer
   284  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   285  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   286  				opts.APIClientFactory = mock.APIClient(testcase.API)
   287  				return opts, nil
   288  			}
   289  			err := app.Run(testcase.Args, nil)
   290  			testutil.AssertErrorContains(t, err, testcase.WantError)
   291  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   292  		})
   293  	}
   294  }