add tests to plugin create/remove/enable/disable commands. Part of wo…

…rk on docker#37

Signed-off-by: Arash Deshmeh <adeshmeh@ca.ibm.com>

cli/command/plugin/client_test.go

@@ -0,0 +1,45 @@
+package plugin
+
+import (
+	"io"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
+	"golang.org/x/net/context"
+)
+
+type fakeClient struct {
+	client.Client
+	pluginCreateFunc  func(createContext io.Reader, createOptions types.PluginCreateOptions) error
+	pluginDisableFunc func(name string, disableOptions types.PluginDisableOptions) error
+	pluginEnableFunc  func(name string, options types.PluginEnableOptions) error
+	pluginRemoveFunc  func(name string, options types.PluginRemoveOptions) error
+}
+
+func (c *fakeClient) PluginCreate(ctx context.Context, createContext io.Reader, createOptions types.PluginCreateOptions) error {
+	if c.pluginCreateFunc != nil {
+		return c.pluginCreateFunc(createContext, createOptions)
+	}
+	return nil
+}
+
+func (c *fakeClient) PluginEnable(ctx context.Context, name string, enableOptions types.PluginEnableOptions) error {
+	if c.pluginEnableFunc != nil {
+		return c.pluginEnableFunc(name, enableOptions)
+	}
+	return nil
+}
+
+func (c *fakeClient) PluginDisable(context context.Context, name string, disableOptions types.PluginDisableOptions) error {
+	if c.pluginDisableFunc != nil {
+		return c.pluginDisableFunc(name, disableOptions)
+	}
+	return nil
+}
+
+func (c *fakeClient) PluginRemove(context context.Context, name string, removeOptions types.PluginRemoveOptions) error {
+	if c.pluginRemoveFunc != nil {
+		return c.pluginRemoveFunc(name, removeOptions)
+	}
+	return nil
+}

cli/command/plugin/create_test.go

@@ -0,0 +1,150 @@
+package plugin
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
+	"github.com/docker/docker/api/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateErrors(t *testing.T) {
+
+	testCases := []struct {
+		args          []string
+		expectedError string
+	}{
+		{
+			args:          []string{},
+			expectedError: "requires at least 2 arguments",
+		},
+		{
+			args:          []string{"INVALID_TAG", "context-dir"},
+			expectedError: "invalid",
+		},
+		{
+			args:          []string{"plugin-foo", "nonexistent_context_dir"},
+			expectedError: "no such file or directory",
+		},
+	}
+
+	for _, tc := range testCases {
+		cli := test.NewFakeCli(&fakeClient{})
+		cmd := newCreateCommand(cli)
+		cmd.SetArgs(tc.args)
+		cmd.SetOutput(ioutil.Discard)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
+	}
+}
+
+func TestCreateErrorOnFileAsContextDir(t *testing.T) {
+	tmpFile, err := ioutil.TempFile("", "file-as-context-dir")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	cli := test.NewFakeCli(&fakeClient{})
+	cmd := newCreateCommand(cli)
+	cmd.SetArgs([]string{"plugin-foo", tmpFile.Name()})
+	cmd.SetOutput(ioutil.Discard)
+	testutil.ErrorContains(t, cmd.Execute(), "context must be a directory")
+}
+
+func TestCreateErrorOnContextDirWithoutConfig(t *testing.T) {
+	tmpDir, err := ioutil.TempDir("", "plugin-create-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	cli := test.NewFakeCli(&fakeClient{})
+	cmd := newCreateCommand(cli)
+	cmd.SetArgs([]string{"plugin-foo", tmpDir})
+	cmd.SetOutput(ioutil.Discard)
+	testutil.ErrorContains(t, cmd.Execute(), "config.json: no such file or directory")
+}
+
+func TestCreateErrorOnInvalidConfig(t *testing.T) {
+	tmpDir, err := ioutil.TempDir("", "plugin-create-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	err = setupPluginDir(tmpDir, []byte("invalid-config-contents"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cli := test.NewFakeCli(&fakeClient{})
+	cmd := newCreateCommand(cli)
+	cmd.SetArgs([]string{"plugin-foo", tmpDir})
+	cmd.SetOutput(ioutil.Discard)
+	testutil.ErrorContains(t, cmd.Execute(), "invalid")
+}
+
+func TestCreateErrorFromDaemon(t *testing.T) {
+	tmpDir, err := ioutil.TempDir("", "plugin-create-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	err = setupPluginDir(tmpDir, []byte(`{ "Name": "plugin-foo" }`))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cli := test.NewFakeCli(&fakeClient{
+		pluginCreateFunc: func(createContext io.Reader, createOptions types.PluginCreateOptions) error {
+			return fmt.Errorf("Error creating plugin")
+		},
+	})
+
+	cmd := newCreateCommand(cli)
+	cmd.SetArgs([]string{"plugin-foo", tmpDir})
+	cmd.SetOutput(ioutil.Discard)
+	testutil.ErrorContains(t, cmd.Execute(), "Error creating plugin")
+}
+
+func setupPluginDir(dir string, data []byte) error {
+	rootfs := filepath.Join(dir, "rootfs")
+	if err := os.Mkdir(rootfs, 0600); err != nil {
+		return err
+	}
+
+	configFile := filepath.Join(dir, "config.json")
+	return ioutil.WriteFile(configFile, data, 0600)
+}
+
+func TestCreatePlugin(t *testing.T) {
+	tmpDir, err := ioutil.TempDir("", "plugin-create-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	err = setupPluginDir(tmpDir, []byte(`{ "Name": "plugin-foo" }`))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cli := test.NewFakeCli(&fakeClient{
+		pluginCreateFunc: func(createContext io.Reader, createOptions types.PluginCreateOptions) error {
+			return nil
+		},
+	})
+
+	cmd := newCreateCommand(cli)
+	cmd.SetArgs([]string{"plugin-foo", tmpDir})
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "plugin-foo", strings.TrimSpace(cli.OutBuffer().String()))
+}

cli/command/plugin/disable_test.go

@@ -0,0 +1,59 @@
+package plugin
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strings"
+	"testing"
+
+	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
+	"github.com/docker/docker/api/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPluginDisableErrors(t *testing.T) {
+	testCases := []struct {
+		args              []string
+		expectedError     string
+		pluginDisableFunc func(name string, disableOptions types.PluginDisableOptions) error
+	}{
+		{
+			args:          []string{},
+			expectedError: "requires exactly 1 argument",
+		},
+		{
+			args:          []string{"too", "many", "arguments"},
+			expectedError: "requires exactly 1 argument",
+		},
+		{
+			args:          []string{"plugin-foo"},
+			expectedError: "Error disabling plugin",
+			pluginDisableFunc: func(name string, disableOptions types.PluginDisableOptions) error {
+				return fmt.Errorf("Error disabling plugin")
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		cmd := newDisableCommand(
+			test.NewFakeCli(&fakeClient{
+				pluginDisableFunc: tc.pluginDisableFunc,
+			}))
+		cmd.SetArgs(tc.args)
+		cmd.SetOutput(ioutil.Discard)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
+	}
+}
+
+func TestPluginDisable(t *testing.T) {
+	cli := test.NewFakeCli(&fakeClient{
+		pluginDisableFunc: func(name string, disableOptions types.PluginDisableOptions) error {
+			return nil
+		},
+	})
+	cmd := newDisableCommand(cli)
+	cmd.SetArgs([]string{"plugin-foo"})
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "plugin-foo", strings.TrimSpace(cli.OutBuffer().String()))
+}

cli/command/plugin/enable_test.go

@@ -0,0 +1,71 @@
+package plugin
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strings"
+	"testing"
+
+	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
+	"github.com/docker/docker/api/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPluginEnableErrors(t *testing.T) {
+	testCases := []struct {
+		args             []string
+		flags            map[string]string
+		pluginEnableFunc func(name string, options types.PluginEnableOptions) error
+		expectedError    string
+	}{
+		{
+			args:          []string{},
+			expectedError: "requires exactly 1 argument",
+		},
+		{
+			args:          []string{"too-many", "arguments"},
+			expectedError: "requires exactly 1 argument",
+		},
+		{
+			args: []string{"plugin-foo"},
+			pluginEnableFunc: func(name string, options types.PluginEnableOptions) error {
+				return fmt.Errorf("failed to enable plugin")
+			},
+			expectedError: "failed to enable plugin",
+		},
+		{
+			args: []string{"plugin-foo"},
+			flags: map[string]string{
+				"timeout": "-1",
+			},
+			expectedError: "negative timeout -1 is invalid",
+		},
+	}
+
+	for _, tc := range testCases {
+		cmd := newEnableCommand(
+			test.NewFakeCli(&fakeClient{
+				pluginEnableFunc: tc.pluginEnableFunc,
+			}))
+		cmd.SetArgs(tc.args)
+		for key, value := range tc.flags {
+			cmd.Flags().Set(key, value)
+		}
+		cmd.SetOutput(ioutil.Discard)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
+	}
+}
+
+func TestPluginEnable(t *testing.T) {
+	cli := test.NewFakeCli(&fakeClient{
+		pluginEnableFunc: func(name string, options types.PluginEnableOptions) error {
+			return nil
+		},
+	})
+
+	cmd := newEnableCommand(cli)
+	cmd.SetArgs([]string{"plugin-foo"})
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "plugin-foo", strings.TrimSpace(cli.OutBuffer().String()))
+}