package main
 
 import (
 	"os"
 	"path/filepath"

 	"testing"

 	"gotest.tools/assert"

 )
 
 // Try all of the test cases from the archive package which implements the
 // internals of `docker cp` and ensure that the behavior matches when actually
 // copying to and from containers.
 
 // Basic assumptions about SRC and DST:
 // 1. SRC must exist.
 // 2. If SRC ends with a trailing separator, it must be a directory.
 // 3. DST parent directory must exist.
 // 4. If DST exists as a file, it must not end with a trailing separator.
 

 // Check that copying from a container to a local symlink copies to the symlink
 // target and does not overwrite the local symlink itself.

 // TODO: move to docker/cli and/or integration/container/copy_test.go

 func (s *DockerSuite) TestCpFromSymlinkDestination(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{addContent: true})

 
 	tmpDir := getTestDir(c, "test-cp-from-err-dst-not-dir")
 	defer os.RemoveAll(tmpDir)
 
 	makeTestContentInDir(c, tmpDir)
 
 	// 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(containerID, "/file2")

 	dstPath := cpPath(tmpDir, "symlinkToFile1")
 

 	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 
 	// The symlink should not have been modified.

 	assert.Assert(c, symlinkTargetEquals(c, dstPath, "file1") == nil)

 
 	// The file should have the contents of "file2" now.

 	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "file1"), "file2\n") == nil)

 
 	// 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")
 

 	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 
 	// The symlink should not have been modified.

 	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dir1") == nil)

 
 	// The file should have the contents of "file2" now.

 	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "file2"), "file2\n") == nil)

 
 	// 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")
 

 	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 
 	// The symlink should not have been modified.

 	assert.Assert(c, symlinkTargetEquals(c, dstPath, "fileX") == nil)

 
 	// The file should have the contents of "file2" now.

 	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "fileX"), "file2\n") == nil)

 
 	// 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(containerID, "/dir2")

 	dstPath = cpPath(tmpDir, "symlinkToDir1")
 

 	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 
 	// The symlink should not have been modified.

 	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dir1") == nil)

 
 	// The directory should now contain a copy of "dir2".

 	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "dir1/dir2/file2-1"), "file2-1\n") == nil)

 
 	// Next, copy a directory from the container to a symlink to a local
 	// directory that does not exist (a broken symlink). This should create
 	// the target as a directory with the contents of the source directory. It
 	// should not modify the symlink.
 	dstPath = cpPath(tmpDir, "brokenSymlinkToDirX")
 

 	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 
 	// The symlink should not have been modified.

 	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dirX") == nil)

 
 	// The "dirX" directory should now be a copy of "dir2".

 	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "dirX/file2-1"), "file2-1\n") == nil)

 }
 

 // Possibilities are reduced to the remaining 10 cases:
 //
 //  case | srcIsDir | onlyDirContents | dstExists | dstIsDir | dstTrSep | action
 // ===================================================================================================
 //   A   |  no      |  -              |  no       |  -       |  no      |  create file
 //   B   |  no      |  -              |  no       |  -       |  yes     |  error
 //   C   |  no      |  -              |  yes      |  no      |  -       |  overwrite file
 //   D   |  no      |  -              |  yes      |  yes     |  -       |  create file in dst dir
 //   E   |  yes     |  no             |  no       |  -       |  -       |  create dir, copy contents
 //   F   |  yes     |  no             |  yes      |  no      |  -       |  error
 //   G   |  yes     |  no             |  yes      |  yes     |  -       |  copy dir and contents
 //   H   |  yes     |  yes            |  no       |  -       |  -       |  create dir, copy contents
 //   I   |  yes     |  yes            |  yes      |  no      |  -       |  error
 //   J   |  yes     |  yes            |  yes      |  yes     |  -       |  copy dir contents
 //
 
 // A. SRC specifies a file and DST (no trailing path separator) doesn't
 //    exist. This should create a file with the name DST and copy the
 //    contents of the source file into it.

 func (s *DockerSuite) TestCpFromCaseA(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{

 		addContent: true, workDir: "/root",
 	})
 
 	tmpDir := getTestDir(c, "test-cp-from-case-a")
 	defer os.RemoveAll(tmpDir)
 

 	srcPath := containerCpPath(containerID, "/root/file1")

 	dstPath := cpPath(tmpDir, "itWorks.txt")
 

 	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 }
 
 // B. SRC specifies a file and DST (with trailing path separator) doesn't
 //    exist. This should cause an error because the copy operation cannot
 //    create a directory when copying a single file.

 func (s *DockerSuite) TestCpFromCaseB(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{addContent: true})

 
 	tmpDir := getTestDir(c, "test-cp-from-case-b")
 	defer os.RemoveAll(tmpDir)
 

 	srcPath := containerCpPath(containerID, "/file1")

 	dstDir := cpPathTrailingSep(tmpDir, "testDir")
 

 	err := runDockerCp(c, srcPath, dstDir, nil)

 	assert.ErrorContains(c, err, "")

 	assert.Assert(c, isCpDirNotExist(err), "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 *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{

 		addContent: true, workDir: "/root",
 	})
 
 	tmpDir := getTestDir(c, "test-cp-from-case-c")
 	defer os.RemoveAll(tmpDir)
 
 	makeTestContentInDir(c, tmpDir)
 

 	srcPath := containerCpPath(containerID, "/root/file1")

 	dstPath := cpPath(tmpDir, "file2")
 
 	// Ensure the local file starts with different content.

 	assert.Assert(c, fileContentEquals(c, dstPath, "file2\n") == nil)

 	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 }
 
 // D. SRC specifies a file and DST exists as a directory. This should place
 //    a copy of the source file inside it using the basename from SRC. Ensure
 //    this works whether DST has a trailing path separator or not.

 func (s *DockerSuite) TestCpFromCaseD(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{addContent: true})

 
 	tmpDir := getTestDir(c, "test-cp-from-case-d")
 	defer os.RemoveAll(tmpDir)
 
 	makeTestContentInDir(c, tmpDir)
 

 	srcPath := containerCpPath(containerID, "/file1")

 	dstDir := cpPath(tmpDir, "dir1")
 	dstPath := filepath.Join(dstDir, "file1")
 
 	// Ensure that dstPath doesn't exist.

 	_, err := os.Stat(dstPath)

 	assert.Assert(c, os.IsNotExist(err), "did not expect dstPath %q to exist", dstPath)

 	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 
 	// Now try again but using a trailing path separator for dstDir.
 

 	// unable to remove dstDir

 	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	// unable to make dstDir

 	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)) == nil)

 
 	dstDir = cpPathTrailingSep(tmpDir, "dir1")
 

 	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 }
 
 // E. SRC specifies a directory and DST does not exist. This should create a
 //    directory at DST and copy the contents of the SRC directory into the DST
 //    directory. Ensure this works whether DST has a trailing path separator or
 //    not.

 func (s *DockerSuite) TestCpFromCaseE(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{addContent: true})

 
 	tmpDir := getTestDir(c, "test-cp-from-case-e")
 	defer os.RemoveAll(tmpDir)
 

 	srcDir := containerCpPath(containerID, "dir1")

 	dstDir := cpPath(tmpDir, "testDir")
 	dstPath := filepath.Join(dstDir, "file1-1")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 
 	// Now try again but using a trailing path separator for dstDir.
 

 	// unable to remove dstDir

 	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 
 	dstDir = cpPathTrailingSep(tmpDir, "testDir")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }
 
 // 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 *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{

 		addContent: true, workDir: "/root",
 	})
 
 	tmpDir := getTestDir(c, "test-cp-from-case-f")
 	defer os.RemoveAll(tmpDir)
 
 	makeTestContentInDir(c, tmpDir)
 

 	srcDir := containerCpPath(containerID, "/root/dir1")

 	dstFile := cpPath(tmpDir, "file1")
 

 	err := runDockerCp(c, srcDir, dstFile, nil)

 	assert.ErrorContains(c, err, "")

 	assert.Assert(c, isCpCannotCopyDir(err), "expected ErrCannotCopyDir error, but got %T: %s", err, err)

 }
 
 // G. SRC specifies a directory and DST exists as a directory. This should copy
 //    the SRC directory and all its contents to the DST directory. Ensure this
 //    works whether DST has a trailing path separator or not.

 func (s *DockerSuite) TestCpFromCaseG(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{

 		addContent: true, workDir: "/root",
 	})
 
 	tmpDir := getTestDir(c, "test-cp-from-case-g")
 	defer os.RemoveAll(tmpDir)
 
 	makeTestContentInDir(c, tmpDir)
 

 	srcDir := containerCpPath(containerID, "/root/dir1")

 	dstDir := cpPath(tmpDir, "dir2")
 	resultDir := filepath.Join(dstDir, "dir1")
 	dstPath := filepath.Join(resultDir, "file1-1")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 
 	// Now try again but using a trailing path separator for dstDir.
 

 	// unable to remove dstDir

 	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	// unable to make dstDir

 	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)) == nil)

 
 	dstDir = cpPathTrailingSep(tmpDir, "dir2")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }
 
 // H. SRC specifies a directory's contents only and DST does not exist. This
 //    should create a directory at DST and copy the contents of the SRC
 //    directory (but not the directory itself) into the DST directory. Ensure
 //    this works whether DST has a trailing path separator or not.

 func (s *DockerSuite) TestCpFromCaseH(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{addContent: true})

 
 	tmpDir := getTestDir(c, "test-cp-from-case-h")
 	defer os.RemoveAll(tmpDir)
 

 	srcDir := containerCpPathTrailingSep(containerID, "dir1") + "."

 	dstDir := cpPath(tmpDir, "testDir")
 	dstPath := filepath.Join(dstDir, "file1-1")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 
 	// Now try again but using a trailing path separator for dstDir.
 

 	// unable to remove resultDir

 	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 
 	dstDir = cpPathTrailingSep(tmpDir, "testDir")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }
 

 // I. SRC specifies a directory's contents only 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) TestCpFromCaseI(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{

 		addContent: true, workDir: "/root",
 	})
 
 	tmpDir := getTestDir(c, "test-cp-from-case-i")
 	defer os.RemoveAll(tmpDir)
 
 	makeTestContentInDir(c, tmpDir)
 

 	srcDir := containerCpPathTrailingSep(containerID, "/root/dir1") + "."

 	dstFile := cpPath(tmpDir, "file1")
 

 	err := runDockerCp(c, srcDir, dstFile, nil)

 	assert.ErrorContains(c, err, "")

 	assert.Assert(c, isCpCannotCopyDir(err), "expected ErrCannotCopyDir error, but got %T: %s", err, err)

 }
 
 // J. SRC specifies a directory's contents only and DST exists as a directory.
 //    This should copy the contents of the SRC directory (but not the directory
 //    itself) into the DST directory. Ensure this works whether DST has a
 //    trailing path separator or not.

 func (s *DockerSuite) TestCpFromCaseJ(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	containerID := makeTestContainer(c, testContainerOptions{

 		addContent: true, workDir: "/root",
 	})
 
 	tmpDir := getTestDir(c, "test-cp-from-case-j")
 	defer os.RemoveAll(tmpDir)
 
 	makeTestContentInDir(c, tmpDir)
 

 	srcDir := containerCpPathTrailingSep(containerID, "/root/dir1") + "."

 	dstDir := cpPath(tmpDir, "dir2")
 	dstPath := filepath.Join(dstDir, "file1-1")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 
 	// Now try again but using a trailing path separator for dstDir.
 

 	// unable to remove dstDir

 	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	// unable to make dstDir

 	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)) == nil)

 
 	dstDir = cpPathTrailingSep(tmpDir, "dir2")
 

 	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }