FilesExpand file tree

 master

/

docker_cli_pull_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

138 lines (118 loc) · 4.72 KB

 master

/

docker_cli_pull_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

138 lines (118 loc) · 4.72 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

package main

import (

"fmt"

"os/exec"

"strings"

"testing"

)

// See issue docker/docker#8141

func TestPullImageWithAliases(t *testing.T) {

defer setupRegistry(t)()

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

defer deleteImages(repoName)

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 {

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

}

defer deleteImages(repo)

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

t.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 {

t.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 {

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

}

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

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

}

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

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

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

}

}

logDone("pull - image with aliases")

}

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

func TestPullVerified(t *testing.T) {

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

defer deleteImages(verifiedName)

// 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 {

t.Skipf("pulling the '%s' image from the registry has failed: %s", verifiedName, err)

}

t.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 {

t.Skipf("pulling the '%s' image from the registry has failed: %s", verifiedName, err)

}

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

}

logDone("pull - pull verified")

}

// pulling an image from the central registry should work

func TestPullImageFromCentralRegistry(t *testing.T) {

testRequires(t, Network)

defer deleteImages("hello-world")

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

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

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

}

logDone("pull - pull hello-world")

}

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

func TestPullNonExistingImage(t *testing.T) {

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

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

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

}

logDone("pull - pull fooblahblah1234 (non-existing image)")

}

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

// ensure all pulls result in the same image

func TestPullImageOfficialNames(t *testing.T) {

testRequires(t, 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 {

t.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 {

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

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

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

}

}

logDone("pull - pull official names")

}