2018-02-15 11:58:17 -05:00
|
|
|
package container
|
|
|
|
|
|
|
|
|
|
import (
|
linting: fmt.Errorf can be replaced with errors.New (perfsprint)
internal/test/cli.go:175:14: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("no notary client available unless defined")
^
cli/command/cli.go:318:29: fmt.Errorf can be replaced with errors.New (perfsprint)
return docker.Endpoint{}, fmt.Errorf("no context store initialized")
^
cli/command/container/attach.go:161:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf(result.Error.Message)
^
cli/command/container/opts.go:577:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("--health-start-period cannot be negative")
^
cli/command/container/opts.go:580:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("--health-start-interval cannot be negative")
^
cli/command/container/stats.go:221:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("filtering is not supported when specifying a list of containers")
^
cli/command/container/attach_test.go:82:17: fmt.Errorf can be replaced with errors.New (perfsprint)
expectedErr = fmt.Errorf("unexpected error")
^
cli/command/container/create_test.go:234:40: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.CreateResponse{}, fmt.Errorf("shouldn't try to pull image")
^
cli/command/container/list_test.go:150:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("error listing containers")
^
cli/command/container/rm_test.go:40:31: fmt.Errorf can be replaced with errors.New (perfsprint)
return errdefs.NotFound(fmt.Errorf("Error: no such container: " + container))
^
cli/command/container/run_test.go:138:40: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.CreateResponse{}, fmt.Errorf("shouldn't try to pull image")
^
cli/command/image/pull_test.go:115:49: fmt.Errorf can be replaced with errors.New (perfsprint)
return io.NopCloser(strings.NewReader("")), fmt.Errorf("shouldn't try to pull image")
^
cli/command/network/connect.go:88:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("invalid key/value pair format in driver options")
^
cli/command/plugin/create_test.go:96:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error creating plugin")
^
cli/command/plugin/disable_test.go:32:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error disabling plugin")
^
cli/command/plugin/enable_test.go:32:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("failed to enable plugin")
^
cli/command/plugin/inspect_test.go:55:22: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, nil, fmt.Errorf("error inspecting plugin")
^
cli/command/plugin/install_test.go:43:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("Error installing plugin")
^
cli/command/plugin/install_test.go:51:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("(image) when fetching")
^
cli/command/plugin/install_test.go:95:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("should not try to install plugin")
^
cli/command/plugin/list_test.go:35:41: fmt.Errorf can be replaced with errors.New (perfsprint)
return types.PluginsListResponse{}, fmt.Errorf("error listing plugins")
^
cli/command/plugin/remove_test.go:27:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error removing plugin")
^
cli/command/registry/login_test.go:36:46: fmt.Errorf can be replaced with errors.New (perfsprint)
return registrytypes.AuthenticateOKBody{}, fmt.Errorf("Invalid Username or Password")
^
cli/command/registry/login_test.go:44:46: fmt.Errorf can be replaced with errors.New (perfsprint)
return registrytypes.AuthenticateOKBody{}, fmt.Errorf(errUnknownUser)
^
cli/command/system/info.go:190:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("errors pretty printing info")
^
cli/command/system/prune.go:77:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf(`ERROR: The "until" filter is not supported with "--volumes"`)
^
cli/command/system/version_test.go:19:28: fmt.Errorf can be replaced with errors.New (perfsprint)
return types.Version{}, fmt.Errorf("no server")
^
cli/command/trust/key_load.go:112:22: fmt.Errorf can be replaced with errors.New (perfsprint)
return []byte{}, fmt.Errorf("could not decrypt key")
^
cli/command/trust/revoke.go:44:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("cannot use a digest reference for IMAGE:TAG")
^
cli/command/trust/revoke.go:105:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("no signed tags to remove")
^
cli/command/trust/signer_add.go:56:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("releases is a reserved keyword, please use a different signer name")
^
cli/command/trust/signer_add.go:60:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("path to a public key must be provided using the `--key` flag")
^
opts/config.go:71:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("source is required")
^
opts/mount.go:168:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("type is required")
^
opts/mount.go:172:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("target is required")
^
opts/network.go:90:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("network name/id is not specified")
^
opts/network.go:129:18: fmt.Errorf can be replaced with errors.New (perfsprint)
return "", "", fmt.Errorf("invalid key value pair format in driver options")
^
opts/opts.go:404:13: fmt.Errorf can be replaced with errors.New (perfsprint)
return 0, fmt.Errorf("value is too precise")
^
opts/opts.go:412:18: fmt.Errorf can be replaced with errors.New (perfsprint)
return "", "", fmt.Errorf("empty string specified for links")
^
opts/parse.go:84:37: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.RestartPolicy{}, fmt.Errorf("invalid restart policy format: no policy provided before colon")
^
opts/parse.go:89:38: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.RestartPolicy{}, fmt.Errorf("invalid restart policy format: maximum retry count must be an integer")
^
opts/port.go:105:13: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("hostip is not supported")
^
opts/secret.go:70:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("source is required")
^
opts/env_test.go:57:11: fmt.Errorf can be replaced with errors.New (perfsprint)
err: fmt.Errorf("invalid environment variable: =a"),
^
opts/env_test.go:93:11: fmt.Errorf can be replaced with errors.New (perfsprint)
err: fmt.Errorf("invalid environment variable: ="),
^
cli-plugins/manager/error_test.go:16:11: fmt.Errorf can be replaced with errors.New (perfsprint)
inner := fmt.Errorf("testing")
^
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
2024-06-10 14:47:07 -04:00
|
|
|
"errors"
|
2022-02-25 07:05:59 -05:00
|
|
|
"io"
|
2018-02-15 11:58:17 -05:00
|
|
|
"testing"
|
|
|
|
|
|
|
|
|
|
"github.com/docker/cli/cli/config/configfile"
|
|
|
|
|
"github.com/docker/cli/internal/test"
|
2023-10-23 08:51:01 -04:00
|
|
|
"github.com/docker/cli/internal/test/builders"
|
2019-12-20 08:57:54 -05:00
|
|
|
"github.com/docker/cli/opts"
|
2018-02-15 11:58:17 -05:00
|
|
|
"github.com/docker/docker/api/types"
|
2023-10-13 14:34:32 -04:00
|
|
|
"github.com/docker/docker/api/types/container"
|
2020-02-22 12:12:14 -05:00
|
|
|
"gotest.tools/v3/assert"
|
|
|
|
|
is "gotest.tools/v3/assert/cmp"
|
|
|
|
|
"gotest.tools/v3/golden"
|
2018-02-15 11:58:17 -05:00
|
|
|
)
|
|
|
|
|
|
2019-12-20 08:57:54 -05:00
|
|
|
func TestContainerListBuildContainerListOptions(t *testing.T) {
|
|
|
|
|
filters := opts.NewFilterOpt()
|
|
|
|
|
assert.NilError(t, filters.Set("foo=bar"))
|
|
|
|
|
assert.NilError(t, filters.Set("baz=foo"))
|
|
|
|
|
|
|
|
|
|
contexts := []struct {
|
|
|
|
|
psOpts *psOptions
|
|
|
|
|
expectedAll bool
|
|
|
|
|
expectedSize bool
|
|
|
|
|
expectedLimit int
|
|
|
|
|
expectedFilters map[string]string
|
|
|
|
|
}{
|
|
|
|
|
{
|
|
|
|
|
psOpts: &psOptions{
|
|
|
|
|
all: true,
|
|
|
|
|
size: true,
|
|
|
|
|
last: 5,
|
|
|
|
|
filter: filters,
|
|
|
|
|
},
|
|
|
|
|
expectedAll: true,
|
|
|
|
|
expectedSize: true,
|
|
|
|
|
expectedLimit: 5,
|
|
|
|
|
expectedFilters: map[string]string{
|
|
|
|
|
"foo": "bar",
|
|
|
|
|
"baz": "foo",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
psOpts: &psOptions{
|
|
|
|
|
all: true,
|
|
|
|
|
size: true,
|
|
|
|
|
last: -1,
|
|
|
|
|
nLatest: true,
|
|
|
|
|
},
|
|
|
|
|
expectedAll: true,
|
|
|
|
|
expectedSize: true,
|
|
|
|
|
expectedLimit: 1,
|
|
|
|
|
expectedFilters: make(map[string]string),
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
psOpts: &psOptions{
|
|
|
|
|
all: true,
|
|
|
|
|
size: false,
|
|
|
|
|
last: 5,
|
|
|
|
|
filter: filters,
|
|
|
|
|
// With .Size, size should be true
|
|
|
|
|
format: "{{.Size}}",
|
|
|
|
|
},
|
|
|
|
|
expectedAll: true,
|
|
|
|
|
expectedSize: true,
|
|
|
|
|
expectedLimit: 5,
|
|
|
|
|
expectedFilters: map[string]string{
|
|
|
|
|
"foo": "bar",
|
|
|
|
|
"baz": "foo",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
psOpts: &psOptions{
|
|
|
|
|
all: true,
|
|
|
|
|
size: false,
|
|
|
|
|
last: 5,
|
|
|
|
|
filter: filters,
|
|
|
|
|
// With .Size, size should be true
|
2019-12-24 10:30:23 -05:00
|
|
|
format: "{{.Size}} {{.CreatedAt}} {{upper .Networks}}",
|
2019-12-20 08:57:54 -05:00
|
|
|
},
|
|
|
|
|
expectedAll: true,
|
|
|
|
|
expectedSize: true,
|
|
|
|
|
expectedLimit: 5,
|
|
|
|
|
expectedFilters: map[string]string{
|
|
|
|
|
"foo": "bar",
|
|
|
|
|
"baz": "foo",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
psOpts: &psOptions{
|
|
|
|
|
all: true,
|
|
|
|
|
size: false,
|
|
|
|
|
last: 5,
|
|
|
|
|
filter: filters,
|
|
|
|
|
// Without .Size, size should be false
|
|
|
|
|
format: "{{.CreatedAt}} {{.Networks}}",
|
|
|
|
|
},
|
|
|
|
|
expectedAll: true,
|
|
|
|
|
expectedSize: false,
|
|
|
|
|
expectedLimit: 5,
|
|
|
|
|
expectedFilters: map[string]string{
|
|
|
|
|
"foo": "bar",
|
|
|
|
|
"baz": "foo",
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for _, c := range contexts {
|
|
|
|
|
options, err := buildContainerListOptions(c.psOpts)
|
|
|
|
|
assert.NilError(t, err)
|
|
|
|
|
|
|
|
|
|
assert.Check(t, is.Equal(c.expectedAll, options.All))
|
|
|
|
|
assert.Check(t, is.Equal(c.expectedSize, options.Size))
|
|
|
|
|
assert.Check(t, is.Equal(c.expectedLimit, options.Limit))
|
|
|
|
|
assert.Check(t, is.Equal(len(c.expectedFilters), options.Filters.Len()))
|
|
|
|
|
|
|
|
|
|
for k, v := range c.expectedFilters {
|
|
|
|
|
f := options.Filters
|
|
|
|
|
if !f.ExactMatch(k, v) {
|
|
|
|
|
t.Fatalf("Expected filter with key %s to be %s but got %s", k, v, f.Get(k))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-15 11:58:17 -05:00
|
|
|
func TestContainerListErrors(t *testing.T) {
|
|
|
|
|
testCases := []struct {
|
|
|
|
|
flags map[string]string
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc func(container.ListOptions) ([]types.Container, error)
|
2018-02-15 11:58:17 -05:00
|
|
|
expectedError string
|
|
|
|
|
}{
|
|
|
|
|
{
|
|
|
|
|
flags: map[string]string{
|
|
|
|
|
"format": "{{invalid}}",
|
|
|
|
|
},
|
|
|
|
|
expectedError: `function "invalid" not defined`,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
flags: map[string]string{
|
|
|
|
|
"format": "{{join}}",
|
|
|
|
|
},
|
|
|
|
|
expectedError: `wrong number of args for join`,
|
|
|
|
|
},
|
|
|
|
|
{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(_ container.ListOptions) ([]types.Container, error) {
|
linting: fmt.Errorf can be replaced with errors.New (perfsprint)
internal/test/cli.go:175:14: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("no notary client available unless defined")
^
cli/command/cli.go:318:29: fmt.Errorf can be replaced with errors.New (perfsprint)
return docker.Endpoint{}, fmt.Errorf("no context store initialized")
^
cli/command/container/attach.go:161:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf(result.Error.Message)
^
cli/command/container/opts.go:577:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("--health-start-period cannot be negative")
^
cli/command/container/opts.go:580:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("--health-start-interval cannot be negative")
^
cli/command/container/stats.go:221:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("filtering is not supported when specifying a list of containers")
^
cli/command/container/attach_test.go:82:17: fmt.Errorf can be replaced with errors.New (perfsprint)
expectedErr = fmt.Errorf("unexpected error")
^
cli/command/container/create_test.go:234:40: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.CreateResponse{}, fmt.Errorf("shouldn't try to pull image")
^
cli/command/container/list_test.go:150:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("error listing containers")
^
cli/command/container/rm_test.go:40:31: fmt.Errorf can be replaced with errors.New (perfsprint)
return errdefs.NotFound(fmt.Errorf("Error: no such container: " + container))
^
cli/command/container/run_test.go:138:40: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.CreateResponse{}, fmt.Errorf("shouldn't try to pull image")
^
cli/command/image/pull_test.go:115:49: fmt.Errorf can be replaced with errors.New (perfsprint)
return io.NopCloser(strings.NewReader("")), fmt.Errorf("shouldn't try to pull image")
^
cli/command/network/connect.go:88:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("invalid key/value pair format in driver options")
^
cli/command/plugin/create_test.go:96:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error creating plugin")
^
cli/command/plugin/disable_test.go:32:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error disabling plugin")
^
cli/command/plugin/enable_test.go:32:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("failed to enable plugin")
^
cli/command/plugin/inspect_test.go:55:22: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, nil, fmt.Errorf("error inspecting plugin")
^
cli/command/plugin/install_test.go:43:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("Error installing plugin")
^
cli/command/plugin/install_test.go:51:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("(image) when fetching")
^
cli/command/plugin/install_test.go:95:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("should not try to install plugin")
^
cli/command/plugin/list_test.go:35:41: fmt.Errorf can be replaced with errors.New (perfsprint)
return types.PluginsListResponse{}, fmt.Errorf("error listing plugins")
^
cli/command/plugin/remove_test.go:27:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error removing plugin")
^
cli/command/registry/login_test.go:36:46: fmt.Errorf can be replaced with errors.New (perfsprint)
return registrytypes.AuthenticateOKBody{}, fmt.Errorf("Invalid Username or Password")
^
cli/command/registry/login_test.go:44:46: fmt.Errorf can be replaced with errors.New (perfsprint)
return registrytypes.AuthenticateOKBody{}, fmt.Errorf(errUnknownUser)
^
cli/command/system/info.go:190:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("errors pretty printing info")
^
cli/command/system/prune.go:77:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf(`ERROR: The "until" filter is not supported with "--volumes"`)
^
cli/command/system/version_test.go:19:28: fmt.Errorf can be replaced with errors.New (perfsprint)
return types.Version{}, fmt.Errorf("no server")
^
cli/command/trust/key_load.go:112:22: fmt.Errorf can be replaced with errors.New (perfsprint)
return []byte{}, fmt.Errorf("could not decrypt key")
^
cli/command/trust/revoke.go:44:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("cannot use a digest reference for IMAGE:TAG")
^
cli/command/trust/revoke.go:105:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("no signed tags to remove")
^
cli/command/trust/signer_add.go:56:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("releases is a reserved keyword, please use a different signer name")
^
cli/command/trust/signer_add.go:60:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("path to a public key must be provided using the `--key` flag")
^
opts/config.go:71:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("source is required")
^
opts/mount.go:168:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("type is required")
^
opts/mount.go:172:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("target is required")
^
opts/network.go:90:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("network name/id is not specified")
^
opts/network.go:129:18: fmt.Errorf can be replaced with errors.New (perfsprint)
return "", "", fmt.Errorf("invalid key value pair format in driver options")
^
opts/opts.go:404:13: fmt.Errorf can be replaced with errors.New (perfsprint)
return 0, fmt.Errorf("value is too precise")
^
opts/opts.go:412:18: fmt.Errorf can be replaced with errors.New (perfsprint)
return "", "", fmt.Errorf("empty string specified for links")
^
opts/parse.go:84:37: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.RestartPolicy{}, fmt.Errorf("invalid restart policy format: no policy provided before colon")
^
opts/parse.go:89:38: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.RestartPolicy{}, fmt.Errorf("invalid restart policy format: maximum retry count must be an integer")
^
opts/port.go:105:13: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("hostip is not supported")
^
opts/secret.go:70:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("source is required")
^
opts/env_test.go:57:11: fmt.Errorf can be replaced with errors.New (perfsprint)
err: fmt.Errorf("invalid environment variable: =a"),
^
opts/env_test.go:93:11: fmt.Errorf can be replaced with errors.New (perfsprint)
err: fmt.Errorf("invalid environment variable: ="),
^
cli-plugins/manager/error_test.go:16:11: fmt.Errorf can be replaced with errors.New (perfsprint)
inner := fmt.Errorf("testing")
^
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
2024-06-10 14:47:07 -04:00
|
|
|
return nil, errors.New("error listing containers")
|
2018-02-15 11:58:17 -05:00
|
|
|
},
|
|
|
|
|
expectedError: "error listing containers",
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
for _, tc := range testCases {
|
|
|
|
|
cmd := newListCommand(
|
|
|
|
|
test.NewFakeCli(&fakeClient{
|
|
|
|
|
containerListFunc: tc.containerListFunc,
|
|
|
|
|
}),
|
|
|
|
|
)
|
|
|
|
|
for key, value := range tc.flags {
|
2023-10-23 08:51:01 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set(key, value))
|
2018-02-15 11:58:17 -05:00
|
|
|
}
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
2022-02-25 07:05:59 -05:00
|
|
|
cmd.SetOut(io.Discard)
|
test spring-cleaning
This makes a quick pass through our tests;
Discard output/err
----------------------------------------------
Many tests were testing for error-conditions, but didn't discard output.
This produced a lot of noise when running the tests, and made it hard
to discover if there were actual failures, or if the output was expected.
For example:
=== RUN TestConfigCreateErrors
Error: "create" requires exactly 2 arguments.
See 'create --help'.
Usage: create [OPTIONS] CONFIG file|- [flags]
Create a config from a file or STDIN
Error: "create" requires exactly 2 arguments.
See 'create --help'.
Usage: create [OPTIONS] CONFIG file|- [flags]
Create a config from a file or STDIN
Error: error creating config
--- PASS: TestConfigCreateErrors (0.00s)
And after discarding output:
=== RUN TestConfigCreateErrors
--- PASS: TestConfigCreateErrors (0.00s)
Use sub-tests where possible
----------------------------------------------
Some tests were already set-up to use test-tables, and even had a usable
name (or in some cases "error" to check for). Change them to actual sub-
tests. Same test as above, but now with sub-tests and output discarded:
=== RUN TestConfigCreateErrors
=== RUN TestConfigCreateErrors/requires_exactly_2_arguments
=== RUN TestConfigCreateErrors/requires_exactly_2_arguments#01
=== RUN TestConfigCreateErrors/error_creating_config
--- PASS: TestConfigCreateErrors (0.00s)
--- PASS: TestConfigCreateErrors/requires_exactly_2_arguments (0.00s)
--- PASS: TestConfigCreateErrors/requires_exactly_2_arguments#01 (0.00s)
--- PASS: TestConfigCreateErrors/error_creating_config (0.00s)
PASS
It's not perfect in all cases (in the above, there's duplicate "expected"
errors, but Go conveniently adds "#01" for the duplicate). There's probably
also various tests I missed that could still use the same changes applied;
we can improve these in follow-ups.
Set cmd.Args to prevent test-failures
----------------------------------------------
When running tests from my IDE, it compiles the tests before running,
then executes the compiled binary to run the tests. Cobra doesn't like
that, because in that situation `os.Args` is taken as argument for the
command that's executed. The command that's tested now sees the test-
flags as arguments (`-test.v -test.run ..`), which causes various tests
to fail ("Command XYZ does not accept arguments").
# compile the tests:
go test -c -o foo.test
# execute the test:
./foo.test -test.v -test.run TestFoo
=== RUN TestFoo
Error: "foo" accepts no arguments.
The Cobra maintainers ran into the same situation, and for their own
use have added a special case to ignore `os.Args` in these cases;
https://github.com/spf13/cobra/blob/v1.8.1/command.go#L1078-L1083
args := c.args
// Workaround FAIL with "go test -v" or "cobra.test -test.v", see #155
if c.args == nil && filepath.Base(os.Args[0]) != "cobra.test" {
args = os.Args[1:]
}
Unfortunately, that exception is too specific (only checks for `cobra.test`),
so doesn't automatically fix the issue for other test-binaries. They did
provide a `cmd.SetArgs()` utility for this purpose
https://github.com/spf13/cobra/blob/v1.8.1/command.go#L276-L280
// SetArgs sets arguments for the command. It is set to os.Args[1:] by default, if desired, can be overridden
// particularly useful when testing.
func (c *Command) SetArgs(a []string) {
c.args = a
}
And the fix is to explicitly set the command's args to an empty slice to
prevent Cobra from falling back to using `os.Args[1:]` as arguments.
cmd := newSomeThingCommand()
cmd.SetArgs([]string{})
Some tests already take this issue into account, and I updated some tests
for this, but there's likely many other ones that can use the same treatment.
Perhaps the Cobra maintainers would accept a contribution to make their
condition less specific and to look for binaries ending with a `.test`
suffix (which is what compiled binaries usually are named as).
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
(cherry picked from commit ab230240ad44fdffa03558a3dbb47971f6336911)
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
2024-07-03 19:29:04 -04:00
|
|
|
cmd.SetErr(io.Discard)
|
2018-03-06 14:03:47 -05:00
|
|
|
assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
|
2018-02-15 11:58:17 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContainerListWithoutFormat(t *testing.T) {
|
|
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(_ container.ListOptions) ([]types.Container, error) {
|
2018-02-15 11:58:17 -05:00
|
|
|
return []types.Container{
|
2023-10-23 08:51:01 -04:00
|
|
|
*builders.Container("c1"),
|
|
|
|
|
*builders.Container("c2", builders.WithName("foo")),
|
|
|
|
|
*builders.Container("c3", builders.WithPort(80, 80, builders.TCP), builders.WithPort(81, 81, builders.TCP), builders.WithPort(82, 82, builders.TCP)),
|
|
|
|
|
*builders.Container("c4", builders.WithPort(81, 81, builders.UDP)),
|
|
|
|
|
*builders.Container("c5", builders.WithPort(82, 82, builders.IP("8.8.8.8"), builders.TCP)),
|
2018-02-15 11:58:17 -05:00
|
|
|
}, nil
|
|
|
|
|
},
|
|
|
|
|
})
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2018-03-06 15:13:00 -05:00
|
|
|
assert.NilError(t, cmd.Execute())
|
2018-02-15 11:58:17 -05:00
|
|
|
golden.Assert(t, cli.OutBuffer().String(), "container-list-without-format.golden")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContainerListNoTrunc(t *testing.T) {
|
|
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(_ container.ListOptions) ([]types.Container, error) {
|
2018-02-15 11:58:17 -05:00
|
|
|
return []types.Container{
|
2023-10-23 08:51:01 -04:00
|
|
|
*builders.Container("c1"),
|
|
|
|
|
*builders.Container("c2", builders.WithName("foo/bar")),
|
2018-02-15 11:58:17 -05:00
|
|
|
}, nil
|
|
|
|
|
},
|
|
|
|
|
})
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2023-10-23 08:51:01 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set("no-trunc", "true"))
|
2018-03-06 15:13:00 -05:00
|
|
|
assert.NilError(t, cmd.Execute())
|
2018-02-15 11:58:17 -05:00
|
|
|
golden.Assert(t, cli.OutBuffer().String(), "container-list-without-format-no-trunc.golden")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Test for GitHub issue docker/docker#21772
|
|
|
|
|
func TestContainerListNamesMultipleTime(t *testing.T) {
|
|
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(_ container.ListOptions) ([]types.Container, error) {
|
2018-02-15 11:58:17 -05:00
|
|
|
return []types.Container{
|
2023-10-23 08:51:01 -04:00
|
|
|
*builders.Container("c1"),
|
|
|
|
|
*builders.Container("c2", builders.WithName("foo/bar")),
|
2018-02-15 11:58:17 -05:00
|
|
|
}, nil
|
|
|
|
|
},
|
|
|
|
|
})
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2023-10-23 08:51:01 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set("format", "{{.Names}} {{.Names}}"))
|
2018-03-06 15:13:00 -05:00
|
|
|
assert.NilError(t, cmd.Execute())
|
2018-02-15 11:58:17 -05:00
|
|
|
golden.Assert(t, cli.OutBuffer().String(), "container-list-format-name-name.golden")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Test for GitHub issue docker/docker#30291
|
|
|
|
|
func TestContainerListFormatTemplateWithArg(t *testing.T) {
|
|
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(_ container.ListOptions) ([]types.Container, error) {
|
2018-02-15 11:58:17 -05:00
|
|
|
return []types.Container{
|
2023-10-23 08:51:01 -04:00
|
|
|
*builders.Container("c1", builders.WithLabel("some.label", "value")),
|
|
|
|
|
*builders.Container("c2", builders.WithName("foo/bar"), builders.WithLabel("foo", "bar")),
|
2018-02-15 11:58:17 -05:00
|
|
|
}, nil
|
|
|
|
|
},
|
|
|
|
|
})
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2023-10-23 08:51:01 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set("format", `{{.Names}} {{.Label "some.label"}}`))
|
2018-03-06 15:13:00 -05:00
|
|
|
assert.NilError(t, cmd.Execute())
|
2018-02-15 11:58:17 -05:00
|
|
|
golden.Assert(t, cli.OutBuffer().String(), "container-list-format-with-arg.golden")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContainerListFormatSizeSetsOption(t *testing.T) {
|
2023-03-02 11:05:28 -05:00
|
|
|
tests := []struct {
|
|
|
|
|
doc, format, sizeFlag string
|
|
|
|
|
sizeExpected bool
|
|
|
|
|
}{
|
|
|
|
|
{
|
|
|
|
|
doc: "detect with all fields",
|
|
|
|
|
format: `{{json .}}`,
|
|
|
|
|
sizeExpected: true,
|
2018-02-15 11:58:17 -05:00
|
|
|
},
|
2023-03-02 11:05:28 -05:00
|
|
|
{
|
|
|
|
|
doc: "detect with explicit field",
|
|
|
|
|
format: `{{.Size}}`,
|
|
|
|
|
sizeExpected: true,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
doc: "detect no size",
|
|
|
|
|
format: `{{.Names}}`,
|
|
|
|
|
sizeExpected: false,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
doc: "override enable",
|
|
|
|
|
format: `{{.Names}}`,
|
|
|
|
|
sizeFlag: "true",
|
|
|
|
|
sizeExpected: true,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
doc: "override disable",
|
|
|
|
|
format: `{{.Size}}`,
|
|
|
|
|
sizeFlag: "false",
|
|
|
|
|
sizeExpected: false,
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for _, tc := range tests {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.doc, func(t *testing.T) {
|
|
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(options container.ListOptions) ([]types.Container, error) {
|
2023-03-02 11:05:28 -05:00
|
|
|
assert.Check(t, is.Equal(options.Size, tc.sizeExpected))
|
|
|
|
|
return []types.Container{}, nil
|
|
|
|
|
},
|
|
|
|
|
})
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2023-10-23 08:51:01 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set("format", tc.format))
|
2023-03-02 11:05:28 -05:00
|
|
|
if tc.sizeFlag != "" {
|
2023-10-23 08:51:01 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set("size", tc.sizeFlag))
|
2023-03-02 11:05:28 -05:00
|
|
|
}
|
|
|
|
|
assert.NilError(t, cmd.Execute())
|
|
|
|
|
})
|
|
|
|
|
}
|
2018-02-15 11:58:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContainerListWithConfigFormat(t *testing.T) {
|
|
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(_ container.ListOptions) ([]types.Container, error) {
|
2018-02-15 11:58:17 -05:00
|
|
|
return []types.Container{
|
2023-10-23 08:51:01 -04:00
|
|
|
*builders.Container("c1", builders.WithLabel("some.label", "value"), builders.WithSize(10700000)),
|
|
|
|
|
*builders.Container("c2", builders.WithName("foo/bar"), builders.WithLabel("foo", "bar"), builders.WithSize(3200000)),
|
2018-02-15 11:58:17 -05:00
|
|
|
}, nil
|
|
|
|
|
},
|
|
|
|
|
})
|
|
|
|
|
cli.SetConfigFile(&configfile.ConfigFile{
|
2022-05-30 21:33:19 -04:00
|
|
|
PsFormat: "{{ .Names }} {{ .Image }} {{ .Labels }} {{ .Size}}",
|
2018-02-15 11:58:17 -05:00
|
|
|
})
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2018-03-06 15:13:00 -05:00
|
|
|
assert.NilError(t, cmd.Execute())
|
2018-02-15 11:58:17 -05:00
|
|
|
golden.Assert(t, cli.OutBuffer().String(), "container-list-with-config-format.golden")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContainerListWithFormat(t *testing.T) {
|
|
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2023-10-13 14:34:32 -04:00
|
|
|
containerListFunc: func(_ container.ListOptions) ([]types.Container, error) {
|
2018-02-15 11:58:17 -05:00
|
|
|
return []types.Container{
|
2023-10-23 08:51:01 -04:00
|
|
|
*builders.Container("c1", builders.WithLabel("some.label", "value")),
|
|
|
|
|
*builders.Container("c2", builders.WithName("foo/bar"), builders.WithLabel("foo", "bar")),
|
2018-02-15 11:58:17 -05:00
|
|
|
}, nil
|
|
|
|
|
},
|
|
|
|
|
})
|
2022-06-07 04:14:31 -04:00
|
|
|
|
|
|
|
|
t.Run("with format", func(t *testing.T) {
|
|
|
|
|
cli.OutBuffer().Reset()
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2022-06-07 04:14:31 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set("format", "{{ .Names }} {{ .Image }} {{ .Labels }}"))
|
|
|
|
|
assert.NilError(t, cmd.Execute())
|
|
|
|
|
golden.Assert(t, cli.OutBuffer().String(), "container-list-with-format.golden")
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("with format and quiet", func(t *testing.T) {
|
|
|
|
|
cli.OutBuffer().Reset()
|
|
|
|
|
cmd := newListCommand(cli)
|
2024-10-13 12:45:20 -04:00
|
|
|
cmd.SetArgs([]string{})
|
|
|
|
|
cmd.SetOut(io.Discard)
|
|
|
|
|
cmd.SetErr(io.Discard)
|
2022-06-07 04:14:31 -04:00
|
|
|
assert.Check(t, cmd.Flags().Set("format", "{{ .Names }} {{ .Image }} {{ .Labels }}"))
|
|
|
|
|
assert.Check(t, cmd.Flags().Set("quiet", "true"))
|
|
|
|
|
assert.NilError(t, cmd.Execute())
|
2023-04-09 19:14:21 -04:00
|
|
|
assert.Equal(t, cli.ErrBuffer().String(), "WARNING: Ignoring custom format, because both --format and --quiet are set.\n")
|
2022-06-07 04:14:31 -04:00
|
|
|
golden.Assert(t, cli.OutBuffer().String(), "container-list-quiet.golden")
|
|
|
|
|
})
|
2018-02-15 11:58:17 -05:00
|
|
|
}
|
