FilesExpand file tree

 docs

/

docker_cli_push_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

158 lines (135 loc) · 5.36 KB

 docs

/

docker_cli_push_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

158 lines (135 loc) · 5.36 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

153

154

155

156

157

158

package main

import (

"fmt"

"io/ioutil"

"os"

"os/exec"

"strings"

"testing"

"time"

"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"

)

// pulling an image from the central registry should work

func TestPushBusyboxImage(t *testing.T) {

defer setupRegistry(t)()

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

// tag the image to upload it tot he private registry

tagCmd := exec.Command(dockerBinary, "tag", "busybox", repoName)

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

t.Fatalf("image tagging failed: %s, %v", out, err)

}

defer deleteImages(repoName)

pushCmd := exec.Command(dockerBinary, "push", repoName)

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

t.Fatalf("pushing the image to the private registry has failed: %s, %v", out, err)

}

logDone("push - busybox to private registry")

}

// pushing an image without a prefix should throw an error

func TestPushUnprefixedRepo(t *testing.T) {

pushCmd := exec.Command(dockerBinary, "push", "busybox")

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

t.Fatalf("pushing an unprefixed repo didn't result in a non-zero exit status: %s", out)

}

logDone("push - unprefixed busybox repo must fail")

}

func TestPushUntagged(t *testing.T) {

defer setupRegistry(t)()

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

expected := "No tags to push"

pushCmd := exec.Command(dockerBinary, "push", repoName)

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

t.Fatalf("pushing the image to the private registry should have failed: outuput %q", out)

} else if !strings.Contains(out, expected) {

t.Fatalf("pushing the image failed with an unexpected message: expected %q, got %q", expected, out)

}

logDone("push - untagged image")

}

func TestPushBadTag(t *testing.T) {

defer setupRegistry(t)()

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

expected := "does not exist"

pushCmd := exec.Command(dockerBinary, "push", repoName)

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

t.Fatalf("pushing the image to the private registry should have failed: outuput %q", out)

} else if !strings.Contains(out, expected) {

t.Fatalf("pushing the image failed with an unexpected message: expected %q, got %q", expected, out)

}

logDone("push - image with bad tag")

}

func TestPushMultipleTags(t *testing.T) {

defer setupRegistry(t)()

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

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

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

// tag the image to upload it tot he private registry

tagCmd1 := exec.Command(dockerBinary, "tag", "busybox", repoTag1)

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

t.Fatalf("image tagging failed: %s, %v", out, err)

}

defer deleteImages(repoTag1)

tagCmd2 := exec.Command(dockerBinary, "tag", "busybox", repoTag2)

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

t.Fatalf("image tagging failed: %s, %v", out, err)

}

defer deleteImages(repoTag2)

pushCmd := exec.Command(dockerBinary, "push", repoName)

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

t.Fatalf("pushing the image to the private registry has failed: %s, %v", out, err)

}

logDone("push - multiple tags to private registry")

}

func TestPushInterrupt(t *testing.T) {

defer setupRegistry(t)()

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

// tag the image to upload it tot he private registry

tagCmd := exec.Command(dockerBinary, "tag", "busybox", repoName)

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

t.Fatalf("image tagging failed: %s, %v", out, err)

}

defer deleteImages(repoName)

pushCmd := exec.Command(dockerBinary, "push", repoName)

if err := pushCmd.Start(); err != nil {

t.Fatalf("Failed to start pushing to private registry: %v", err)

}

// Interrupt push (yes, we have no idea at what point it will get killed).

time.Sleep(200 * time.Millisecond)

if err := pushCmd.Process.Kill(); err != nil {

t.Fatalf("Failed to kill push process: %v", err)

}

// Try agin

pushCmd = exec.Command(dockerBinary, "push", repoName)

if err := pushCmd.Start(); err != nil {

t.Fatalf("Failed to start pushing to private registry: %v", err)

}

logDone("push - interrupted")

}

func TestPushEmptyLayer(t *testing.T) {

defer setupRegistry(t)()

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

emptyTarball, err := ioutil.TempFile("", "empty_tarball")

if err != nil {

t.Fatalf("Unable to create test file: %v", err)

}

tw := tar.NewWriter(emptyTarball)

err = tw.Close()

if err != nil {

t.Fatalf("Error creating empty tarball: %v", err)

}

freader, err := os.Open(emptyTarball.Name())

if err != nil {

t.Fatalf("Could not open test tarball: %v", err)

}

importCmd := exec.Command(dockerBinary, "import", "-", repoName)

importCmd.Stdin = freader

out, _, err := runCommandWithOutput(importCmd)

if err != nil {

t.Errorf("import failed with errors: %v, output: %q", err, out)

}

// Now verify we can push it

pushCmd := exec.Command(dockerBinary, "push", repoName)

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

t.Fatalf("pushing the image to the private registry has failed: %s, %v", out, err)

}

logDone("push - empty layer config to private registry")

}