diff --git a/components/engine/integration-cli/docker_cli_restart_test.go b/components/engine/integration-cli/docker_cli_restart_test.go index c8bb0b1bcc..5f638ad91a 100644 --- a/components/engine/integration-cli/docker_cli_restart_test.go +++ b/components/engine/integration-cli/docker_cli_restart_test.go @@ -22,7 +22,7 @@ func (s *DockerSuite) TestRestartStoppedContainer(c *check.C) { out, _ = dockerCmd(c, "logs", cleanedContainerID) if out != "foobar\nfoobar\n" { - c.Errorf("container should've printed 'foobar' twice") + c.Errorf("container should've printed 'foobar' twice, got %v", out) } } diff --git a/components/engine/integration-cli/docker_cli_save_load_test.go b/components/engine/integration-cli/docker_cli_save_load_test.go index e59e6b561d..543ba9bfc7 100644 --- a/components/engine/integration-cli/docker_cli_save_load_test.go +++ b/components/engine/integration-cli/docker_cli_save_load_test.go @@ -16,25 +16,12 @@ import ( // save a repo using gz compression and try to load it using stdout func (s *DockerSuite) TestSaveXzAndLoadRepoStdout(c *check.C) { name := "test-save-xz-and-load-repo-stdout" - runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "true") - out, _, err := runCommandWithOutput(runCmd) - if err != nil { - c.Fatalf("failed to create a container: %v %v", out, err) - } + dockerCmd(c, "run", "--name", name, "busybox", "true") repoName := "foobar-save-load-test-xz-gz" + out, _ := dockerCmd(c, "commit", name, repoName) - commitCmd := exec.Command(dockerBinary, "commit", name, repoName) - out, _, err = runCommandWithOutput(commitCmd) - if err != nil { - c.Fatalf("failed to commit container: %v %v", out, err) - } - - inspectCmd := exec.Command(dockerBinary, "inspect", repoName) - before, _, err := runCommandWithOutput(inspectCmd) - if err != nil { - c.Fatalf("the repo should exist before saving it: %v %v", before, err) - } + dockerCmd(c, "inspect", repoName) repoTarball, _, err := runCommandPipelineWithOutput( exec.Command(dockerBinary, "save", repoName), @@ -52,8 +39,7 @@ func (s *DockerSuite) TestSaveXzAndLoadRepoStdout(c *check.C) { c.Fatalf("expected error, but succeeded with no error and output: %v", out) } - inspectCmd = exec.Command(dockerBinary, "inspect", repoName) - after, _, err := runCommandWithOutput(inspectCmd) + after, _, err := dockerCmdWithError(c, "inspect", repoName) if err == nil { c.Fatalf("the repo should not exist: %v", after) } @@ -62,27 +48,14 @@ func (s *DockerSuite) TestSaveXzAndLoadRepoStdout(c *check.C) { // save a repo using xz+gz compression and try to load it using stdout func (s *DockerSuite) TestSaveXzGzAndLoadRepoStdout(c *check.C) { name := "test-save-xz-gz-and-load-repo-stdout" - runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "true") - out, _, err := runCommandWithOutput(runCmd) - if err != nil { - c.Fatalf("failed to create a container: %v %v", out, err) - } + dockerCmd(c, "run", "--name", name, "busybox", "true") repoName := "foobar-save-load-test-xz-gz" + dockerCmd(c, "commit", name, repoName) - commitCmd := exec.Command(dockerBinary, "commit", name, repoName) - out, _, err = runCommandWithOutput(commitCmd) - if err != nil { - c.Fatalf("failed to commit container: %v %v", out, err) - } + dockerCmd(c, "inspect", repoName) - inspectCmd := exec.Command(dockerBinary, "inspect", repoName) - before, _, err := runCommandWithOutput(inspectCmd) - if err != nil { - c.Fatalf("the repo should exist before saving it: %v %v", before, err) - } - - out, _, err = runCommandPipelineWithOutput( + out, _, err := runCommandPipelineWithOutput( exec.Command(dockerBinary, "save", repoName), exec.Command("xz", "-c"), exec.Command("gzip", "-c")) @@ -99,8 +72,7 @@ func (s *DockerSuite) TestSaveXzGzAndLoadRepoStdout(c *check.C) { c.Fatalf("expected error, but succeeded with no error and output: %v", out) } - inspectCmd = exec.Command(dockerBinary, "inspect", repoName) - after, _, err := runCommandWithOutput(inspectCmd) + after, _, err := dockerCmdWithError(c, "inspect", repoName) if err == nil { c.Fatalf("the repo should not exist: %v", after) } @@ -108,55 +80,34 @@ func (s *DockerSuite) TestSaveXzGzAndLoadRepoStdout(c *check.C) { func (s *DockerSuite) TestSaveSingleTag(c *check.C) { repoName := "foobar-save-single-tag-test" + dockerCmd(c, "tag", "busybox:latest", fmt.Sprintf("%v:latest", repoName)) - tagCmd := exec.Command(dockerBinary, "tag", "busybox:latest", fmt.Sprintf("%v:latest", repoName)) - if out, _, err := runCommandWithOutput(tagCmd); err != nil { - c.Fatalf("failed to tag repo: %s, %v", out, err) - } - - idCmd := exec.Command(dockerBinary, "images", "-q", "--no-trunc", repoName) - out, _, err := runCommandWithOutput(idCmd) - if err != nil { - c.Fatalf("failed to get repo ID: %s, %v", out, err) - } + out, _ := dockerCmd(c, "images", "-q", "--no-trunc", repoName) cleanedImageID := strings.TrimSpace(out) - out, _, err = runCommandPipelineWithOutput( + out, _, err := runCommandPipelineWithOutput( exec.Command(dockerBinary, "save", fmt.Sprintf("%v:latest", repoName)), exec.Command("tar", "t"), exec.Command("grep", "-E", fmt.Sprintf("(^repositories$|%v)", cleanedImageID))) if err != nil { c.Fatalf("failed to save repo with image ID and 'repositories' file: %s, %v", out, err) } - } func (s *DockerSuite) TestSaveImageId(c *check.C) { repoName := "foobar-save-image-id-test" + dockerCmd(c, "tag", "emptyfs:latest", fmt.Sprintf("%v:latest", repoName)) - tagCmd := exec.Command(dockerBinary, "tag", "emptyfs:latest", fmt.Sprintf("%v:latest", repoName)) - if out, _, err := runCommandWithOutput(tagCmd); err != nil { - c.Fatalf("failed to tag repo: %s, %v", out, err) - } - - idLongCmd := exec.Command(dockerBinary, "images", "-q", "--no-trunc", repoName) - out, _, err := runCommandWithOutput(idLongCmd) - if err != nil { - c.Fatalf("failed to get repo ID: %s, %v", out, err) - } - + out, _ := dockerCmd(c, "images", "-q", "--no-trunc", repoName) cleanedLongImageID := strings.TrimSpace(out) - idShortCmd := exec.Command(dockerBinary, "images", "-q", repoName) - out, _, err = runCommandWithOutput(idShortCmd) - if err != nil { - c.Fatalf("failed to get repo short ID: %s, %v", out, err) - } - + out, _ = dockerCmd(c, "images", "-q", repoName) cleanedShortImageID := strings.TrimSpace(out) saveCmd := exec.Command(dockerBinary, "save", cleanedShortImageID) tarCmd := exec.Command("tar", "t") + + var err error tarCmd.Stdin, err = saveCmd.StdoutPipe() if err != nil { c.Fatalf("cannot set stdout pipe for tar: %v", err) @@ -181,45 +132,28 @@ func (s *DockerSuite) TestSaveImageId(c *check.C) { if err != nil { c.Fatalf("failed to save repo with image ID: %s, %v", out, err) } - } // save a repo and try to load it using flags func (s *DockerSuite) TestSaveAndLoadRepoFlags(c *check.C) { name := "test-save-and-load-repo-flags" - runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "true") - out, _, err := runCommandWithOutput(runCmd) - if err != nil { - c.Fatalf("failed to create a container: %s, %v", out, err) - } + dockerCmd(c, "run", "--name", name, "busybox", "true") + repoName := "foobar-save-load-test" - commitCmd := exec.Command(dockerBinary, "commit", name, repoName) deleteImages(repoName) - if out, _, err = runCommandWithOutput(commitCmd); err != nil { - c.Fatalf("failed to commit container: %s, %v", out, err) - } + dockerCmd(c, "commit", name, repoName) - inspectCmd := exec.Command(dockerBinary, "inspect", repoName) - before, _, err := runCommandWithOutput(inspectCmd) - if err != nil { - c.Fatalf("the repo should exist before saving it: %s, %v", before, err) + before, _ := dockerCmd(c, "inspect", repoName) - } - - out, _, err = runCommandPipelineWithOutput( + out, _, err := runCommandPipelineWithOutput( exec.Command(dockerBinary, "save", repoName), exec.Command(dockerBinary, "load")) if err != nil { c.Fatalf("failed to save and load repo: %s, %v", out, err) } - inspectCmd = exec.Command(dockerBinary, "inspect", repoName) - after, _, err := runCommandWithOutput(inspectCmd) - if err != nil { - c.Fatalf("the repo should exist after loading it: %s, %v", after, err) - } - + after, _ := dockerCmd(c, "inspect", repoName) if before != after { c.Fatalf("inspect is not the same after a save / load") } @@ -229,19 +163,12 @@ func (s *DockerSuite) TestSaveMultipleNames(c *check.C) { repoName := "foobar-save-multi-name-test" // Make one image - tagCmd := exec.Command(dockerBinary, "tag", "emptyfs:latest", fmt.Sprintf("%v-one:latest", repoName)) - if out, _, err := runCommandWithOutput(tagCmd); err != nil { - c.Fatalf("failed to tag repo: %s, %v", out, err) - } + dockerCmd(c, "tag", "emptyfs:latest", fmt.Sprintf("%v-one:latest", repoName)) // Make two images - tagCmd = exec.Command(dockerBinary, "tag", "emptyfs:latest", fmt.Sprintf("%v-two:latest", repoName)) - out, _, err := runCommandWithOutput(tagCmd) - if err != nil { - c.Fatalf("failed to tag repo: %s, %v", out, err) - } + dockerCmd(c, "tag", "emptyfs:latest", fmt.Sprintf("%v-two:latest", repoName)) - out, _, err = runCommandPipelineWithOutput( + out, _, err := runCommandPipelineWithOutput( exec.Command(dockerBinary, "save", fmt.Sprintf("%v-one", repoName), fmt.Sprintf("%v-two:latest", repoName)), exec.Command("tar", "xO", "repositories"), exec.Command("grep", "-q", "-E", "(-one|-two)"), @@ -249,26 +176,18 @@ func (s *DockerSuite) TestSaveMultipleNames(c *check.C) { if err != nil { c.Fatalf("failed to save multiple repos: %s, %v", out, err) } - } func (s *DockerSuite) TestSaveRepoWithMultipleImages(c *check.C) { makeImage := func(from string, tag string) string { - runCmd := exec.Command(dockerBinary, "run", "-d", from, "true") var ( out string - err error ) - if out, _, err = runCommandWithOutput(runCmd); err != nil { - c.Fatalf("failed to create a container: %v %v", out, err) - } + out, _ = dockerCmd(c, "run", "-d", from, "true") cleanedContainerID := strings.TrimSpace(out) - commitCmd := exec.Command(dockerBinary, "commit", cleanedContainerID, tag) - if out, _, err = runCommandWithOutput(commitCmd); err != nil { - c.Fatalf("failed to commit container: %v %v", out, err) - } + out, _ = dockerCmd(c, "commit", cleanedContainerID, tag) imageID := strings.TrimSpace(out) return imageID } @@ -294,11 +213,7 @@ func (s *DockerSuite) TestSaveRepoWithMultipleImages(c *check.C) { actual := strings.Split(strings.TrimSpace(out), "\n") // make the list of expected layers - out, _, err = runCommandWithOutput(exec.Command(dockerBinary, "history", "-q", "--no-trunc", "busybox:latest")) - if err != nil { - c.Fatalf("failed to get history: %s, %v", out, err) - } - + out, _ = dockerCmd(c, "history", "-q", "--no-trunc", "busybox:latest") expected := append(strings.Split(strings.TrimSpace(out), "\n"), idFoo, idBar) sort.Strings(actual) @@ -306,7 +221,6 @@ func (s *DockerSuite) TestSaveRepoWithMultipleImages(c *check.C) { if !reflect.DeepEqual(expected, actual) { c.Fatalf("archive does not contains the right layers: got %v, expected %v", actual, expected) } - } // Issue #6722 #5892 ensure directories are included in changes diff --git a/components/engine/integration-cli/docker_cli_save_load_unix_test.go b/components/engine/integration-cli/docker_cli_save_load_unix_test.go index f16cd17192..2bca3b85a7 100644 --- a/components/engine/integration-cli/docker_cli_save_load_unix_test.go +++ b/components/engine/integration-cli/docker_cli_save_load_unix_test.go @@ -15,24 +15,12 @@ import ( // save a repo and try to load it using stdout func (s *DockerSuite) TestSaveAndLoadRepoStdout(c *check.C) { name := "test-save-and-load-repo-stdout" - runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "true") - out, _, err := runCommandWithOutput(runCmd) - if err != nil { - c.Fatalf("failed to create a container: %s, %v", out, err) - } + dockerCmd(c, "run", "--name", name, "busybox", "true") repoName := "foobar-save-load-test" + out, _ := dockerCmd(c, "commit", name, repoName) - commitCmd := exec.Command(dockerBinary, "commit", name, repoName) - if out, _, err = runCommandWithOutput(commitCmd); err != nil { - c.Fatalf("failed to commit container: %s, %v", out, err) - } - - inspectCmd := exec.Command(dockerBinary, "inspect", repoName) - before, _, err := runCommandWithOutput(inspectCmd) - if err != nil { - c.Fatalf("the repo should exist before saving it: %s, %v", before, err) - } + before, _ := dockerCmd(c, "inspect", repoName) tmpFile, err := ioutil.TempFile("", "foobar-save-load-test.tar") c.Assert(err, check.IsNil) @@ -57,11 +45,7 @@ func (s *DockerSuite) TestSaveAndLoadRepoStdout(c *check.C) { c.Fatalf("failed to load repo: %s, %v", out, err) } - inspectCmd = exec.Command(dockerBinary, "inspect", repoName) - after, _, err := runCommandWithOutput(inspectCmd) - if err != nil { - c.Fatalf("the repo should exist after loading it: %s %v", after, err) - } + after, _ := dockerCmd(c, "inspect", repoName) if before != after { c.Fatalf("inspect is not the same after a save / load") @@ -94,5 +78,4 @@ func (s *DockerSuite) TestSaveAndLoadRepoStdout(c *check.C) { if !bytes.Contains(buf[:n], []byte("Cowardly refusing")) { c.Fatal("help output is not being yielded", out) } - } diff --git a/components/engine/integration-cli/docker_cli_search_test.go b/components/engine/integration-cli/docker_cli_search_test.go index f689bba96d..d89c05ccc6 100644 --- a/components/engine/integration-cli/docker_cli_search_test.go +++ b/components/engine/integration-cli/docker_cli_search_test.go @@ -1,7 +1,6 @@ package main import ( - "os/exec" "strings" "github.com/go-check/check" @@ -10,21 +9,19 @@ import ( // search for repos named "registry" on the central registry func (s *DockerSuite) TestSearchOnCentralRegistry(c *check.C) { testRequires(c, Network) - searchCmd := exec.Command(dockerBinary, "search", "busybox") - out, exitCode, err := runCommandWithOutput(searchCmd) - if err != nil || exitCode != 0 { - c.Fatalf("failed to search on the central registry: %s, %v", out, err) + + out, exitCode := dockerCmd(c, "search", "busybox") + if exitCode != 0 { + c.Fatalf("failed to search on the central registry: %s", out) } if !strings.Contains(out, "Busybox base image.") { c.Fatal("couldn't find any repository named (or containing) 'Busybox base image.'") } - } func (s *DockerSuite) TestSearchStarsOptionWithWrongParameter(c *check.C) { - searchCmdStarsChars := exec.Command(dockerBinary, "search", "--stars=a", "busybox") - out, exitCode, err := runCommandWithOutput(searchCmdStarsChars) + out, exitCode, err := dockerCmdWithError(c, "search", "--stars=a", "busybox") if err == nil || exitCode == 0 { c.Fatalf("Should not get right information: %s, %v", out, err) } @@ -33,8 +30,7 @@ func (s *DockerSuite) TestSearchStarsOptionWithWrongParameter(c *check.C) { c.Fatal("couldn't find the invalid value warning") } - searchCmdStarsNegativeNumber := exec.Command(dockerBinary, "search", "-s=-1", "busybox") - out, exitCode, err = runCommandWithOutput(searchCmdStarsNegativeNumber) + out, exitCode, err = dockerCmdWithError(c, "search", "-s=-1", "busybox") if err == nil || exitCode == 0 { c.Fatalf("Should not get right information: %s, %v", out, err) } @@ -42,64 +38,54 @@ func (s *DockerSuite) TestSearchStarsOptionWithWrongParameter(c *check.C) { if !strings.Contains(out, "invalid value") { c.Fatal("couldn't find the invalid value warning") } - } func (s *DockerSuite) TestSearchCmdOptions(c *check.C) { testRequires(c, Network) - searchCmdhelp := exec.Command(dockerBinary, "search", "--help") - out, exitCode, err := runCommandWithOutput(searchCmdhelp) - if err != nil || exitCode != 0 { - c.Fatalf("failed to get search help information: %s, %v", out, err) + + out, exitCode := dockerCmd(c, "search", "--help") + if exitCode != 0 { + c.Fatalf("failed to get search help information: %s", out) } if !strings.Contains(out, "Usage:\tdocker search [OPTIONS] TERM") { - c.Fatalf("failed to show docker search usage: %s, %v", out, err) + c.Fatalf("failed to show docker search usage: %s", out) } - searchCmd := exec.Command(dockerBinary, "search", "busybox") - outSearchCmd, exitCode, err := runCommandWithOutput(searchCmd) - if err != nil || exitCode != 0 { - c.Fatalf("failed to search on the central registry: %s, %v", outSearchCmd, err) + outSearchCmd, exitCode := dockerCmd(c, "search", "busybox") + if exitCode != 0 { + c.Fatalf("failed to search on the central registry: %s", outSearchCmd) } - searchCmdNotrunc := exec.Command(dockerBinary, "search", "--no-trunc=true", "busybox") - outSearchCmdNotrunc, _, err := runCommandWithOutput(searchCmdNotrunc) - if err != nil { - c.Fatalf("failed to search on the central registry: %s, %v", outSearchCmdNotrunc, err) - } + outSearchCmdNotrunc, _ := dockerCmd(c, "search", "--no-trunc=true", "busybox") if len(outSearchCmd) > len(outSearchCmdNotrunc) { c.Fatalf("The no-trunc option can't take effect.") } - searchCmdautomated := exec.Command(dockerBinary, "search", "--automated=true", "busybox") - outSearchCmdautomated, exitCode, err := runCommandWithOutput(searchCmdautomated) //The busybox is a busybox base image, not an AUTOMATED image. - if err != nil || exitCode != 0 { - c.Fatalf("failed to search with automated=true on the central registry: %s, %v", outSearchCmdautomated, err) + outSearchCmdautomated, exitCode := dockerCmd(c, "search", "--automated=true", "busybox") //The busybox is a busybox base image, not an AUTOMATED image. + if exitCode != 0 { + c.Fatalf("failed to search with automated=true on the central registry: %s", outSearchCmdautomated) } outSearchCmdautomatedSlice := strings.Split(outSearchCmdautomated, "\n") for i := range outSearchCmdautomatedSlice { if strings.HasPrefix(outSearchCmdautomatedSlice[i], "busybox ") { - c.Fatalf("The busybox is not an AUTOMATED image: %s, %v", out, err) + c.Fatalf("The busybox is not an AUTOMATED image: %s", out) } } - searchCmdStars := exec.Command(dockerBinary, "search", "-s=2", "busybox") - outSearchCmdStars, exitCode, err := runCommandWithOutput(searchCmdStars) - if err != nil || exitCode != 0 { - c.Fatalf("failed to search with stars=2 on the central registry: %s, %v", outSearchCmdStars, err) + outSearchCmdStars, exitCode := dockerCmd(c, "search", "-s=2", "busybox") + if exitCode != 0 { + c.Fatalf("failed to search with stars=2 on the central registry: %s", outSearchCmdStars) } if strings.Count(outSearchCmdStars, "[OK]") > strings.Count(outSearchCmd, "[OK]") { - c.Fatalf("The quantity of images with stars should be less than that of all images: %s, %v", outSearchCmdStars, err) + c.Fatalf("The quantity of images with stars should be less than that of all images: %s", outSearchCmdStars) } - searchCmdOptions := exec.Command(dockerBinary, "search", "--stars=2", "--automated=true", "--no-trunc=true", "busybox") - out, exitCode, err = runCommandWithOutput(searchCmdOptions) - if err != nil || exitCode != 0 { - c.Fatalf("failed to search with stars&automated&no-trunc options on the central registry: %s, %v", out, err) + out, exitCode = dockerCmd(c, "search", "--stars=2", "--automated=true", "--no-trunc=true", "busybox") + if exitCode != 0 { + c.Fatalf("failed to search with stars&automated&no-trunc options on the central registry: %s", out) } - } diff --git a/components/engine/integration-cli/docker_cli_service_test.go b/components/engine/integration-cli/docker_cli_service_test.go index d61871e1bd..aaf5e8199e 100644 --- a/components/engine/integration-cli/docker_cli_service_test.go +++ b/components/engine/integration-cli/docker_cli_service_test.go @@ -4,7 +4,6 @@ package main import ( "fmt" - "os/exec" "strings" "github.com/go-check/check" @@ -23,9 +22,7 @@ func assertSrvNotAvailable(c *check.C, sname, name string) { } func isSrvPresent(c *check.C, sname, name string) bool { - runCmd := exec.Command(dockerBinary, "service", "ls") - out, _, _, err := runCommandWithStdoutStderr(runCmd) - c.Assert(err, check.IsNil) + out, _, _ := dockerCmdWithStdoutStderr(c, "service", "ls") lines := strings.Split(out, "\n") for i := 1; i < len(lines)-1; i++ { if strings.Contains(lines[i], sname) && strings.Contains(lines[i], name) { @@ -36,9 +33,7 @@ func isSrvPresent(c *check.C, sname, name string) bool { } func isCntPresent(c *check.C, cname, sname, name string) bool { - runCmd := exec.Command(dockerBinary, "service", "ls", "--no-trunc") - out, _, _, err := runCommandWithStdoutStderr(runCmd) - c.Assert(err, check.IsNil) + out, _, _ := dockerCmdWithStdoutStderr(c, "service", "ls", "--no-trunc") lines := strings.Split(out, "\n") for i := 1; i < len(lines)-1; i++ { fmt.Println(lines) @@ -50,37 +45,25 @@ func isCntPresent(c *check.C, cname, sname, name string) bool { } func (s *DockerSuite) TestDockerServiceCreateDelete(c *check.C) { - runCmd := exec.Command(dockerBinary, "network", "create", "test") - _, _, _, err := runCommandWithStdoutStderr(runCmd) - c.Assert(err, check.IsNil) + dockerCmdWithStdoutStderr(c, "network", "create", "test") assertNwIsAvailable(c, "test") - runCmd = exec.Command(dockerBinary, "service", "publish", "s1.test") - _, _, _, err = runCommandWithStdoutStderr(runCmd) - c.Assert(err, check.IsNil) + dockerCmdWithStdoutStderr(c, "service", "publish", "s1.test") assertSrvIsAvailable(c, "s1", "test") - runCmd = exec.Command(dockerBinary, "service", "unpublish", "s1.test") - _, _, _, err = runCommandWithStdoutStderr(runCmd) - c.Assert(err, check.IsNil) + dockerCmdWithStdoutStderr(c, "service", "unpublish", "s1.test") assertSrvNotAvailable(c, "s1", "test") - runCmd = exec.Command(dockerBinary, "network", "rm", "test") - _, _, _, err = runCommandWithStdoutStderr(runCmd) - c.Assert(err, check.IsNil) + dockerCmdWithStdoutStderr(c, "network", "rm", "test") assertNwNotAvailable(c, "test") } func (s *DockerSuite) TestDockerPublishServiceFlag(c *check.C) { // Run saying the container is the backend for the specified service on the specified network - runCmd := exec.Command(dockerBinary, "run", "-d", "--expose=23", "--publish-service", "telnet.production", "busybox", "top") - out, _, err := runCommandWithOutput(runCmd) - c.Assert(err, check.IsNil) + out, _ := dockerCmd(c, "run", "-d", "--expose=23", "--publish-service", "telnet.production", "busybox", "top") cid := strings.TrimSpace(out) // Verify container is attached in service ps o/p assertSrvIsAvailable(c, "telnet", "production") - runCmd = exec.Command(dockerBinary, "rm", "-f", cid) - out, _, err = runCommandWithOutput(runCmd) - c.Assert(err, check.IsNil) + dockerCmd(c, "rm", "-f", cid) } diff --git a/components/engine/integration-cli/docker_cli_start_test.go b/components/engine/integration-cli/docker_cli_start_test.go index 0475826738..ce5c48e62d 100644 --- a/components/engine/integration-cli/docker_cli_start_test.go +++ b/components/engine/integration-cli/docker_cli_start_test.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "os/exec" "strings" "time" @@ -11,12 +10,11 @@ import ( // Regression test for https://github.com/docker/docker/issues/7843 func (s *DockerSuite) TestStartAttachReturnsOnError(c *check.C) { - dockerCmd(c, "run", "-d", "--name", "test", "busybox") dockerCmd(c, "wait", "test") // Expect this to fail because the above container is stopped, this is what we want - if _, err := runCommand(exec.Command(dockerBinary, "run", "-d", "--name", "test2", "--link", "test:test", "busybox")); err == nil { + if _, _, err := dockerCmdWithError(c, "run", "-d", "--name", "test2", "--link", "test:test", "busybox"); err == nil { c.Fatal("Expected error but got none") } @@ -24,7 +22,7 @@ func (s *DockerSuite) TestStartAttachReturnsOnError(c *check.C) { go func() { // Attempt to start attached to the container that won't start // This should return an error immediately since the container can't be started - if _, err := runCommand(exec.Command(dockerBinary, "start", "-a", "test2")); err == nil { + if _, _, err := dockerCmdWithError(c, "start", "-a", "test2"); err == nil { ch <- fmt.Errorf("Expected error but got none") } close(ch) @@ -36,28 +34,17 @@ func (s *DockerSuite) TestStartAttachReturnsOnError(c *check.C) { case <-time.After(time.Second): c.Fatalf("Attach did not exit properly") } - } // gh#8555: Exit code should be passed through when using start -a func (s *DockerSuite) TestStartAttachCorrectExitCode(c *check.C) { - - runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sh", "-c", "sleep 2; exit 1") - out, _, _, err := runCommandWithStdoutStderr(runCmd) - if err != nil { - c.Fatalf("failed to run container: %v, output: %q", err, out) - } - + out, _, _ := dockerCmdWithStdoutStderr(c, "run", "-d", "busybox", "sh", "-c", "sleep 2; exit 1") out = strings.TrimSpace(out) // make sure the container has exited before trying the "start -a" - waitCmd := exec.Command(dockerBinary, "wait", out) - if _, _, err = runCommandWithOutput(waitCmd); err != nil { - c.Fatalf("Failed to wait on container: %v", err) - } + dockerCmd(c, "wait", out) - startCmd := exec.Command(dockerBinary, "start", "-a", out) - startOut, exitCode, err := runCommandWithOutput(startCmd) + startOut, exitCode, err := dockerCmdWithError(c, "start", "-a", out) if err != nil && !strings.Contains("exit status 1", fmt.Sprintf("%s", err)) { c.Fatalf("start command failed unexpectedly with error: %v, output: %q", err, startOut) } @@ -68,29 +55,16 @@ func (s *DockerSuite) TestStartAttachCorrectExitCode(c *check.C) { } func (s *DockerSuite) TestStartAttachSilent(c *check.C) { - name := "teststartattachcorrectexitcode" - runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "echo", "test") - out, _, _, err := runCommandWithStdoutStderr(runCmd) - if err != nil { - c.Fatalf("failed to run container: %v, output: %q", err, out) - } + dockerCmd(c, "run", "--name", name, "busybox", "echo", "test") // make sure the container has exited before trying the "start -a" - waitCmd := exec.Command(dockerBinary, "wait", name) - if _, _, err = runCommandWithOutput(waitCmd); err != nil { - c.Fatalf("wait command failed with error: %v", err) - } + dockerCmd(c, "wait", name) - startCmd := exec.Command(dockerBinary, "start", "-a", name) - startOut, _, err := runCommandWithOutput(startCmd) - if err != nil { - c.Fatalf("start command failed unexpectedly with error: %v, output: %q", err, startOut) - } + startOut, _ := dockerCmd(c, "start", "-a", name) if expected := "test\n"; startOut != expected { c.Fatalf("start -a produced unexpected output: expected %q, got %q", expected, startOut) } - } func (s *DockerSuite) TestStartRecordError(c *check.C) { @@ -104,10 +78,11 @@ func (s *DockerSuite) TestStartRecordError(c *check.C) { } // Expect this to fail and records error because of ports conflict - out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-d", "--name", "test2", "-p", "9999:9999", "busybox", "top")) + out, _, err := dockerCmdWithError(c, "run", "-d", "--name", "test2", "-p", "9999:9999", "busybox", "top") if err == nil { c.Fatalf("Expected error but got none, output %q", out) } + stateErr, err = inspectField("test2", "State.Error") c.Assert(err, check.IsNil) expected := "port is already allocated" @@ -123,47 +98,31 @@ func (s *DockerSuite) TestStartRecordError(c *check.C) { if stateErr != "" { c.Fatalf("Expected to not have state error but got state.Error(%q)", stateErr) } - } func (s *DockerSuite) TestStartPausedContainer(c *check.C) { defer unpauseAllContainers() - runCmd := exec.Command(dockerBinary, "run", "-d", "--name", "testing", "busybox", "top") - if out, _, err := runCommandWithOutput(runCmd); err != nil { - c.Fatal(out, err) - } + dockerCmd(c, "run", "-d", "--name", "testing", "busybox", "top") - runCmd = exec.Command(dockerBinary, "pause", "testing") - if out, _, err := runCommandWithOutput(runCmd); err != nil { - c.Fatal(out, err) - } + dockerCmd(c, "pause", "testing") - runCmd = exec.Command(dockerBinary, "start", "testing") - if out, _, err := runCommandWithOutput(runCmd); err == nil || !strings.Contains(out, "Cannot start a paused container, try unpause instead.") { + if out, _, err := dockerCmdWithError(c, "start", "testing"); err == nil || !strings.Contains(out, "Cannot start a paused container, try unpause instead.") { c.Fatalf("an error should have been shown that you cannot start paused container: %s\n%v", out, err) } - } func (s *DockerSuite) TestStartMultipleContainers(c *check.C) { // run a container named 'parent' and create two container link to `parent` - cmd := exec.Command(dockerBinary, "run", "-d", "--name", "parent", "busybox", "top") - if out, _, err := runCommandWithOutput(cmd); err != nil { - c.Fatal(out, err) - } + dockerCmd(c, "run", "-d", "--name", "parent", "busybox", "top") + for _, container := range []string{"child_first", "child_second"} { - cmd = exec.Command(dockerBinary, "create", "--name", container, "--link", "parent:parent", "busybox", "top") - if out, _, err := runCommandWithOutput(cmd); err != nil { - c.Fatal(out, err) - } + dockerCmd(c, "create", "--name", container, "--link", "parent:parent", "busybox", "top") } // stop 'parent' container - cmd = exec.Command(dockerBinary, "stop", "parent") - if out, _, err := runCommandWithOutput(cmd); err != nil { - c.Fatal(out, err) - } + dockerCmd(c, "stop", "parent") + out, err := inspectField("parent", "State.Running") c.Assert(err, check.IsNil) if out != "false" { @@ -172,8 +131,7 @@ func (s *DockerSuite) TestStartMultipleContainers(c *check.C) { // start all the three containers, container `child_first` start first which should be failed // container 'parent' start second and then start container 'child_second' - cmd = exec.Command(dockerBinary, "start", "child_first", "parent", "child_second") - out, _, err = runCommandWithOutput(cmd) + out, _, err = dockerCmdWithError(c, "start", "child_first", "parent", "child_second") if !strings.Contains(out, "Cannot start container child_first") || err == nil { c.Fatal("Expected error but got none") } @@ -186,33 +144,22 @@ func (s *DockerSuite) TestStartMultipleContainers(c *check.C) { } } - } func (s *DockerSuite) TestStartAttachMultipleContainers(c *check.C) { - - var cmd *exec.Cmd - // run multiple containers to test for _, container := range []string{"test1", "test2", "test3"} { - cmd = exec.Command(dockerBinary, "run", "-d", "--name", container, "busybox", "top") - if out, _, err := runCommandWithOutput(cmd); err != nil { - c.Fatal(out, err) - } + dockerCmd(c, "run", "-d", "--name", container, "busybox", "top") } // stop all the containers for _, container := range []string{"test1", "test2", "test3"} { - cmd = exec.Command(dockerBinary, "stop", container) - if out, _, err := runCommandWithOutput(cmd); err != nil { - c.Fatal(out, err) - } + dockerCmd(c, "stop", container) } // test start and attach multiple containers at once, expected error for _, option := range []string{"-a", "-i", "-ai"} { - cmd = exec.Command(dockerBinary, "start", option, "test1", "test2", "test3") - out, _, err := runCommandWithOutput(cmd) + out, _, err := dockerCmdWithError(c, "start", option, "test1", "test2", "test3") if !strings.Contains(out, "You cannot start and attach multiple containers at once.") || err == nil { c.Fatal("Expected error but got none") } @@ -228,5 +175,4 @@ func (s *DockerSuite) TestStartAttachMultipleContainers(c *check.C) { c.Fatal("Container running state wrong") } } - }