github.com/toophy/docker@v1.8.2/runconfig/hostconfig_test.go (about) 1 package runconfig 2 3 import ( 4 "bytes" 5 "encoding/json" 6 "fmt" 7 "io/ioutil" 8 "testing" 9 ) 10 11 func TestNetworkModeTest(t *testing.T) { 12 networkModes := map[NetworkMode][]bool{ 13 // private, bridge, host, container, none, default 14 "": {true, false, false, false, false, false}, 15 "something:weird": {true, false, false, false, false, false}, 16 "bridge": {true, true, false, false, false, false}, 17 DefaultDaemonNetworkMode(): {true, true, false, false, false, false}, 18 "host": {false, false, true, false, false, false}, 19 "container:name": {false, false, false, true, false, false}, 20 "none": {true, false, false, false, true, false}, 21 "default": {true, false, false, false, false, true}, 22 } 23 networkModeNames := map[NetworkMode]string{ 24 "": "", 25 "something:weird": "", 26 "bridge": "bridge", 27 DefaultDaemonNetworkMode(): "bridge", 28 "host": "host", 29 "container:name": "container", 30 "none": "none", 31 "default": "default", 32 } 33 for networkMode, state := range networkModes { 34 if networkMode.IsPrivate() != state[0] { 35 t.Fatalf("NetworkMode.IsPrivate for %v should have been %v but was %v", networkMode, state[0], networkMode.IsPrivate()) 36 } 37 if networkMode.IsBridge() != state[1] { 38 t.Fatalf("NetworkMode.IsBridge for %v should have been %v but was %v", networkMode, state[1], networkMode.IsBridge()) 39 } 40 if networkMode.IsHost() != state[2] { 41 t.Fatalf("NetworkMode.IsHost for %v should have been %v but was %v", networkMode, state[2], networkMode.IsHost()) 42 } 43 if networkMode.IsContainer() != state[3] { 44 t.Fatalf("NetworkMode.IsContainer for %v should have been %v but was %v", networkMode, state[3], networkMode.IsContainer()) 45 } 46 if networkMode.IsNone() != state[4] { 47 t.Fatalf("NetworkMode.IsNone for %v should have been %v but was %v", networkMode, state[4], networkMode.IsNone()) 48 } 49 if networkMode.IsDefault() != state[5] { 50 t.Fatalf("NetworkMode.IsDefault for %v should have been %v but was %v", networkMode, state[5], networkMode.IsDefault()) 51 } 52 if networkMode.NetworkName() != networkModeNames[networkMode] { 53 t.Fatalf("Expected name %v, got %v", networkModeNames[networkMode], networkMode.NetworkName()) 54 } 55 } 56 } 57 58 func TestIpcModeTest(t *testing.T) { 59 ipcModes := map[IpcMode][]bool{ 60 // private, host, container, valid 61 "": {true, false, false, true}, 62 "something:weird": {true, false, false, false}, 63 ":weird": {true, false, false, true}, 64 "host": {false, true, false, true}, 65 "container:name": {false, false, true, true}, 66 "container:name:something": {false, false, true, false}, 67 "container:": {false, false, true, false}, 68 } 69 for ipcMode, state := range ipcModes { 70 if ipcMode.IsPrivate() != state[0] { 71 t.Fatalf("IpcMode.IsPrivate for %v should have been %v but was %v", ipcMode, state[0], ipcMode.IsPrivate()) 72 } 73 if ipcMode.IsHost() != state[1] { 74 t.Fatalf("IpcMode.IsHost for %v should have been %v but was %v", ipcMode, state[1], ipcMode.IsHost()) 75 } 76 if ipcMode.IsContainer() != state[2] { 77 t.Fatalf("IpcMode.IsContainer for %v should have been %v but was %v", ipcMode, state[2], ipcMode.IsContainer()) 78 } 79 if ipcMode.Valid() != state[3] { 80 t.Fatalf("IpcMode.Valid for %v should have been %v but was %v", ipcMode, state[3], ipcMode.Valid()) 81 } 82 } 83 containerIpcModes := map[IpcMode]string{ 84 "": "", 85 "something": "", 86 "something:weird": "weird", 87 "container": "", 88 "container:": "", 89 "container:name": "name", 90 "container:name1:name2": "name1:name2", 91 } 92 for ipcMode, container := range containerIpcModes { 93 if ipcMode.Container() != container { 94 t.Fatalf("Expected %v for %v but was %v", container, ipcMode, ipcMode.Container()) 95 } 96 } 97 } 98 99 func TestUTSModeTest(t *testing.T) { 100 utsModes := map[UTSMode][]bool{ 101 // private, host, valid 102 "": {true, false, true}, 103 "something:weird": {true, false, false}, 104 "host": {false, true, true}, 105 "host:name": {true, false, true}, 106 } 107 for utsMode, state := range utsModes { 108 if utsMode.IsPrivate() != state[0] { 109 t.Fatalf("UtsMode.IsPrivate for %v should have been %v but was %v", utsMode, state[0], utsMode.IsPrivate()) 110 } 111 if utsMode.IsHost() != state[1] { 112 t.Fatalf("UtsMode.IsHost for %v should have been %v but was %v", utsMode, state[1], utsMode.IsHost()) 113 } 114 if utsMode.Valid() != state[2] { 115 t.Fatalf("UtsMode.Valid for %v should have been %v but was %v", utsMode, state[2], utsMode.Valid()) 116 } 117 } 118 } 119 120 func TestPidModeTest(t *testing.T) { 121 pidModes := map[PidMode][]bool{ 122 // private, host, valid 123 "": {true, false, true}, 124 "something:weird": {true, false, false}, 125 "host": {false, true, true}, 126 "host:name": {true, false, true}, 127 } 128 for pidMode, state := range pidModes { 129 if pidMode.IsPrivate() != state[0] { 130 t.Fatalf("PidMode.IsPrivate for %v should have been %v but was %v", pidMode, state[0], pidMode.IsPrivate()) 131 } 132 if pidMode.IsHost() != state[1] { 133 t.Fatalf("PidMode.IsHost for %v should have been %v but was %v", pidMode, state[1], pidMode.IsHost()) 134 } 135 if pidMode.Valid() != state[2] { 136 t.Fatalf("PidMode.Valid for %v should have been %v but was %v", pidMode, state[2], pidMode.Valid()) 137 } 138 } 139 } 140 141 func TestRestartPolicy(t *testing.T) { 142 restartPolicies := map[RestartPolicy][]bool{ 143 // none, always, failure 144 RestartPolicy{}: {false, false, false}, 145 RestartPolicy{"something", 0}: {false, false, false}, 146 RestartPolicy{"no", 0}: {true, false, false}, 147 RestartPolicy{"always", 0}: {false, true, false}, 148 RestartPolicy{"on-failure", 0}: {false, false, true}, 149 } 150 for restartPolicy, state := range restartPolicies { 151 if restartPolicy.IsNone() != state[0] { 152 t.Fatalf("RestartPolicy.IsNone for %v should have been %v but was %v", restartPolicy, state[0], restartPolicy.IsNone()) 153 } 154 if restartPolicy.IsAlways() != state[1] { 155 t.Fatalf("RestartPolicy.IsAlways for %v should have been %v but was %v", restartPolicy, state[1], restartPolicy.IsAlways()) 156 } 157 if restartPolicy.IsOnFailure() != state[2] { 158 t.Fatalf("RestartPolicy.IsOnFailure for %v should have been %v but was %v", restartPolicy, state[2], restartPolicy.IsOnFailure()) 159 } 160 } 161 } 162 163 func TestLxcConfigMarshalJSON(t *testing.T) { 164 lxcConfigs := map[*LxcConfig]string{ 165 nil: "", 166 &LxcConfig{}: "null", 167 &LxcConfig{ 168 []KeyValuePair{{"key1", "value1"}}, 169 }: `[{"Key":"key1","Value":"value1"}]`, 170 } 171 172 for lxcconfig, expected := range lxcConfigs { 173 data, err := lxcconfig.MarshalJSON() 174 if err != nil { 175 t.Fatal(err) 176 } 177 if string(data) != expected { 178 t.Fatalf("Expected %v, got %v", expected, string(data)) 179 } 180 } 181 } 182 183 func TestLxcConfigUnmarshalJSON(t *testing.T) { 184 keyvaluePairs := map[string][]KeyValuePair{ 185 "": {{"key1", "value1"}}, 186 "[]": {}, 187 `[{"Key":"key2","Value":"value2"}]`: {{"key2", "value2"}}, 188 } 189 for json, expectedParts := range keyvaluePairs { 190 lxcConfig := &LxcConfig{ 191 []KeyValuePair{{"key1", "value1"}}, 192 } 193 if err := lxcConfig.UnmarshalJSON([]byte(json)); err != nil { 194 t.Fatal(err) 195 } 196 197 actualParts := lxcConfig.Slice() 198 if len(actualParts) != len(expectedParts) { 199 t.Fatalf("Expected %v keyvaluePairs, got %v (%v)", len(expectedParts), len(actualParts), expectedParts) 200 } 201 for index, part := range actualParts { 202 if part != expectedParts[index] { 203 t.Fatalf("Expected %v, got %v", expectedParts, actualParts) 204 break 205 } 206 } 207 } 208 } 209 210 func TestMergeConfigs(t *testing.T) { 211 expectedHostname := "hostname" 212 expectedContainerIDFile := "containerIdFile" 213 config := &Config{ 214 Hostname: expectedHostname, 215 } 216 hostConfig := &HostConfig{ 217 ContainerIDFile: expectedContainerIDFile, 218 } 219 containerConfigWrapper := MergeConfigs(config, hostConfig) 220 if containerConfigWrapper.Config.Hostname != expectedHostname { 221 t.Fatalf("containerConfigWrapper config hostname expected %v got %v", expectedHostname, containerConfigWrapper.Config.Hostname) 222 } 223 if containerConfigWrapper.InnerHostConfig.ContainerIDFile != expectedContainerIDFile { 224 t.Fatalf("containerConfigWrapper hostconfig containerIdfile expected %v got %v", expectedContainerIDFile, containerConfigWrapper.InnerHostConfig.ContainerIDFile) 225 } 226 if containerConfigWrapper.Cpuset != "" { 227 t.Fatalf("Expected empty Cpuset, got %v", containerConfigWrapper.Cpuset) 228 } 229 } 230 231 func TestDecodeHostConfig(t *testing.T) { 232 fixtures := []struct { 233 file string 234 }{ 235 {"fixtures/container_hostconfig_1_14.json"}, 236 {"fixtures/container_hostconfig_1_19.json"}, 237 } 238 239 for _, f := range fixtures { 240 b, err := ioutil.ReadFile(f.file) 241 if err != nil { 242 t.Fatal(err) 243 } 244 245 c, err := DecodeHostConfig(bytes.NewReader(b)) 246 if err != nil { 247 t.Fatal(fmt.Errorf("Error parsing %s: %v", f, err)) 248 } 249 250 if c.Privileged != false { 251 t.Fatalf("Expected privileged false, found %v\n", c.Privileged) 252 } 253 254 if l := len(c.Binds); l != 1 { 255 t.Fatalf("Expected 1 bind, found %d\n", l) 256 } 257 258 if c.CapAdd.Len() != 1 && c.CapAdd.Slice()[0] != "NET_ADMIN" { 259 t.Fatalf("Expected CapAdd NET_ADMIN, got %v", c.CapAdd) 260 } 261 262 if c.CapDrop.Len() != 1 && c.CapDrop.Slice()[0] != "NET_ADMIN" { 263 t.Fatalf("Expected CapDrop MKNOD, got %v", c.CapDrop) 264 } 265 } 266 } 267 268 func TestCapListUnmarshalSliceAndString(t *testing.T) { 269 var cl *CapList 270 cap0, err := json.Marshal([]string{"CAP_SOMETHING"}) 271 if err != nil { 272 t.Fatal(err) 273 } 274 if err := json.Unmarshal(cap0, &cl); err != nil { 275 t.Fatal(err) 276 } 277 278 slice := cl.Slice() 279 if len(slice) != 1 { 280 t.Fatalf("expected 1 element after unmarshal: %q", slice) 281 } 282 283 if slice[0] != "CAP_SOMETHING" { 284 t.Fatalf("expected `CAP_SOMETHING`, got: %q", slice[0]) 285 } 286 287 cap1, err := json.Marshal("CAP_SOMETHING") 288 if err != nil { 289 t.Fatal(err) 290 } 291 if err := json.Unmarshal(cap1, &cl); err != nil { 292 t.Fatal(err) 293 } 294 295 slice = cl.Slice() 296 if len(slice) != 1 { 297 t.Fatalf("expected 1 element after unmarshal: %q", slice) 298 } 299 300 if slice[0] != "CAP_SOMETHING" { 301 t.Fatalf("expected `CAP_SOMETHING`, got: %q", slice[0]) 302 } 303 }