gopkg.in/docker/docker.v20@v20.10.27/integration-cli/docker_cli_import_test.go (about)

     1  package main
     2  
     3  import (
     4  	"bufio"
     5  	"compress/gzip"
     6  	"os"
     7  	"os/exec"
     8  	"regexp"
     9  	"strings"
    10  	"testing"
    11  
    12  	"github.com/docker/docker/integration-cli/cli"
    13  	"gotest.tools/v3/assert"
    14  	"gotest.tools/v3/icmd"
    15  )
    16  
    17  func (s *DockerSuite) TestImportDisplay(c *testing.T) {
    18  	testRequires(c, DaemonIsLinux)
    19  	out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
    20  	cleanedContainerID := strings.TrimSpace(out)
    21  
    22  	out, err := RunCommandPipelineWithOutput(
    23  		exec.Command(dockerBinary, "export", cleanedContainerID),
    24  		exec.Command(dockerBinary, "import", "-"),
    25  	)
    26  	assert.NilError(c, err)
    27  
    28  	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
    29  
    30  	image := strings.TrimSpace(out)
    31  	out, _ = dockerCmd(c, "run", "--rm", image, "true")
    32  	assert.Equal(c, out, "", "command output should've been nothing.")
    33  }
    34  
    35  func (s *DockerSuite) TestImportBadURL(c *testing.T) {
    36  	out, _, err := dockerCmdWithError("import", "http://nourl/bad")
    37  	assert.Assert(c, err != nil, "import was supposed to fail but didn't")
    38  	// Depending on your system you can get either of these errors
    39  	if !strings.Contains(out, "dial tcp") &&
    40  		!strings.Contains(out, "ApplyLayer exit status 1 stdout:  stderr: archive/tar: invalid tar header") &&
    41  		!strings.Contains(out, "Error processing tar file") {
    42  		c.Fatalf("expected an error msg but didn't get one.\nErr: %v\nOut: %v", err, out)
    43  	}
    44  }
    45  
    46  func (s *DockerSuite) TestImportFile(c *testing.T) {
    47  	testRequires(c, DaemonIsLinux)
    48  	dockerCmd(c, "run", "--name", "test-import", "busybox", "true")
    49  
    50  	temporaryFile, err := os.CreateTemp("", "exportImportTest")
    51  	assert.Assert(c, err == nil, "failed to create temporary file")
    52  	defer os.Remove(temporaryFile.Name())
    53  
    54  	icmd.RunCmd(icmd.Cmd{
    55  		Command: []string{dockerBinary, "export", "test-import"},
    56  		Stdout:  bufio.NewWriter(temporaryFile),
    57  	}).Assert(c, icmd.Success)
    58  
    59  	out, _ := dockerCmd(c, "import", temporaryFile.Name())
    60  	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
    61  	image := strings.TrimSpace(out)
    62  
    63  	out, _ = dockerCmd(c, "run", "--rm", image, "true")
    64  	assert.Equal(c, out, "", "command output should've been nothing.")
    65  }
    66  
    67  func (s *DockerSuite) TestImportGzipped(c *testing.T) {
    68  	testRequires(c, DaemonIsLinux)
    69  	dockerCmd(c, "run", "--name", "test-import", "busybox", "true")
    70  
    71  	temporaryFile, err := os.CreateTemp("", "exportImportTest")
    72  	assert.Assert(c, err == nil, "failed to create temporary file")
    73  	defer os.Remove(temporaryFile.Name())
    74  
    75  	w := gzip.NewWriter(temporaryFile)
    76  	icmd.RunCmd(icmd.Cmd{
    77  		Command: []string{dockerBinary, "export", "test-import"},
    78  		Stdout:  w,
    79  	}).Assert(c, icmd.Success)
    80  	assert.Assert(c, w.Close() == nil, "failed to close gzip writer")
    81  	temporaryFile.Close()
    82  	out, _ := dockerCmd(c, "import", temporaryFile.Name())
    83  	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
    84  	image := strings.TrimSpace(out)
    85  
    86  	out, _ = dockerCmd(c, "run", "--rm", image, "true")
    87  	assert.Equal(c, out, "", "command output should've been nothing.")
    88  }
    89  
    90  func (s *DockerSuite) TestImportFileWithMessage(c *testing.T) {
    91  	testRequires(c, DaemonIsLinux)
    92  	dockerCmd(c, "run", "--name", "test-import", "busybox", "true")
    93  
    94  	temporaryFile, err := os.CreateTemp("", "exportImportTest")
    95  	assert.Assert(c, err == nil, "failed to create temporary file")
    96  	defer os.Remove(temporaryFile.Name())
    97  
    98  	icmd.RunCmd(icmd.Cmd{
    99  		Command: []string{dockerBinary, "export", "test-import"},
   100  		Stdout:  bufio.NewWriter(temporaryFile),
   101  	}).Assert(c, icmd.Success)
   102  
   103  	message := "Testing commit message"
   104  	out, _ := dockerCmd(c, "import", "-m", message, temporaryFile.Name())
   105  	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
   106  	image := strings.TrimSpace(out)
   107  
   108  	out, _ = dockerCmd(c, "history", image)
   109  	split := strings.Split(out, "\n")
   110  
   111  	assert.Equal(c, len(split), 3, "expected 3 lines from image history")
   112  	r := regexp.MustCompile(`[\s]{2,}`)
   113  	split = r.Split(split[1], -1)
   114  
   115  	assert.Equal(c, message, split[3], "didn't get expected value in commit message")
   116  
   117  	out, _ = dockerCmd(c, "run", "--rm", image, "true")
   118  	assert.Equal(c, out, "", "command output should've been nothing")
   119  }
   120  
   121  func (s *DockerSuite) TestImportFileNonExistentFile(c *testing.T) {
   122  	_, _, err := dockerCmdWithError("import", "example.com/myImage.tar")
   123  	assert.Assert(c, err != nil, "import non-existing file must failed")
   124  }
   125  
   126  func (s *DockerSuite) TestImportWithQuotedChanges(c *testing.T) {
   127  	testRequires(c, DaemonIsLinux)
   128  	cli.DockerCmd(c, "run", "--name", "test-import", "busybox", "true")
   129  
   130  	temporaryFile, err := os.CreateTemp("", "exportImportTest")
   131  	assert.Assert(c, err == nil, "failed to create temporary file")
   132  	defer os.Remove(temporaryFile.Name())
   133  
   134  	cli.Docker(cli.Args("export", "test-import"), cli.WithStdout(bufio.NewWriter(temporaryFile))).Assert(c, icmd.Success)
   135  
   136  	result := cli.DockerCmd(c, "import", "-c", `ENTRYPOINT ["/bin/sh", "-c"]`, temporaryFile.Name())
   137  	image := strings.TrimSpace(result.Stdout())
   138  
   139  	result = cli.DockerCmd(c, "run", "--rm", image, "true")
   140  	result.Assert(c, icmd.Expected{Out: icmd.None})
   141  }