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

     1  package subscription_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  	certificateAuthority  = "lets-encrypt"
    19  	mockResponseID        = "123"
    20  	validateAPIError      = "validate API error"
    21  	validateAPISuccess    = "validate API success"
    22  	validateMissingIDFlag = "validate missing --id flag"
    23  )
    24  
    25  func TestTLSSubscriptionCreate(t *testing.T) {
    26  	args := testutil.Args
    27  	scenarios := []testutil.TestScenario{
    28  		{
    29  			Name:      "validate missing --domain flag",
    30  			Args:      args("tls-subscription create"),
    31  			WantError: "required flag --domain not provided",
    32  		},
    33  		{
    34  			Name: validateAPIError,
    35  			API: mock.API{
    36  				CreateTLSSubscriptionFn: func(_ *fastly.CreateTLSSubscriptionInput) (*fastly.TLSSubscription, error) {
    37  					return nil, testutil.Err
    38  				},
    39  			},
    40  			Args:      args("tls-subscription create --domain example.com"),
    41  			WantError: testutil.Err.Error(),
    42  		},
    43  		{
    44  			Name: validateAPISuccess,
    45  			API: mock.API{
    46  				CreateTLSSubscriptionFn: func(_ *fastly.CreateTLSSubscriptionInput) (*fastly.TLSSubscription, error) {
    47  					return &fastly.TLSSubscription{
    48  						ID:                   mockResponseID,
    49  						CertificateAuthority: certificateAuthority,
    50  						CommonName: &fastly.TLSDomain{
    51  							ID: "example.com",
    52  						},
    53  					}, nil
    54  				},
    55  			},
    56  			Args:       args("tls-subscription create --domain example.com"),
    57  			WantOutput: fmt.Sprintf("Created TLS Subscription '%s' (Authority: %s, Common Name: example.com)", mockResponseID, certificateAuthority),
    58  		},
    59  	}
    60  
    61  	for testcaseIdx := range scenarios {
    62  		testcase := &scenarios[testcaseIdx]
    63  		t.Run(testcase.Name, func(t *testing.T) {
    64  			var stdout bytes.Buffer
    65  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
    66  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
    67  				opts.APIClientFactory = mock.APIClient(testcase.API)
    68  				return opts, nil
    69  			}
    70  			err := app.Run(testcase.Args, nil)
    71  			testutil.AssertErrorContains(t, err, testcase.WantError)
    72  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
    73  		})
    74  	}
    75  }
    76  
    77  func TestTLSSubscriptionDelete(t *testing.T) {
    78  	args := testutil.Args
    79  	scenarios := []testutil.TestScenario{
    80  		{
    81  			Name:      validateMissingIDFlag,
    82  			Args:      args("tls-subscription delete"),
    83  			WantError: "error parsing arguments: required flag --id not provided",
    84  		},
    85  		{
    86  			Name: validateAPIError,
    87  			API: mock.API{
    88  				DeleteTLSSubscriptionFn: func(_ *fastly.DeleteTLSSubscriptionInput) error {
    89  					return testutil.Err
    90  				},
    91  			},
    92  			Args:      args("tls-subscription delete --id example"),
    93  			WantError: testutil.Err.Error(),
    94  		},
    95  		{
    96  			Name: validateAPISuccess,
    97  			API: mock.API{
    98  				DeleteTLSSubscriptionFn: func(_ *fastly.DeleteTLSSubscriptionInput) error {
    99  					return nil
   100  				},
   101  			},
   102  			Args:       args("tls-subscription delete --id example"),
   103  			WantOutput: "Deleted TLS Subscription 'example' (force: false)",
   104  		},
   105  	}
   106  
   107  	for testcaseIdx := range scenarios {
   108  		testcase := &scenarios[testcaseIdx]
   109  		t.Run(testcase.Name, func(t *testing.T) {
   110  			var stdout bytes.Buffer
   111  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   112  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   113  				opts.APIClientFactory = mock.APIClient(testcase.API)
   114  				return opts, nil
   115  			}
   116  			err := app.Run(testcase.Args, nil)
   117  			testutil.AssertErrorContains(t, err, testcase.WantError)
   118  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   119  		})
   120  	}
   121  }
   122  
   123  func TestTLSSubscriptionDescribe(t *testing.T) {
   124  	args := testutil.Args
   125  	scenarios := []testutil.TestScenario{
   126  		{
   127  			Name:      validateMissingIDFlag,
   128  			Args:      args("tls-subscription describe"),
   129  			WantError: "error parsing arguments: required flag --id not provided",
   130  		},
   131  		{
   132  			Name: validateAPIError,
   133  			API: mock.API{
   134  				GetTLSSubscriptionFn: func(_ *fastly.GetTLSSubscriptionInput) (*fastly.TLSSubscription, error) {
   135  					return nil, testutil.Err
   136  				},
   137  			},
   138  			Args:      args("tls-subscription describe --id example"),
   139  			WantError: testutil.Err.Error(),
   140  		},
   141  		{
   142  			Name: validateAPISuccess,
   143  			API: mock.API{
   144  				GetTLSSubscriptionFn: func(_ *fastly.GetTLSSubscriptionInput) (*fastly.TLSSubscription, error) {
   145  					t := testutil.Date
   146  					return &fastly.TLSSubscription{
   147  						ID:                   mockResponseID,
   148  						CertificateAuthority: certificateAuthority,
   149  						State:                "pending",
   150  						CreatedAt:            &t,
   151  						UpdatedAt:            &t,
   152  					}, nil
   153  				},
   154  			},
   155  			Args:       args("tls-subscription describe --id example"),
   156  			WantOutput: "\nID: " + mockResponseID + "\nCertificate Authority: " + certificateAuthority + "\nState: pending\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 TestTLSSubscriptionList(t *testing.T) {
   177  	args := testutil.Args
   178  	scenarios := []testutil.TestScenario{
   179  		{
   180  			Name: validateAPIError,
   181  			API: mock.API{
   182  				ListTLSSubscriptionsFn: func(_ *fastly.ListTLSSubscriptionsInput) ([]*fastly.TLSSubscription, error) {
   183  					return nil, testutil.Err
   184  				},
   185  			},
   186  			Args:      args("tls-subscription list"),
   187  			WantError: testutil.Err.Error(),
   188  		},
   189  		{
   190  			Name: validateAPISuccess,
   191  			API: mock.API{
   192  				ListTLSSubscriptionsFn: func(_ *fastly.ListTLSSubscriptionsInput) ([]*fastly.TLSSubscription, error) {
   193  					t := testutil.Date
   194  					return []*fastly.TLSSubscription{
   195  						{
   196  							ID:                   mockResponseID,
   197  							CertificateAuthority: certificateAuthority,
   198  							State:                "pending",
   199  							CreatedAt:            &t,
   200  							UpdatedAt:            &t,
   201  						},
   202  					}, nil
   203  				},
   204  			},
   205  			Args:       args("tls-subscription list --verbose"),
   206  			WantOutput: "\nID: " + mockResponseID + "\nCertificate Authority: " + certificateAuthority + "\nState: pending\nCreated at: 2021-06-15 23:00:00 +0000 UTC\nUpdated at: 2021-06-15 23:00:00 +0000 UTC\n",
   207  		},
   208  	}
   209  
   210  	for testcaseIdx := range scenarios {
   211  		testcase := &scenarios[testcaseIdx]
   212  		t.Run(testcase.Name, 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 TestTLSSubscriptionUpdate(t *testing.T) {
   227  	args := testutil.Args
   228  	scenarios := []testutil.TestScenario{
   229  		{
   230  			Name:      validateMissingIDFlag,
   231  			Args:      args("tls-subscription update"),
   232  			WantError: "required flag --id not provided",
   233  		},
   234  		{
   235  			Name: validateAPIError,
   236  			API: mock.API{
   237  				UpdateTLSSubscriptionFn: func(_ *fastly.UpdateTLSSubscriptionInput) (*fastly.TLSSubscription, error) {
   238  					return nil, testutil.Err
   239  				},
   240  			},
   241  			Args:      args("tls-subscription update --id example"),
   242  			WantError: testutil.Err.Error(),
   243  		},
   244  		{
   245  			Name: validateAPISuccess,
   246  			API: mock.API{
   247  				UpdateTLSSubscriptionFn: func(_ *fastly.UpdateTLSSubscriptionInput) (*fastly.TLSSubscription, error) {
   248  					return &fastly.TLSSubscription{
   249  						ID:                   mockResponseID,
   250  						CertificateAuthority: certificateAuthority,
   251  						CommonName: &fastly.TLSDomain{
   252  							ID: "example.com",
   253  						},
   254  					}, nil
   255  				},
   256  			},
   257  			Args:       args("tls-subscription update --id example"),
   258  			WantOutput: fmt.Sprintf("Updated TLS Subscription '%s' (Authority: %s, Common Name: example.com)", mockResponseID, certificateAuthority),
   259  		},
   260  	}
   261  
   262  	for testcaseIdx := range scenarios {
   263  		testcase := &scenarios[testcaseIdx]
   264  		t.Run(testcase.Name, func(t *testing.T) {
   265  			var stdout bytes.Buffer
   266  			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
   267  				opts := testutil.MockGlobalData(testcase.Args, &stdout)
   268  				opts.APIClientFactory = mock.APIClient(testcase.API)
   269  				return opts, nil
   270  			}
   271  			err := app.Run(testcase.Args, nil)
   272  			testutil.AssertErrorContains(t, err, testcase.WantError)
   273  			testutil.AssertStringContains(t, stdout.String(), testcase.WantOutput)
   274  		})
   275  	}
   276  }