FilesExpand file tree

 master

/

docker_cli_pull_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

152 lines (129 loc) · 5.26 KB

 master

/

docker_cli_pull_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

152 lines (129 loc) · 5.26 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

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

package main

import (

"fmt"

"os/exec"

"strings"

"github.com/go-check/check"

)

// See issue docker/docker#8141

func (s *DockerRegistrySuite) TestPullImageWithAliases(c *check.C) {

repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)

repos := []string{}

for _, tag := range []string{"recent", "fresh"} {

repos = append(repos, fmt.Sprintf("%v:%v", repoName, tag))

}

// Tag and push the same image multiple times.

for _, repo := range repos {

if out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "tag", "busybox", repo)); err != nil {

c.Fatalf("Failed to tag image %v: error %v, output %q", repos, err, out)

}

if out, err := exec.Command(dockerBinary, "push", repo).CombinedOutput(); err != nil {

c.Fatalf("Failed to push image %v: error %v, output %q", repo, err, string(out))

}

}

// Clear local images store.

args := append([]string{"rmi"}, repos...)

if out, err := exec.Command(dockerBinary, args...).CombinedOutput(); err != nil {

c.Fatalf("Failed to clean images: error %v, output %q", err, string(out))

}

// Pull a single tag and verify it doesn't bring down all aliases.

pullCmd := exec.Command(dockerBinary, "pull", repos[0])

if out, _, err := runCommandWithOutput(pullCmd); err != nil {

c.Fatalf("Failed to pull %v: error %v, output %q", repoName, err, out)

}

if err := exec.Command(dockerBinary, "inspect", repos[0]).Run(); err != nil {

c.Fatalf("Image %v was not pulled down", repos[0])

}

for _, repo := range repos[1:] {

if err := exec.Command(dockerBinary, "inspect", repo).Run(); err == nil {

c.Fatalf("Image %v shouldn't have been pulled down", repo)

}

}

}

// pulling library/hello-world should show verified message

func (s *DockerSuite) TestPullVerified(c *check.C) {

c.Skip("Skipping hub dependent test")

// Image must be pulled from central repository to get verified message

// unless keychain is manually updated to contain the daemon's sign key.

verifiedName := "hello-world"

// pull it

expected := "The image you are pulling has been verified"

pullCmd := exec.Command(dockerBinary, "pull", verifiedName)

if out, exitCode, err := runCommandWithOutput(pullCmd); err != nil || !strings.Contains(out, expected) {

if err != nil || exitCode != 0 {

c.Skip(fmt.Sprintf("pulling the '%s' image from the registry has failed: %v", verifiedName, err))

}

c.Fatalf("pulling a verified image failed. expected: %s\ngot: %s, %v", expected, out, err)

}

// pull it again

pullCmd = exec.Command(dockerBinary, "pull", verifiedName)

if out, exitCode, err := runCommandWithOutput(pullCmd); err != nil || strings.Contains(out, expected) {

if err != nil || exitCode != 0 {

c.Skip(fmt.Sprintf("pulling the '%s' image from the registry has failed: %v", verifiedName, err))

}

c.Fatalf("pulling a verified image failed. unexpected verify message\ngot: %s, %v", out, err)

}

}

// pulling an image from the central registry should work

func (s *DockerSuite) TestPullImageFromCentralRegistry(c *check.C) {

testRequires(c, Network)

pullCmd := exec.Command(dockerBinary, "pull", "hello-world")

if out, _, err := runCommandWithOutput(pullCmd); err != nil {

c.Fatalf("pulling the hello-world image from the registry has failed: %s, %v", out, err)

}

}

// pulling a non-existing image from the central registry should return a non-zero exit code

func (s *DockerSuite) TestPullNonExistingImage(c *check.C) {

testRequires(c, Network)

name := "sadfsadfasdf"

pullCmd := exec.Command(dockerBinary, "pull", name)

out, _, err := runCommandWithOutput(pullCmd)

if err == nil || !strings.Contains(out, fmt.Sprintf("Error: image library/%s:latest not found", name)) {

c.Fatalf("expected non-zero exit status when pulling non-existing image: %s", out)

}

}

// pulling an image from the central registry using official names should work

// ensure all pulls result in the same image

func (s *DockerSuite) TestPullImageOfficialNames(c *check.C) {

testRequires(c, Network)

names := []string{

"docker.io/hello-world",

"index.docker.io/hello-world",

"library/hello-world",

"docker.io/library/hello-world",

"index.docker.io/library/hello-world",

}

for _, name := range names {

pullCmd := exec.Command(dockerBinary, "pull", name)

out, exitCode, err := runCommandWithOutput(pullCmd)

if err != nil || exitCode != 0 {

c.Errorf("pulling the '%s' image from the registry has failed: %s", name, err)

continue

}

// ensure we don't have multiple image names.

imagesCmd := exec.Command(dockerBinary, "images")

out, _, err = runCommandWithOutput(imagesCmd)

if err != nil {

c.Errorf("listing images failed with errors: %v", err)

} else if strings.Contains(out, name) {

c.Errorf("images should not have listed '%s'", name)

}

}

}

func (s *DockerSuite) TestPullScratchNotAllowed(c *check.C) {

testRequires(c, Network)

pullCmd := exec.Command(dockerBinary, "pull", "scratch")

out, exitCode, err := runCommandWithOutput(pullCmd)

if err == nil {

c.Fatal("expected pull of scratch to fail, but it didn't")

}

if exitCode != 1 {

c.Fatalf("pulling scratch expected exit code 1, got %d", exitCode)

}

if strings.Contains(out, "Pulling repository scratch") {

c.Fatalf("pulling scratch should not have begun: %s", out)

}

if !strings.Contains(out, "'scratch' is a reserved name") {

c.Fatalf("unexpected output pulling scratch: %s", out)

}

}