2017-10-30 17:52:08 -04:00
|
|
|
package container
|
|
|
|
|
|
|
|
import (
|
2023-09-09 18:27:44 -04:00
|
|
|
"context"
|
2017-10-30 17:52:08 -04:00
|
|
|
"io"
|
2018-02-27 16:38:02 -05:00
|
|
|
"os"
|
2017-10-30 17:52:08 -04:00
|
|
|
"runtime"
|
|
|
|
"strings"
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
"github.com/docker/cli/internal/test"
|
2024-06-09 07:54:37 -04:00
|
|
|
"github.com/docker/docker/api/types/container"
|
2017-10-30 17:52:08 -04:00
|
|
|
"github.com/docker/docker/pkg/archive"
|
2020-02-22 12:12:14 -05:00
|
|
|
"gotest.tools/v3/assert"
|
|
|
|
is "gotest.tools/v3/assert/cmp"
|
|
|
|
"gotest.tools/v3/fs"
|
|
|
|
"gotest.tools/v3/skip"
|
2017-10-30 17:52:08 -04:00
|
|
|
)
|
|
|
|
|
|
|
|
func TestRunCopyWithInvalidArguments(t *testing.T) {
|
2022-09-29 11:21:51 -04:00
|
|
|
testcases := []struct {
|
2017-10-30 17:52:08 -04:00
|
|
|
doc string
|
|
|
|
options copyOptions
|
|
|
|
expectedErr string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
doc: "copy between container",
|
|
|
|
options: copyOptions{
|
|
|
|
source: "first:/path",
|
|
|
|
destination: "second:/path",
|
|
|
|
},
|
|
|
|
expectedErr: "copying between containers is not supported",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
doc: "copy without a container",
|
|
|
|
options: copyOptions{
|
|
|
|
source: "./source",
|
|
|
|
destination: "./dest",
|
|
|
|
},
|
|
|
|
expectedErr: "must specify at least one container source",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
for _, testcase := range testcases {
|
|
|
|
t.Run(testcase.doc, func(t *testing.T) {
|
2023-09-09 18:27:44 -04:00
|
|
|
err := runCopy(context.TODO(), test.NewFakeCli(nil), testcase.options)
|
2018-03-06 15:54:24 -05:00
|
|
|
assert.Error(t, err, testcase.expectedErr)
|
2017-10-30 17:52:08 -04:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestRunCopyFromContainerToStdout(t *testing.T) {
|
|
|
|
tarContent := "the tar content"
|
|
|
|
|
2024-06-09 08:06:13 -04:00
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2024-06-09 07:54:37 -04:00
|
|
|
containerCopyFromFunc: func(ctr, srcPath string) (io.ReadCloser, container.PathStat, error) {
|
2024-06-09 08:06:13 -04:00
|
|
|
assert.Check(t, is.Equal("container", ctr))
|
2024-06-09 07:54:37 -04:00
|
|
|
return io.NopCloser(strings.NewReader(tarContent)), container.PathStat{}, nil
|
2017-10-30 17:52:08 -04:00
|
|
|
},
|
2024-06-09 08:06:13 -04:00
|
|
|
})
|
|
|
|
err := runCopy(context.TODO(), cli, copyOptions{
|
|
|
|
source: "container:/path",
|
|
|
|
destination: "-",
|
|
|
|
})
|
2018-03-05 18:53:52 -05:00
|
|
|
assert.NilError(t, err)
|
|
|
|
assert.Check(t, is.Equal(tarContent, cli.OutBuffer().String()))
|
|
|
|
assert.Check(t, is.Equal("", cli.ErrBuffer().String()))
|
2017-10-30 17:52:08 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestRunCopyFromContainerToFilesystem(t *testing.T) {
|
|
|
|
destDir := fs.NewDir(t, "cp-test",
|
|
|
|
fs.WithFile("file1", "content\n"))
|
|
|
|
defer destDir.Remove()
|
|
|
|
|
2024-06-09 08:06:13 -04:00
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2024-06-09 07:54:37 -04:00
|
|
|
containerCopyFromFunc: func(ctr, srcPath string) (io.ReadCloser, container.PathStat, error) {
|
2024-06-09 08:06:13 -04:00
|
|
|
assert.Check(t, is.Equal("container", ctr))
|
2017-10-30 17:52:08 -04:00
|
|
|
readCloser, err := archive.TarWithOptions(destDir.Path(), &archive.TarOptions{})
|
2024-06-09 07:54:37 -04:00
|
|
|
return readCloser, container.PathStat{}, err
|
2017-10-30 17:52:08 -04:00
|
|
|
},
|
2024-06-09 08:06:13 -04:00
|
|
|
})
|
|
|
|
err := runCopy(context.TODO(), cli, copyOptions{
|
|
|
|
source: "container:/path",
|
|
|
|
destination: destDir.Path(),
|
|
|
|
quiet: true,
|
|
|
|
})
|
2018-03-05 18:53:52 -05:00
|
|
|
assert.NilError(t, err)
|
|
|
|
assert.Check(t, is.Equal("", cli.OutBuffer().String()))
|
|
|
|
assert.Check(t, is.Equal("", cli.ErrBuffer().String()))
|
2017-10-30 17:52:08 -04:00
|
|
|
|
2022-02-25 07:05:59 -05:00
|
|
|
content, err := os.ReadFile(destDir.Join("file1"))
|
2018-03-05 18:53:52 -05:00
|
|
|
assert.NilError(t, err)
|
|
|
|
assert.Check(t, is.Equal("content\n", string(content)))
|
2017-10-30 17:52:08 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestRunCopyFromContainerToFilesystemMissingDestinationDirectory(t *testing.T) {
|
|
|
|
destDir := fs.NewDir(t, "cp-test",
|
|
|
|
fs.WithFile("file1", "content\n"))
|
|
|
|
defer destDir.Remove()
|
|
|
|
|
2024-06-09 08:06:13 -04:00
|
|
|
cli := test.NewFakeCli(&fakeClient{
|
2024-06-09 07:54:37 -04:00
|
|
|
containerCopyFromFunc: func(ctr, srcPath string) (io.ReadCloser, container.PathStat, error) {
|
2024-06-09 08:06:13 -04:00
|
|
|
assert.Check(t, is.Equal("container", ctr))
|
2017-10-30 17:52:08 -04:00
|
|
|
readCloser, err := archive.TarWithOptions(destDir.Path(), &archive.TarOptions{})
|
2024-06-09 07:54:37 -04:00
|
|
|
return readCloser, container.PathStat{}, err
|
2017-10-30 17:52:08 -04:00
|
|
|
},
|
2024-06-09 08:06:13 -04:00
|
|
|
})
|
|
|
|
err := runCopy(context.TODO(), cli, copyOptions{
|
2017-10-30 17:52:08 -04:00
|
|
|
source: "container:/path",
|
|
|
|
destination: destDir.Join("missing", "foo"),
|
2024-06-09 08:06:13 -04:00
|
|
|
})
|
2018-03-06 14:03:47 -05:00
|
|
|
assert.ErrorContains(t, err, destDir.Join("missing"))
|
2017-10-30 17:52:08 -04:00
|
|
|
}
|
|
|
|
|
2018-02-27 16:38:02 -05:00
|
|
|
func TestRunCopyToContainerFromFileWithTrailingSlash(t *testing.T) {
|
|
|
|
srcFile := fs.NewFile(t, t.Name())
|
|
|
|
defer srcFile.Remove()
|
|
|
|
|
2024-06-09 08:06:13 -04:00
|
|
|
cli := test.NewFakeCli(&fakeClient{})
|
|
|
|
err := runCopy(context.TODO(), cli, copyOptions{
|
2018-02-27 16:38:02 -05:00
|
|
|
source: srcFile.Path() + string(os.PathSeparator),
|
|
|
|
destination: "container:/path",
|
2024-06-09 08:06:13 -04:00
|
|
|
})
|
2018-02-27 10:54:36 -05:00
|
|
|
|
|
|
|
expectedError := "not a directory"
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
expectedError = "The filename, directory name, or volume label syntax is incorrect"
|
|
|
|
}
|
|
|
|
assert.ErrorContains(t, err, expectedError)
|
2018-02-27 16:38:02 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestRunCopyToContainerSourceDoesNotExist(t *testing.T) {
|
2024-06-09 08:06:13 -04:00
|
|
|
cli := test.NewFakeCli(&fakeClient{})
|
|
|
|
err := runCopy(context.TODO(), cli, copyOptions{
|
2018-02-27 16:38:02 -05:00
|
|
|
source: "/does/not/exist",
|
|
|
|
destination: "container:/path",
|
2024-06-09 08:06:13 -04:00
|
|
|
})
|
2018-02-27 16:38:02 -05:00
|
|
|
expected := "no such file or directory"
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
expected = "cannot find the file specified"
|
|
|
|
}
|
2018-03-06 14:03:47 -05:00
|
|
|
assert.ErrorContains(t, err, expected)
|
2018-02-27 16:38:02 -05:00
|
|
|
}
|
|
|
|
|
2017-10-30 17:52:08 -04:00
|
|
|
func TestSplitCpArg(t *testing.T) {
|
2022-09-29 11:21:51 -04:00
|
|
|
testcases := []struct {
|
2017-10-30 17:52:08 -04:00
|
|
|
doc string
|
|
|
|
path string
|
|
|
|
os string
|
|
|
|
expectedContainer string
|
|
|
|
expectedPath string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
doc: "absolute path with colon",
|
|
|
|
os: "linux",
|
|
|
|
path: "/abs/path:withcolon",
|
|
|
|
expectedPath: "/abs/path:withcolon",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
doc: "relative path with colon",
|
|
|
|
path: "./relative:path",
|
|
|
|
expectedPath: "./relative:path",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
doc: "absolute path with drive",
|
|
|
|
os: "windows",
|
|
|
|
path: `d:\abs\path`,
|
|
|
|
expectedPath: `d:\abs\path`,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
doc: "no separator",
|
|
|
|
path: "relative/path",
|
|
|
|
expectedPath: "relative/path",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
doc: "with separator",
|
|
|
|
path: "container:/opt/foo",
|
|
|
|
expectedPath: "/opt/foo",
|
|
|
|
expectedContainer: "container",
|
|
|
|
},
|
|
|
|
}
|
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>
2024-07-03 19:29:04 -04:00
|
|
|
for _, tc := range testcases {
|
|
|
|
tc := tc
|
|
|
|
t.Run(tc.doc, func(t *testing.T) {
|
|
|
|
skip.If(t, tc.os == "windows" && runtime.GOOS != "windows" || tc.os == "linux" && runtime.GOOS == "windows")
|
|
|
|
|
|
|
|
ctr, path := splitCpArg(tc.path)
|
|
|
|
assert.Check(t, is.Equal(tc.expectedContainer, ctr))
|
|
|
|
assert.Check(t, is.Equal(tc.expectedPath, path))
|
2017-10-30 17:52:08 -04:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
2019-02-07 03:17:35 -05:00
|
|
|
|
|
|
|
func TestRunCopyFromContainerToFilesystemIrregularDestination(t *testing.T) {
|
|
|
|
cli := test.NewFakeCli(nil)
|
2024-06-09 08:06:13 -04:00
|
|
|
err := runCopy(context.TODO(), cli, copyOptions{
|
|
|
|
source: "container:/dev/null",
|
|
|
|
destination: "/dev/random",
|
|
|
|
})
|
2019-02-07 03:17:35 -05:00
|
|
|
assert.Assert(t, err != nil)
|
|
|
|
expected := `"/dev/random" must be a directory or a regular file`
|
|
|
|
assert.ErrorContains(t, err, expected)
|
|
|
|
}
|