1. docker
  2. Commit 57464c32b99b36a2963fb37da86b9870c9a56145
Browse code

Implement daemon suite for integration-cli

For creating and stopping test daemons automatically.

Signed-off-by: Alexander Morozov <lk4d4@docker.com>

Alexander Morozov authored on 2015/04/26 11:47:42
Showing 4 changed files
integration-cli/check_test.go
History View file @ 57464c3
... ... 
@@ -58,3 +58,24 @@ func (s *DockerRegistrySuite) TearDownTest(c *check.C) {
58 58 
 	s.reg.Close()
59 59 
 	s.ds.TearDownTest(c)
60 60 
 }
61 
+
62 
+func init() {
63 
+	check.Suite(&DockerDaemonSuite{
64 
+		ds: &DockerSuite{},
65 
+	})
66 
+}
67 
+
68 
+type DockerDaemonSuite struct {
69 
+	ds *DockerSuite
70 
+	d  *Daemon
71 
+}
72 
+
73 
+func (s *DockerDaemonSuite) SetUpTest(c *check.C) {
74 
+	s.d = NewDaemon(c)
75 
+	s.ds.SetUpTest(c)
76 
+}
77 
+
78 
+func (s *DockerDaemonSuite) TearDownTest(c *check.C) {
79 
+	s.d.Stop()
80 
+	s.ds.TearDownTest(c)
81 
+}
integration-cli/docker_cli_daemon_test.go
History View file @ 57464c3
... ... 
@@ -16,25 +16,23 @@ import (
16 16 
 	"github.com/go-check/check"
17 17 
 )
18 18
19 
-func (s *DockerSuite) TestDaemonRestartWithRunningContainersPorts(c *check.C) {
20 
-	d := NewDaemon(c)
21 
-	if err := d.StartWithBusybox(); err != nil {
19 
+func (s *DockerDaemonSuite) TestDaemonRestartWithRunningContainersPorts(c *check.C) {
20 
+	if err := s.d.StartWithBusybox(); err != nil {
22 21 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
23 22 
 	}
24 
-	defer d.Stop()
25 23
26 
-	if out, err := d.Cmd("run", "-d", "--name", "top1", "-p", "1234:80", "--restart", "always", "busybox:latest", "top"); err != nil {
24 
+	if out, err := s.d.Cmd("run", "-d", "--name", "top1", "-p", "1234:80", "--restart", "always", "busybox:latest", "top"); err != nil {
27 25 
 		c.Fatalf("Could not run top1: err=%v\n%s", err, out)
28 26 
 	}
29 27 
 	// --restart=no by default
30 
-	if out, err := d.Cmd("run", "-d", "--name", "top2", "-p", "80", "busybox:latest", "top"); err != nil {
28 
+	if out, err := s.d.Cmd("run", "-d", "--name", "top2", "-p", "80", "busybox:latest", "top"); err != nil {
31 29 
 		c.Fatalf("Could not run top2: err=%v\n%s", err, out)
32 30 
 	}
33 31
34 32 
 	testRun := func(m map[string]bool, prefix string) {
35 33 
 		var format string
36 34 
 		for cont, shouldRun := range m {
37 
-			out, err := d.Cmd("ps")
35 
+			out, err := s.d.Cmd("ps")
38 36 
 			if err != nil {
39 37 
 				c.Fatalf("Could not run ps: err=%v\n%q", err, out)
40 38 
 			}
... ... 
@@ -51,34 +49,30 @@ func (s *DockerSuite) TestDaemonRestartWithRunningContainersPorts(c *check.C) {
51 51
52 52 
 	testRun(map[string]bool{"top1": true, "top2": true}, "")
53 53
54 
-	if err := d.Restart(); err != nil {
54 
+	if err := s.d.Restart(); err != nil {
55 55 
 		c.Fatalf("Could not restart daemon: %v", err)
56 56 
 	}
57 
-
58 57 
 	testRun(map[string]bool{"top1": true, "top2": false}, "After daemon restart: ")
59 
-
60 58 
 }
61 59
62 
-func (s *DockerSuite) TestDaemonRestartWithVolumesRefs(c *check.C) {
63 
-	d := NewDaemon(c)
64 
-	if err := d.StartWithBusybox(); err != nil {
60 
+func (s *DockerDaemonSuite) TestDaemonRestartWithVolumesRefs(c *check.C) {
61 
+	if err := s.d.StartWithBusybox(); err != nil {
65 62 
 		c.Fatal(err)
66 63 
 	}
67 
-	defer d.Stop()
68 64
69 
-	if out, err := d.Cmd("run", "-d", "--name", "volrestarttest1", "-v", "/foo", "busybox"); err != nil {
65 
+	if out, err := s.d.Cmd("run", "-d", "--name", "volrestarttest1", "-v", "/foo", "busybox"); err != nil {
70 66 
 		c.Fatal(err, out)
71 67 
 	}
72 
-	if err := d.Restart(); err != nil {
68 
+	if err := s.d.Restart(); err != nil {
73 69 
 		c.Fatal(err)
74 70 
 	}
75 
-	if _, err := d.Cmd("run", "-d", "--volumes-from", "volrestarttest1", "--name", "volrestarttest2", "busybox", "top"); err != nil {
71 
+	if _, err := s.d.Cmd("run", "-d", "--volumes-from", "volrestarttest1", "--name", "volrestarttest2", "busybox", "top"); err != nil {
76 72 
 		c.Fatal(err)
77 73 
 	}
78 
-	if out, err := d.Cmd("rm", "-fv", "volrestarttest2"); err != nil {
74 
+	if out, err := s.d.Cmd("rm", "-fv", "volrestarttest2"); err != nil {
79 75 
 		c.Fatal(err, out)
80 76 
 	}
81 
-	v, err := d.Cmd("inspect", "--format", "{{ json .Volumes }}", "volrestarttest1")
77 
+	v, err := s.d.Cmd("inspect", "--format", "{{ json .Volumes }}", "volrestarttest1")
82 78 
 	if err != nil {
83 79 
 		c.Fatal(err)
84 80 
 	}
... ... 
@@ -87,30 +81,25 @@ func (s *DockerSuite) TestDaemonRestartWithVolumesRefs(c *check.C) {
87 87 
 	if _, err := os.Stat(volumes["/foo"]); err != nil {
88 88 
 		c.Fatalf("Expected volume to exist: %s - %s", volumes["/foo"], err)
89 89 
 	}
90 
-
91 90 
 }
92 91
93 
-func (s *DockerSuite) TestDaemonStartIptablesFalse(c *check.C) {
94 
-	d := NewDaemon(c)
95 
-	if err := d.Start("--iptables=false"); err != nil {
92 
+func (s *DockerDaemonSuite) TestDaemonStartIptablesFalse(c *check.C) {
93 
+	if err := s.d.Start("--iptables=false"); err != nil {
96 94 
 		c.Fatalf("we should have been able to start the daemon with passing iptables=false: %v", err)
97 95 
 	}
98 
-	d.Stop()
99 
-
100 96 
 }
101 97
102 98 
 // Issue #8444: If docker0 bridge is modified (intentionally or unintentionally) and
103 99 
 // no longer has an IP associated, we should gracefully handle that case and associate
104 100 
 // an IP with it rather than fail daemon start
105 
-func (s *DockerSuite) TestDaemonStartBridgeWithoutIPAssociation(c *check.C) {
106 
-	d := NewDaemon(c)
101 
+func (s *DockerDaemonSuite) TestDaemonStartBridgeWithoutIPAssociation(c *check.C) {
107 102 
 	// rather than depending on brctl commands to verify docker0 is created and up
108 103 
 	// let's start the daemon and stop it, and then make a modification to run the
109 104 
 	// actual test
110 
-	if err := d.Start(); err != nil {
105 
+	if err := s.d.Start(); err != nil {
111 106 
 		c.Fatalf("Could not start daemon: %v", err)
112 107 
 	}
113 
-	if err := d.Stop(); err != nil {
108 
+	if err := s.d.Stop(); err != nil {
114 109 
 		c.Fatalf("Could not stop daemon: %v", err)
115 110 
 	}
116 111
... ... 
@@ -121,27 +110,18 @@ func (s *DockerSuite) TestDaemonStartBridgeWithoutIPAssociation(c *check.C) {
121 121 
 		c.Fatalf("failed to remove docker0 IP association: %v, stdout: %q, stderr: %q", err, stdout, stderr)
122 122 
 	}
123 123
124 
-	if err := d.Start(); err != nil {
124 
+	if err := s.d.Start(); err != nil {
125 125 
 		warning := "**WARNING: Docker bridge network in bad state--delete docker0 bridge interface to fix"
126 126 
 		c.Fatalf("Could not start daemon when docker0 has no IP address: %v\n%s", err, warning)
127 127 
 	}
128 
-
129 
-	// cleanup - stop the daemon if test passed
130 
-	if err := d.Stop(); err != nil {
131 
-		c.Fatalf("Could not stop daemon: %v", err)
132 
-	}
133 
-
134 128 
 }
135 129
136 
-func (s *DockerSuite) TestDaemonIptablesClean(c *check.C) {
137 
-
138 
-	d := NewDaemon(c)
139 
-	if err := d.StartWithBusybox(); err != nil {
130 
+func (s *DockerDaemonSuite) TestDaemonIptablesClean(c *check.C) {
131 
+	if err := s.d.StartWithBusybox(); err != nil {
140 132 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
141 133 
 	}
142 
-	defer d.Stop()
143 134
144 
-	if out, err := d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
135 
+	if out, err := s.d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
145 136 
 		c.Fatalf("Could not run top: %s, %v", out, err)
146 137 
 	}
147 138
... ... 
@@ -157,7 +137,7 @@ func (s *DockerSuite) TestDaemonIptablesClean(c *check.C) {
157 157 
 		c.Fatalf("iptables output should have contained %q, but was %q", ipTablesSearchString, out)
158 158 
 	}
159 159
160 
-	if err := d.Stop(); err != nil {
160 
+	if err := s.d.Stop(); err != nil {
161 161 
 		c.Fatalf("Could not stop daemon: %v", err)
162 162 
 	}
163 163
... ... 
@@ -171,18 +151,14 @@ func (s *DockerSuite) TestDaemonIptablesClean(c *check.C) {
171 171 
 	if strings.Contains(out, ipTablesSearchString) {
172 172 
 		c.Fatalf("iptables output should not have contained %q, but was %q", ipTablesSearchString, out)
173 173 
 	}
174 
-
175 174 
 }
176 175
177 
-func (s *DockerSuite) TestDaemonIptablesCreate(c *check.C) {
178 
-
179 
-	d := NewDaemon(c)
180 
-	if err := d.StartWithBusybox(); err != nil {
176 
+func (s *DockerDaemonSuite) TestDaemonIptablesCreate(c *check.C) {
177 
+	if err := s.d.StartWithBusybox(); err != nil {
181 178 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
182 179 
 	}
183 
-	defer d.Stop()
184 180
185 
-	if out, err := d.Cmd("run", "-d", "--name", "top", "--restart=always", "-p", "80", "busybox:latest", "top"); err != nil {
181 
+	if out, err := s.d.Cmd("run", "-d", "--name", "top", "--restart=always", "-p", "80", "busybox:latest", "top"); err != nil {
186 182 
 		c.Fatalf("Could not run top: %s, %v", out, err)
187 183 
 	}
188 184
... ... 
@@ -198,12 +174,12 @@ func (s *DockerSuite) TestDaemonIptablesCreate(c *check.C) {
198 198 
 		c.Fatalf("iptables output should have contained %q, but was %q", ipTablesSearchString, out)
199 199 
 	}
200 200
201 
-	if err := d.Restart(); err != nil {
201 
+	if err := s.d.Restart(); err != nil {
202 202 
 		c.Fatalf("Could not restart daemon: %v", err)
203 203 
 	}
204 204
205 205 
 	// make sure the container is not running
206 
-	runningOut, err := d.Cmd("inspect", "--format='{{.State.Running}}'", "top")
206 
+	runningOut, err := s.d.Cmd("inspect", "--format='{{.State.Running}}'", "top")
207 207 
 	if err != nil {
208 208 
 		c.Fatalf("Could not inspect on container: %s, %v", out, err)
209 209 
 	}
... ... 
@@ -221,69 +197,64 @@ func (s *DockerSuite) TestDaemonIptablesCreate(c *check.C) {
221 221 
 	if !strings.Contains(out, ipTablesSearchString) {
222 222 
 		c.Fatalf("iptables output after restart should have contained %q, but was %q", ipTablesSearchString, out)
223 223 
 	}
224 
-
225 224 
 }
226 225
227 
-func (s *DockerSuite) TestDaemonLoggingLevel(c *check.C) {
228 
-	d := NewDaemon(c)
229 
-
230 
-	if err := d.Start("--log-level=bogus"); err == nil {
231 
-		c.Fatal("Daemon should not have been able to start")
232 
-	}
226 
+func (s *DockerDaemonSuite) TestDaemonLogLevelWrong(c *check.C) {
227 
+	c.Assert(s.d.Start("--log-level=bogus"), check.NotNil, check.Commentf("Daemon shouldn't start with wrong log level"))
228 
+}
233 229
234 
-	d = NewDaemon(c)
235 
-	if err := d.Start("--log-level=debug"); err != nil {
230 
+func (s *DockerDaemonSuite) TestDaemonLogLevelDebug(c *check.C) {
231 
+	if err := s.d.Start("--log-level=debug"); err != nil {
236 232 
 		c.Fatal(err)
237 233 
 	}
238 
-	d.Stop()
239 
-	content, _ := ioutil.ReadFile(d.logFile.Name())
234 
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
240 235 
 	if !strings.Contains(string(content), `level=debug`) {
241 236 
 		c.Fatalf(`Missing level="debug" in log file:\n%s`, string(content))
242 237 
 	}
238 
+}
243 239
244 
-	d = NewDaemon(c)
245 
-	if err := d.Start("--log-level=fatal"); err != nil {
240 
+func (s *DockerDaemonSuite) TestDaemonLogLevelFatal(c *check.C) {
241 
+	// we creating new daemons to create new logFile
242 
+	if err := s.d.Start("--log-level=fatal"); err != nil {
246 243 
 		c.Fatal(err)
247 244 
 	}
248 
-	d.Stop()
249 
-	content, _ = ioutil.ReadFile(d.logFile.Name())
245 
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
250 246 
 	if strings.Contains(string(content), `level=debug`) {
251 247 
 		c.Fatalf(`Should not have level="debug" in log file:\n%s`, string(content))
252 248 
 	}
249 
+}
253 250
254 
-	d = NewDaemon(c)
255 
-	if err := d.Start("-D"); err != nil {
251 
+func (s *DockerDaemonSuite) TestDaemonFlagD(c *check.C) {
252 
+	if err := s.d.Start("-D"); err != nil {
256 253 
 		c.Fatal(err)
257 254 
 	}
258 
-	d.Stop()
259 
-	content, _ = ioutil.ReadFile(d.logFile.Name())
255 
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
260 256 
 	if !strings.Contains(string(content), `level=debug`) {
261 257 
 		c.Fatalf(`Missing level="debug" in log file using -D:\n%s`, string(content))
262 258 
 	}
259 
+}
263 260
264 
-	d = NewDaemon(c)
265 
-	if err := d.Start("--debug"); err != nil {
261 
+func (s *DockerDaemonSuite) TestDaemonFlagDebug(c *check.C) {
262 
+	if err := s.d.Start("--debug"); err != nil {
266 263 
 		c.Fatal(err)
267 264 
 	}
268 
-	d.Stop()
269 
-	content, _ = ioutil.ReadFile(d.logFile.Name())
265 
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
270 266 
 	if !strings.Contains(string(content), `level=debug`) {
271 267 
 		c.Fatalf(`Missing level="debug" in log file using --debug:\n%s`, string(content))
272 268 
 	}
269 
+}
273 270
274 
-	d = NewDaemon(c)
275 
-	if err := d.Start("--debug", "--log-level=fatal"); err != nil {
271 
+func (s *DockerDaemonSuite) TestDaemonFlagDebugLogLevelFatal(c *check.C) {
272 
+	if err := s.d.Start("--debug", "--log-level=fatal"); err != nil {
276 273 
 		c.Fatal(err)
277 274 
 	}
278 
-	d.Stop()
279 
-	content, _ = ioutil.ReadFile(d.logFile.Name())
275 
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
280 276 
 	if !strings.Contains(string(content), `level=debug`) {
281 277 
 		c.Fatalf(`Missing level="debug" in log file when using both --debug and --log-level=fatal:\n%s`, string(content))
282 278 
 	}
283 
-
284 279 
 }
285 280
286 
-func (s *DockerSuite) TestDaemonAllocatesListeningPort(c *check.C) {
281 
+func (s *DockerDaemonSuite) TestDaemonAllocatesListeningPort(c *check.C) {
287 282 
 	listeningPorts := [][]string{
288 283 
 		{"0.0.0.0", "0.0.0.0", "5678"},
289 284 
 		{"127.0.0.1", "127.0.0.1", "1234"},
... ... 
@@ -295,31 +266,25 @@ func (s *DockerSuite) TestDaemonAllocatesListeningPort(c *check.C) {
295 295 
 		cmdArgs = append(cmdArgs, "--host", fmt.Sprintf("tcp://%s:%s", hostDirective[0], hostDirective[2]))
296 296 
 	}
297 297
298 
-	d := NewDaemon(c)
299 
-	if err := d.StartWithBusybox(cmdArgs...); err != nil {
298 
+	if err := s.d.StartWithBusybox(cmdArgs...); err != nil {
300 299 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
301 300 
 	}
302 
-	defer d.Stop()
303 301
304 302 
 	for _, hostDirective := range listeningPorts {
305 
-		output, err := d.Cmd("run", "-p", fmt.Sprintf("%s:%s:80", hostDirective[1], hostDirective[2]), "busybox", "true")
303 
+		output, err := s.d.Cmd("run", "-p", fmt.Sprintf("%s:%s:80", hostDirective[1], hostDirective[2]), "busybox", "true")
306 304 
 		if err == nil {
307 305 
 			c.Fatalf("Container should not start, expected port already allocated error: %q", output)
308 306 
 		} else if !strings.Contains(output, "port is already allocated") {
309 307 
 			c.Fatalf("Expected port is already allocated error: %q", output)
310 308 
 		}
311 309 
 	}
312 
-
313 310 
 }
314 311
315 312 
 // #9629
316 
-func (s *DockerSuite) TestDaemonVolumesBindsRefs(c *check.C) {
317 
-	d := NewDaemon(c)
318 
-
319 
-	if err := d.StartWithBusybox(); err != nil {
313 
+func (s *DockerDaemonSuite) TestDaemonVolumesBindsRefs(c *check.C) {
314 
+	if err := s.d.StartWithBusybox(); err != nil {
320 315 
 		c.Fatal(err)
321 316 
 	}
322 
-	defer d.Stop()
323 317
324 318 
 	tmp, err := ioutil.TempDir(os.TempDir(), "")
325 319 
 	if err != nil {
... ... 
@@ -331,28 +296,26 @@ func (s *DockerSuite) TestDaemonVolumesBindsRefs(c *check.C) {
331 331 
 		c.Fatal(err)
332 332 
 	}
333 333
334 
-	if out, err := d.Cmd("create", "-v", tmp+":/foo", "--name=voltest", "busybox"); err != nil {
334 
+	if out, err := s.d.Cmd("create", "-v", tmp+":/foo", "--name=voltest", "busybox"); err != nil {
335 335 
 		c.Fatal(err, out)
336 336 
 	}
337 337
338 
-	if err := d.Restart(); err != nil {
338 
+	if err := s.d.Restart(); err != nil {
339 339 
 		c.Fatal(err)
340 340 
 	}
341 341
342 
-	if out, err := d.Cmd("run", "--volumes-from=voltest", "--name=consumer", "busybox", "/bin/sh", "-c", "[ -f /foo/test ]"); err != nil {
342 
+	if out, err := s.d.Cmd("run", "--volumes-from=voltest", "--name=consumer", "busybox", "/bin/sh", "-c", "[ -f /foo/test ]"); err != nil {
343 343 
 		c.Fatal(err, out)
344 344 
 	}
345 
-
346 345 
 }
347 346
348 
-func (s *DockerSuite) TestDaemonKeyGeneration(c *check.C) {
347 
+func (s *DockerDaemonSuite) TestDaemonKeyGeneration(c *check.C) {
349 348 
 	// TODO: skip or update for Windows daemon
350 349 
 	os.Remove("/etc/docker/key.json")
351 
-	d := NewDaemon(c)
352 
-	if err := d.Start(); err != nil {
350 
+	if err := s.d.Start(); err != nil {
353 351 
 		c.Fatalf("Could not start daemon: %v", err)
354 352 
 	}
355 
-	d.Stop()
353 
+	s.d.Stop()
356 354
357 355 
 	k, err := libtrust.LoadKeyFile("/etc/docker/key.json")
358 356 
 	if err != nil {
... ... 
@@ -363,10 +326,9 @@ func (s *DockerSuite) TestDaemonKeyGeneration(c *check.C) {
363 363 
 	if len(kid) != 59 {
364 364 
 		c.Fatalf("Bad key ID: %s", kid)
365 365 
 	}
366 
-
367 366 
 }
368 367
369 
-func (s *DockerSuite) TestDaemonKeyMigration(c *check.C) {
368 
+func (s *DockerDaemonSuite) TestDaemonKeyMigration(c *check.C) {
370 369 
 	// TODO: skip or update for Windows daemon
371 370 
 	os.Remove("/etc/docker/key.json")
372 371 
 	k1, err := libtrust.GenerateECP256PrivateKey()
... ... 
@@ -380,11 +342,10 @@ func (s *DockerSuite) TestDaemonKeyMigration(c *check.C) {
380 380 
 		c.Fatalf("Error saving private key: %s", err)
381 381 
 	}
382 382
383 
-	d := NewDaemon(c)
384 
-	if err := d.Start(); err != nil {
383 
+	if err := s.d.Start(); err != nil {
385 384 
 		c.Fatalf("Could not start daemon: %v", err)
386 385 
 	}
387 
-	d.Stop()
386 
+	s.d.Stop()
388 387
389 388 
 	k2, err := libtrust.LoadKeyFile("/etc/docker/key.json")
390 389 
 	if err != nil {
... ... 
@@ -393,29 +354,25 @@ func (s *DockerSuite) TestDaemonKeyMigration(c *check.C) {
393 393 
 	if k1.KeyID() != k2.KeyID() {
394 394 
 		c.Fatalf("Key not migrated")
395 395 
 	}
396 
-
397 396 
 }
398 397
399 398 
 // Simulate an older daemon (pre 1.3) coming up with volumes specified in containers
400 399 
 //	without corresponding volume json
401 
-func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
402 
-	d := NewDaemon(c)
403 
-
400 
+func (s *DockerDaemonSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
404 401 
 	graphDir := filepath.Join(os.TempDir(), "docker-test")
405 402 
 	defer os.RemoveAll(graphDir)
406 
-	if err := d.StartWithBusybox("-g", graphDir); err != nil {
403 
+	if err := s.d.StartWithBusybox("-g", graphDir); err != nil {
407 404 
 		c.Fatal(err)
408 405 
 	}
409 
-	defer d.Stop()
410 406
411 407 
 	tmpDir := filepath.Join(os.TempDir(), "test")
412 408 
 	defer os.RemoveAll(tmpDir)
413 409
414 
-	if out, err := d.Cmd("create", "-v", tmpDir+":/foo", "--name=test", "busybox"); err != nil {
410 
+	if out, err := s.d.Cmd("create", "-v", tmpDir+":/foo", "--name=test", "busybox"); err != nil {
415 411 
 		c.Fatal(err, out)
416 412 
 	}
417 413
418 
-	if err := d.Stop(); err != nil {
414 
+	if err := s.d.Stop(); err != nil {
419 415 
 		c.Fatal(err)
420 416 
 	}
421 417
... ... 
@@ -430,7 +387,7 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
430 430 
 		c.Fatal(err)
431 431 
 	}
432 432
433 
-	if err := d.Start("-g", graphDir); err != nil {
433 
+	if err := s.d.Start("-g", graphDir); err != nil {
434 434 
 		c.Fatal(err)
435 435 
 	}
436 436
... ... 
@@ -447,7 +404,7 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
447 447 
 	}
448 448
449 449 
 	// Now with just removing the volume config and not the volume data
450 
-	if err := d.Stop(); err != nil {
450 
+	if err := s.d.Stop(); err != nil {
451 451 
 		c.Fatal(err)
452 452 
 	}
453 453
... ... 
@@ -455,7 +412,7 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
455 455 
 		c.Fatal(err)
456 456 
 	}
457 457
458 
-	if err := d.Start("-g", graphDir); err != nil {
458 
+	if err := s.d.Start("-g", graphDir); err != nil {
459 459 
 		c.Fatal(err)
460 460 
 	}
461 461
... ... 
@@ -467,45 +424,37 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
467 467 
 	if len(dir) == 0 {
468 468 
 		c.Fatalf("expected volumes config dir to contain data for new volume")
469 469 
 	}
470 
-
471 470 
 }
472 471
473 472 
 // GH#11320 - verify that the daemon exits on failure properly
474 473 
 // Note that this explicitly tests the conflict of {-b,--bridge} and {--bip} options as the means
475 474 
 // to get a daemon init failure; no other tests for -b/--bip conflict are therefore required
476 
-func (s *DockerSuite) TestDaemonExitOnFailure(c *check.C) {
477 
-	d := NewDaemon(c)
478 
-	defer d.Stop()
479 
-
475 
+func (s *DockerDaemonSuite) TestDaemonExitOnFailure(c *check.C) {
480 476 
 	//attempt to start daemon with incorrect flags (we know -b and --bip conflict)
481 
-	if err := d.Start("--bridge", "nosuchbridge", "--bip", "1.1.1.1"); err != nil {
477 
+	if err := s.d.Start("--bridge", "nosuchbridge", "--bip", "1.1.1.1"); err != nil {
482 478 
 		//verify we got the right error
483 479 
 		if !strings.Contains(err.Error(), "Daemon exited and never started") {
484 480 
 			c.Fatalf("Expected daemon not to start, got %v", err)
485 481 
 		}
486 482 
 		// look in the log and make sure we got the message that daemon is shutting down
487 
-		runCmd := exec.Command("grep", "Error starting daemon", d.LogfileName())
483 
+		runCmd := exec.Command("grep", "Error starting daemon", s.d.LogfileName())
488 484 
 		if out, _, err := runCommandWithOutput(runCmd); err != nil {
489 485 
 			c.Fatalf("Expected 'Error starting daemon' message; but doesn't exist in log: %q, err: %v", out, err)
490 486 
 		}
491 487 
 	} else {
492 488 
 		//if we didn't get an error and the daemon is running, this is a failure
493 
-		d.Stop()
494 489 
 		c.Fatal("Conflicting options should cause the daemon to error out with a failure")
495 490 
 	}
496 
-
497 491 
 }
498 492
499 
-func (s *DockerSuite) TestDaemonUlimitDefaults(c *check.C) {
493 
+func (s *DockerDaemonSuite) TestDaemonUlimitDefaults(c *check.C) {
500 494 
 	testRequires(c, NativeExecDriver)
501 
-	d := NewDaemon(c)
502 495
503 
-	if err := d.StartWithBusybox("--default-ulimit", "nofile=42:42", "--default-ulimit", "nproc=1024:1024"); err != nil {
496 
+	if err := s.d.StartWithBusybox("--default-ulimit", "nofile=42:42", "--default-ulimit", "nproc=1024:1024"); err != nil {
504 497 
 		c.Fatal(err)
505 498 
 	}
506 
-	defer d.Stop()
507 499
508 
-	out, err := d.Cmd("run", "--ulimit", "nproc=2048", "--name=test", "busybox", "/bin/sh", "-c", "echo $(ulimit -n); echo $(ulimit -p)")
500 
+	out, err := s.d.Cmd("run", "--ulimit", "nproc=2048", "--name=test", "busybox", "/bin/sh", "-c", "echo $(ulimit -n); echo $(ulimit -p)")
509 501 
 	if err != nil {
510 502 
 		c.Fatal(out, err)
511 503 
 	}
... ... 
@@ -525,11 +474,11 @@ func (s *DockerSuite) TestDaemonUlimitDefaults(c *check.C) {
525 525 
 	}
526 526
527 527 
 	// Now restart daemon with a new default
528 
-	if err := d.Restart("--default-ulimit", "nofile=43"); err != nil {
528 
+	if err := s.d.Restart("--default-ulimit", "nofile=43"); err != nil {
529 529 
 		c.Fatal(err)
530 530 
 	}
531 531
532 
-	out, err = d.Cmd("start", "-a", "test")
532 
+	out, err = s.d.Cmd("start", "-a", "test")
533 533 
 	if err != nil {
534 534 
 		c.Fatal(err)
535 535 
 	}
... ... 
@@ -547,53 +496,46 @@ func (s *DockerSuite) TestDaemonUlimitDefaults(c *check.C) {
547 547 
 	if nproc != "2048" {
548 548 
 		c.Fatalf("exepcted `ulimit -p` to be 2048, got: %s", nproc)
549 549 
 	}
550 
-
551 550 
 }
552 551
553 552 
 // #11315
554 
-func (s *DockerSuite) TestDaemonRestartRenameContainer(c *check.C) {
555 
-	d := NewDaemon(c)
556 
-	if err := d.StartWithBusybox(); err != nil {
553 
+func (s *DockerDaemonSuite) TestDaemonRestartRenameContainer(c *check.C) {
554 
+	if err := s.d.StartWithBusybox(); err != nil {
557 555 
 		c.Fatal(err)
558 556 
 	}
559 
-	defer d.Stop()
560 557
561 
-	if out, err := d.Cmd("run", "--name=test", "busybox"); err != nil {
558 
+	if out, err := s.d.Cmd("run", "--name=test", "busybox"); err != nil {
562 559 
 		c.Fatal(err, out)
563 560 
 	}
564 561
565 
-	if out, err := d.Cmd("rename", "test", "test2"); err != nil {
562 
+	if out, err := s.d.Cmd("rename", "test", "test2"); err != nil {
566 563 
 		c.Fatal(err, out)
567 564 
 	}
568 565
569 
-	if err := d.Restart(); err != nil {
566 
+	if err := s.d.Restart(); err != nil {
570 567 
 		c.Fatal(err)
571 568 
 	}
572 569
573 
-	if out, err := d.Cmd("start", "test2"); err != nil {
570 
+	if out, err := s.d.Cmd("start", "test2"); err != nil {
574 571 
 		c.Fatal(err, out)
575 572 
 	}
576 
-
577 573 
 }
578 574
579 
-func (s *DockerSuite) TestDaemonLoggingDriverDefault(c *check.C) {
580 
-	d := NewDaemon(c)
581 
-
582 
-	if err := d.StartWithBusybox(); err != nil {
575 
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverDefault(c *check.C) {
576 
+	if err := s.d.StartWithBusybox(); err != nil {
583 577 
 		c.Fatal(err)
584 578 
 	}
585 
-	defer d.Stop()
586 579
587 
-	out, err := d.Cmd("run", "-d", "busybox", "echo", "testline")
580 
+	out, err := s.d.Cmd("run", "-d", "busybox", "echo", "testline")
588 581 
 	if err != nil {
589 582 
 		c.Fatal(out, err)
590 583 
 	}
591 584 
 	id := strings.TrimSpace(out)
592 585
593 
-	if out, err := d.Cmd("wait", id); err != nil {
586 
+	if out, err := s.d.Cmd("wait", id); err != nil {
594 587 
 		c.Fatal(out, err)
595 588 
 	}
596 
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
589 
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
597 590
598 591 
 	if _, err := os.Stat(logPath); err != nil {
599 592 
 		c.Fatal(err)
... ... 
@@ -621,72 +563,63 @@ func (s *DockerSuite) TestDaemonLoggingDriverDefault(c *check.C) {
621 621 
 	}
622 622 
 }
623 623
624 
-func (s *DockerSuite) TestDaemonLoggingDriverDefaultOverride(c *check.C) {
625 
-	d := NewDaemon(c)
626 
-
627 
-	if err := d.StartWithBusybox(); err != nil {
624 
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverDefaultOverride(c *check.C) {
625 
+	if err := s.d.StartWithBusybox(); err != nil {
628 626 
 		c.Fatal(err)
629 627 
 	}
630 
-	defer d.Stop()
631 628
632 
-	out, err := d.Cmd("run", "-d", "--log-driver=none", "busybox", "echo", "testline")
629 
+	out, err := s.d.Cmd("run", "-d", "--log-driver=none", "busybox", "echo", "testline")
633 630 
 	if err != nil {
634 631 
 		c.Fatal(out, err)
635 632 
 	}
636 633 
 	id := strings.TrimSpace(out)
637 634
638 
-	if out, err := d.Cmd("wait", id); err != nil {
635 
+	if out, err := s.d.Cmd("wait", id); err != nil {
639 636 
 		c.Fatal(out, err)
640 637 
 	}
641 
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
638 
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
642 639
643 640 
 	if _, err := os.Stat(logPath); err == nil || !os.IsNotExist(err) {
644 641 
 		c.Fatalf("%s shouldn't exits, error on Stat: %s", logPath, err)
645 642 
 	}
646 643 
 }
647 644
648 
-func (s *DockerSuite) TestDaemonLoggingDriverNone(c *check.C) {
649 
-	d := NewDaemon(c)
650 
-
651 
-	if err := d.StartWithBusybox("--log-driver=none"); err != nil {
645 
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverNone(c *check.C) {
646 
+	if err := s.d.StartWithBusybox("--log-driver=none"); err != nil {
652 647 
 		c.Fatal(err)
653 648 
 	}
654 
-	defer d.Stop()
655 649
656 
-	out, err := d.Cmd("run", "-d", "busybox", "echo", "testline")
650 
+	out, err := s.d.Cmd("run", "-d", "busybox", "echo", "testline")
657 651 
 	if err != nil {
658 652 
 		c.Fatal(out, err)
659 653 
 	}
660 654 
 	id := strings.TrimSpace(out)
661 
-	if out, err := d.Cmd("wait", id); err != nil {
655 
+	if out, err := s.d.Cmd("wait", id); err != nil {
662 656 
 		c.Fatal(out, err)
663 657 
 	}
664 658
665 
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
659 
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
666 660
667 661 
 	if _, err := os.Stat(logPath); err == nil || !os.IsNotExist(err) {
668 662 
 		c.Fatalf("%s shouldn't exits, error on Stat: %s", logPath, err)
669 663 
 	}
670 664 
 }
671 665
672 
-func (s *DockerSuite) TestDaemonLoggingDriverNoneOverride(c *check.C) {
673 
-	d := NewDaemon(c)
674 
-
675 
-	if err := d.StartWithBusybox("--log-driver=none"); err != nil {
666 
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverNoneOverride(c *check.C) {
667 
+	if err := s.d.StartWithBusybox("--log-driver=none"); err != nil {
676 668 
 		c.Fatal(err)
677 669 
 	}
678 
-	defer d.Stop()
679 670
680 
-	out, err := d.Cmd("run", "-d", "--log-driver=json-file", "busybox", "echo", "testline")
671 
+	out, err := s.d.Cmd("run", "-d", "--log-driver=json-file", "busybox", "echo", "testline")
681 672 
 	if err != nil {
682 673 
 		c.Fatal(out, err)
683 674 
 	}
684 675 
 	id := strings.TrimSpace(out)
685 676
686 
-	if out, err := d.Cmd("wait", id); err != nil {
677 
+	if out, err := s.d.Cmd("wait", id); err != nil {
687 678 
 		c.Fatal(out, err)
688 679 
 	}
689 
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
680 
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
690 681
691 682 
 	if _, err := os.Stat(logPath); err != nil {
692 683 
 		c.Fatal(err)
... ... 
@@ -714,20 +647,17 @@ func (s *DockerSuite) TestDaemonLoggingDriverNoneOverride(c *check.C) {
714 714 
 	}
715 715 
 }
716 716
717 
-func (s *DockerSuite) TestDaemonLoggingDriverNoneLogsError(c *check.C) {
718 
-	d := NewDaemon(c)
719 
-
720 
-	if err := d.StartWithBusybox("--log-driver=none"); err != nil {
717 
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverNoneLogsError(c *check.C) {
718 
+	if err := s.d.StartWithBusybox("--log-driver=none"); err != nil {
721 719 
 		c.Fatal(err)
722 720 
 	}
723 
-	defer d.Stop()
724 721
725 
-	out, err := d.Cmd("run", "-d", "busybox", "echo", "testline")
722 
+	out, err := s.d.Cmd("run", "-d", "busybox", "echo", "testline")
726 723 
 	if err != nil {
727 724 
 		c.Fatal(out, err)
728 725 
 	}
729 726 
 	id := strings.TrimSpace(out)
730 
-	out, err = d.Cmd("logs", id)
727 
+	out, err = s.d.Cmd("logs", id)
731 728 
 	if err == nil {
732 729 
 		c.Fatalf("Logs should fail with \"none\" driver")
733 730 
 	}
... ... 
@@ -736,54 +666,50 @@ func (s *DockerSuite) TestDaemonLoggingDriverNoneLogsError(c *check.C) {
736 736 
 	}
737 737 
 }
738 738
739 
-func (s *DockerSuite) TestDaemonDots(c *check.C) {
740 
-	d := NewDaemon(c)
741 
-	if err := d.StartWithBusybox(); err != nil {
739 
+func (s *DockerDaemonSuite) TestDaemonDots(c *check.C) {
740 
+	if err := s.d.StartWithBusybox(); err != nil {
742 741 
 		c.Fatal(err)
743 742 
 	}
744 
-	defer d.Stop()
745 743
746 744 
 	// Now create 4 containers
747 
-	if _, err := d.Cmd("create", "busybox"); err != nil {
745 
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
748 746 
 		c.Fatalf("Error creating container: %q", err)
749 747 
 	}
750 
-	if _, err := d.Cmd("create", "busybox"); err != nil {
748 
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
751 749 
 		c.Fatalf("Error creating container: %q", err)
752 750 
 	}
753 
-	if _, err := d.Cmd("create", "busybox"); err != nil {
751 
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
754 752 
 		c.Fatalf("Error creating container: %q", err)
755 753 
 	}
756 
-	if _, err := d.Cmd("create", "busybox"); err != nil {
754 
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
757 755 
 		c.Fatalf("Error creating container: %q", err)
758 756 
 	}
759 757
760 
-	d.Stop()
758 
+	s.d.Stop()
761 759
762 
-	d.Start("--log-level=debug")
763 
-	d.Stop()
764 
-	content, _ := ioutil.ReadFile(d.logFile.Name())
760 
+	s.d.Start("--log-level=debug")
761 
+	s.d.Stop()
762 
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
765 763 
 	if strings.Contains(string(content), "....") {
766 764 
 		c.Fatalf("Debug level should not have ....\n%s", string(content))
767 765 
 	}
768 766
769 
-	d.Start("--log-level=error")
770 
-	d.Stop()
771 
-	content, _ = ioutil.ReadFile(d.logFile.Name())
767 
+	s.d.Start("--log-level=error")
768 
+	s.d.Stop()
769 
+	content, _ = ioutil.ReadFile(s.d.logFile.Name())
772 770 
 	if strings.Contains(string(content), "....") {
773 771 
 		c.Fatalf("Error level should not have ....\n%s", string(content))
774 772 
 	}
775 773
776 
-	d.Start("--log-level=info")
777 
-	d.Stop()
778 
-	content, _ = ioutil.ReadFile(d.logFile.Name())
774 
+	s.d.Start("--log-level=info")
775 
+	s.d.Stop()
776 
+	content, _ = ioutil.ReadFile(s.d.logFile.Name())
779 777 
 	if !strings.Contains(string(content), "....") {
780 778 
 		c.Fatalf("Info level should have ....\n%s", string(content))
781 779 
 	}
782 
-
783 780 
 }
784 781
785 
-func (s *DockerSuite) TestDaemonUnixSockCleanedUp(c *check.C) {
786 
-	d := NewDaemon(c)
782 
+func (s *DockerDaemonSuite) TestDaemonUnixSockCleanedUp(c *check.C) {
787 783 
 	dir, err := ioutil.TempDir("", "socket-cleanup-test")
788 784 
 	if err != nil {
789 785 
 		c.Fatal(err)
... ... 
@@ -791,26 +717,24 @@ func (s *DockerSuite) TestDaemonUnixSockCleanedUp(c *check.C) {
791 791 
 	defer os.RemoveAll(dir)
792 792
793 793 
 	sockPath := filepath.Join(dir, "docker.sock")
794 
-	if err := d.Start("--host", "unix://"+sockPath); err != nil {
794 
+	if err := s.d.Start("--host", "unix://"+sockPath); err != nil {
795 795 
 		c.Fatal(err)
796 796 
 	}
797 
-	defer d.Stop()
798 797
799 798 
 	if _, err := os.Stat(sockPath); err != nil {
800 799 
 		c.Fatal("socket does not exist")
801 800 
 	}
802 801
803 
-	if err := d.Stop(); err != nil {
802 
+	if err := s.d.Stop(); err != nil {
804 803 
 		c.Fatal(err)
805 804 
 	}
806 805
807 806 
 	if _, err := os.Stat(sockPath); err == nil || !os.IsNotExist(err) {
808 807 
 		c.Fatal("unix socket is not cleaned up")
809 808 
 	}
810 
-
811 809 
 }
812 810
813 
-func (s *DockerSuite) TestDaemonwithwrongkey(c *check.C) {
811 
+func (s *DockerDaemonSuite) TestDaemonwithwrongkey(c *check.C) {
814 812 
 	type Config struct {
815 813 
 		Crv string `json:"crv"`
816 814 
 		D   string `json:"d"`
... ... 
@@ -821,12 +745,11 @@ func (s *DockerSuite) TestDaemonwithwrongkey(c *check.C) {
821 821 
 	}
822 822
823 823 
 	os.Remove("/etc/docker/key.json")
824 
-	d := NewDaemon(c)
825 
-	if err := d.Start(); err != nil {
824 
+	if err := s.d.Start(); err != nil {
826 825 
 		c.Fatalf("Failed to start daemon: %v", err)
827 826 
 	}
828 827
829 
-	if err := d.Stop(); err != nil {
828 
+	if err := s.d.Stop(); err != nil {
830 829 
 		c.Fatalf("Could not stop daemon: %v", err)
831 830 
 	}
832 831
... ... 
@@ -855,46 +778,41 @@ func (s *DockerSuite) TestDaemonwithwrongkey(c *check.C) {
855 855 
 		c.Fatalf("Error ioutil.WriteFile: %s", err)
856 856 
 	}
857 857
858 
-	d1 := NewDaemon(c)
859 858 
 	defer os.Remove("/etc/docker/key.json")
860 859
861 
-	if err := d1.Start(); err == nil {
862 
-		d1.Stop()
860 
+	if err := s.d.Start(); err == nil {
863 861 
 		c.Fatalf("It should not be successful to start daemon with wrong key: %v", err)
864 862 
 	}
865 863
866 
-	content, _ := ioutil.ReadFile(d1.logFile.Name())
864 
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
867 865
868 866 
 	if !strings.Contains(string(content), "Public Key ID does not match") {
869 867 
 		c.Fatal("Missing KeyID message from daemon logs")
870 868 
 	}
871 
-
872 869 
 }
873 870
874 
-func (s *DockerSuite) TestDaemonRestartKillWait(c *check.C) {
875 
-	d := NewDaemon(c)
876 
-	if err := d.StartWithBusybox(); err != nil {
871 
+func (s *DockerDaemonSuite) TestDaemonRestartKillWait(c *check.C) {
872 
+	if err := s.d.StartWithBusybox(); err != nil {
877 873 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
878 874 
 	}
879 
-	defer d.Stop()
880 875
881 
-	out, err := d.Cmd("run", "-id", "busybox", "/bin/cat")
876 
+	out, err := s.d.Cmd("run", "-id", "busybox", "/bin/cat")
882 877 
 	if err != nil {
883 878 
 		c.Fatalf("Could not run /bin/cat: err=%v\n%s", err, out)
884 879 
 	}
885 880 
 	containerID := strings.TrimSpace(out)
886 881
887 
-	if out, err := d.Cmd("kill", containerID); err != nil {
882 
+	if out, err := s.d.Cmd("kill", containerID); err != nil {
888 883 
 		c.Fatalf("Could not kill %s: err=%v\n%s", containerID, err, out)
889 884 
 	}
890 885
891 
-	if err := d.Restart(); err != nil {
886 
+	if err := s.d.Restart(); err != nil {
892 887 
 		c.Fatalf("Could not restart daemon: %v", err)
893 888 
 	}
894 889
895 890 
 	errchan := make(chan error)
896 891 
 	go func() {
897 
-		if out, err := d.Cmd("wait", containerID); err != nil {
892 
+		if out, err := s.d.Cmd("wait", containerID); err != nil {
898 893 
 			errchan <- fmt.Errorf("%v:\n%s", err, out)
899 894 
 		}
900 895 
 		close(errchan)
... ... 
@@ -908,26 +826,23 @@ func (s *DockerSuite) TestDaemonRestartKillWait(c *check.C) {
908 908 
 			c.Fatal(err)
909 909 
 		}
910 910 
 	}
911 
-
912 911 
 }
913 912
914 913 
 // TestHttpsInfo connects via two-way authenticated HTTPS to the info endpoint
915 
-func (s *DockerSuite) TestHttpsInfo(c *check.C) {
914 
+func (s *DockerDaemonSuite) TestHttpsInfo(c *check.C) {
916 915 
 	const (
917 916 
 		testDaemonHttpsAddr = "localhost:4271"
918 917 
 	)
919 918
920 
-	d := NewDaemon(c)
921 
-	if err := d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
919 
+	if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
922 920 
 		"--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHttpsAddr); err != nil {
923 921 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
924 922 
 	}
925 
-	defer d.Stop()
926 923
927 924 
 	//force tcp protocol
928 925 
 	host := fmt.Sprintf("tcp://%s", testDaemonHttpsAddr)
929 926 
 	daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-cert.pem", "--tlskey", "fixtures/https/client-key.pem"}
930 
-	out, err := d.CmdWithArgs(daemonArgs, "info")
927 
+	out, err := s.d.CmdWithArgs(daemonArgs, "info")
931 928 
 	if err != nil {
932 929 
 		c.Fatalf("Error Occurred: %s and output: %s", err, out)
933 930 
 	}
... ... 
@@ -935,22 +850,20 @@ func (s *DockerSuite) TestHttpsInfo(c *check.C) {
935 935
936 936 
 // TestHttpsInfoRogueCert connects via two-way authenticated HTTPS to the info endpoint
937 937 
 // by using a rogue client certificate and checks that it fails with the expected error.
938 
-func (s *DockerSuite) TestHttpsInfoRogueCert(c *check.C) {
938 
+func (s *DockerDaemonSuite) TestHttpsInfoRogueCert(c *check.C) {
939 939 
 	const (
940 940 
 		errBadCertificate   = "remote error: bad certificate"
941 941 
 		testDaemonHttpsAddr = "localhost:4271"
942 942 
 	)
943 
-	d := NewDaemon(c)
944 
-	if err := d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
943 
+	if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
945 944 
 		"--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHttpsAddr); err != nil {
946 945 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
947 946 
 	}
948 
-	defer d.Stop()
949 947
950 948 
 	//force tcp protocol
951 949 
 	host := fmt.Sprintf("tcp://%s", testDaemonHttpsAddr)
952 950 
 	daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"}
953 
-	out, err := d.CmdWithArgs(daemonArgs, "info")
951 
+	out, err := s.d.CmdWithArgs(daemonArgs, "info")
954 952 
 	if err == nil || !strings.Contains(out, errBadCertificate) {
955 953 
 		c.Fatalf("Expected err: %s, got instead: %s and output: %s", errBadCertificate, err, out)
956 954 
 	}
... ... 
@@ -958,22 +871,20 @@ func (s *DockerSuite) TestHttpsInfoRogueCert(c *check.C) {
958 958
959 959 
 // TestHttpsInfoRogueServerCert connects via two-way authenticated HTTPS to the info endpoint
960 960 
 // which provides a rogue server certificate and checks that it fails with the expected error
961 
-func (s *DockerSuite) TestHttpsInfoRogueServerCert(c *check.C) {
961 
+func (s *DockerDaemonSuite) TestHttpsInfoRogueServerCert(c *check.C) {
962 962 
 	const (
963 963 
 		errCaUnknown             = "x509: certificate signed by unknown authority"
964 964 
 		testDaemonRogueHttpsAddr = "localhost:4272"
965 965 
 	)
966 
-	d := NewDaemon(c)
967 
-	if err := d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-rogue-cert.pem",
966 
+	if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-rogue-cert.pem",
968 967 
 		"--tlskey", "fixtures/https/server-rogue-key.pem", "-H", testDaemonRogueHttpsAddr); err != nil {
969 968 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
970 969 
 	}
971 
-	defer d.Stop()
972 970
973 971 
 	//force tcp protocol
974 972 
 	host := fmt.Sprintf("tcp://%s", testDaemonRogueHttpsAddr)
975 973 
 	daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"}
976 
-	out, err := d.CmdWithArgs(daemonArgs, "info")
974 
+	out, err := s.d.CmdWithArgs(daemonArgs, "info")
977 975 
 	if err == nil || !strings.Contains(out, errCaUnknown) {
978 976 
 		c.Fatalf("Expected err: %s, got instead: %s and output: %s", errCaUnknown, err, out)
979 977 
 	}
integration-cli/docker_cli_exec_test.go
History View file @ 57464c3
... ... 
@@ -117,28 +117,26 @@ func (s *DockerSuite) TestExecAfterContainerRestart(c *check.C) {
117 117
118 118 
 }
119 119
120 
-func (s *DockerSuite) TestExecAfterDaemonRestart(c *check.C) {
120 
+func (s *DockerDaemonSuite) TestExecAfterDaemonRestart(c *check.C) {
121 121 
 	testRequires(c, SameHostDaemon)
122 122
123 
-	d := NewDaemon(c)
124 
-	if err := d.StartWithBusybox(); err != nil {
123 
+	if err := s.d.StartWithBusybox(); err != nil {
125 124 
 		c.Fatalf("Could not start daemon with busybox: %v", err)
126 125 
 	}
127 
-	defer d.Stop()
128 126
129 
-	if out, err := d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
127 
+	if out, err := s.d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
130 128 
 		c.Fatalf("Could not run top: err=%v\n%s", err, out)
131 129 
 	}
132 130
133 
-	if err := d.Restart(); err != nil {
131 
+	if err := s.d.Restart(); err != nil {
134 132 
 		c.Fatalf("Could not restart daemon: %v", err)
135 133 
 	}
136 134
137 
-	if out, err := d.Cmd("start", "top"); err != nil {
135 
+	if out, err := s.d.Cmd("start", "top"); err != nil {
138 136 
 		c.Fatalf("Could not start top after daemon restart: err=%v\n%s", err, out)
139 137 
 	}
140 138
141 
-	out, err := d.Cmd("exec", "top", "echo", "hello")
139 
+	out, err := s.d.Cmd("exec", "top", "echo", "hello")
142 140 
 	if err != nil {
143 141 
 		c.Fatalf("Could not exec on container top: err=%v\n%s", err, out)
144 142 
 	}
... ... 
@@ -147,7 +145,6 @@ func (s *DockerSuite) TestExecAfterDaemonRestart(c *check.C) {
147 147 
 	if outStr != "hello" {
148 148 
 		c.Errorf("container should've printed hello, instead printed %q", outStr)
149 149 
 	}
150 
-
151 150 
 }
152 151
153 152 
 // Regression test for #9155, #9044
integration-cli/docker_cli_proxy_test.go
History View file @ 57464c3
... ... 
@@ -22,7 +22,7 @@ func (s *DockerSuite) TestCliProxyDisableProxyUnixSock(c *check.C) {
22 22
23 23 
 // Can't use localhost here since go has a special case to not use proxy if connecting to localhost
24 24 
 // See https://golang.org/pkg/net/http/#ProxyFromEnvironment
25 
-func (s *DockerSuite) TestCliProxyProxyTCPSock(c *check.C) {
25 
+func (s *DockerDaemonSuite) TestCliProxyProxyTCPSock(c *check.C) {
26 26 
 	testRequires(c, SameHostDaemon)
27 27 
 	// get the IP to use to connect since we can't use localhost
28 28 
 	addrs, err := net.InterfaceAddrs()
... ... 
@@ -43,8 +43,7 @@ func (s *DockerSuite) TestCliProxyProxyTCPSock(c *check.C) {
43 43 
 		c.Fatal("could not find ip to connect to")
44 44 
 	}
45 45
46 
-	d := NewDaemon(c)
47 
-	if err := d.Start("-H", "tcp://"+ip+":2375"); err != nil {
46 
+	if err := s.d.Start("-H", "tcp://"+ip+":2375"); err != nil {
48 47 
 		c.Fatal(err)
49 48 
 	}
50 49