github.com/justincormack/cli@v0.0.0-20201215022714-831ebeae9675/cli/command/secret/ls_test.go (about)

     1  package secret
     2  
     3  import (
     4  	"io/ioutil"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/docker/cli/cli/config/configfile"
     9  	"github.com/docker/cli/internal/test"
    10  	. "github.com/docker/cli/internal/test/builders" // Import builders to get the builder function as package function
    11  	"github.com/docker/docker/api/types"
    12  	"github.com/docker/docker/api/types/swarm"
    13  	"github.com/pkg/errors"
    14  	"gotest.tools/v3/assert"
    15  	is "gotest.tools/v3/assert/cmp"
    16  	"gotest.tools/v3/golden"
    17  )
    18  
    19  func TestSecretListErrors(t *testing.T) {
    20  	testCases := []struct {
    21  		args           []string
    22  		secretListFunc func(types.SecretListOptions) ([]swarm.Secret, error)
    23  		expectedError  string
    24  	}{
    25  		{
    26  			args:          []string{"foo"},
    27  			expectedError: "accepts no argument",
    28  		},
    29  		{
    30  			secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) {
    31  				return []swarm.Secret{}, errors.Errorf("error listing secrets")
    32  			},
    33  			expectedError: "error listing secrets",
    34  		},
    35  	}
    36  	for _, tc := range testCases {
    37  		cmd := newSecretListCommand(
    38  			test.NewFakeCli(&fakeClient{
    39  				secretListFunc: tc.secretListFunc,
    40  			}),
    41  		)
    42  		cmd.SetArgs(tc.args)
    43  		cmd.SetOut(ioutil.Discard)
    44  		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
    45  	}
    46  }
    47  
    48  func TestSecretList(t *testing.T) {
    49  	cli := test.NewFakeCli(&fakeClient{
    50  		secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) {
    51  			return []swarm.Secret{
    52  				*Secret(SecretID("ID-1-foo"),
    53  					SecretName("1-foo"),
    54  					SecretVersion(swarm.Version{Index: 10}),
    55  					SecretCreatedAt(time.Now().Add(-2*time.Hour)),
    56  					SecretUpdatedAt(time.Now().Add(-1*time.Hour)),
    57  				),
    58  				*Secret(SecretID("ID-10-foo"),
    59  					SecretName("10-foo"),
    60  					SecretVersion(swarm.Version{Index: 11}),
    61  					SecretCreatedAt(time.Now().Add(-2*time.Hour)),
    62  					SecretUpdatedAt(time.Now().Add(-1*time.Hour)),
    63  					SecretDriver("driver"),
    64  				),
    65  				*Secret(SecretID("ID-2-foo"),
    66  					SecretName("2-foo"),
    67  					SecretVersion(swarm.Version{Index: 11}),
    68  					SecretCreatedAt(time.Now().Add(-2*time.Hour)),
    69  					SecretUpdatedAt(time.Now().Add(-1*time.Hour)),
    70  					SecretDriver("driver"),
    71  				),
    72  			}, nil
    73  		},
    74  	})
    75  	cmd := newSecretListCommand(cli)
    76  	assert.NilError(t, cmd.Execute())
    77  	golden.Assert(t, cli.OutBuffer().String(), "secret-list-sort.golden")
    78  }
    79  
    80  func TestSecretListWithQuietOption(t *testing.T) {
    81  	cli := test.NewFakeCli(&fakeClient{
    82  		secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) {
    83  			return []swarm.Secret{
    84  				*Secret(SecretID("ID-foo"), SecretName("foo")),
    85  				*Secret(SecretID("ID-bar"), SecretName("bar"), SecretLabels(map[string]string{
    86  					"label": "label-bar",
    87  				})),
    88  			}, nil
    89  		},
    90  	})
    91  	cmd := newSecretListCommand(cli)
    92  	cmd.Flags().Set("quiet", "true")
    93  	assert.NilError(t, cmd.Execute())
    94  	golden.Assert(t, cli.OutBuffer().String(), "secret-list-with-quiet-option.golden")
    95  }
    96  
    97  func TestSecretListWithConfigFormat(t *testing.T) {
    98  	cli := test.NewFakeCli(&fakeClient{
    99  		secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) {
   100  			return []swarm.Secret{
   101  				*Secret(SecretID("ID-foo"), SecretName("foo")),
   102  				*Secret(SecretID("ID-bar"), SecretName("bar"), SecretLabels(map[string]string{
   103  					"label": "label-bar",
   104  				})),
   105  			}, nil
   106  		},
   107  	})
   108  	cli.SetConfigFile(&configfile.ConfigFile{
   109  		SecretFormat: "{{ .Name }} {{ .Labels }}",
   110  	})
   111  	cmd := newSecretListCommand(cli)
   112  	assert.NilError(t, cmd.Execute())
   113  	golden.Assert(t, cli.OutBuffer().String(), "secret-list-with-config-format.golden")
   114  }
   115  
   116  func TestSecretListWithFormat(t *testing.T) {
   117  	cli := test.NewFakeCli(&fakeClient{
   118  		secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) {
   119  			return []swarm.Secret{
   120  				*Secret(SecretID("ID-foo"), SecretName("foo")),
   121  				*Secret(SecretID("ID-bar"), SecretName("bar"), SecretLabels(map[string]string{
   122  					"label": "label-bar",
   123  				})),
   124  			}, nil
   125  		},
   126  	})
   127  	cmd := newSecretListCommand(cli)
   128  	cmd.Flags().Set("format", "{{ .Name }} {{ .Labels }}")
   129  	assert.NilError(t, cmd.Execute())
   130  	golden.Assert(t, cli.OutBuffer().String(), "secret-list-with-format.golden")
   131  }
   132  
   133  func TestSecretListWithFilter(t *testing.T) {
   134  	cli := test.NewFakeCli(&fakeClient{
   135  		secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) {
   136  			assert.Check(t, is.Equal("foo", options.Filters.Get("name")[0]), "foo")
   137  			assert.Check(t, is.Equal("lbl1=Label-bar", options.Filters.Get("label")[0]))
   138  			return []swarm.Secret{
   139  				*Secret(SecretID("ID-foo"),
   140  					SecretName("foo"),
   141  					SecretVersion(swarm.Version{Index: 10}),
   142  					SecretCreatedAt(time.Now().Add(-2*time.Hour)),
   143  					SecretUpdatedAt(time.Now().Add(-1*time.Hour)),
   144  				),
   145  				*Secret(SecretID("ID-bar"),
   146  					SecretName("bar"),
   147  					SecretVersion(swarm.Version{Index: 11}),
   148  					SecretCreatedAt(time.Now().Add(-2*time.Hour)),
   149  					SecretUpdatedAt(time.Now().Add(-1*time.Hour)),
   150  				),
   151  			}, nil
   152  		},
   153  	})
   154  	cmd := newSecretListCommand(cli)
   155  	cmd.Flags().Set("filter", "name=foo")
   156  	cmd.Flags().Set("filter", "label=lbl1=Label-bar")
   157  	assert.NilError(t, cmd.Execute())
   158  	golden.Assert(t, cli.OutBuffer().String(), "secret-list-with-filter.golden")
   159  }