add unit tests for package cli/command/secret

cli/command/secret/client_test.go

@@ -0,0 +1,44 @@
+package secret
+
+import (
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/docker/docker/client"
+	"golang.org/x/net/context"
+)
+
+type fakeClient struct {
+	client.Client
+	secretCreateFunc  func(swarm.SecretSpec) (types.SecretCreateResponse, error)
+	secretInspectFunc func(string) (swarm.Secret, []byte, error)
+	secretListFunc    func(types.SecretListOptions) ([]swarm.Secret, error)
+	secretRemoveFunc  func(string) error
+}
+
+func (c *fakeClient) SecretCreate(ctx context.Context, spec swarm.SecretSpec) (types.SecretCreateResponse, error) {
+	if c.secretCreateFunc != nil {
+		return c.secretCreateFunc(spec)
+	}
+	return types.SecretCreateResponse{}, nil
+}
+
+func (c *fakeClient) SecretInspectWithRaw(ctx context.Context, id string) (swarm.Secret, []byte, error) {
+	if c.secretInspectFunc != nil {
+		return c.secretInspectFunc(id)
+	}
+	return swarm.Secret{}, nil, nil
+}
+
+func (c *fakeClient) SecretList(ctx context.Context, options types.SecretListOptions) ([]swarm.Secret, error) {
+	if c.secretListFunc != nil {
+		return c.secretListFunc(options)
+	}
+	return []swarm.Secret{}, nil
+}
+
+func (c *fakeClient) SecretRemove(ctx context.Context, name string) error {
+	if c.secretRemoveFunc != nil {
+		return c.secretRemoveFunc(name)
+	}
+	return nil
+}

cli/command/secret/create.go

@@ -22,7 +22,7 @@ type createOptions struct {
 	labels opts.ListOpts
 }
 
-func newSecretCreateCommand(dockerCli *command.DockerCli) *cobra.Command {
+func newSecretCreateCommand(dockerCli command.Cli) *cobra.Command {
 	createOpts := createOptions{
 		labels: opts.NewListOpts(opts.ValidateEnv),
 	}
@@ -43,7 +43,7 @@ func newSecretCreateCommand(dockerCli *command.DockerCli) *cobra.Command {
 	return cmd
 }
 
-func runSecretCreate(dockerCli *command.DockerCli, options createOptions) error {
+func runSecretCreate(dockerCli command.Cli, options createOptions) error {
 	client := dockerCli.Client()
 	ctx := context.Background()
 

cli/command/secret/create_test.go

@@ -0,0 +1,126 @@
+package secret
+
+import (
+	"bytes"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/docker/docker/cli/internal/test"
+	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/pkg/errors"
+)
+
+const secretDataFile = "secret-create-with-name.golden"
+
+func TestSecretCreateErrors(t *testing.T) {
+	testCases := []struct {
+		args             []string
+		secretCreateFunc func(swarm.SecretSpec) (types.SecretCreateResponse, error)
+		expectedError    string
+	}{
+		{
+			args:          []string{"too_few"},
+			expectedError: "requires exactly 2 argument(s)",
+		},
+		{args: []string{"too", "many", "arguments"},
+			expectedError: "requires exactly 2 argument(s)",
+		},
+		{
+			args: []string{"name", filepath.Join("testdata", secretDataFile)},
+			secretCreateFunc: func(secretSpec swarm.SecretSpec) (types.SecretCreateResponse, error) {
+				return types.SecretCreateResponse{}, errors.Errorf("error creating secret")
+			},
+			expectedError: "error creating secret",
+		},
+	}
+	for _, tc := range testCases {
+		buf := new(bytes.Buffer)
+		cmd := newSecretCreateCommand(
+			test.NewFakeCli(&fakeClient{
+				secretCreateFunc: tc.secretCreateFunc,
+			}, buf),
+		)
+		cmd.SetArgs(tc.args)
+		cmd.SetOutput(ioutil.Discard)
+		assert.Error(t, cmd.Execute(), tc.expectedError)
+	}
+}
+
+func TestSecretCreateWithName(t *testing.T) {
+	name := "foo"
+	buf := new(bytes.Buffer)
+	var actual []byte
+	cli := test.NewFakeCli(&fakeClient{
+		secretCreateFunc: func(spec swarm.SecretSpec) (types.SecretCreateResponse, error) {
+			if spec.Name != name {
+				return types.SecretCreateResponse{}, errors.Errorf("expected name %q, got %q", name, spec.Name)
+			}
+
+			actual = spec.Data
+
+			return types.SecretCreateResponse{
+				ID: "ID-" + spec.Name,
+			}, nil
+		},
+	}, buf)
+
+	cmd := newSecretCreateCommand(cli)
+	cmd.SetArgs([]string{name, filepath.Join("testdata", secretDataFile)})
+	assert.NilError(t, cmd.Execute())
+	expected := golden.Get(t, actual, secretDataFile)
+	assert.Equal(t, string(actual), string(expected))
+	assert.Equal(t, strings.TrimSpace(buf.String()), "ID-"+name)
+}
+
+func TestSecretCreateWithLabels(t *testing.T) {
+	expectedLabels := map[string]string{
+		"lbl1": "Label-foo",
+		"lbl2": "Label-bar",
+	}
+	name := "foo"
+
+	buf := new(bytes.Buffer)
+	cli := test.NewFakeCli(&fakeClient{
+		secretCreateFunc: func(spec swarm.SecretSpec) (types.SecretCreateResponse, error) {
+			if spec.Name != name {
+				return types.SecretCreateResponse{}, errors.Errorf("expected name %q, got %q", name, spec.Name)
+			}
+
+			if !compareMap(spec.Labels, expectedLabels) {
+				return types.SecretCreateResponse{}, errors.Errorf("expected labels %v, got %v", expectedLabels, spec.Labels)
+			}
+
+			return types.SecretCreateResponse{
+				ID: "ID-" + spec.Name,
+			}, nil
+		},
+	}, buf)
+
+	cmd := newSecretCreateCommand(cli)
+	cmd.SetArgs([]string{name, filepath.Join("testdata", secretDataFile)})
+	cmd.Flags().Set("label", "lbl1=Label-foo")
+	cmd.Flags().Set("label", "lbl2=Label-bar")
+	assert.NilError(t, cmd.Execute())
+	assert.Equal(t, strings.TrimSpace(buf.String()), "ID-"+name)
+}
+
+func compareMap(actual map[string]string, expected map[string]string) bool {
+	if len(actual) != len(expected) {
+		return false
+	}
+	for key, value := range actual {
+		if expectedValue, ok := expected[key]; ok {
+			if expectedValue != value {
+				return false
+			}
+		} else {
+			return false
+		}
+	}
+	return true
+}

cli/command/secret/inspect.go

@@ -13,7 +13,7 @@ type inspectOptions struct {
 	format string
 }
 
-func newSecretInspectCommand(dockerCli *command.DockerCli) *cobra.Command {
+func newSecretInspectCommand(dockerCli command.Cli) *cobra.Command {
 	opts := inspectOptions{}
 	cmd := &cobra.Command{
 		Use:   "inspect [OPTIONS] SECRET [SECRET...]",
@@ -29,7 +29,7 @@ func newSecretInspectCommand(dockerCli *command.DockerCli) *cobra.Command {
 	return cmd
 }
 
-func runSecretInspect(dockerCli *command.DockerCli, opts inspectOptions) error {
+func runSecretInspect(dockerCli command.Cli, opts inspectOptions) error {
 	client := dockerCli.Client()
 	ctx := context.Background()
 

cli/command/secret/inspect_test.go

@@ -0,0 +1,149 @@
+package secret
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"testing"
+
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/docker/docker/cli/internal/test"
+	"github.com/pkg/errors"
+	// Import builders to get the builder function as package function
+	. "github.com/docker/docker/cli/internal/test/builders"
+	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil/golden"
+)
+
+func TestSecretInspectErrors(t *testing.T) {
+	testCases := []struct {
+		args              []string
+		flags             map[string]string
+		secretInspectFunc func(secretID string) (swarm.Secret, []byte, error)
+		expectedError     string
+	}{
+		{
+			expectedError: "requires at least 1 argument",
+		},
+		{
+			args: []string{"foo"},
+			secretInspectFunc: func(secretID string) (swarm.Secret, []byte, error) {
+				return swarm.Secret{}, nil, errors.Errorf("error while inspecting the secret")
+			},
+			expectedError: "error while inspecting the secret",
+		},
+		{
+			args: []string{"foo"},
+			flags: map[string]string{
+				"format": "{{invalid format}}",
+			},
+			expectedError: "Template parsing error",
+		},
+		{
+			args: []string{"foo", "bar"},
+			secretInspectFunc: func(secretID string) (swarm.Secret, []byte, error) {
+				if secretID == "foo" {
+					return *Secret(SecretName("foo")), nil, nil
+				}
+				return swarm.Secret{}, nil, errors.Errorf("error while inspecting the secret")
+			},
+			expectedError: "error while inspecting the secret",
+		},
+	}
+	for _, tc := range testCases {
+		buf := new(bytes.Buffer)
+		cmd := newSecretInspectCommand(
+			test.NewFakeCli(&fakeClient{
+				secretInspectFunc: tc.secretInspectFunc,
+			}, buf),
+		)
+		cmd.SetArgs(tc.args)
+		for key, value := range tc.flags {
+			cmd.Flags().Set(key, value)
+		}
+		cmd.SetOutput(ioutil.Discard)
+		assert.Error(t, cmd.Execute(), tc.expectedError)
+	}
+}
+
+func TestSecretInspectWithoutFormat(t *testing.T) {
+	testCases := []struct {
+		name              string
+		args              []string
+		secretInspectFunc func(secretID string) (swarm.Secret, []byte, error)
+	}{
+		{
+			name: "single-secret",
+			args: []string{"foo"},
+			secretInspectFunc: func(name string) (swarm.Secret, []byte, error) {
+				if name != "foo" {
+					return swarm.Secret{}, nil, errors.Errorf("Invalid name, expected %s, got %s", "foo", name)
+				}
+				return *Secret(SecretID("ID-foo"), SecretName("foo")), nil, nil
+			},
+		},
+		{
+			name: "multiple-secrets-with-labels",
+			args: []string{"foo", "bar"},
+			secretInspectFunc: func(name string) (swarm.Secret, []byte, error) {
+				return *Secret(SecretID("ID-"+name), SecretName(name), SecretLabels(map[string]string{
+					"label1": "label-foo",
+				})), nil, nil
+			},
+		},
+	}
+	for _, tc := range testCases {
+		buf := new(bytes.Buffer)
+		cmd := newSecretInspectCommand(
+			test.NewFakeCli(&fakeClient{
+				secretInspectFunc: tc.secretInspectFunc,
+			}, buf),
+		)
+		cmd.SetArgs(tc.args)
+		assert.NilError(t, cmd.Execute())
+		actual := buf.String()
+		expected := golden.Get(t, []byte(actual), fmt.Sprintf("secret-inspect-without-format.%s.golden", tc.name))
+		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	}
+}
+
+func TestSecretInspectWithFormat(t *testing.T) {
+	secretInspectFunc := func(name string) (swarm.Secret, []byte, error) {
+		return *Secret(SecretName("foo"), SecretLabels(map[string]string{
+			"label1": "label-foo",
+		})), nil, nil
+	}
+	testCases := []struct {
+		name              string
+		format            string
+		args              []string
+		secretInspectFunc func(name string) (swarm.Secret, []byte, error)
+	}{
+		{
+			name:              "simple-template",
+			format:            "{{.Spec.Name}}",
+			args:              []string{"foo"},
+			secretInspectFunc: secretInspectFunc,
+		},
+		{
+			name:              "json-template",
+			format:            "{{json .Spec.Labels}}",
+			args:              []string{"foo"},
+			secretInspectFunc: secretInspectFunc,
+		},
+	}
+	for _, tc := range testCases {
+		buf := new(bytes.Buffer)
+		cmd := newSecretInspectCommand(
+			test.NewFakeCli(&fakeClient{
+				secretInspectFunc: tc.secretInspectFunc,
+			}, buf),
+		)
+		cmd.SetArgs(tc.args)
+		cmd.Flags().Set("format", tc.format)
+		assert.NilError(t, cmd.Execute())
+		actual := buf.String()
+		expected := golden.Get(t, []byte(actual), fmt.Sprintf("secret-inspect-with-format.%s.golden", tc.name))
+		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	}
+}

cli/command/secret/ls.go

@@ -16,7 +16,7 @@ type listOptions struct {
 	filter opts.FilterOpt
 }
 
-func newSecretListCommand(dockerCli *command.DockerCli) *cobra.Command {
+func newSecretListCommand(dockerCli command.Cli) *cobra.Command {
 	opts := listOptions{filter: opts.NewFilterOpt()}
 
 	cmd := &cobra.Command{
@@ -37,7 +37,7 @@ func newSecretListCommand(dockerCli *command.DockerCli) *cobra.Command {
 	return cmd
 }
 
-func runSecretList(dockerCli *command.DockerCli, opts listOptions) error {
+func runSecretList(dockerCli command.Cli, opts listOptions) error {
 	client := dockerCli.Client()
 	ctx := context.Background()