diff --git a/integration-cli/docker_cli_cp_from_container_test.go b/integration-cli/docker_cli_cp_from_container_test.go index 2618384c87..677085a134 100644 --- a/integration-cli/docker_cli_cp_from_container_test.go +++ b/integration-cli/docker_cli_cp_from_container_test.go @@ -4,6 +4,7 @@ import ( "os" "path/filepath" + "github.com/docker/docker/pkg/integration/checker" "github.com/go-check/check" ) @@ -24,48 +25,37 @@ import ( // Test for error when SRC does not exist. func (s *DockerSuite) TestCpFromErrSrcNotExists(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{}) tmpDir := getTestDir(c, "test-cp-from-err-src-not-exists") defer os.RemoveAll(tmpDir) - err := runDockerCp(c, containerCpPath(cID, "file1"), tmpDir) - if err == nil { - c.Fatal("expected IsNotExist error, but got nil instead") - } + err := runDockerCp(c, containerCpPath(containerID, "file1"), tmpDir) + c.Assert(err, checker.NotNil) - if !isCpNotExist(err) { - c.Fatalf("expected IsNotExist error, but got %T: %s", err, err) - } + c.Assert(isCpNotExist(err), checker.True, check.Commentf("expected IsNotExist error, but got %T: %s", err, err)) } // Test for error when SRC ends in a trailing // path separator but it exists as a file. func (s *DockerSuite) TestCpFromErrSrcNotDir(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-err-src-not-dir") defer os.RemoveAll(tmpDir) - err := runDockerCp(c, containerCpPathTrailingSep(cID, "file1"), tmpDir) - if err == nil { - c.Fatal("expected IsNotDir error, but got nil instead") - } + err := runDockerCp(c, containerCpPathTrailingSep(containerID, "file1"), tmpDir) + c.Assert(err, checker.NotNil) - if !isCpNotDir(err) { - c.Fatalf("expected IsNotDir error, but got %T: %s", err, err) - } + c.Assert(isCpNotDir(err), checker.True, check.Commentf("expected IsNotDir error, but got %T: %s", err, err)) } // Test for error when SRC is a valid file or directory, // bu the DST parent directory does not exist. func (s *DockerSuite) TestCpFromErrDstParentNotExists(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-err-dst-parent-not-exists") defer os.RemoveAll(tmpDir) @@ -73,36 +63,28 @@ func (s *DockerSuite) TestCpFromErrDstParentNotExists(c *check.C) { makeTestContentInDir(c, tmpDir) // Try with a file source. - srcPath := containerCpPath(cID, "/file1") + srcPath := containerCpPath(containerID, "/file1") dstPath := cpPath(tmpDir, "notExists", "file1") err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected IsNotExist error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpNotExist(err) { - c.Fatalf("expected IsNotExist error, but got %T: %s", err, err) - } + c.Assert(isCpNotExist(err), checker.True, check.Commentf("expected IsNotExist error, but got %T: %s", err, err)) // Try with a directory source. - srcPath = containerCpPath(cID, "/dir1") + srcPath = containerCpPath(containerID, "/dir1") - if err := runDockerCp(c, srcPath, dstPath); err == nil { - c.Fatal("expected IsNotExist error, but got nil instead") - } + err = runDockerCp(c, srcPath, dstPath) + c.Assert(err, checker.NotNil) - if !isCpNotExist(err) { - c.Fatalf("expected IsNotExist error, but got %T: %s", err, err) - } + c.Assert(isCpNotExist(err), checker.True, check.Commentf("expected IsNotExist error, but got %T: %s", err, err)) } // Test for error when DST ends in a trailing // path separator but exists as a file. func (s *DockerSuite) TestCpFromErrDstNotDir(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-err-dst-not-dir") defer os.RemoveAll(tmpDir) @@ -110,36 +92,28 @@ func (s *DockerSuite) TestCpFromErrDstNotDir(c *check.C) { makeTestContentInDir(c, tmpDir) // Try with a file source. - srcPath := containerCpPath(cID, "/file1") + srcPath := containerCpPath(containerID, "/file1") dstPath := cpPathTrailingSep(tmpDir, "file1") err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected IsNotDir error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpNotDir(err) { - c.Fatalf("expected IsNotDir error, but got %T: %s", err, err) - } + c.Assert(isCpNotDir(err), checker.True, check.Commentf("expected IsNotDir error, but got %T: %s", err, err)) // Try with a directory source. - srcPath = containerCpPath(cID, "/dir1") + srcPath = containerCpPath(containerID, "/dir1") - if err := runDockerCp(c, srcPath, dstPath); err == nil { - c.Fatal("expected IsNotDir error, but got nil instead") - } + err = runDockerCp(c, srcPath, dstPath) + c.Assert(err, checker.NotNil) - if !isCpNotDir(err) { - c.Fatalf("expected IsNotDir error, but got %T: %s", err, err) - } + c.Assert(isCpNotDir(err), checker.True, check.Commentf("expected IsNotDir error, but got %T: %s", err, err)) } // Check that copying from a container to a local symlink copies to the symlink // target and does not overwrite the local symlink itself. func (s *DockerSuite) TestCpFromSymlinkDestination(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-err-dst-not-dir") defer os.RemoveAll(tmpDir) @@ -148,79 +122,55 @@ func (s *DockerSuite) TestCpFromSymlinkDestination(c *check.C) { // First, copy a file from the container to a symlink to a file. This // should overwrite the symlink target contents with the source contents. - srcPath := containerCpPath(cID, "/file2") + srcPath := containerCpPath(containerID, "/file2") dstPath := cpPath(tmpDir, "symlinkToFile1") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, dstPath, "file1"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, dstPath, "file1"), checker.IsNil) // The file should have the contents of "file2" now. - if err := fileContentEquals(c, cpPath(tmpDir, "file1"), "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(tmpDir, "file1"), "file2\n"), checker.IsNil) // Next, copy a file from the container to a symlink to a directory. This // should copy the file into the symlink target directory. dstPath = cpPath(tmpDir, "symlinkToDir1") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, dstPath, "dir1"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, dstPath, "dir1"), checker.IsNil) // The file should have the contents of "file2" now. - if err := fileContentEquals(c, cpPath(tmpDir, "file2"), "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(tmpDir, "file2"), "file2\n"), checker.IsNil) // Next, copy a file from the container to a symlink to a file that does // not exist (a broken symlink). This should create the target file with // the contents of the source file. dstPath = cpPath(tmpDir, "brokenSymlinkToFileX") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, dstPath, "fileX"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, dstPath, "fileX"), checker.IsNil) // The file should have the contents of "file2" now. - if err := fileContentEquals(c, cpPath(tmpDir, "fileX"), "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(tmpDir, "fileX"), "file2\n"), checker.IsNil) // Next, copy a directory from the container to a symlink to a local // directory. This should copy the directory into the symlink target // directory and not modify the symlink. - srcPath = containerCpPath(cID, "/dir2") + srcPath = containerCpPath(containerID, "/dir2") dstPath = cpPath(tmpDir, "symlinkToDir1") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, dstPath, "dir1"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, dstPath, "dir1"), checker.IsNil) // The directory should now contain a copy of "dir2". - if err := fileContentEquals(c, cpPath(tmpDir, "dir1/dir2/file2-1"), "file2-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(tmpDir, "dir1/dir2/file2-1"), "file2-1\n"), checker.IsNil) // Next, copy a directory from the container to a symlink to a local // directory that does not exist (a broken symlink). This should create @@ -228,19 +178,13 @@ func (s *DockerSuite) TestCpFromSymlinkDestination(c *check.C) { // should not modify the symlink. dstPath = cpPath(tmpDir, "brokenSymlinkToDirX") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, dstPath, "dirX"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, dstPath, "dirX"), checker.IsNil) // The "dirX" directory should now be a copy of "dir2". - if err := fileContentEquals(c, cpPath(tmpDir, "dirX/file2-1"), "file2-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(tmpDir, "dirX/file2-1"), "file2-1\n"), checker.IsNil) } // Possibilities are reduced to the remaining 10 cases: @@ -264,24 +208,19 @@ func (s *DockerSuite) TestCpFromSymlinkDestination(c *check.C) { // contents of the source file into it. func (s *DockerSuite) TestCpFromCaseA(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-from-case-a") defer os.RemoveAll(tmpDir) - srcPath := containerCpPath(cID, "/root/file1") + srcPath := containerCpPath(containerID, "/root/file1") dstPath := cpPath(tmpDir, "itWorks.txt") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1\n"), checker.IsNil) } // B. SRC specifies a file and DST (with trailing path separator) doesn't @@ -289,54 +228,42 @@ func (s *DockerSuite) TestCpFromCaseA(c *check.C) { // create a directory when copying a single file. func (s *DockerSuite) TestCpFromCaseB(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-case-b") defer os.RemoveAll(tmpDir) - srcPath := containerCpPath(cID, "/file1") + srcPath := containerCpPath(containerID, "/file1") dstDir := cpPathTrailingSep(tmpDir, "testDir") err := runDockerCp(c, srcPath, dstDir) - if err == nil { - c.Fatal("expected DirNotExists error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpDirNotExist(err) { - c.Fatalf("expected DirNotExists error, but got %T: %s", err, err) - } + c.Assert(isCpDirNotExist(err), checker.True, check.Commentf("expected DirNotExists error, but got %T: %s", err, err)) } // C. SRC specifies a file and DST exists as a file. This should overwrite // the file at DST with the contents of the source file. func (s *DockerSuite) TestCpFromCaseC(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-from-case-c") defer os.RemoveAll(tmpDir) makeTestContentInDir(c, tmpDir) - srcPath := containerCpPath(cID, "/root/file1") + srcPath := containerCpPath(containerID, "/root/file1") dstPath := cpPath(tmpDir, "file2") // Ensure the local file starts with different content. - if err := fileContentEquals(c, dstPath, "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file2\n"), checker.IsNil) - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1\n"), checker.IsNil) } // D. SRC specifies a file and DST exists as a directory. This should place @@ -344,50 +271,38 @@ func (s *DockerSuite) TestCpFromCaseC(c *check.C) { // this works whether DST has a trailing path separator or not. func (s *DockerSuite) TestCpFromCaseD(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-case-d") defer os.RemoveAll(tmpDir) makeTestContentInDir(c, tmpDir) - srcPath := containerCpPath(cID, "/file1") + srcPath := containerCpPath(containerID, "/file1") dstDir := cpPath(tmpDir, "dir1") dstPath := filepath.Join(dstDir, "file1") // Ensure that dstPath doesn't exist. - if _, err := os.Stat(dstPath); !os.IsNotExist(err) { - c.Fatalf("did not expect dstPath %q to exist", dstPath) - } + _, err := os.Stat(dstPath) + c.Assert(os.IsNotExist(err), checker.True, check.Commentf("did not expect dstPath %q to exist", dstPath)) - if err := runDockerCp(c, srcPath, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. - if err := os.RemoveAll(dstDir); err != nil { - c.Fatalf("unable to remove dstDir: %s", err) - } + // unable to remove dstDir + c.Assert(os.RemoveAll(dstDir), checker.IsNil) - if err := os.MkdirAll(dstDir, os.FileMode(0755)); err != nil { - c.Fatalf("unable to make dstDir: %s", err) - } + // unable to make dstDir + c.Assert(os.MkdirAll(dstDir, os.FileMode(0755)), checker.IsNil) dstDir = cpPathTrailingSep(tmpDir, "dir1") - if err := runDockerCp(c, srcPath, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1\n"), checker.IsNil) } // E. SRC specifies a directory and DST does not exist. This should create a @@ -396,66 +311,51 @@ func (s *DockerSuite) TestCpFromCaseD(c *check.C) { // not. func (s *DockerSuite) TestCpFromCaseE(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-case-e") defer os.RemoveAll(tmpDir) - srcDir := containerCpPath(cID, "dir1") + srcDir := containerCpPath(containerID, "dir1") dstDir := cpPath(tmpDir, "testDir") dstPath := filepath.Join(dstDir, "file1-1") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. - if err := os.RemoveAll(dstDir); err != nil { - c.Fatalf("unable to remove dstDir: %s", err) - } + // unable to remove dstDir + c.Assert(os.RemoveAll(dstDir), checker.IsNil) dstDir = cpPathTrailingSep(tmpDir, "testDir") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) } // F. SRC specifies a directory and DST exists as a file. This should cause an // error as it is not possible to overwrite a file with a directory. func (s *DockerSuite) TestCpFromCaseF(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-from-case-f") defer os.RemoveAll(tmpDir) makeTestContentInDir(c, tmpDir) - srcDir := containerCpPath(cID, "/root/dir1") + srcDir := containerCpPath(containerID, "/root/dir1") dstFile := cpPath(tmpDir, "file1") err := runDockerCp(c, srcDir, dstFile) - if err == nil { - c.Fatal("expected ErrCannotCopyDir error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpCannotCopyDir(err) { - c.Fatalf("expected ErrCannotCopyDir error, but got %T: %s", err, err) - } + c.Assert(isCpCannotCopyDir(err), checker.True, check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err)) } // G. SRC specifies a directory and DST exists as a directory. This should copy @@ -463,48 +363,37 @@ func (s *DockerSuite) TestCpFromCaseF(c *check.C) { // works whether DST has a trailing path separator or not. func (s *DockerSuite) TestCpFromCaseG(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-from-case-g") defer os.RemoveAll(tmpDir) makeTestContentInDir(c, tmpDir) - srcDir := containerCpPath(cID, "/root/dir1") + srcDir := containerCpPath(containerID, "/root/dir1") dstDir := cpPath(tmpDir, "dir2") resultDir := filepath.Join(dstDir, "dir1") dstPath := filepath.Join(resultDir, "file1-1") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. - if err := os.RemoveAll(dstDir); err != nil { - c.Fatalf("unable to remove dstDir: %s", err) - } + // unable to remove dstDir + c.Assert(os.RemoveAll(dstDir), checker.IsNil) - if err := os.MkdirAll(dstDir, os.FileMode(0755)); err != nil { - c.Fatalf("unable to make dstDir: %s", err) - } + // unable to make dstDir + c.Assert(os.MkdirAll(dstDir, os.FileMode(0755)), checker.IsNil) dstDir = cpPathTrailingSep(tmpDir, "dir2") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) } // H. SRC specifies a directory's contents only and DST does not exist. This @@ -513,39 +402,29 @@ func (s *DockerSuite) TestCpFromCaseG(c *check.C) { // this works whether DST has a trailing path separator or not. func (s *DockerSuite) TestCpFromCaseH(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-from-case-h") defer os.RemoveAll(tmpDir) - srcDir := containerCpPathTrailingSep(cID, "dir1") + "." + srcDir := containerCpPathTrailingSep(containerID, "dir1") + "." dstDir := cpPath(tmpDir, "testDir") dstPath := filepath.Join(dstDir, "file1-1") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. - if err := os.RemoveAll(dstDir); err != nil { - c.Fatalf("unable to remove resultDir: %s", err) - } + // unable to remove resultDir + c.Assert(os.RemoveAll(dstDir), checker.IsNil) dstDir = cpPathTrailingSep(tmpDir, "testDir") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) } // I. SRC specifies a directory's contents only and DST exists as a file. This @@ -553,27 +432,22 @@ func (s *DockerSuite) TestCpFromCaseH(c *check.C) { // directory. func (s *DockerSuite) TestCpFromCaseI(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-from-case-i") defer os.RemoveAll(tmpDir) makeTestContentInDir(c, tmpDir) - srcDir := containerCpPathTrailingSep(cID, "/root/dir1") + "." + srcDir := containerCpPathTrailingSep(containerID, "/root/dir1") + "." dstFile := cpPath(tmpDir, "file1") err := runDockerCp(c, srcDir, dstFile) - if err == nil { - c.Fatal("expected ErrCannotCopyDir error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpCannotCopyDir(err) { - c.Fatalf("expected ErrCannotCopyDir error, but got %T: %s", err, err) - } + c.Assert(isCpCannotCopyDir(err), checker.True, check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err)) } // J. SRC specifies a directory's contents only and DST exists as a directory. @@ -582,45 +456,34 @@ func (s *DockerSuite) TestCpFromCaseI(c *check.C) { // trailing path separator or not. func (s *DockerSuite) TestCpFromCaseJ(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-from-case-j") defer os.RemoveAll(tmpDir) makeTestContentInDir(c, tmpDir) - srcDir := containerCpPathTrailingSep(cID, "/root/dir1") + "." + srcDir := containerCpPathTrailingSep(containerID, "/root/dir1") + "." dstDir := cpPath(tmpDir, "dir2") dstPath := filepath.Join(dstDir, "file1-1") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. - if err := os.RemoveAll(dstDir); err != nil { - c.Fatalf("unable to remove dstDir: %s", err) - } + // unable to remove dstDir + c.Assert(os.RemoveAll(dstDir), checker.IsNil) - if err := os.MkdirAll(dstDir, os.FileMode(0755)); err != nil { - c.Fatalf("unable to make dstDir: %s", err) - } + // unable to make dstDir + c.Assert(os.MkdirAll(dstDir, os.FileMode(0755)), checker.IsNil) dstDir = cpPathTrailingSep(tmpDir, "dir2") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) - if err := fileContentEquals(c, dstPath, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil) } diff --git a/integration-cli/docker_cli_cp_test.go b/integration-cli/docker_cli_cp_test.go index adc3adb19d..384473551a 100644 --- a/integration-cli/docker_cli_cp_test.go +++ b/integration-cli/docker_cli_cp_test.go @@ -10,6 +10,7 @@ import ( "path/filepath" "strings" + "github.com/docker/docker/pkg/integration/checker" "github.com/go-check/check" ) @@ -26,107 +27,77 @@ const ( // Ensure that an all-local path case returns an error. func (s *DockerSuite) TestCpLocalOnly(c *check.C) { err := runDockerCp(c, "foo", "bar") - if err == nil { - c.Fatal("expected failure, got success") - } + c.Assert(err, checker.NotNil) - if !strings.Contains(err.Error(), "must specify at least one container source") { - c.Fatalf("unexpected output: %s", err.Error()) - } + c.Assert(err.Error(), checker.Contains, "must specify at least one container source") } // Test for #5656 // Check that garbage paths don't escape the container's rootfs func (s *DockerSuite) TestCpGarbagePath(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath) - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath) - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") - if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil { - c.Fatal(err) - } + c.Assert(os.MkdirAll(cpTestPath, os.ModeDir), checker.IsNil) hostFile, err := os.Create(cpFullPath) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer hostFile.Close() defer os.RemoveAll(cpTestPathParent) fmt.Fprintf(hostFile, "%s", cpHostContents) tmpdir, err := ioutil.TempDir("", "docker-integration") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) tmpname := filepath.Join(tmpdir, cpTestName) defer os.RemoveAll(tmpdir) path := path.Join("../../../../../../../../../../../../", cpFullPath) - dockerCmd(c, "cp", cleanedContainerID+":"+path, tmpdir) + dockerCmd(c, "cp", containerID+":"+path, tmpdir) file, _ := os.Open(tmpname) defer file.Close() test, err := ioutil.ReadAll(file) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) - if string(test) == cpHostContents { - c.Errorf("output matched host file -- garbage path can escape container rootfs") - } - - if string(test) != cpContainerContents { - c.Errorf("output doesn't match the input for garbage path") - } + // output matched host file -- garbage path can escape container rootfs + c.Assert(string(test), checker.Not(checker.Equals), cpHostContents) + // output doesn't match the input for garbage path + c.Assert(string(test), checker.Equals, cpContainerContents) } // Check that relative paths are relative to the container's rootfs func (s *DockerSuite) TestCpRelativePath(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath) - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath) - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") - if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil { - c.Fatal(err) - } + c.Assert(os.MkdirAll(cpTestPath, os.ModeDir), checker.IsNil) hostFile, err := os.Create(cpFullPath) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer hostFile.Close() defer os.RemoveAll(cpTestPathParent) fmt.Fprintf(hostFile, "%s", cpHostContents) tmpdir, err := ioutil.TempDir("", "docker-integration") - - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) tmpname := filepath.Join(tmpdir, cpTestName) defer os.RemoveAll(tmpdir) @@ -136,200 +107,151 @@ func (s *DockerSuite) TestCpRelativePath(c *check.C) { // normally this is `filepath.Rel("/", cpFullPath)` but we cannot // get this unix-path manipulation on windows with filepath. relPath = cpFullPath[1:] - } else { - c.Fatalf("path %s was assumed to be an absolute path", cpFullPath) } + c.Assert(path.IsAbs(cpFullPath), checker.True, check.Commentf("path %s was assumed to be an absolute path", cpFullPath)) - dockerCmd(c, "cp", cleanedContainerID+":"+relPath, tmpdir) + dockerCmd(c, "cp", containerID+":"+relPath, tmpdir) file, _ := os.Open(tmpname) defer file.Close() test, err := ioutil.ReadAll(file) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) - if string(test) == cpHostContents { - c.Errorf("output matched host file -- relative path can escape container rootfs") - } - - if string(test) != cpContainerContents { - c.Errorf("output doesn't match the input for relative path") - } + // output matched host file -- relative path can escape container rootfs + c.Assert(string(test), checker.Not(checker.Equals), cpHostContents) + // output doesn't match the input for relative path + c.Assert(string(test), checker.Equals, cpContainerContents) } // Check that absolute paths are relative to the container's rootfs func (s *DockerSuite) TestCpAbsolutePath(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath) - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath) - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") - if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil { - c.Fatal(err) - } + c.Assert(os.MkdirAll(cpTestPath, os.ModeDir), checker.IsNil) hostFile, err := os.Create(cpFullPath) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer hostFile.Close() defer os.RemoveAll(cpTestPathParent) fmt.Fprintf(hostFile, "%s", cpHostContents) tmpdir, err := ioutil.TempDir("", "docker-integration") - - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) tmpname := filepath.Join(tmpdir, cpTestName) defer os.RemoveAll(tmpdir) path := cpFullPath - dockerCmd(c, "cp", cleanedContainerID+":"+path, tmpdir) + dockerCmd(c, "cp", containerID+":"+path, tmpdir) file, _ := os.Open(tmpname) defer file.Close() test, err := ioutil.ReadAll(file) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) - if string(test) == cpHostContents { - c.Errorf("output matched host file -- absolute path can escape container rootfs") - } - - if string(test) != cpContainerContents { - c.Errorf("output doesn't match the input for absolute path") - } + // output matched host file -- absolute path can escape container rootfs + c.Assert(string(test), checker.Not(checker.Equals), cpHostContents) + // output doesn't match the input for absolute path + c.Assert(string(test), checker.Equals, cpContainerContents) } // Test for #5619 // Check that absolute symlinks are still relative to the container's rootfs func (s *DockerSuite) TestCpAbsoluteSymlink(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpFullPath+" container_path") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpFullPath+" container_path") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") - if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil { - c.Fatal(err) - } + c.Assert(os.MkdirAll(cpTestPath, os.ModeDir), checker.IsNil) hostFile, err := os.Create(cpFullPath) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer hostFile.Close() defer os.RemoveAll(cpTestPathParent) fmt.Fprintf(hostFile, "%s", cpHostContents) tmpdir, err := ioutil.TempDir("", "docker-integration") - - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) tmpname := filepath.Join(tmpdir, "container_path") defer os.RemoveAll(tmpdir) path := path.Join("/", "container_path") - dockerCmd(c, "cp", cleanedContainerID+":"+path, tmpdir) + dockerCmd(c, "cp", containerID+":"+path, tmpdir) // We should have copied a symlink *NOT* the file itself! linkTarget, err := os.Readlink(tmpname) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) - if linkTarget != filepath.FromSlash(cpFullPath) { - c.Errorf("symlink target was %q, but expected: %q", linkTarget, cpFullPath) - } + c.Assert(linkTarget, checker.Equals, filepath.FromSlash(cpFullPath)) } // Check that symlinks to a directory behave as expected when copying one from // a container. func (s *DockerSuite) TestCpFromSymlinkToDirectory(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpTestPathParent+" /dir_link") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpTestPathParent+" /dir_link") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") testDir, err := ioutil.TempDir("", "test-cp-from-symlink-to-dir-") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(testDir) // This copy command should copy the symlink, not the target, into the // temporary directory. - dockerCmd(c, "cp", cleanedContainerID+":"+"/dir_link", testDir) + dockerCmd(c, "cp", containerID+":"+"/dir_link", testDir) expectedPath := filepath.Join(testDir, "dir_link") linkTarget, err := os.Readlink(expectedPath) - if err != nil { - c.Fatalf("unable to read symlink at %q: %v", expectedPath, err) - } + c.Assert(err, checker.IsNil) - if linkTarget != filepath.FromSlash(cpTestPathParent) { - c.Errorf("symlink target was %q, but expected: %q", linkTarget, cpTestPathParent) - } + c.Assert(linkTarget, checker.Equals, filepath.FromSlash(cpTestPathParent)) os.Remove(expectedPath) // This copy command should resolve the symlink (note the trailing // separator), copying the target into the temporary directory. - dockerCmd(c, "cp", cleanedContainerID+":"+"/dir_link/", testDir) + dockerCmd(c, "cp", containerID+":"+"/dir_link/", testDir) // It *should not* have copied the directory using the target's name, but // used the given name instead. unexpectedPath := filepath.Join(testDir, cpTestPathParent) - if stat, err := os.Lstat(unexpectedPath); err == nil { - c.Fatalf("target name was copied: %q - %q", stat.Mode(), stat.Name()) + stat, err := os.Lstat(unexpectedPath) + if err == nil { + out = fmt.Sprintf("target name was copied: %q - %q", stat.Mode(), stat.Name()) } + c.Assert(err, checker.NotNil, check.Commentf(out)) // It *should* have copied the directory using the asked name "dir_link". - stat, err := os.Lstat(expectedPath) - if err != nil { - c.Fatalf("unable to stat resource at %q: %v", expectedPath, err) - } + stat, err = os.Lstat(expectedPath) + c.Assert(err, checker.IsNil, check.Commentf("unable to stat resource at %q", expectedPath)) - if !stat.IsDir() { - c.Errorf("should have copied a directory but got %q instead", stat.Mode()) - } + c.Assert(stat.IsDir(), checker.True, check.Commentf("should have copied a directory but got %q instead", stat.Mode())) } // Check that symlinks to a directory behave as expected when copying one to a @@ -339,65 +261,46 @@ func (s *DockerSuite) TestCpToSymlinkToDirectory(c *check.C) { testRequires(c, SameHostDaemon) // Requires local volume mount bind. testVol, err := ioutil.TempDir("", "test-cp-to-symlink-to-dir-") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(testVol) // Create a test container with a local volume. We will test by copying // to the volume path in the container which we can then verify locally. - out, exitCode := dockerCmd(c, "create", "-v", testVol+":/testVol", "busybox") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "create", "-v", testVol+":/testVol", "busybox") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) // Create a temp directory to hold a test file nested in a direcotry. testDir, err := ioutil.TempDir("", "test-cp-to-symlink-to-dir-") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(testDir) // This file will be at "/testDir/some/path/test" and will be copied into // the test volume later. hostTestFilename := filepath.Join(testDir, cpFullPath) - if err := os.MkdirAll(filepath.Dir(hostTestFilename), os.FileMode(0700)); err != nil { - c.Fatal(err) - } - if err := ioutil.WriteFile(hostTestFilename, []byte(cpHostContents), os.FileMode(0600)); err != nil { - c.Fatal(err) - } + c.Assert(os.MkdirAll(filepath.Dir(hostTestFilename), os.FileMode(0700)), checker.IsNil) + c.Assert(ioutil.WriteFile(hostTestFilename, []byte(cpHostContents), os.FileMode(0600)), checker.IsNil) // Now create another temp directory to hold a symlink to the // "/testDir/some" directory. linkDir, err := ioutil.TempDir("", "test-cp-to-symlink-to-dir-") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(linkDir) // Then symlink "/linkDir/dir_link" to "/testdir/some". linkTarget := filepath.Join(testDir, cpTestPathParent) localLink := filepath.Join(linkDir, "dir_link") - if err := os.Symlink(linkTarget, localLink); err != nil { - c.Fatal(err) - } + c.Assert(os.Symlink(linkTarget, localLink), checker.IsNil) // Now copy that symlink into the test volume in the container. - dockerCmd(c, "cp", localLink, cleanedContainerID+":/testVol") + dockerCmd(c, "cp", localLink, containerID+":/testVol") // This copy command should have copied the symlink *not* the target. expectedPath := filepath.Join(testVol, "dir_link") actualLinkTarget, err := os.Readlink(expectedPath) - if err != nil { - c.Fatalf("unable to read symlink at %q: %v", expectedPath, err) - } + c.Assert(err, checker.IsNil, check.Commentf("unable to read symlink at %q", expectedPath)) - if actualLinkTarget != linkTarget { - c.Errorf("symlink target was %q, but expected: %q", actualLinkTarget, linkTarget) - } + c.Assert(actualLinkTarget, checker.Equals, linkTarget) // Good, now remove that copied link for the next test. os.Remove(expectedPath) @@ -405,62 +308,48 @@ func (s *DockerSuite) TestCpToSymlinkToDirectory(c *check.C) { // This copy command should resolve the symlink (note the trailing // separator), copying the target into the test volume directory in the // container. - dockerCmd(c, "cp", localLink+"/", cleanedContainerID+":/testVol") + dockerCmd(c, "cp", localLink+"/", containerID+":/testVol") // It *should not* have copied the directory using the target's name, but // used the given name instead. unexpectedPath := filepath.Join(testVol, cpTestPathParent) - if stat, err := os.Lstat(unexpectedPath); err == nil { - c.Fatalf("target name was copied: %q - %q", stat.Mode(), stat.Name()) + stat, err := os.Lstat(unexpectedPath) + if err == nil { + out = fmt.Sprintf("target name was copied: %q - %q", stat.Mode(), stat.Name()) } + c.Assert(err, checker.NotNil, check.Commentf(out)) // It *should* have copied the directory using the asked name "dir_link". - stat, err := os.Lstat(expectedPath) - if err != nil { - c.Fatalf("unable to stat resource at %q: %v", expectedPath, err) - } + stat, err = os.Lstat(expectedPath) + c.Assert(err, checker.IsNil, check.Commentf("unable to stat resource at %q", expectedPath)) - if !stat.IsDir() { - c.Errorf("should have copied a directory but got %q instead", stat.Mode()) - } + c.Assert(stat.IsDir(), checker.True, check.Commentf("should have copied a directory but got %q instead", stat.Mode())) // And this directory should contain the file copied from the host at the // expected location: "/testVol/dir_link/path/test" expectedFilepath := filepath.Join(testVol, "dir_link/path/test") fileContents, err := ioutil.ReadFile(expectedFilepath) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) - if string(fileContents) != cpHostContents { - c.Fatalf("file contains %q but expected %q", string(fileContents), cpHostContents) - } + c.Assert(string(fileContents), checker.Equals, cpHostContents) } // Test for #5619 // Check that symlinks which are part of the resource path are still relative to the container's rootfs func (s *DockerSuite) TestCpSymlinkComponent(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpTestPath+" container_path") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpTestPath+" container_path") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") - if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil { - c.Fatal(err) - } + c.Assert(os.MkdirAll(cpTestPath, os.ModeDir), checker.IsNil) hostFile, err := os.Create(cpFullPath) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer hostFile.Close() defer os.RemoveAll(cpTestPathParent) @@ -468,33 +357,26 @@ func (s *DockerSuite) TestCpSymlinkComponent(c *check.C) { tmpdir, err := ioutil.TempDir("", "docker-integration") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) tmpname := filepath.Join(tmpdir, cpTestName) defer os.RemoveAll(tmpdir) path := path.Join("/", "container_path", cpTestName) - dockerCmd(c, "cp", cleanedContainerID+":"+path, tmpdir) + dockerCmd(c, "cp", containerID+":"+path, tmpdir) file, _ := os.Open(tmpname) defer file.Close() test, err := ioutil.ReadAll(file) - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) - if string(test) == cpHostContents { - c.Errorf("output matched host file -- symlink path component can escape container rootfs") - } - - if string(test) != cpContainerContents { - c.Errorf("output doesn't match the input for symlink path component") - } + // output matched host file -- symlink path component can escape container rootfs + c.Assert(string(test), checker.Not(checker.Equals), cpHostContents) + // output doesn't match the input for symlink path component + c.Assert(string(test), checker.Equals, cpContainerContents) } // Check that cp with unprivileged user doesn't return any error @@ -502,36 +384,25 @@ func (s *DockerSuite) TestCpUnprivilegedUser(c *check.C) { testRequires(c, DaemonIsLinux) testRequires(c, UnixCli) // uses chmod/su: not available on windows - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "touch "+cpTestName) - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "touch "+cpTestName) - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") tmpdir, err := ioutil.TempDir("", "docker-integration") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(tmpdir) - if err = os.Chmod(tmpdir, 0777); err != nil { - c.Fatal(err) - } + c.Assert(os.Chmod(tmpdir, 0777), checker.IsNil) path := cpTestName - _, _, err = runCommandWithOutput(exec.Command("su", "unprivilegeduser", "-c", dockerBinary+" cp "+cleanedContainerID+":"+path+" "+tmpdir)) - if err != nil { - c.Fatalf("couldn't copy with unprivileged user: %s:%s %s", cleanedContainerID, path, err) - } - + _, _, err = runCommandWithOutput(exec.Command("su", "unprivilegeduser", "-c", dockerBinary+" cp "+containerID+":"+path+" "+tmpdir)) + c.Assert(err, checker.IsNil, check.Commentf("couldn't copy with unprivileged user: %s:%s", containerID, path)) } func (s *DockerSuite) TestCpSpecialFiles(c *check.C) { @@ -539,53 +410,43 @@ func (s *DockerSuite) TestCpSpecialFiles(c *check.C) { testRequires(c, SameHostDaemon) outDir, err := ioutil.TempDir("", "cp-test-special-files") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(outDir) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "touch /foo") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "touch /foo") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") // Copy actual /etc/resolv.conf - dockerCmd(c, "cp", cleanedContainerID+":/etc/resolv.conf", outDir) + dockerCmd(c, "cp", containerID+":/etc/resolv.conf", outDir) - expected, err := readContainerFile(cleanedContainerID, "resolv.conf") + expected, err := readContainerFile(containerID, "resolv.conf") actual, err := ioutil.ReadFile(outDir + "/resolv.conf") - if !bytes.Equal(actual, expected) { - c.Fatalf("Expected copied file to be duplicate of the container resolvconf") - } + // Expected copied file to be duplicate of the container resolvconf + c.Assert(bytes.Equal(actual, expected), checker.True) // Copy actual /etc/hosts - dockerCmd(c, "cp", cleanedContainerID+":/etc/hosts", outDir) + dockerCmd(c, "cp", containerID+":/etc/hosts", outDir) - expected, err = readContainerFile(cleanedContainerID, "hosts") + expected, err = readContainerFile(containerID, "hosts") actual, err = ioutil.ReadFile(outDir + "/hosts") - if !bytes.Equal(actual, expected) { - c.Fatalf("Expected copied file to be duplicate of the container hosts") - } + // Expected copied file to be duplicate of the container hosts + c.Assert(bytes.Equal(actual, expected), checker.True) // Copy actual /etc/resolv.conf - dockerCmd(c, "cp", cleanedContainerID+":/etc/hostname", outDir) + dockerCmd(c, "cp", containerID+":/etc/hostname", outDir) - expected, err = readContainerFile(cleanedContainerID, "hostname") + expected, err = readContainerFile(containerID, "hostname") actual, err = ioutil.ReadFile(outDir + "/hostname") - if !bytes.Equal(actual, expected) { - c.Fatalf("Expected copied file to be duplicate of the container resolvconf") - } - + // Expected copied file to be duplicate of the container resolvconf + c.Assert(bytes.Equal(actual, expected), checker.True) } func (s *DockerSuite) TestCpVolumePath(c *check.C) { @@ -595,216 +456,148 @@ func (s *DockerSuite) TestCpVolumePath(c *check.C) { testRequires(c, SameHostDaemon) tmpDir, err := ioutil.TempDir("", "cp-test-volumepath") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(tmpDir) outDir, err := ioutil.TempDir("", "cp-test-volumepath-out") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(outDir) _, err = os.Create(tmpDir + "/test") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) - out, exitCode := dockerCmd(c, "run", "-d", "-v", "/foo", "-v", tmpDir+"/test:/test", "-v", tmpDir+":/baz", "busybox", "/bin/sh", "-c", "touch /foo/bar") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "-v", "/foo", "-v", tmpDir+"/test:/test", "-v", tmpDir+":/baz", "busybox", "/bin/sh", "-c", "touch /foo/bar") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") // Copy actual volume path - dockerCmd(c, "cp", cleanedContainerID+":/foo", outDir) + dockerCmd(c, "cp", containerID+":/foo", outDir) stat, err := os.Stat(outDir + "/foo") - if err != nil { - c.Fatal(err) - } - if !stat.IsDir() { - c.Fatal("expected copied content to be dir") - } + c.Assert(err, checker.IsNil) + // expected copied content to be dir + c.Assert(stat.IsDir(), checker.True) stat, err = os.Stat(outDir + "/foo/bar") - if err != nil { - c.Fatal(err) - } - if stat.IsDir() { - c.Fatal("Expected file `bar` to be a file") - } + c.Assert(err, checker.IsNil) + // Expected file `bar` to be a file + c.Assert(stat.IsDir(), checker.False) // Copy file nested in volume - dockerCmd(c, "cp", cleanedContainerID+":/foo/bar", outDir) + dockerCmd(c, "cp", containerID+":/foo/bar", outDir) stat, err = os.Stat(outDir + "/bar") - if err != nil { - c.Fatal(err) - } - if stat.IsDir() { - c.Fatal("Expected file `bar` to be a file") - } + c.Assert(err, checker.IsNil) + // Expected file `bar` to be a file + c.Assert(stat.IsDir(), checker.False) // Copy Bind-mounted dir - dockerCmd(c, "cp", cleanedContainerID+":/baz", outDir) + dockerCmd(c, "cp", containerID+":/baz", outDir) stat, err = os.Stat(outDir + "/baz") - if err != nil { - c.Fatal(err) - } - if !stat.IsDir() { - c.Fatal("Expected `baz` to be a dir") - } + c.Assert(err, checker.IsNil) + // Expected `baz` to be a dir + c.Assert(stat.IsDir(), checker.True) // Copy file nested in bind-mounted dir - dockerCmd(c, "cp", cleanedContainerID+":/baz/test", outDir) + dockerCmd(c, "cp", containerID+":/baz/test", outDir) fb, err := ioutil.ReadFile(outDir + "/baz/test") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) fb2, err := ioutil.ReadFile(tmpDir + "/test") - if err != nil { - c.Fatal(err) - } - if !bytes.Equal(fb, fb2) { - c.Fatalf("Expected copied file to be duplicate of bind-mounted file") - } + c.Assert(err, checker.IsNil) + // Expected copied file to be duplicate of bind-mounted file + c.Assert(bytes.Equal(fb, fb2), checker.True) // Copy bind-mounted file - dockerCmd(c, "cp", cleanedContainerID+":/test", outDir) + dockerCmd(c, "cp", containerID+":/test", outDir) fb, err = ioutil.ReadFile(outDir + "/test") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) fb2, err = ioutil.ReadFile(tmpDir + "/test") - if err != nil { - c.Fatal(err) - } - if !bytes.Equal(fb, fb2) { - c.Fatalf("Expected copied file to be duplicate of bind-mounted file") - } - + c.Assert(err, checker.IsNil) + // Expected copied file to be duplicate of bind-mounted file + c.Assert(bytes.Equal(fb, fb2), checker.True) } func (s *DockerSuite) TestCpToDot(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") tmpdir, err := ioutil.TempDir("", "docker-integration") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(tmpdir) cwd, err := os.Getwd() - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.Chdir(cwd) - if err := os.Chdir(tmpdir); err != nil { - c.Fatal(err) - } - dockerCmd(c, "cp", cleanedContainerID+":/test", ".") + c.Assert(os.Chdir(tmpdir), checker.IsNil) + dockerCmd(c, "cp", containerID+":/test", ".") content, err := ioutil.ReadFile("./test") - if string(content) != "lololol\n" { - c.Fatalf("Wrong content in copied file %q, should be %q", content, "lololol\n") - } + c.Assert(string(content), checker.Equals, "lololol\n") } func (s *DockerSuite) TestCpToStdout(c *check.C) { testRequires(c, DaemonIsLinux) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test") - if exitCode != 0 { - c.Fatalf("failed to create a container:%s\n", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test") - cID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cID) - if strings.TrimSpace(out) != "0" { - c.Fatalf("failed to set up container:%s\n", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") out, _, err := runCommandPipelineWithOutput( - exec.Command(dockerBinary, "cp", cID+":/test", "-"), + exec.Command(dockerBinary, "cp", containerID+":/test", "-"), exec.Command("tar", "-vtf", "-")) - if err != nil { - c.Fatalf("Failed to run commands: %s", err) - } + c.Assert(err, checker.IsNil) - if !strings.Contains(out, "test") || !strings.Contains(out, "-rw") { - c.Fatalf("Missing file from tar TOC:\n%s", out) - } + c.Assert(out, checker.Contains, "test") + c.Assert(out, checker.Contains, "-rw") } func (s *DockerSuite) TestCpNameHasColon(c *check.C) { testRequires(c, SameHostDaemon) - out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /te:s:t") - if exitCode != 0 { - c.Fatal("failed to create a container", out) - } + out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /te:s:t") - cleanedContainerID := strings.TrimSpace(out) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", cleanedContainerID) - if strings.TrimSpace(out) != "0" { - c.Fatal("failed to set up container", out) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") tmpdir, err := ioutil.TempDir("", "docker-integration") - if err != nil { - c.Fatal(err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(tmpdir) - dockerCmd(c, "cp", cleanedContainerID+":/te:s:t", tmpdir) + dockerCmd(c, "cp", containerID+":/te:s:t", tmpdir) content, err := ioutil.ReadFile(tmpdir + "/te:s:t") - if string(content) != "lololol\n" { - c.Fatalf("Wrong content in copied file %q, should be %q", content, "lololol\n") - } + c.Assert(string(content), checker.Equals, "lololol\n") } func (s *DockerSuite) TestCopyAndRestart(c *check.C) { testRequires(c, DaemonIsLinux) expectedMsg := "hello" out, _ := dockerCmd(c, "run", "-d", "busybox", "echo", expectedMsg) - id := strings.TrimSpace(string(out)) + containerID := strings.TrimSpace(out) - out, _ = dockerCmd(c, "wait", id) - - status := strings.TrimSpace(out) - if status != "0" { - c.Fatalf("container exited with status %s", status) - } + out, _ = dockerCmd(c, "wait", containerID) + // failed to set up container + c.Assert(strings.TrimSpace(out), checker.Equals, "0") tmpDir, err := ioutil.TempDir("", "test-docker-restart-after-copy-") - if err != nil { - c.Fatalf("unable to make temporary directory: %s", err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(tmpDir) - dockerCmd(c, "cp", fmt.Sprintf("%s:/etc/group", id), tmpDir) + dockerCmd(c, "cp", fmt.Sprintf("%s:/etc/group", containerID), tmpDir) - out, _ = dockerCmd(c, "start", "-a", id) + out, _ = dockerCmd(c, "start", "-a", containerID) - msg := strings.TrimSpace(out) - if msg != expectedMsg { - c.Fatalf("expected %q but got %q", expectedMsg, msg) - } + c.Assert(strings.TrimSpace(out), checker.Equals, expectedMsg) } func (s *DockerSuite) TestCopyCreatedContainer(c *check.C) { @@ -812,9 +605,7 @@ func (s *DockerSuite) TestCopyCreatedContainer(c *check.C) { dockerCmd(c, "create", "--name", "test_cp", "-v", "/test", "busybox") tmpDir, err := ioutil.TempDir("", "test") - if err != nil { - c.Fatalf("unable to make temporary directory: %s", err) - } + c.Assert(err, checker.IsNil) defer os.RemoveAll(tmpDir) dockerCmd(c, "cp", "test_cp:/bin/sh", tmpDir) } diff --git a/integration-cli/docker_cli_cp_to_container_test.go b/integration-cli/docker_cli_cp_to_container_test.go index 39bac8511a..c0db6ef158 100644 --- a/integration-cli/docker_cli_cp_to_container_test.go +++ b/integration-cli/docker_cli_cp_to_container_test.go @@ -3,6 +3,7 @@ package main import ( "os" + "github.com/docker/docker/pkg/integration/checker" "github.com/go-check/check" ) @@ -23,31 +24,25 @@ import ( // Test for error when SRC does not exist. func (s *DockerSuite) TestCpToErrSrcNotExists(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{}) tmpDir := getTestDir(c, "test-cp-to-err-src-not-exists") defer os.RemoveAll(tmpDir) srcPath := cpPath(tmpDir, "file1") - dstPath := containerCpPath(cID, "file1") + dstPath := containerCpPath(containerID, "file1") err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected IsNotExist error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpNotExist(err) { - c.Fatalf("expected IsNotExist error, but got %T: %s", err, err) - } + c.Assert(isCpNotExist(err), checker.True, check.Commentf("expected IsNotExist error, but got %T: %s", err, err)) } // Test for error when SRC ends in a trailing // path separator but it exists as a file. func (s *DockerSuite) TestCpToErrSrcNotDir(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{}) tmpDir := getTestDir(c, "test-cp-to-err-src-not-dir") defer os.RemoveAll(tmpDir) @@ -55,24 +50,19 @@ func (s *DockerSuite) TestCpToErrSrcNotDir(c *check.C) { makeTestContentInDir(c, tmpDir) srcPath := cpPathTrailingSep(tmpDir, "file1") - dstPath := containerCpPath(cID, "testDir") + dstPath := containerCpPath(containerID, "testDir") err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected IsNotDir error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpNotDir(err) { - c.Fatalf("expected IsNotDir error, but got %T: %s", err, err) - } + c.Assert(isCpNotDir(err), checker.True, check.Commentf("expected IsNotDir error, but got %T: %s", err, err)) } // Test for error when SRC is a valid file or directory, // bu the DST parent directory does not exist. func (s *DockerSuite) TestCpToErrDstParentNotExists(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-to-err-dst-parent-not-exists") defer os.RemoveAll(tmpDir) @@ -81,27 +71,19 @@ func (s *DockerSuite) TestCpToErrDstParentNotExists(c *check.C) { // Try with a file source. srcPath := cpPath(tmpDir, "file1") - dstPath := containerCpPath(cID, "/notExists", "file1") + dstPath := containerCpPath(containerID, "/notExists", "file1") err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected IsNotExist error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpNotExist(err) { - c.Fatalf("expected IsNotExist error, but got %T: %s", err, err) - } + c.Assert(isCpNotExist(err), checker.True, check.Commentf("expected IsNotExist error, but got %T: %s", err, err)) // Try with a directory source. srcPath = cpPath(tmpDir, "dir1") - if err := runDockerCp(c, srcPath, dstPath); err == nil { - c.Fatal("expected IsNotExist error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpNotExist(err) { - c.Fatalf("expected IsNotExist error, but got %T: %s", err, err) - } + c.Assert(isCpNotExist(err), checker.True, check.Commentf("expected IsNotExist error, but got %T: %s", err, err)) } // Test for error when DST ends in a trailing path separator but exists as a @@ -109,8 +91,7 @@ func (s *DockerSuite) TestCpToErrDstParentNotExists(c *check.C) { // non-directory and cannot overwrite an existing func (s *DockerSuite) TestCpToErrDstNotDir(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{addContent: true}) - defer deleteContainer(cID) + containerID := makeTestContainer(c, testContainerOptions{addContent: true}) tmpDir := getTestDir(c, "test-cp-to-err-dst-not-dir") defer os.RemoveAll(tmpDir) @@ -119,19 +100,15 @@ func (s *DockerSuite) TestCpToErrDstNotDir(c *check.C) { // Try with a file source. srcPath := cpPath(tmpDir, "dir1/file1-1") - dstPath := containerCpPathTrailingSep(cID, "file1") + dstPath := containerCpPathTrailingSep(containerID, "file1") // The client should encounter an error trying to stat the destination // and then be unable to copy since the destination is asserted to be a // directory but does not exist. err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected DirNotExist error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpDirNotExist(err) { - c.Fatalf("expected DirNotExist error, but got %T: %s", err, err) - } + c.Assert(isCpDirNotExist(err), checker.True, check.Commentf("expected DirNotExist error, but got %T: %s", err, err)) // Try with a directory source. srcPath = cpPath(tmpDir, "dir1") @@ -141,13 +118,9 @@ func (s *DockerSuite) TestCpToErrDstNotDir(c *check.C) { // name in the source archive, but this directory would overwrite the // existing file with the same name. err = runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected CannotOverwriteNonDirWithDir error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCannotOverwriteNonDirWithDir(err) { - c.Fatalf("expected CannotOverwriteNonDirWithDir error, but got %T: %s", err, err) - } + c.Assert(isCannotOverwriteNonDirWithDir(err), checker.True, check.Commentf("expected CannotOverwriteNonDirWithDir error, but got %T: %s", err, err)) } // Check that copying from a local path to a symlink in a container copies to @@ -163,106 +136,75 @@ func (s *DockerSuite) TestCpToSymlinkDestination(c *check.C) { makeTestContentInDir(c, testVol) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ volumes: defaultVolumes(testVol), // Our bind mount is at /vol2 }) - defer deleteContainer(cID) // First, copy a local file to a symlink to a file in the container. This // should overwrite the symlink target contents with the source contents. srcPath := cpPath(testVol, "file2") - dstPath := containerCpPath(cID, "/vol2/symlinkToFile1") + dstPath := containerCpPath(containerID, "/vol2/symlinkToFile1") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, cpPath(testVol, "symlinkToFile1"), "file1"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, cpPath(testVol, "symlinkToFile1"), "file1"), checker.IsNil) // The file should have the contents of "file2" now. - if err := fileContentEquals(c, cpPath(testVol, "file1"), "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(testVol, "file1"), "file2\n"), checker.IsNil) // Next, copy a local file to a symlink to a directory in the container. // This should copy the file into the symlink target directory. - dstPath = containerCpPath(cID, "/vol2/symlinkToDir1") + dstPath = containerCpPath(containerID, "/vol2/symlinkToDir1") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1"), checker.IsNil) // The file should have the contents of "file2" now. - if err := fileContentEquals(c, cpPath(testVol, "file2"), "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(testVol, "file2"), "file2\n"), checker.IsNil) // Next, copy a file to a symlink to a file that does not exist (a broken // symlink) in the container. This should create the target file with the // contents of the source file. - dstPath = containerCpPath(cID, "/vol2/brokenSymlinkToFileX") + dstPath = containerCpPath(containerID, "/vol2/brokenSymlinkToFileX") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToFileX"), "fileX"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToFileX"), "fileX"), checker.IsNil) // The file should have the contents of "file2" now. - if err := fileContentEquals(c, cpPath(testVol, "fileX"), "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(testVol, "fileX"), "file2\n"), checker.IsNil) // Next, copy a local directory to a symlink to a directory in the // container. This should copy the directory into the symlink target // directory and not modify the symlink. srcPath = cpPath(testVol, "/dir2") - dstPath = containerCpPath(cID, "/vol2/symlinkToDir1") + dstPath = containerCpPath(containerID, "/vol2/symlinkToDir1") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1"), checker.IsNil) // The directory should now contain a copy of "dir2". - if err := fileContentEquals(c, cpPath(testVol, "dir1/dir2/file2-1"), "file2-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(testVol, "dir1/dir2/file2-1"), "file2-1\n"), checker.IsNil) // Next, copy a local directory to a symlink to a local directory that does // not exist (a broken symlink) in the container. This should create the // target as a directory with the contents of the source directory. It // should not modify the symlink. - dstPath = containerCpPath(cID, "/vol2/brokenSymlinkToDirX") + dstPath = containerCpPath(containerID, "/vol2/brokenSymlinkToDirX") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // The symlink should not have been modified. - if err := symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToDirX"), "dirX"); err != nil { - c.Fatal(err) - } + c.Assert(symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToDirX"), "dirX"), checker.IsNil) // The "dirX" directory should now be a copy of "dir2". - if err := fileContentEquals(c, cpPath(testVol, "dirX/file2-1"), "file2-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(fileContentEquals(c, cpPath(testVol, "dirX/file2-1"), "file2-1\n"), checker.IsNil) } // Possibilities are reduced to the remaining 10 cases: @@ -286,10 +228,9 @@ func (s *DockerSuite) TestCpToSymlinkDestination(c *check.C) { // contents of the source file into it. func (s *DockerSuite) TestCpToCaseA(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ workDir: "/root", command: makeCatFileCommand("itWorks.txt"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-a") defer os.RemoveAll(tmpDir) @@ -297,15 +238,11 @@ func (s *DockerSuite) TestCpToCaseA(c *check.C) { makeTestContentInDir(c, tmpDir) srcPath := cpPath(tmpDir, "file1") - dstPath := containerCpPath(cID, "/root/itWorks.txt") + dstPath := containerCpPath(containerID, "/root/itWorks.txt") - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) - if err := containerStartOutputEquals(c, cID, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil) } // B. SRC specifies a file and DST (with trailing path separator) doesn't @@ -313,10 +250,9 @@ func (s *DockerSuite) TestCpToCaseA(c *check.C) { // create a directory when copying a single file. func (s *DockerSuite) TestCpToCaseB(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ command: makeCatFileCommand("testDir/file1"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-b") defer os.RemoveAll(tmpDir) @@ -324,27 +260,22 @@ func (s *DockerSuite) TestCpToCaseB(c *check.C) { makeTestContentInDir(c, tmpDir) srcPath := cpPath(tmpDir, "file1") - dstDir := containerCpPathTrailingSep(cID, "testDir") + dstDir := containerCpPathTrailingSep(containerID, "testDir") err := runDockerCp(c, srcPath, dstDir) - if err == nil { - c.Fatal("expected DirNotExists error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpDirNotExist(err) { - c.Fatalf("expected DirNotExists error, but got %T: %s", err, err) - } + c.Assert(isCpDirNotExist(err), checker.True, check.Commentf("expected DirNotExists error, but got %T: %s", err, err)) } // C. SRC specifies a file and DST exists as a file. This should overwrite // the file at DST with the contents of the source file. func (s *DockerSuite) TestCpToCaseC(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", command: makeCatFileCommand("file2"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-c") defer os.RemoveAll(tmpDir) @@ -352,21 +283,15 @@ func (s *DockerSuite) TestCpToCaseC(c *check.C) { makeTestContentInDir(c, tmpDir) srcPath := cpPath(tmpDir, "file1") - dstPath := containerCpPath(cID, "/root/file2") + dstPath := containerCpPath(containerID, "/root/file2") // Ensure the container's file starts with the original content. - if err := containerStartOutputEquals(c, cID, "file2\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file2\n"), checker.IsNil) - if err := runDockerCp(c, srcPath, dstPath); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstPath), checker.IsNil) // Should now contain file1's contents. - if err := containerStartOutputEquals(c, cID, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil) } // D. SRC specifies a file and DST exists as a directory. This should place @@ -374,11 +299,10 @@ func (s *DockerSuite) TestCpToCaseC(c *check.C) { // this works whether DST has a trailing path separator or not. func (s *DockerSuite) TestCpToCaseD(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, command: makeCatFileCommand("/dir1/file1"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-d") defer os.RemoveAll(tmpDir) @@ -386,46 +310,33 @@ func (s *DockerSuite) TestCpToCaseD(c *check.C) { makeTestContentInDir(c, tmpDir) srcPath := cpPath(tmpDir, "file1") - dstDir := containerCpPath(cID, "dir1") + dstDir := containerCpPath(containerID, "dir1") // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) - if err := runDockerCp(c, srcPath, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstDir), checker.IsNil) // Should now contain file1's contents. - if err := containerStartOutputEquals(c, cID, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. // Make new destination container. - cID = makeTestContainer(c, testContainerOptions{ + containerID = makeTestContainer(c, testContainerOptions{ addContent: true, command: makeCatFileCommand("/dir1/file1"), }) - defer deleteContainer(cID) - dstDir = containerCpPathTrailingSep(cID, "dir1") + dstDir = containerCpPathTrailingSep(containerID, "dir1") // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) - if err := runDockerCp(c, srcPath, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcPath, dstDir), checker.IsNil) // Should now contain file1's contents. - if err := containerStartOutputEquals(c, cID, "file1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil) } // E. SRC specifies a directory and DST does not exist. This should create a @@ -434,10 +345,9 @@ func (s *DockerSuite) TestCpToCaseD(c *check.C) { // not. func (s *DockerSuite) TestCpToCaseE(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ command: makeCatFileCommand("/testDir/file1-1"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-e") defer os.RemoveAll(tmpDir) @@ -445,46 +355,35 @@ func (s *DockerSuite) TestCpToCaseE(c *check.C) { makeTestContentInDir(c, tmpDir) srcDir := cpPath(tmpDir, "dir1") - dstDir := containerCpPath(cID, "testDir") + dstDir := containerCpPath(containerID, "testDir") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. // Make new destination container. - cID = makeTestContainer(c, testContainerOptions{ + containerID = makeTestContainer(c, testContainerOptions{ command: makeCatFileCommand("/testDir/file1-1"), }) - defer deleteContainer(cID) - dstDir = containerCpPathTrailingSep(cID, "testDir") + dstDir = containerCpPathTrailingSep(containerID, "testDir") - err := runDockerCp(c, srcDir, dstDir) - if err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) } // F. SRC specifies a directory and DST exists as a file. This should cause an // error as it is not possible to overwrite a file with a directory. func (s *DockerSuite) TestCpToCaseF(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-f") defer os.RemoveAll(tmpDir) @@ -492,16 +391,12 @@ func (s *DockerSuite) TestCpToCaseF(c *check.C) { makeTestContentInDir(c, tmpDir) srcDir := cpPath(tmpDir, "dir1") - dstFile := containerCpPath(cID, "/root/file1") + dstFile := containerCpPath(containerID, "/root/file1") err := runDockerCp(c, srcDir, dstFile) - if err == nil { - c.Fatal("expected ErrCannotCopyDir error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpCannotCopyDir(err) { - c.Fatalf("expected ErrCannotCopyDir error, but got %T: %s", err, err) - } + c.Assert(isCpCannotCopyDir(err), checker.True, check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err)) } // G. SRC specifies a directory and DST exists as a directory. This should copy @@ -509,11 +404,10 @@ func (s *DockerSuite) TestCpToCaseF(c *check.C) { // works whether DST has a trailing path separator or not. func (s *DockerSuite) TestCpToCaseG(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", command: makeCatFileCommand("dir2/dir1/file1-1"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-g") defer os.RemoveAll(tmpDir) @@ -521,46 +415,33 @@ func (s *DockerSuite) TestCpToCaseG(c *check.C) { makeTestContentInDir(c, tmpDir) srcDir := cpPath(tmpDir, "dir1") - dstDir := containerCpPath(cID, "/root/dir2") + dstDir := containerCpPath(containerID, "/root/dir2") // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. // Make new destination container. - cID = makeTestContainer(c, testContainerOptions{ + containerID = makeTestContainer(c, testContainerOptions{ addContent: true, command: makeCatFileCommand("/dir2/dir1/file1-1"), }) - defer deleteContainer(cID) - dstDir = containerCpPathTrailingSep(cID, "/dir2") + dstDir = containerCpPathTrailingSep(containerID, "/dir2") // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) } // H. SRC specifies a directory's contents only and DST does not exist. This @@ -569,10 +450,9 @@ func (s *DockerSuite) TestCpToCaseG(c *check.C) { // this works whether DST has a trailing path separator or not. func (s *DockerSuite) TestCpToCaseH(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ command: makeCatFileCommand("/testDir/file1-1"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-h") defer os.RemoveAll(tmpDir) @@ -580,35 +460,26 @@ func (s *DockerSuite) TestCpToCaseH(c *check.C) { makeTestContentInDir(c, tmpDir) srcDir := cpPathTrailingSep(tmpDir, "dir1") + "." - dstDir := containerCpPath(cID, "testDir") + dstDir := containerCpPath(containerID, "testDir") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. // Make new destination container. - cID = makeTestContainer(c, testContainerOptions{ + containerID = makeTestContainer(c, testContainerOptions{ command: makeCatFileCommand("/testDir/file1-1"), }) - defer deleteContainer(cID) - dstDir = containerCpPathTrailingSep(cID, "testDir") + dstDir = containerCpPathTrailingSep(containerID, "testDir") - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) } // I. SRC specifies a directory's contents only and DST exists as a file. This @@ -616,10 +487,9 @@ func (s *DockerSuite) TestCpToCaseH(c *check.C) { // directory. func (s *DockerSuite) TestCpToCaseI(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-i") defer os.RemoveAll(tmpDir) @@ -627,16 +497,12 @@ func (s *DockerSuite) TestCpToCaseI(c *check.C) { makeTestContentInDir(c, tmpDir) srcDir := cpPathTrailingSep(tmpDir, "dir1") + "." - dstFile := containerCpPath(cID, "/root/file1") + dstFile := containerCpPath(containerID, "/root/file1") err := runDockerCp(c, srcDir, dstFile) - if err == nil { - c.Fatal("expected ErrCannotCopyDir error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpCannotCopyDir(err) { - c.Fatalf("expected ErrCannotCopyDir error, but got %T: %s", err, err) - } + c.Assert(isCpCannotCopyDir(err), checker.True, check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err)) } // J. SRC specifies a directory's contents only and DST exists as a directory. @@ -645,11 +511,10 @@ func (s *DockerSuite) TestCpToCaseI(c *check.C) { // trailing path separator or not. func (s *DockerSuite) TestCpToCaseJ(c *check.C) { testRequires(c, DaemonIsLinux) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ addContent: true, workDir: "/root", command: makeCatFileCommand("/dir2/file1-1"), }) - defer deleteContainer(cID) tmpDir := getTestDir(c, "test-cp-to-case-j") defer os.RemoveAll(tmpDir) @@ -657,45 +522,32 @@ func (s *DockerSuite) TestCpToCaseJ(c *check.C) { makeTestContentInDir(c, tmpDir) srcDir := cpPathTrailingSep(tmpDir, "dir1") + "." - dstDir := containerCpPath(cID, "/dir2") + dstDir := containerCpPath(containerID, "/dir2") // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) // Now try again but using a trailing path separator for dstDir. // Make new destination container. - cID = makeTestContainer(c, testContainerOptions{ + containerID = makeTestContainer(c, testContainerOptions{ command: makeCatFileCommand("/dir2/file1-1"), }) - defer deleteContainer(cID) - dstDir = containerCpPathTrailingSep(cID, "/dir2") + dstDir = containerCpPathTrailingSep(containerID, "/dir2") // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) - if err := runDockerCp(c, srcDir, dstDir); err != nil { - c.Fatalf("unexpected error %T: %s", err, err) - } + c.Assert(runDockerCp(c, srcDir, dstDir), checker.IsNil) // Should now contain file1-1's contents. - if err := containerStartOutputEquals(c, cID, "file1-1\n"); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil) } // The `docker cp` command should also ensure that you cannot @@ -708,28 +560,21 @@ func (s *DockerSuite) TestCpToErrReadOnlyRootfs(c *check.C) { makeTestContentInDir(c, tmpDir) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ readOnly: true, workDir: "/root", command: makeCatFileCommand("shouldNotExist"), }) - defer deleteContainer(cID) srcPath := cpPath(tmpDir, "file1") - dstPath := containerCpPath(cID, "/root/shouldNotExist") + dstPath := containerCpPath(containerID, "/root/shouldNotExist") err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected ErrContainerRootfsReadonly error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpCannotCopyReadOnly(err) { - c.Fatalf("expected ErrContainerRootfsReadonly error, but got %T: %s", err, err) - } + c.Assert(isCpCannotCopyReadOnly(err), checker.True, check.Commentf("expected ErrContainerRootfsReadonly error, but got %T: %s", err, err)) // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) } // The `docker cp` command should also ensure that you @@ -742,26 +587,19 @@ func (s *DockerSuite) TestCpToErrReadOnlyVolume(c *check.C) { makeTestContentInDir(c, tmpDir) - cID := makeTestContainer(c, testContainerOptions{ + containerID := makeTestContainer(c, testContainerOptions{ volumes: defaultVolumes(tmpDir), workDir: "/root", command: makeCatFileCommand("/vol_ro/shouldNotExist"), }) - defer deleteContainer(cID) srcPath := cpPath(tmpDir, "file1") - dstPath := containerCpPath(cID, "/vol_ro/shouldNotExist") + dstPath := containerCpPath(containerID, "/vol_ro/shouldNotExist") err := runDockerCp(c, srcPath, dstPath) - if err == nil { - c.Fatal("expected ErrVolumeReadonly error, but got nil instead") - } + c.Assert(err, checker.NotNil) - if !isCpCannotCopyReadOnly(err) { - c.Fatalf("expected ErrVolumeReadonly error, but got %T: %s", err, err) - } + c.Assert(isCpCannotCopyReadOnly(err), checker.True, check.Commentf("expected ErrVolumeReadonly error, but got %T: %s", err, err)) // Ensure that dstPath doesn't exist. - if err := containerStartOutputEquals(c, cID, ""); err != nil { - c.Fatal(err) - } + c.Assert(containerStartOutputEquals(c, containerID, ""), checker.IsNil) } diff --git a/integration-cli/docker_cli_cp_utils.go b/integration-cli/docker_cli_cp_utils.go index 4642922e00..0501c5d735 100644 --- a/integration-cli/docker_cli_cp_utils.go +++ b/integration-cli/docker_cli_cp_utils.go @@ -10,6 +10,7 @@ import ( "strings" "github.com/docker/docker/pkg/archive" + "github.com/docker/docker/pkg/integration/checker" "github.com/go-check/check" ) @@ -90,17 +91,11 @@ func makeTestContentInDir(c *check.C, dir string) { path := filepath.Join(dir, filepath.FromSlash(fd.path)) switch fd.filetype { case ftRegular: - if err := ioutil.WriteFile(path, []byte(fd.contents+"\n"), os.FileMode(0666)); err != nil { - c.Fatal(err) - } + c.Assert(ioutil.WriteFile(path, []byte(fd.contents+"\n"), os.FileMode(0666)), checker.IsNil) case ftDir: - if err := os.Mkdir(path, os.FileMode(0777)); err != nil { - c.Fatal(err) - } + c.Assert(os.Mkdir(path, os.FileMode(0777)), checker.IsNil) case ftSymlink: - if err := os.Symlink(fd.contents, path); err != nil { - c.Fatal(err) - } + c.Assert(os.Symlink(fd.contents, path), checker.IsNil) } } } @@ -143,25 +138,17 @@ func makeTestContainer(c *check.C, options testContainerOptions) (containerID st args = append(args, "busybox", "/bin/sh", "-c", options.command) - out, status := dockerCmd(c, args...) - if status != 0 { - c.Fatalf("failed to run container, status %d: %s", status, out) - } + out, _ := dockerCmd(c, args...) containerID = strings.TrimSpace(out) - out, status = dockerCmd(c, "wait", containerID) - if status != 0 { - c.Fatalf("failed to wait for test container container, status %d: %s", status, out) - } + out, _ = dockerCmd(c, "wait", containerID) - if exitCode := strings.TrimSpace(out); exitCode != "0" { - logs, status := dockerCmd(c, "logs", containerID) - if status != 0 { - logs = "UNABLE TO GET LOGS" - } - c.Fatalf("failed to make test container, exit code (%s): %s", exitCode, logs) + exitCode := strings.TrimSpace(out) + if exitCode != "0" { + out, _ = dockerCmd(c, "logs", containerID) } + c.Assert(exitCode, checker.Equals, "0", check.Commentf("failed to make test container: %s", out)) return } @@ -204,10 +191,10 @@ func runDockerCp(c *check.C, src, dst string) (err error) { return } -func startContainerGetOutput(c *check.C, cID string) (out string, err error) { - c.Logf("running `docker start -a %s`", cID) +func startContainerGetOutput(c *check.C, containerID string) (out string, err error) { + c.Logf("running `docker start -a %s`", containerID) - args := []string{"start", "-a", cID} + args := []string{"start", "-a", containerID} out, _, err = runCommandWithOutput(exec.Command(dockerBinary, args...)) if err != nil { @@ -220,9 +207,9 @@ func startContainerGetOutput(c *check.C, cID string) (out string, err error) { func getTestDir(c *check.C, label string) (tmpDir string) { var err error - if tmpDir, err = ioutil.TempDir("", label); err != nil { - c.Fatalf("unable to make temporary directory: %s", err) - } + tmpDir, err = ioutil.TempDir("", label) + // unable to make temporary directory + c.Assert(err, checker.IsNil) return } @@ -276,22 +263,22 @@ func symlinkTargetEquals(c *check.C, symlink, expectedTarget string) (err error) actualTarget, err := os.Readlink(symlink) if err != nil { - return err + return } if actualTarget != expectedTarget { - return fmt.Errorf("symlink target points to %q not %q", actualTarget, expectedTarget) + err = fmt.Errorf("symlink target points to %q not %q", actualTarget, expectedTarget) } - return nil + return } -func containerStartOutputEquals(c *check.C, cID, contents string) (err error) { - c.Logf("checking that container %q start output contains %q\n", cID, contents) +func containerStartOutputEquals(c *check.C, containerID, contents string) (err error) { + c.Logf("checking that container %q start output contains %q\n", containerID, contents) - out, err := startContainerGetOutput(c, cID) + out, err := startContainerGetOutput(c, containerID) if err != nil { - return err + return } if out != contents {