FilesExpand file tree

 master

/

docker_cli_create_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

148 lines (122 loc) · 3.67 KB

 master

/

docker_cli_create_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

148 lines (122 loc) · 3.67 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

package main

import (

"encoding/json"

"os"

"os/exec"

"testing"

"time"

)

// Make sure we can create a simple container with some args

func TestCreateArgs(t *testing.T) {

runCmd := exec.Command(dockerBinary, "create", "busybox", "command", "arg1", "arg2", "arg with space")

out, _, _, err := runCommandWithStdoutStderr(runCmd)

if err != nil {

t.Fatal(out, err)

}

cleanedContainerID := stripTrailingCharacters(out)

inspectCmd := exec.Command(dockerBinary, "inspect", cleanedContainerID)

out, _, err = runCommandWithOutput(inspectCmd)

if err != nil {

t.Fatalf("out should've been a container id: %s, %v", out, err)

}

containers := []struct {

ID string

Created time.Time

Path string

Args []string

Image string

}{}

if err := json.Unmarshal([]byte(out), &containers); err != nil {

t.Fatalf("Error inspecting the container: %s", err)

}

if len(containers) != 1 {

t.Fatalf("Unexpected container count. Expected 0, received: %d", len(containers))

}

c := containers[0]

if c.Path != "command" {

t.Fatalf("Unexpected container path. Expected command, received: %s", c.Path)

}

b := false

expected := []string{"arg1", "arg2", "arg with space"}

for i, arg := range expected {

if arg != c.Args[i] {

b = true

break

}

}

if len(c.Args) != len(expected) || b {

t.Fatalf("Unexpected args. Expected %v, received: %v", expected, c.Args)

}

deleteAllContainers()

logDone("create - args")

}

// Make sure we can set hostconfig options too

func TestCreateHostConfig(t *testing.T) {

runCmd := exec.Command(dockerBinary, "create", "-P", "busybox", "echo")

out, _, _, err := runCommandWithStdoutStderr(runCmd)

if err != nil {

t.Fatal(out, err)

}

cleanedContainerID := stripTrailingCharacters(out)

inspectCmd := exec.Command(dockerBinary, "inspect", cleanedContainerID)

out, _, err = runCommandWithOutput(inspectCmd)

if err != nil {

t.Fatalf("out should've been a container id: %s, %v", out, err)

}

containers := []struct {

HostConfig *struct {

PublishAllPorts bool

}

}{}

if err := json.Unmarshal([]byte(out), &containers); err != nil {

t.Fatalf("Error inspecting the container: %s", err)

}

if len(containers) != 1 {

t.Fatalf("Unexpected container count. Expected 0, received: %d", len(containers))

}

c := containers[0]

if c.HostConfig == nil {

t.Fatalf("Expected HostConfig, got none")

}

if !c.HostConfig.PublishAllPorts {

t.Fatalf("Expected PublishAllPorts, got false")

}

deleteAllContainers()

logDone("create - hostconfig")

}

// "test123" should be printed by docker create + start

func TestCreateEchoStdout(t *testing.T) {

runCmd := exec.Command(dockerBinary, "create", "busybox", "echo", "test123")

out, _, _, err := runCommandWithStdoutStderr(runCmd)

if err != nil {

t.Fatal(out, err)

}

cleanedContainerID := stripTrailingCharacters(out)

runCmd = exec.Command(dockerBinary, "start", "-ai", cleanedContainerID)

out, _, _, err = runCommandWithStdoutStderr(runCmd)

if err != nil {

t.Fatal(out, err)

}

if out != "test123\n" {

t.Errorf("container should've printed 'test123', got %q", out)

}

deleteAllContainers()

logDone("create - echo test123")

}

func TestCreateVolumesCreated(t *testing.T) {

name := "test_create_volume"

if out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "create", "--name", name, "-v", "/foo", "busybox")); err != nil {

t.Fatal(out, err)

}

dir, err := inspectFieldMap(name, "Volumes", "/foo")

if err != nil {

t.Fatalf("Error getting volume host path: %q", err)

}

if _, err := os.Stat(dir); err != nil && os.IsNotExist(err) {

t.Fatalf("Volume was not created")

}

if err != nil {

t.Fatalf("Error statting volume host path: %q", err)

}

logDone("create - volumes are created")

}