From 74f8a4eca4d504867aaea63a35ef1e491d332f74 Mon Sep 17 00:00:00 2001 From: Qiang Huang Date: Mon, 18 May 2015 10:06:13 +0800 Subject: [PATCH] Use inspectField to simplify code Signed-off-by: Qiang Huang --- integration-cli/docker_cli_commit_test.go | 13 +- integration-cli/docker_cli_inspect_test.go | 42 +++---- integration-cli/docker_cli_nat_test.go | 9 +- integration-cli/docker_cli_restart_test.go | 40 ++----- integration-cli/docker_cli_rmi_test.go | 4 +- integration-cli/docker_cli_run_test.go | 133 ++++++--------------- integration-cli/docker_cli_start_test.go | 32 ++--- integration-cli/docker_cli_tag_test.go | 13 +- integration-cli/docker_cli_wait_test.go | 16 +-- 9 files changed, 84 insertions(+), 218 deletions(-) diff --git a/integration-cli/docker_cli_commit_test.go b/integration-cli/docker_cli_commit_test.go index 391cd4ebc5..ef157c63f8 100644 --- a/integration-cli/docker_cli_commit_test.go +++ b/integration-cli/docker_cli_commit_test.go @@ -85,16 +85,11 @@ func (s *DockerSuite) TestCommitPausedContainer(c *check.C) { c.Fatalf("failed to commit container to image: %s, %v", out, err) } - cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.State.Paused}}", cleanedContainerID) - out, _, _, err = runCommandWithStdoutStderr(cmd) - if err != nil { - c.Fatalf("failed to inspect container: %v, output: %q", err, out) - } - + out, err = inspectField(cleanedContainerID, "State.Paused") + c.Assert(err, check.IsNil) if !strings.Contains(out, "true") { c.Fatalf("commit should not unpause a paused container") } - } func (s *DockerSuite) TestCommitNewFile(c *check.C) { @@ -242,9 +237,7 @@ func (s *DockerSuite) TestCommitChange(c *check.C) { for conf, value := range expected { res, err := inspectField(imageId, conf) - if err != nil { - c.Errorf("failed to get value %s, error: %s", conf, err) - } + c.Assert(err, check.IsNil) if res != value { c.Errorf("%s('%s'), expected %s", conf, res, value) } diff --git a/integration-cli/docker_cli_inspect_test.go b/integration-cli/docker_cli_inspect_test.go index 58c61a9d0f..4e0357b132 100644 --- a/integration-cli/docker_cli_inspect_test.go +++ b/integration-cli/docker_cli_inspect_test.go @@ -12,13 +12,10 @@ import ( func (s *DockerSuite) TestInspectImage(c *check.C) { imageTest := "emptyfs" imageTestID := "511136ea3c5a64f264b78b5433614aec563103b4d4702f3ba7d4d2698e22c158" - imagesCmd := exec.Command(dockerBinary, "inspect", "--format='{{.Id}}'", imageTest) - out, exitCode, err := runCommandWithOutput(imagesCmd) - if exitCode != 0 || err != nil { - c.Fatalf("failed to inspect image: %s, %v", out, err) - } + id, err := inspectField(imageTest, "Id") + c.Assert(err, check.IsNil) - if id := strings.TrimSuffix(out, "\n"); id != imageTestID { + if id != imageTestID { c.Fatalf("Expected id: %s for image: %s but received id: %s", imageTestID, imageTest, id) } @@ -33,33 +30,28 @@ func (s *DockerSuite) TestInspectInt64(c *check.C) { out = strings.TrimSpace(out) - inspectCmd := exec.Command(dockerBinary, "inspect", "-f", "{{.HostConfig.Memory}}", out) - inspectOut, _, err := runCommandWithOutput(inspectCmd) - if err != nil { - c.Fatalf("failed to inspect container: %v, output: %q", err, inspectOut) - } + inspectOut, err := inspectField(out, "HostConfig.Memory") + c.Assert(err, check.IsNil) - if strings.TrimSpace(inspectOut) != "314572800" { + if inspectOut != "314572800" { c.Fatalf("inspect got wrong value, got: %q, expected: 314572800", inspectOut) } } func (s *DockerSuite) TestInspectImageFilterInt(c *check.C) { imageTest := "emptyfs" - imagesCmd := exec.Command(dockerBinary, "inspect", "--format='{{.Size}}'", imageTest) - out, exitCode, err := runCommandWithOutput(imagesCmd) - if exitCode != 0 || err != nil { - c.Fatalf("failed to inspect image: %s, %v", out, err) - } - size, err := strconv.Atoi(strings.TrimSuffix(out, "\n")) + out, err := inspectField(imageTest, "Size") + c.Assert(err, check.IsNil) + + size, err := strconv.Atoi(out) if err != nil { c.Fatalf("failed to inspect size of the image: %s, %v", out, err) } //now see if the size turns out to be the same formatStr := fmt.Sprintf("--format='{{eq .Size %d}}'", size) - imagesCmd = exec.Command(dockerBinary, "inspect", formatStr, imageTest) - out, exitCode, err = runCommandWithOutput(imagesCmd) + imagesCmd := exec.Command(dockerBinary, "inspect", formatStr, imageTest) + out, exitCode, err := runCommandWithOutput(imagesCmd) if exitCode != 0 || err != nil { c.Fatalf("failed to inspect image: %s, %v", out, err) } @@ -77,12 +69,10 @@ func (s *DockerSuite) TestInspectContainerFilterInt(c *check.C) { id := strings.TrimSpace(out) - runCmd = exec.Command(dockerBinary, "inspect", "--format='{{.State.ExitCode}}'", id) - out, _, err = runCommandWithOutput(runCmd) - if err != nil { - c.Fatalf("failed to inspect container: %s, %v", out, err) - } - exitCode, err := strconv.Atoi(strings.TrimSuffix(out, "\n")) + out, err = inspectField(id, "State.ExitCode") + c.Assert(err, check.IsNil) + + exitCode, err := strconv.Atoi(out) if err != nil { c.Fatalf("failed to inspect exitcode of the container: %s, %v", out, err) } diff --git a/integration-cli/docker_cli_nat_test.go b/integration-cli/docker_cli_nat_test.go index 9e99d5716f..f623881630 100644 --- a/integration-cli/docker_cli_nat_test.go +++ b/integration-cli/docker_cli_nat_test.go @@ -53,12 +53,9 @@ func getContainerLogs(c *check.C, containerID string) string { } func getContainerStatus(c *check.C, containerID string) string { - runCmd := exec.Command(dockerBinary, "inspect", "-f", "{{.State.Running}}", containerID) - out, _, err := runCommandWithOutput(runCmd) - if err != nil { - c.Fatal(out, err) - } - return strings.Trim(out, "\r\n") + out, err := inspectField(containerID, "State.Running") + c.Assert(err, check.IsNil) + return out } func (s *DockerSuite) TestNetworkNat(c *check.C) { diff --git a/integration-cli/docker_cli_restart_test.go b/integration-cli/docker_cli_restart_test.go index 2b9d5e2323..fd95fd0226 100644 --- a/integration-cli/docker_cli_restart_test.go +++ b/integration-cli/docker_cli_restart_test.go @@ -112,11 +112,8 @@ func (s *DockerSuite) TestRestartWithVolumes(c *check.C) { c.Errorf("expect 1 volume received %s", out) } - runCmd = exec.Command(dockerBinary, "inspect", "--format", "{{ .Volumes }}", cleanedContainerID) - volumes, _, err := runCommandWithOutput(runCmd) - if err != nil { - c.Fatal(volumes, err) - } + volumes, err := inspectField(cleanedContainerID, ".Volumes") + c.Assert(err, check.IsNil) runCmd = exec.Command(dockerBinary, "restart", cleanedContainerID) if out, _, err = runCommandWithOutput(runCmd); err != nil { @@ -133,15 +130,10 @@ func (s *DockerSuite) TestRestartWithVolumes(c *check.C) { c.Errorf("expect 1 volume after restart received %s", out) } - runCmd = exec.Command(dockerBinary, "inspect", "--format", "{{ .Volumes }}", cleanedContainerID) - volumesAfterRestart, _, err := runCommandWithOutput(runCmd) - if err != nil { - c.Fatal(volumesAfterRestart, err) - } + volumesAfterRestart, err := inspectField(cleanedContainerID, ".Volumes") + c.Assert(err, check.IsNil) if volumes != volumesAfterRestart { - volumes = strings.Trim(volumes, " \n\r") - volumesAfterRestart = strings.Trim(volumesAfterRestart, " \n\r") c.Errorf("expected volume path: %s Actual path: %s", volumes, volumesAfterRestart) } @@ -157,9 +149,7 @@ func (s *DockerSuite) TestRestartPolicyNO(c *check.C) { id := strings.TrimSpace(string(out)) name, err := inspectField(id, "HostConfig.RestartPolicy.Name") - if err != nil { - c.Fatal(err, out) - } + c.Assert(err, check.IsNil) if name != "no" { c.Fatalf("Container restart policy name is %s, expected %s", name, "no") } @@ -176,17 +166,13 @@ func (s *DockerSuite) TestRestartPolicyAlways(c *check.C) { id := strings.TrimSpace(string(out)) name, err := inspectField(id, "HostConfig.RestartPolicy.Name") - if err != nil { - c.Fatal(err, out) - } + c.Assert(err, check.IsNil) if name != "always" { c.Fatalf("Container restart policy name is %s, expected %s", name, "always") } MaximumRetryCount, err := inspectField(id, "HostConfig.RestartPolicy.MaximumRetryCount") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) // MaximumRetryCount=0 if the restart policy is always if MaximumRetryCount != "0" { @@ -205,9 +191,7 @@ func (s *DockerSuite) TestRestartPolicyOnFailure(c *check.C) { id := strings.TrimSpace(string(out)) name, err := inspectField(id, "HostConfig.RestartPolicy.Name") - if err != nil { - c.Fatal(err, out) - } + c.Assert(err, check.IsNil) if name != "on-failure" { c.Fatalf("Container restart policy name is %s, expected %s", name, "on-failure") } @@ -226,16 +210,12 @@ func (s *DockerSuite) TestContainerRestartwithGoodContainer(c *check.C) { c.Fatal(err) } count, err := inspectField(id, "RestartCount") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if count != "0" { c.Fatalf("Container was restarted %s times, expected %d", count, 0) } MaximumRetryCount, err := inspectField(id, "HostConfig.RestartPolicy.MaximumRetryCount") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if MaximumRetryCount != "3" { c.Fatalf("Container Maximum Retry Count is %s, expected %s", MaximumRetryCount, "3") } diff --git a/integration-cli/docker_cli_rmi_test.go b/integration-cli/docker_cli_rmi_test.go index 9dc2ee297a..fa82916f2b 100644 --- a/integration-cli/docker_cli_rmi_test.go +++ b/integration-cli/docker_cli_rmi_test.go @@ -101,8 +101,8 @@ func (s *DockerSuite) TestRmiImgIDForce(c *check.C) { c.Fatalf("tag busybox to create 4 more images with same imageID; docker images shows: %q\n", imagesAfter) } } - out, _ = dockerCmd(c, "inspect", "-f", "{{.Id}}", "busybox-test") - imgID := strings.TrimSpace(out) + imgID, err := inspectField("busybox-test", "Id") + c.Assert(err, check.IsNil) // first checkout without force it fails runCmd = exec.Command(dockerBinary, "rmi", imgID) diff --git a/integration-cli/docker_cli_run_test.go b/integration-cli/docker_cli_run_test.go index af0bebd472..d2c113d265 100644 --- a/integration-cli/docker_cli_run_test.go +++ b/integration-cli/docker_cli_run_test.go @@ -87,7 +87,7 @@ func (s *DockerSuite) TestRunEchoStdoutWithCPUAndMemoryLimit(c *check.C) { } // "test" should be printed -func (s *DockerSuite) TestRunEchoStdoutWitCPUQuota(c *check.C) { +func (s *DockerSuite) TestRunEchoStdoutWithCPUQuota(c *check.C) { runCmd := exec.Command(dockerBinary, "run", "--cpu-quota", "8000", "--name", "test", "busybox", "echo", "test") out, _, _, err := runCommandWithStdoutStderr(runCmd) if err != nil { @@ -101,12 +101,9 @@ func (s *DockerSuite) TestRunEchoStdoutWitCPUQuota(c *check.C) { c.Errorf("container should've printed 'test'") } - cmd := exec.Command(dockerBinary, "inspect", "-f", "{{.HostConfig.CpuQuota}}", "test") - out, _, err = runCommandWithOutput(cmd) - if err != nil { - c.Fatalf("failed to inspect container: %s, %v", out, err) - } - out = strings.TrimSpace(out) + out, err = inspectField("test", "HostConfig.CpuQuota") + c.Assert(err, check.IsNil) + if out != "8000" { c.Errorf("setting the CPU CFS quota failed") } @@ -302,12 +299,8 @@ func (s *DockerSuite) TestRunLinksContainerWithContainerName(c *check.C) { if err != nil { c.Fatalf("failed to run container: %v, output: %q", err, out) } - cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.NetworkSettings.IPAddress}}", "parent") - ip, _, _, err := runCommandWithStdoutStderr(cmd) - if err != nil { - c.Fatalf("failed to inspect container: %v, output: %q", err, ip) - } - ip = strings.TrimSpace(ip) + ip, err := inspectField("parent", "NetworkSettings.IPAddress") + c.Assert(err, check.IsNil) cmd = exec.Command(dockerBinary, "run", "--link", "parent:test", "busybox", "/bin/cat", "/etc/hosts") out, _, err = runCommandWithOutput(cmd) if err != nil { @@ -326,12 +319,8 @@ func (s *DockerSuite) TestRunLinksContainerWithContainerId(c *check.C) { c.Fatalf("failed to run container: %v, output: %q", err, cID) } cID = strings.TrimSpace(cID) - cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.NetworkSettings.IPAddress}}", cID) - ip, _, _, err := runCommandWithStdoutStderr(cmd) - if err != nil { - c.Fatalf("failed to inspect container: %v, output: %q", err, ip) - } - ip = strings.TrimSpace(ip) + ip, err := inspectField(cID, "NetworkSettings.IPAddress") + c.Assert(err, check.IsNil) cmd = exec.Command(dockerBinary, "run", "--link", cID+":test", "busybox", "/bin/cat", "/etc/hosts") out, _, err := runCommandWithOutput(cmd) if err != nil { @@ -1175,12 +1164,8 @@ func (s *DockerSuite) TestRunWithCpuPeriod(c *check.C) { c.Skip("Your kernel does not support CPU cfs period, skip this test") } - cmd := exec.Command(dockerBinary, "inspect", "-f", "{{.HostConfig.CpuPeriod}}", "test") - out, _, err = runCommandWithOutput(cmd) - if err != nil { - c.Fatalf("failed to inspect container: %s, %v", out, err) - } - out = strings.TrimSpace(out) + out, err = inspectField("test", "HostConfig.CpuPeriod") + c.Assert(err, check.IsNil) if out != "50000" { c.Errorf("setting the CPU CFS period failed") } @@ -1753,16 +1738,12 @@ func (s *DockerSuite) TestRunState(c *check.C) { } id := strings.TrimSpace(out) state, err := inspectField(id, "State.Running") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if state != "true" { c.Fatal("Container state is 'not running'") } pid1, err := inspectField(id, "State.Pid") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if pid1 == "0" { c.Fatal("Container state Pid 0") } @@ -1773,16 +1754,12 @@ func (s *DockerSuite) TestRunState(c *check.C) { c.Fatal(err, out) } state, err = inspectField(id, "State.Running") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if state != "false" { c.Fatal("Container state is 'running'") } pid2, err := inspectField(id, "State.Pid") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if pid2 == pid1 { c.Fatalf("Container state Pid %s, but expected %s", pid2, pid1) } @@ -1793,16 +1770,12 @@ func (s *DockerSuite) TestRunState(c *check.C) { c.Fatal(err, out) } state, err = inspectField(id, "State.Running") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if state != "true" { c.Fatal("Container state is 'not running'") } pid3, err := inspectField(id, "State.Pid") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if pid3 == pid1 { c.Fatalf("Container state Pid %s, but expected %s", pid2, pid1) } @@ -2178,9 +2151,7 @@ func (s *DockerSuite) TestRunNetworkNotInitializedNoneMode(c *check.C) { } id := strings.TrimSpace(out) res, err := inspectField(id, "NetworkSettings.IPAddress") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if res != "" { c.Fatalf("For 'none' mode network must not be initialized, but container got IP: %s", res) } @@ -2209,9 +2180,7 @@ func (s *DockerSuite) TestRunInspectMacAddress(c *check.C) { } id := strings.TrimSpace(out) inspectedMac, err := inspectField(id, "NetworkSettings.MacAddress") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if inspectedMac != mac { c.Fatalf("docker inspect outputs wrong MAC address: %q, should be: %q", inspectedMac, mac) } @@ -2237,9 +2206,7 @@ func (s *DockerSuite) TestRunDeallocatePortOnMissingIptablesRule(c *check.C) { } id := strings.TrimSpace(out) ip, err := inspectField(id, "NetworkSettings.IPAddress") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) iptCmd := exec.Command("iptables", "-D", "DOCKER", "-d", fmt.Sprintf("%s/32", ip), "!", "-i", "docker0", "-o", "docker0", "-p", "tcp", "-m", "tcp", "--dport", "23", "-j", "ACCEPT") out, _, err = runCommandWithOutput(iptCmd) @@ -2499,32 +2466,24 @@ func (s *DockerSuite) TestRunVolumesCleanPaths(c *check.C) { } out, err := inspectFieldMap("dark_helmet", "Volumes", "/foo/") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if out != "" { c.Fatalf("Found unexpected volume entry for '/foo/' in volumes\n%q", out) } out, err = inspectFieldMap("dark_helmet", "Volumes", "/foo") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if !strings.Contains(out, volumesStoragePath) { c.Fatalf("Volume was not defined for /foo\n%q", out) } out, err = inspectFieldMap("dark_helmet", "Volumes", "/bar/") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if out != "" { c.Fatalf("Found unexpected volume entry for '/bar/' in volumes\n%q", out) } out, err = inspectFieldMap("dark_helmet", "Volumes", "/bar") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if !strings.Contains(out, volumesStoragePath) { c.Fatalf("Volume was not defined for /bar\n%q", out) } @@ -2561,9 +2520,7 @@ func (s *DockerSuite) TestRunAllowPortRangeThroughExpose(c *check.C) { } id := strings.TrimSpace(out) portstr, err := inspectFieldJSON(id, "NetworkSettings.Ports") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) var ports nat.PortMap if err = unmarshalJSON([]byte(portstr), &ports); err != nil { c.Fatal(err) @@ -2604,14 +2561,8 @@ func (s *DockerSuite) TestRunUnknownCommand(c *check.C) { runCmd = exec.Command(dockerBinary, "start", cID) _, _, _, _ = runCommandWithStdoutStderr(runCmd) - runCmd = exec.Command(dockerBinary, "inspect", "--format={{.State.ExitCode}}", cID) - rc, _, _, err2 := runCommandWithStdoutStderr(runCmd) - rc = strings.TrimSpace(rc) - - if err2 != nil { - c.Fatalf("Error getting status of container: %v", err2) - } - + rc, err := inspectField(cID, "State.ExitCode") + c.Assert(err, check.IsNil) if rc == "0" { c.Fatalf("ExitCode(%v) cannot be 0", rc) } @@ -2658,16 +2609,12 @@ func (s *DockerSuite) TestRunModeIpcContainer(c *check.C) { } id := strings.TrimSpace(out) state, err := inspectField(id, "State.Running") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if state != "true" { c.Fatal("Container state is 'not running'") } pid1, err := inspectField(id, "State.Pid") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) parentContainerIpc, err := os.Readlink(fmt.Sprintf("/proc/%s/ns/ipc", pid1)) if err != nil { @@ -2706,9 +2653,7 @@ func (s *DockerSuite) TestContainerNetworkMode(c *check.C) { c.Fatal(err) } pid1, err := inspectField(id, "State.Pid") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) parentContainerNet, err := os.Readlink(fmt.Sprintf("/proc/%s/ns/net", pid1)) if err != nil { @@ -2963,9 +2908,7 @@ func (s *DockerSuite) TestRunAllowPortRangeThroughPublish(c *check.C) { id := strings.TrimSpace(out) portstr, err := inspectFieldJSON(id, "NetworkSettings.Ports") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) var ports nat.PortMap err = unmarshalJSON([]byte(portstr), &ports) for port, binding := range ports { @@ -3003,12 +2946,8 @@ func (s *DockerSuite) TestRunSetDefaultRestartPolicy(c *check.C) { if out, _, err := runCommandWithOutput(runCmd); err != nil { c.Fatalf("failed to run container: %v, output: %q", err, out) } - cmd := exec.Command(dockerBinary, "inspect", "-f", "{{.HostConfig.RestartPolicy.Name}}", "test") - out, _, err := runCommandWithOutput(cmd) - if err != nil { - c.Fatalf("failed to inspect container: %v, output: %q", err, out) - } - out = strings.Trim(out, "\r\n") + out, err := inspectField("test", "HostConfig.RestartPolicy.Name") + c.Assert(err, check.IsNil) if out != "no" { c.Fatalf("Set default restart policy failed") } @@ -3024,16 +2963,12 @@ func (s *DockerSuite) TestRunRestartMaxRetries(c *check.C) { c.Fatal(err) } count, err := inspectField(id, "RestartCount") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if count != "3" { c.Fatalf("Container was restarted %s times, expected %d", count, 3) } MaximumRetryCount, err := inspectField(id, "HostConfig.RestartPolicy.MaximumRetryCount") - if err != nil { - c.Fatal(err) - } + c.Assert(err, check.IsNil) if MaximumRetryCount != "3" { c.Fatalf("Container Maximum Retry Count is %s, expected %s", MaximumRetryCount, "3") } diff --git a/integration-cli/docker_cli_start_test.go b/integration-cli/docker_cli_start_test.go index fddc8c97bb..caf8428738 100644 --- a/integration-cli/docker_cli_start_test.go +++ b/integration-cli/docker_cli_start_test.go @@ -98,9 +98,7 @@ func (s *DockerSuite) TestStartRecordError(c *check.C) { // when container runs successfully, we should not have state.Error dockerCmd(c, "run", "-d", "-p", "9999:9999", "--name", "test", "busybox", "top") stateErr, err := inspectField("test", "State.Error") - if err != nil { - c.Fatalf("Failed to inspect %q state's error, got error %q", "test", err) - } + c.Assert(err, check.IsNil) if stateErr != "" { c.Fatalf("Expected to not have state error but got state.Error(%q)", stateErr) } @@ -111,9 +109,7 @@ func (s *DockerSuite) TestStartRecordError(c *check.C) { c.Fatalf("Expected error but got none, output %q", out) } stateErr, err = inspectField("test2", "State.Error") - if err != nil { - c.Fatalf("Failed to inspect %q state's error, got error %q", "test2", err) - } + c.Assert(err, check.IsNil) expected := "port is already allocated" if stateErr == "" || !strings.Contains(stateErr, expected) { c.Fatalf("State.Error(%q) does not include %q", stateErr, expected) @@ -123,9 +119,7 @@ func (s *DockerSuite) TestStartRecordError(c *check.C) { dockerCmd(c, "stop", "test") dockerCmd(c, "start", "test2") stateErr, err = inspectField("test2", "State.Error") - if err != nil { - c.Fatalf("Failed to inspect %q state's error, got error %q", "test", err) - } + c.Assert(err, check.IsNil) if stateErr != "" { c.Fatalf("Expected to not have state error but got state.Error(%q)", stateErr) } @@ -196,12 +190,8 @@ func (s *DockerSuite) TestStartMultipleContainers(c *check.C) { if out, _, err := runCommandWithOutput(cmd); err != nil { c.Fatal(out, err) } - cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.State.Running}}", "parent") - out, _, err := runCommandWithOutput(cmd) - if err != nil { - c.Fatal(out, err) - } - out = strings.Trim(out, "\r\n") + out, err := inspectField("parent", "State.Running") + c.Assert(err, check.IsNil) if out != "false" { c.Fatal("Container should be stopped") } @@ -215,12 +205,8 @@ func (s *DockerSuite) TestStartMultipleContainers(c *check.C) { } for container, expected := range map[string]string{"parent": "true", "child_first": "false", "child_second": "true"} { - cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.State.Running}}", container) - out, _, err = runCommandWithOutput(cmd) - if err != nil { - c.Fatal(out, err) - } - out = strings.Trim(out, "\r\n") + out, err := inspectField(container, "State.Running") + c.Assert(err, check.IsNil) if out != expected { c.Fatal("Container running state wrong") } @@ -260,12 +246,10 @@ func (s *DockerSuite) TestStartAttachMultipleContainers(c *check.C) { // confirm the state of all the containers be stopped for container, expected := range map[string]string{"test1": "false", "test2": "false", "test3": "false"} { - cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.State.Running}}", container) - out, _, err := runCommandWithOutput(cmd) + out, err := inspectField(container, "State.Running") if err != nil { c.Fatal(out, err) } - out = strings.Trim(out, "\r\n") if out != expected { c.Fatal("Container running state wrong") } diff --git a/integration-cli/docker_cli_tag_test.go b/integration-cli/docker_cli_tag_test.go index 694bab95c1..7db21a6f37 100644 --- a/integration-cli/docker_cli_tag_test.go +++ b/integration-cli/docker_cli_tag_test.go @@ -22,15 +22,10 @@ func (s *DockerSuite) TestTagUnprefixedRepoByName(c *check.C) { // tagging an image by ID in a new unprefixed repo should work func (s *DockerSuite) TestTagUnprefixedRepoByID(c *check.C) { - getIDCmd := exec.Command(dockerBinary, "inspect", "-f", "{{.Id}}", "busybox") - out, _, err := runCommandWithOutput(getIDCmd) - if err != nil { - c.Fatalf("failed to get the image ID of busybox: %s, %v", out, err) - } - - cleanedImageID := strings.TrimSpace(out) - tagCmd := exec.Command(dockerBinary, "tag", cleanedImageID, "testfoobarbaz") - if out, _, err = runCommandWithOutput(tagCmd); err != nil { + imageID, err := inspectField("busybox", "Id") + c.Assert(err, check.IsNil) + tagCmd := exec.Command(dockerBinary, "tag", imageID, "testfoobarbaz") + if out, _, err := runCommandWithOutput(tagCmd); err != nil { c.Fatal(out, err) } } diff --git a/integration-cli/docker_cli_wait_test.go b/integration-cli/docker_cli_wait_test.go index b7fb3fe958..c6d469eed0 100644 --- a/integration-cli/docker_cli_wait_test.go +++ b/integration-cli/docker_cli_wait_test.go @@ -21,12 +21,8 @@ func (s *DockerSuite) TestWaitNonBlockedExitZero(c *check.C) { status := "true" for i := 0; status != "false"; i++ { - runCmd = exec.Command(dockerBinary, "inspect", "--format='{{.State.Running}}'", containerID) - status, _, err = runCommandWithOutput(runCmd) - if err != nil { - c.Fatal(status, err) - } - status = strings.TrimSpace(status) + status, err = inspectField(containerID, "State.Running") + c.Assert(err, check.IsNil) time.Sleep(time.Second) if i >= 60 { @@ -84,12 +80,8 @@ func (s *DockerSuite) TestWaitNonBlockedExitRandom(c *check.C) { status := "true" for i := 0; status != "false"; i++ { - runCmd = exec.Command(dockerBinary, "inspect", "--format='{{.State.Running}}'", containerID) - status, _, err = runCommandWithOutput(runCmd) - if err != nil { - c.Fatal(status, err) - } - status = strings.TrimSpace(status) + status, err = inspectField(containerID, "State.Running") + c.Assert(err, check.IsNil) time.Sleep(time.Second) if i >= 60 {