FilesExpand file tree

 docs

/

docker_cli_pull_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

140 lines (120 loc) · 4.82 KB

 docs

/

docker_cli_pull_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

140 lines (120 loc) · 4.82 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

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", 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 busybox should show verified message

func TestPullVerified(t *testing.T) {

defer setupRegistry(t)()

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

defer deleteImages(repo)

// tag the image

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

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

}

// push it

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

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

}

// remove it locally

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

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

}

// pull it

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

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

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

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

}

// pull it again

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

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

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

}

logDone("pull - pull verified")

}

// pulling an image from the central registry should work

func TestPullImageFromCentralRegistry(t *testing.T) {

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

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

}