FilesExpand file tree

docker-29.x

/

docker_cli_save_load_unix_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

113 lines (90 loc) · 3.24 KB

docker-29.x

/

docker_cli_save_load_unix_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

113 lines (90 loc) · 3.24 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

//go:build !windows

package main

import (

"context"

"fmt"

"os"

"os/exec"

"strings"

"testing"

"time"

"github.com/creack/pty"

"github.com/moby/moby/v2/integration-cli/cli"

"github.com/moby/moby/v2/integration-cli/cli/build"

"github.com/moby/moby/v2/internal/testutil"

"gotest.tools/v3/assert"

is "gotest.tools/v3/assert/cmp"

"gotest.tools/v3/icmd"

"gotest.tools/v3/skip"

)

// save a repo and try to load it using stdout

func (s *DockerCLISaveLoadSuite) TestSaveAndLoadRepoStdout(c *testing.T) {

name := "test-save-and-load-repo-stdout"

cli.DockerCmd(c, "run", "--name", name, "busybox", "true")

imgRepoName := "foobar-save-load-test"

before := cli.DockerCmd(c, "commit", name, imgRepoName).Stdout()

before = strings.TrimRight(before, "\n")

tmpFile, err := os.CreateTemp(c.TempDir(), "foobar-save-load-test.tar")

assert.NilError(c, err)

c.Cleanup(func() { _ = tmpFile.Close() })

icmd.RunCmd(icmd.Cmd{

Command: []string{dockerBinary, "save", imgRepoName},

Stdout: tmpFile,

}).Assert(c, icmd.Success)

tmpFile, err = os.Open(tmpFile.Name())

assert.NilError(c, err)

c.Cleanup(func() { _ = tmpFile.Close() })

deleteImages(imgRepoName)

icmd.RunCmd(icmd.Cmd{

Command: []string{dockerBinary, "load"},

Stdin: tmpFile,

}).Assert(c, icmd.Success)

after := inspectField(c, imgRepoName, "Id")

after = strings.TrimRight(after, "\n")

assert.Equal(c, after, before, "inspect is not the same after a save / load")

deleteImages(imgRepoName)

p, tty, err := pty.Open()

assert.NilError(c, err)

cmd := exec.Command(dockerBinary, "save", imgRepoName)

cmd.Stdin = tty

cmd.Stdout = tty

cmd.Stderr = tty

assert.NilError(c, cmd.Start())

assert.ErrorContains(c, cmd.Wait(), "", "did not break writing to a TTY")

buf := make([]byte, 1024)

n, err := p.Read(buf)

assert.NilError(c, err, "could not read tty output")

assert.Assert(c, strings.Contains(string(buf[:n]), "cowardly refusing"), "help output is not being yielded")

}

func (s *DockerCLISaveLoadSuite) TestSaveAndLoadWithProgressBar(c *testing.T) {

// TODO(vvoland): https://github.com/moby/moby/issues/43910

skip.If(c, testEnv.UsingSnapshotter(), "TODO: Not implemented yet")

name := "test-load"

cli.BuildCmd(c, name, build.WithDockerfile(`FROM busybox

RUN touch aa

`))

tmptar := name + ".tar"

cli.DockerCmd(c, "save", "-o", tmptar, name)

c.Cleanup(func() { _ = os.Remove(tmptar) })

cli.DockerCmd(c, "rmi", name)

cli.DockerCmd(c, "tag", "busybox", name)

out := cli.DockerCmd(c, "load", "-i", tmptar).Combined()

expected := fmt.Sprintf("The image %s:latest already exists, renaming the old one with ID", name)

assert.Assert(c, is.Contains(out, expected))

}

// fail because load didn't receive data from stdin

func (s *DockerCLISaveLoadSuite) TestLoadNoStdinFail(c *testing.T) {

p, tty, err := pty.Open()

assert.NilError(c, err)

ctx, cancel := context.WithTimeout(testutil.GetContext(c), 5*time.Second)

defer cancel()

cmd := exec.CommandContext(ctx, dockerBinary, "load")

cmd.Stdin = tty

cmd.Stdout = tty

cmd.Stderr = tty

assert.ErrorContains(c, cmd.Run(), "", "docker-load should fail")

buf := make([]byte, 1024)

n, err := p.Read(buf)

assert.NilError(c, err) // could not read tty output

assert.Assert(c, is.Contains(string(buf[:n]), "requested load from stdin, but stdin is empty"))

}