DockerCLI/e2e/cli-plugins/flags_test.go

259 lines
6.6 KiB
Go

package cliplugins
import (
"os"
"testing"
"gotest.tools/icmd"
)
// TestRunGoodArgument ensures correct behaviour when running a valid plugin with an `--argument`.
func TestRunGoodArgument(t *testing.T) {
run, _, cleanup := prepare(t)
defer cleanup()
res := icmd.RunCmd(run("helloworld", "--who", "Cleveland"))
res.Assert(t, icmd.Expected{
ExitCode: 0,
Out: "Hello Cleveland!",
})
}
// TestClashWithGlobalArgs ensures correct behaviour when a plugin
// has an argument with the same name as one of the globals.
func TestClashWithGlobalArgs(t *testing.T) {
run, _, cleanup := prepare(t)
defer cleanup()
for _, tc := range []struct {
name string
args []string
expectedOut, expectedErr string
}{
{
name: "short-without-val",
args: []string{"-D"},
expectedOut: "Hello World!",
expectedErr: "Plugin debug mode enabled",
},
{
name: "long-without-val",
args: []string{"--debug"},
expectedOut: "Hello World!",
expectedErr: "Plugin debug mode enabled",
},
{
name: "short-with-val",
args: []string{"-c", "Christmas"},
expectedOut: "Merry Christmas!",
expectedErr: icmd.None,
},
{
name: "short-with-val",
args: []string{"--context", "Christmas"},
expectedOut: "Merry Christmas!",
expectedErr: icmd.None,
},
} {
t.Run(tc.name, func(t *testing.T) {
args := append([]string{"helloworld"}, tc.args...)
res := icmd.RunCmd(run(args...))
res.Assert(t, icmd.Expected{
ExitCode: 0,
Out: tc.expectedOut,
Err: tc.expectedErr,
})
})
}
}
// TestGlobalArgsOnlyParsedOnce checks that global args are only parsed
// once (cf https://github.com/docker/cli/issues/1801). These tests
// rely on `-H` being a list type (i.e. NewNamedListOptsRef) which
// reject multiple uses dynamically (see `getServerHost()` in
// github.com/docker/cli/cli/command/cli.go) in order to detect this
// scenario.
func TestGlobalArgsOnlyParsedOnce(t *testing.T) {
run, _, cleanup := prepare(t)
defer cleanup()
// We can rely on `$DOCKER_HOST` being set due to the call to
// `environment.Setup` in our `TestMain`.
dh := os.Getenv("DOCKER_HOST")
for _, tc := range []struct {
name string
args []string
expectedExitCode int
expectedOut, expectedErr string
}{
{
// This is checking the precondition wrt -H mentioned in the function comment
name: "fails-if-H-used-twice",
args: []string{"-H", dh, "-H", dh, "version", "-f", "{{.Client.Version}}"},
expectedExitCode: 1,
expectedOut: icmd.None,
expectedErr: "Please specify only one -H",
},
{
name: "builtin",
args: []string{"-H", dh, "version", "-f", "{{.Client.Version}}"},
expectedExitCode: 0,
expectedOut: "", // Will be the client version, but the specifics aren't important so long as stderr is empty.
expectedErr: icmd.None,
},
{
name: "plugin",
args: []string{"-H", dh, "helloworld", "apiversion"},
expectedExitCode: 0,
expectedOut: "", // Will be the client version, but the specifics aren't important so long as stderr is empty.
expectedErr: icmd.None,
},
} {
t.Run(tc.name, func(t *testing.T) {
res := icmd.RunCmd(run(tc.args...))
res.Assert(t, icmd.Expected{
ExitCode: tc.expectedExitCode,
Out: tc.expectedOut,
Err: tc.expectedErr,
})
})
}
}
// TestUnknownGlobal checks that unknown globals report errors
func TestUnknownGlobal(t *testing.T) {
run, _, cleanup := prepare(t)
defer cleanup()
for name, args := range map[string][]string{
"no-val": {"--unknown", "helloworld"},
"separate-val": {"--unknown", "foo", "helloworld"},
"joined-val": {"--unknown=foo", "helloworld"},
} {
t.Run(name, func(t *testing.T) {
res := icmd.RunCmd(run(args...))
res.Assert(t, icmd.Expected{
ExitCode: 125,
Out: icmd.None,
Err: "unknown flag: --unknown",
})
})
}
}
// TestCliPluginsVersion checks that `-v` and friends DTRT
func TestCliPluginsVersion(t *testing.T) {
run, _, cleanup := prepare(t)
defer cleanup()
for _, tc := range []struct {
name string
args []string
expCode int
expOut, expErr string
}{
{
name: "global-version",
args: []string{"version"},
expCode: 0,
expOut: "Client:\n Version:",
expErr: icmd.None,
},
{
name: "global-version-flag",
args: []string{"--version"},
expCode: 0,
expOut: "Docker version",
expErr: icmd.None,
},
{
name: "global-short-version-flag",
args: []string{"-v"},
expCode: 0,
expOut: "Docker version",
expErr: icmd.None,
},
{
name: "global-with-unknown-arg",
args: []string{"version", "foo"},
expCode: 1,
expOut: icmd.None,
expErr: `"docker version" accepts no arguments.`,
},
{
name: "global-with-plugin-arg",
args: []string{"version", "helloworld"},
expCode: 1,
expOut: icmd.None,
expErr: `"docker version" accepts no arguments.`,
},
{
name: "global-version-flag-with-unknown-arg",
args: []string{"--version", "foo"},
expCode: 0,
expOut: "Docker version",
expErr: icmd.None,
},
{
name: "global-short-version-flag-with-unknown-arg",
args: []string{"-v", "foo"},
expCode: 0,
expOut: "Docker version",
expErr: icmd.None,
},
{
name: "global-version-flag-with-plugin",
args: []string{"--version", "helloworld"},
expCode: 125,
expOut: icmd.None,
expErr: "unknown flag: --version",
},
{
name: "global-short-version-flag-with-plugin",
args: []string{"-v", "helloworld"},
expCode: 125,
expOut: icmd.None,
expErr: "unknown shorthand flag: 'v' in -v",
},
{
name: "plugin-with-version",
args: []string{"helloworld", "version"},
expCode: 0,
expOut: "Hello World!",
expErr: icmd.None,
},
{
name: "plugin-with-version-flag",
args: []string{"helloworld", "--version"},
expCode: 125,
expOut: icmd.None,
expErr: "unknown flag: --version",
},
{
name: "plugin-with-short-version-flag",
args: []string{"helloworld", "-v"},
expCode: 125,
expOut: icmd.None,
expErr: "unknown shorthand flag: 'v' in -v",
},
{
name: "",
args: []string{},
expCode: 0,
expOut: "",
expErr: "",
},
} {
t.Run(tc.name, func(t *testing.T) {
res := icmd.RunCmd(run(tc.args...))
res.Assert(t, icmd.Expected{
ExitCode: tc.expCode,
Out: tc.expOut,
Err: tc.expErr,
})
})
}
}