Use dockerCmd when possible (#14603)

- integration-cli/docker_cli_attach_test.go
- integration-cli/docker_cli_attach_unix_test.go
- integration-cli/docker_cli_build_test.go
- integration-cli/docker_cli_build_unix_test.go
- integration-cli/docker_cli_by_digest_test.go
- integration-cli/docker_cli_commit_test.go
- integration-cli/docker_cli_config_test.go
- integration-cli/docker_cli_cp_test.go
- integration-cli/docker_cli_create_test.go
- integration-cli/docker_cli_pause_test.go
- integration-cli/docker_cli_port_test.go
- integration-cli/docker_cli_port_unix_test.go
- integration-cli/docker_cli_proxy_test.go
- integration-cli/docker_cli_ps_test.go
- integration-cli/docker_cli_pull_test.go
- integration-cli/docker_cli_push_test.go

- docker_api_attach_test.go
- docker_api_containers_test.go
- docker_api_events_test.go
- docker_api_exec_resize_test.go
- docker_api_exec_test.go
- docker_api_images_test.go
- docker_api_info_test.go

Signed-off-by: Vincent Demeester <vincent@sbr.pm>

integration-cli/docker_cli_commit_test.go

@@ -1,91 +1,51 @@
 package main
 
 import (
-	"os/exec"
 	"strings"
 
 	"github.com/go-check/check"
 )
 
 func (s *DockerSuite) TestCommitAfterContainerIsDone(c *check.C) {
-	runCmd := exec.Command(dockerBinary, "run", "-i", "-a", "stdin", "busybox", "echo", "foo")
-	out, _, _, err := runCommandWithStdoutStderr(runCmd)
-	if err != nil {
-		c.Fatalf("failed to run container: %s, %v", out, err)
-	}
+	out, _ := dockerCmd(c, "run", "-i", "-a", "stdin", "busybox", "echo", "foo")
 
 	cleanedContainerID := strings.TrimSpace(out)
 
-	waitCmd := exec.Command(dockerBinary, "wait", cleanedContainerID)
-	if _, _, err = runCommandWithOutput(waitCmd); err != nil {
-		c.Fatalf("error thrown while waiting for container: %s, %v", out, err)
-	}
+	dockerCmd(c, "wait", cleanedContainerID)
 
-	commitCmd := exec.Command(dockerBinary, "commit", cleanedContainerID)
-	out, _, err = runCommandWithOutput(commitCmd)
-	if err != nil {
-		c.Fatalf("failed to commit container to image: %s, %v", out, err)
-	}
+	out, _ = dockerCmd(c, "commit", cleanedContainerID)
 
 	cleanedImageID := strings.TrimSpace(out)
 
-	inspectCmd := exec.Command(dockerBinary, "inspect", cleanedImageID)
-	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {
-		c.Fatalf("failed to inspect image: %s, %v", out, err)
-	}
+	dockerCmd(c, "inspect", cleanedImageID)
 }
 
 func (s *DockerSuite) TestCommitWithoutPause(c *check.C) {
-	runCmd := exec.Command(dockerBinary, "run", "-i", "-a", "stdin", "busybox", "echo", "foo")
-	out, _, _, err := runCommandWithStdoutStderr(runCmd)
-	if err != nil {
-		c.Fatalf("failed to run container: %s, %v", out, err)
-	}
+	out, _ := dockerCmd(c, "run", "-i", "-a", "stdin", "busybox", "echo", "foo")
 
 	cleanedContainerID := strings.TrimSpace(out)
 
-	waitCmd := exec.Command(dockerBinary, "wait", cleanedContainerID)
-	if _, _, err = runCommandWithOutput(waitCmd); err != nil {
-		c.Fatalf("error thrown while waiting for container: %s, %v", out, err)
-	}
+	dockerCmd(c, "wait", cleanedContainerID)
 
-	commitCmd := exec.Command(dockerBinary, "commit", "-p=false", cleanedContainerID)
-	out, _, err = runCommandWithOutput(commitCmd)
-	if err != nil {
-		c.Fatalf("failed to commit container to image: %s, %v", out, err)
-	}
+	out, _ = dockerCmd(c, "commit", "-p=false", cleanedContainerID)
 
 	cleanedImageID := strings.TrimSpace(out)
 
-	inspectCmd := exec.Command(dockerBinary, "inspect", cleanedImageID)
-	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {
-		c.Fatalf("failed to inspect image: %s, %v", out, err)
-	}
+	dockerCmd(c, "inspect", cleanedImageID)
 }
 
 //test commit a paused container should not unpause it after commit
 func (s *DockerSuite) TestCommitPausedContainer(c *check.C) {
 	defer unpauseAllContainers()
-	cmd := exec.Command(dockerBinary, "run", "-i", "-d", "busybox")
-	out, _, _, err := runCommandWithStdoutStderr(cmd)
-	if err != nil {
-		c.Fatalf("failed to run container: %v, output: %q", err, out)
-	}
+	out, _ := dockerCmd(c, "run", "-i", "-d", "busybox")
 
 	cleanedContainerID := strings.TrimSpace(out)
-	cmd = exec.Command(dockerBinary, "pause", cleanedContainerID)
-	out, _, _, err = runCommandWithStdoutStderr(cmd)
-	if err != nil {
-		c.Fatalf("failed to pause container: %v, output: %q", err, out)
-	}
 
-	commitCmd := exec.Command(dockerBinary, "commit", cleanedContainerID)
-	out, _, err = runCommandWithOutput(commitCmd)
-	if err != nil {
-		c.Fatalf("failed to commit container to image: %s, %v", out, err)
-	}
+	dockerCmd(c, "pause", cleanedContainerID)
 
-	out, err = inspectField(cleanedContainerID, "State.Paused")
+	out, _ = dockerCmd(c, "commit", cleanedContainerID)
+
+	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")
@@ -94,24 +54,13 @@ func (s *DockerSuite) TestCommitPausedContainer(c *check.C) {
 
 func (s *DockerSuite) TestCommitNewFile(c *check.C) {
 
-	cmd := exec.Command(dockerBinary, "run", "--name", "commiter", "busybox", "/bin/sh", "-c", "echo koye > /foo")
-	if _, err := runCommand(cmd); err != nil {
-		c.Fatal(err)
-	}
+	dockerCmd(c, "run", "--name", "commiter", "busybox", "/bin/sh", "-c", "echo koye > /foo")
 
-	cmd = exec.Command(dockerBinary, "commit", "commiter")
-	imageID, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(err)
-	}
+	imageID, _ := dockerCmd(c, "commit", "commiter")
 	imageID = strings.Trim(imageID, "\r\n")
 
-	cmd = exec.Command(dockerBinary, "run", imageID, "cat", "/foo")
+	out, _ := dockerCmd(c, "run", imageID, "cat", "/foo")
 
-	out, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(err, out)
-	}
 	if actual := strings.Trim(out, "\r\n"); actual != "koye" {
 		c.Fatalf("expected output koye received %q", actual)
 	}
@@ -120,13 +69,9 @@ func (s *DockerSuite) TestCommitNewFile(c *check.C) {
 
 func (s *DockerSuite) TestCommitHardlink(c *check.C) {
 
-	cmd := exec.Command(dockerBinary, "run", "-t", "--name", "hardlinks", "busybox", "sh", "-c", "touch file1 && ln file1 file2 && ls -di file1 file2")
-	firstOuput, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(err)
-	}
+	firstOutput, _ := dockerCmd(c, "run", "-t", "--name", "hardlinks", "busybox", "sh", "-c", "touch file1 && ln file1 file2 && ls -di file1 file2")
 
-	chunks := strings.Split(strings.TrimSpace(firstOuput), " ")
+	chunks := strings.Split(strings.TrimSpace(firstOutput), " ")
 	inode := chunks[0]
 	found := false
 	for _, chunk := range chunks[1:] {
@@ -139,20 +84,12 @@ func (s *DockerSuite) TestCommitHardlink(c *check.C) {
 		c.Fatalf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:])
 	}
 
-	cmd = exec.Command(dockerBinary, "commit", "hardlinks", "hardlinks")
-	imageID, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(imageID, err)
-	}
+	imageID, _ := dockerCmd(c, "commit", "hardlinks", "hardlinks")
 	imageID = strings.Trim(imageID, "\r\n")
 
-	cmd = exec.Command(dockerBinary, "run", "-t", "hardlinks", "ls", "-di", "file1", "file2")
-	secondOuput, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(err)
-	}
+	secondOutput, _ := dockerCmd(c, "run", "-t", "hardlinks", "ls", "-di", "file1", "file2")
 
-	chunks = strings.Split(strings.TrimSpace(secondOuput), " ")
+	chunks = strings.Split(strings.TrimSpace(secondOutput), " ")
 	inode = chunks[0]
 	found = false
 	for _, chunk := range chunks[1:] {
@@ -169,56 +106,31 @@ func (s *DockerSuite) TestCommitHardlink(c *check.C) {
 
 func (s *DockerSuite) TestCommitTTY(c *check.C) {
 
-	cmd := exec.Command(dockerBinary, "run", "-t", "--name", "tty", "busybox", "/bin/ls")
-	if _, err := runCommand(cmd); err != nil {
-		c.Fatal(err)
-	}
+	dockerCmd(c, "run", "-t", "--name", "tty", "busybox", "/bin/ls")
 
-	cmd = exec.Command(dockerBinary, "commit", "tty", "ttytest")
-	imageID, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(err)
-	}
+	imageID, _ := dockerCmd(c, "commit", "tty", "ttytest")
 	imageID = strings.Trim(imageID, "\r\n")
 
-	cmd = exec.Command(dockerBinary, "run", "ttytest", "/bin/ls")
-	if _, err := runCommand(cmd); err != nil {
-		c.Fatal(err)
-	}
+	dockerCmd(c, "run", "ttytest", "/bin/ls")
 
 }
 
 func (s *DockerSuite) TestCommitWithHostBindMount(c *check.C) {
 
-	cmd := exec.Command(dockerBinary, "run", "--name", "bind-commit", "-v", "/dev/null:/winning", "busybox", "true")
-	if _, err := runCommand(cmd); err != nil {
-		c.Fatal(err)
-	}
-
-	cmd = exec.Command(dockerBinary, "commit", "bind-commit", "bindtest")
-	imageID, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(imageID, err)
-	}
+	dockerCmd(c, "run", "--name", "bind-commit", "-v", "/dev/null:/winning", "busybox", "true")
 
+	imageID, _ := dockerCmd(c, "commit", "bind-commit", "bindtest")
 	imageID = strings.Trim(imageID, "\r\n")
 
-	cmd = exec.Command(dockerBinary, "run", "bindtest", "true")
-
-	if _, err := runCommand(cmd); err != nil {
-		c.Fatal(err)
-	}
+	dockerCmd(c, "run", "bindtest", "true")
 
 }
 
 func (s *DockerSuite) TestCommitChange(c *check.C) {
 
-	cmd := exec.Command(dockerBinary, "run", "--name", "test", "busybox", "true")
-	if _, err := runCommand(cmd); err != nil {
-		c.Fatal(err)
-	}
+	dockerCmd(c, "run", "--name", "test", "busybox", "true")
 
-	cmd = exec.Command(dockerBinary, "commit",
+	imageID, _ := dockerCmd(c, "commit",
 		"--change", "EXPOSE 8080",
 		"--change", "ENV DEBUG true",
 		"--change", "ENV test 1",
@@ -231,11 +143,7 @@ func (s *DockerSuite) TestCommitChange(c *check.C) {
 		"--change", "VOLUME /var/lib/docker",
 		"--change", "ONBUILD /usr/local/bin/python-build --dir /app/src",
 		"test", "test-commit")
-	imageId, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatal(imageId, err)
-	}
-	imageId = strings.Trim(imageId, "\r\n")
+	imageID = strings.Trim(imageID, "\r\n")
 
 	expected := map[string]string{
 		"Config.ExposedPorts": "map[8080/tcp:{}]",
@@ -250,7 +158,7 @@ func (s *DockerSuite) TestCommitChange(c *check.C) {
 	}
 
 	for conf, value := range expected {
-		res, err := inspectField(imageId, conf)
+		res, err := inspectField(imageID, conf)
 		c.Assert(err, check.IsNil)
 		if res != value {
 			c.Errorf("%s('%s'), expected %s", conf, res, value)