kotovalexarian-likes-github
/
moby--moby
mirror of https://github.com/moby/moby.git
1
0
Fork 0
Code Releases Activity

Removed unnecessary error output from dockerCmd 

Changed method declaration. Fixed all calls to dockerCmd
method to reflect the change.

resolves #12355

Signed-off-by: bobby abbott <ttobbaybbob@gmail.com>
This commit is contained in:
bobby abbott 2015-04-13 22:16:19 -07:00
parent 24af878358
commit 621b601b3c
16 changed files with 127 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
integration-cli/docker_api_containers_test.go
View File

@ -627,7 +627,7 @@ func TestContainerApiPause(t *testing.T) {
func TestContainerApiTop(t *testing.T) {
defer deleteAllContainers()
out, _, _ := dockerCmd(t, "run", "-d", "-i", "busybox", "/bin/sh", "-c", "cat")
out, _ := dockerCmd(t, "run", "-d", "-i", "busybox", "/bin/sh", "-c", "cat")
id := strings.TrimSpace(out)
if err := waitRun(id); err != nil {
t.Fatal(err)
@ -667,7 +667,7 @@ func TestContainerApiTop(t *testing.T) {
}
func TestContainerApiCommit(t *testing.T) {
out, _, _ := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "touch /test")
out, _ := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "touch /test")
id := strings.TrimSpace(out)
name := "testcommit"
@ -714,7 +714,7 @@ func TestContainerApiCreate(t *testing.T) {
t.Fatal(err)
}
out, _, _ := dockerCmd(t, "start", "-a", container.Id)
out, _ := dockerCmd(t, "start", "-a", container.Id)
if strings.TrimSpace(out) != "/test" {
t.Fatalf("expected output `/test`, got %q", out)
}

2
integration-cli/docker_api_images_test.go
View File

@ -91,7 +91,7 @@ func TestApiImagesSaveAndLoad(t *testing.T) {
}
defer loadBody.Close()
out, _, _ = dockerCmd(t, "inspect", "--format='{{ .Id }}'", id)
out, _ = dockerCmd(t, "inspect", "--format='{{ .Id }}'", id)
if strings.TrimSpace(out) != id {
t.Fatal("load did not work properly")
}

2
integration-cli/docker_cli_attach_test.go
View File

@ -138,7 +138,7 @@ func TestAttachTtyWithoutStdin(t *testing.T) {
func TestAttachDisconnect(t *testing.T) {
defer deleteAllContainers()
out, _, _ := dockerCmd(t, "run", "-di", "busybox", "/bin/cat")
out, _ := dockerCmd(t, "run", "-di", "busybox", "/bin/cat")
id := strings.TrimSpace(out)
cmd := exec.Command(dockerBinary, "attach", id)

4
integration-cli/docker_cli_attach_unix_test.go
View File

@ -142,7 +142,7 @@ func TestAttachAfterDetach(t *testing.T) {
// TestAttachDetach checks that attach in tty mode can be detached using the long container ID
func TestAttachDetach(t *testing.T) {
out, _, _ := dockerCmd(t, "run", "-itd", "busybox", "cat")
out, _ := dockerCmd(t, "run", "-itd", "busybox", "cat")
id := strings.TrimSpace(out)
if err := waitRun(id); err != nil {
t.Fatal(err)
@ -217,7 +217,7 @@ func TestAttachDetach(t *testing.T) {
// TestAttachDetachTruncatedID checks that attach in tty mode can be detached
func TestAttachDetachTruncatedID(t *testing.T) {
out, _, _ := dockerCmd(t, "run", "-itd", "busybox", "cat")
out, _ := dockerCmd(t, "run", "-itd", "busybox", "cat")
id := stringid.TruncateID(strings.TrimSpace(out))
if err := waitRun(id); err != nil {
t.Fatal(err)

13
integration-cli/docker_cli_build_test.go
View File

@ -3294,7 +3294,7 @@ func TestBuildNoContext(t *testing.T) {
t.Fatalf("build failed to complete: %v %v", out, err)
}
if out, _, err := dockerCmd(t, "run", "--rm", "nocontext"); out != "ok\n" || err != nil {
if out, _ := dockerCmd(t, "run", "--rm", "nocontext"); out != "ok\n" {
t.Fatalf("run produced invalid output: %q, expected %q", out, "ok")
}
@ -5562,10 +5562,7 @@ func TestBuildResourceConstraintsAreUsed(t *testing.T) {
if err != nil {
t.Fatal(err, out)
}
out, _, err = dockerCmd(t, "ps", "-lq")
if err != nil {
t.Fatal(err, out)
}
out, _ = dockerCmd(t, "ps", "-lq")
cID := strings.TrimSpace(out)
@ -5593,10 +5590,8 @@ func TestBuildResourceConstraintsAreUsed(t *testing.T) {
}
// Make sure constraints aren't saved to image
_, _, err = dockerCmd(t, "run", "--name=test", name)
if err != nil {
t.Fatal(err)
}
_, _ = dockerCmd(t, "run", "--name=test", name)
cfg, err = inspectFieldJSON("test", "HostConfig")
if err != nil {
t.Fatal(err)

4
integration-cli/docker_cli_commit_test.go
View File

@ -284,13 +284,13 @@ func TestCommitChange(t *testing.T) {
func TestCommitMergeConfigRun(t *testing.T) {
defer deleteAllContainers()
name := "commit-test"
out, _, _ := dockerCmd(t, "run", "-d", "-e=FOO=bar", "busybox", "/bin/sh", "-c", "echo testing > /tmp/foo")
out, _ := dockerCmd(t, "run", "-d", "-e=FOO=bar", "busybox", "/bin/sh", "-c", "echo testing > /tmp/foo")
id := strings.TrimSpace(out)
dockerCmd(t, "commit", `--run={"Cmd": ["cat", "/tmp/foo"]}`, id, "commit-test")
defer deleteImages("commit-test")
out, _, _ = dockerCmd(t, "run", "--name", name, "commit-test")
out, _ = dockerCmd(t, "run", "--name", name, "commit-test")
if strings.TrimSpace(out) != "testing" {
t.Fatal("run config in commited container was not merged")
}

206
integration-cli/docker_cli_cp_test.go
View File

@ -25,17 +25,17 @@ const (
// Test for #5656
// Check that garbage paths don't escape the container's rootfs
func TestCpGarbagePath(t *testing.T) {
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath)
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath)
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil {
@ -61,10 +61,7 @@ func TestCpGarbagePath(t *testing.T) {
path := path.Join("../../../../../../../../../../../../", cpFullPath)
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
if err != nil {
t.Fatalf("couldn't copy from garbage path: %s:%s %s", cleanedContainerID, path, err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
file, _ := os.Open(tmpname)
defer file.Close()
@ -87,17 +84,17 @@ func TestCpGarbagePath(t *testing.T) {
// Check that relative paths are relative to the container's rootfs
func TestCpRelativePath(t *testing.T) {
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath)
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath)
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil {
@ -131,10 +128,7 @@ func TestCpRelativePath(t *testing.T) {
t.Fatalf("path %s was assumed to be an absolute path", cpFullPath)
}
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":"+relPath, tmpdir)
if err != nil {
t.Fatalf("couldn't copy from relative path: %s:%s %s", cleanedContainerID, relPath, err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":"+relPath, tmpdir)
file, _ := os.Open(tmpname)
defer file.Close()
@ -157,17 +151,17 @@ func TestCpRelativePath(t *testing.T) {
// Check that absolute paths are relative to the container's rootfs
func TestCpAbsolutePath(t *testing.T) {
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath)
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath)
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil {
@ -194,10 +188,7 @@ func TestCpAbsolutePath(t *testing.T) {
path := cpFullPath
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
if err != nil {
t.Fatalf("couldn't copy from absolute path: %s:%s %s", cleanedContainerID, path, err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
file, _ := os.Open(tmpname)
defer file.Close()
@ -221,17 +212,17 @@ func TestCpAbsolutePath(t *testing.T) {
// Test for #5619
// Check that absolute symlinks are still relative to the container's rootfs
func TestCpAbsoluteSymlink(t *testing.T) {
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpFullPath+" container_path")
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpFullPath+" container_path")
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil {
@ -258,10 +249,7 @@ func TestCpAbsoluteSymlink(t *testing.T) {
path := path.Join("/", "container_path")
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
if err != nil {
t.Fatalf("couldn't copy from absolute path: %s:%s %s", cleanedContainerID, path, err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
file, _ := os.Open(tmpname)
defer file.Close()
@ -285,17 +273,17 @@ func TestCpAbsoluteSymlink(t *testing.T) {
// Test for #5619
// Check that symlinks which are part of the resource path are still relative to the container's rootfs
func TestCpSymlinkComponent(t *testing.T) {
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpTestPath+" container_path")
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir -p '"+cpTestPath+"' && echo -n '"+cpContainerContents+"' > "+cpFullPath+" && ln -s "+cpTestPath+" container_path")
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
if err := os.MkdirAll(cpTestPath, os.ModeDir); err != nil {
@ -322,10 +310,7 @@ func TestCpSymlinkComponent(t *testing.T) {
path := path.Join("/", "container_path", cpTestName)
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
if err != nil {
t.Fatalf("couldn't copy from symlink path component: %s:%s %s", cleanedContainerID, path, err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":"+path, tmpdir)
file, _ := os.Open(tmpname)
defer file.Close()
@ -350,17 +335,17 @@ func TestCpSymlinkComponent(t *testing.T) {
func TestCpUnprivilegedUser(t *testing.T) {
testRequires(t, UnixCli) // uses chmod/su: not available on windows
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "touch "+cpTestName)
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "touch "+cpTestName)
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
tmpdir, err := ioutil.TempDir("", "docker-integration")
@ -393,24 +378,21 @@ func TestCpSpecialFiles(t *testing.T) {
}
defer os.RemoveAll(outDir)
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "touch /foo")
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "touch /foo")
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
// Copy actual /etc/resolv.conf
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/etc/resolv.conf", outDir)
if err != nil {
t.Fatalf("couldn't copy from container: %s:%s %v", cleanedContainerID, "/etc/resolv.conf", err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/etc/resolv.conf", outDir)
expected, err := ioutil.ReadFile("/var/lib/docker/containers/" + cleanedContainerID + "/resolv.conf")
actual, err := ioutil.ReadFile(outDir + "/resolv.conf")
@ -420,10 +402,7 @@ func TestCpSpecialFiles(t *testing.T) {
}
// Copy actual /etc/hosts
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/etc/hosts", outDir)
if err != nil {
t.Fatalf("couldn't copy from container: %s:%s %v", cleanedContainerID, "/etc/hosts", err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/etc/hosts", outDir)
expected, err = ioutil.ReadFile("/var/lib/docker/containers/" + cleanedContainerID + "/hosts")
actual, err = ioutil.ReadFile(outDir + "/hosts")
@ -433,10 +412,7 @@ func TestCpSpecialFiles(t *testing.T) {
}
// Copy actual /etc/resolv.conf
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/etc/hostname", outDir)
if err != nil {
t.Fatalf("couldn't copy from container: %s:%s %v", cleanedContainerID, "/etc/hostname", err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/etc/hostname", outDir)
expected, err = ioutil.ReadFile("/var/lib/docker/containers/" + cleanedContainerID + "/hostname")
actual, err = ioutil.ReadFile(outDir + "/hostname")
@ -466,24 +442,22 @@ func TestCpVolumePath(t *testing.T) {
t.Fatal(err)
}
out, exitCode, err := dockerCmd(t, "run", "-d", "-v", "/foo", "-v", tmpDir+"/test:/test", "-v", tmpDir+":/baz", "busybox", "/bin/sh", "-c", "touch /foo/bar")
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "-v", "/foo", "-v", tmpDir+"/test:/test", "-v", tmpDir+":/baz", "busybox", "/bin/sh", "-c", "touch /foo/bar")
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer dockerCmd(t, "rm", "-fv", cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
// Copy actual volume path
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/foo", outDir)
if err != nil {
t.Fatalf("couldn't copy from volume path: %s:%s %v", cleanedContainerID, "/foo", err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/foo", outDir)
stat, err := os.Stat(outDir + "/foo")
if err != nil {
t.Fatal(err)
@ -500,10 +474,8 @@ func TestCpVolumePath(t *testing.T) {
}
// Copy file nested in volume
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/foo/bar", outDir)
if err != nil {
t.Fatalf("couldn't copy from volume path: %s:%s %v", cleanedContainerID, "/foo", err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/foo/bar", outDir)
stat, err = os.Stat(outDir + "/bar")
if err != nil {
t.Fatal(err)
@ -513,10 +485,7 @@ func TestCpVolumePath(t *testing.T) {
}
// Copy Bind-mounted dir
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/baz", outDir)
if err != nil {
t.Fatalf("couldn't copy from bind-mounted volume path: %s:%s %v", cleanedContainerID, "/baz", err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/baz", outDir)
stat, err = os.Stat(outDir + "/baz")
if err != nil {
t.Fatal(err)
@ -526,7 +495,7 @@ func TestCpVolumePath(t *testing.T) {
}
// Copy file nested in bind-mounted dir
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/baz/test", outDir)
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/baz/test", outDir)
fb, err := ioutil.ReadFile(outDir + "/baz/test")
if err != nil {
t.Fatal(err)
@ -540,7 +509,7 @@ func TestCpVolumePath(t *testing.T) {
}
// Copy bind-mounted file
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/test", outDir)
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/test", outDir)
fb, err = ioutil.ReadFile(outDir + "/test")
if err != nil {
t.Fatal(err)
@ -557,17 +526,17 @@ func TestCpVolumePath(t *testing.T) {
}
func TestCpToDot(t *testing.T) {
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test")
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test")
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
tmpdir, err := ioutil.TempDir("", "docker-integration")
@ -583,10 +552,7 @@ func TestCpToDot(t *testing.T) {
if err := os.Chdir(tmpdir); err != nil {
t.Fatal(err)
}
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/test", ".")
if err != nil {
t.Fatalf("couldn't docker cp to \".\" path: %s", err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/test", ".")
content, err := ioutil.ReadFile("./test")
if string(content) != "lololol\n" {
t.Fatalf("Wrong content in copied file %q, should be %q", content, "lololol\n")
@ -595,22 +561,23 @@ func TestCpToDot(t *testing.T) {
}
func TestCpToStdout(t *testing.T) {
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test")
if err != nil || exitCode != 0 {
t.Fatalf("failed to create a container:%s\n%s", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test")
if exitCode != 0 {
t.Fatalf("failed to create a container:%s\n", out)
}
cID := strings.TrimSpace(out)
defer deleteContainer(cID)
out, _, err = dockerCmd(t, "wait", cID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatalf("failed to set up container:%s\n%s", out, err)
out, _ = dockerCmd(t, "wait", cID)
if strings.TrimSpace(out) != "0" {
t.Fatalf("failed to set up container:%s\n", out)
}
out, _, err = runCommandPipelineWithOutput(
out, _, err := runCommandPipelineWithOutput(
exec.Command(dockerBinary, "cp", cID+":/test", "-"),
exec.Command("tar", "-vtf", "-"))
if err != nil {
t.Fatalf("Failed to run commands: %s", err)
}
@ -624,17 +591,17 @@ func TestCpToStdout(t *testing.T) {
func TestCpNameHasColon(t *testing.T) {
testRequires(t, SameHostDaemon)
out, exitCode, err := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /te:s:t")
if err != nil || exitCode != 0 {
t.Fatal("failed to create a container", out, err)
out, exitCode := dockerCmd(t, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /te:s:t")
if exitCode != 0 {
t.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
defer deleteContainer(cleanedContainerID)
out, _, err = dockerCmd(t, "wait", cleanedContainerID)
if err != nil || strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out, err)
out, _ = dockerCmd(t, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
t.Fatal("failed to set up container", out)
}
tmpdir, err := ioutil.TempDir("", "docker-integration")
@ -642,10 +609,7 @@ func TestCpNameHasColon(t *testing.T) {
t.Fatal(err)
}
defer os.RemoveAll(tmpdir)
_, _, err = dockerCmd(t, "cp", cleanedContainerID+":/te:s:t", tmpdir)
if err != nil {
t.Fatalf("couldn't docker cp to %s: %s", tmpdir, err)
}
_, _ = dockerCmd(t, "cp", cleanedContainerID+":/te:s:t", tmpdir)
content, err := ioutil.ReadFile(tmpdir + "/te:s:t")
if string(content) != "lololol\n" {
t.Fatalf("Wrong content in copied file %q, should be %q", content, "lololol\n")

2
integration-cli/docker_cli_create_test.go
View File

@ -307,7 +307,7 @@ func TestCreateLabelFromImage(t *testing.T) {
}
func TestCreateHostnameWithNumber(t *testing.T) {
out, _, _ := dockerCmd(t, "run", "-h", "web.0", "busybox", "hostname")
out, _ := dockerCmd(t, "run", "-h", "web.0", "busybox", "hostname")
if strings.TrimSpace(out) != "web.0" {
t.Fatalf("hostname not set, expected `web.0`, got: %s", out)
}

2
integration-cli/docker_cli_events_test.go
View File

@ -38,7 +38,7 @@ func TestEventsUntag(t *testing.T) {
func TestEventsContainerFailStartDie(t *testing.T) {
defer deleteAllContainers()
out, _, _ := dockerCmd(t, "images", "-q")
out, _ := dockerCmd(t, "images", "-q")
image := strings.Split(out, "\n")[0]
eventsCmd := exec.Command(dockerBinary, "run", "--name", "testeventdie", image, "blerg")
_, _, err := runCommandWithOutput(eventsCmd)

4
integration-cli/docker_cli_exec_test.go
View File

@ -500,12 +500,12 @@ func TestLinksPingLinkedContainersOnRename(t *testing.T) {
defer deleteAllContainers()
var out string
out, _, _ = dockerCmd(t, "run", "-d", "--name", "container1", "busybox", "top")
out, _ = dockerCmd(t, "run", "-d", "--name", "container1", "busybox", "top")
idA := strings.TrimSpace(out)
if idA == "" {
t.Fatal(out, "id should not be nil")
}
out, _, _ = dockerCmd(t, "run", "-d", "--link", "container1:alias1", "--name", "container2", "busybox", "top")
out, _ = dockerCmd(t, "run", "-d", "--link", "container1:alias1", "--name", "container2", "busybox", "top")
idB := strings.TrimSpace(out)
if idB == "" {
t.Fatal(out, "id should not be nil")

4
integration-cli/docker_cli_links_test.go
View File

@ -110,9 +110,9 @@ func TestLinksPingLinkedContainers(t *testing.T) {
func TestLinksPingLinkedContainersAfterRename(t *testing.T) {
defer deleteAllContainers()
out, _, _ := dockerCmd(t, "run", "-d", "--name", "container1", "busybox", "top")
out, _ := dockerCmd(t, "run", "-d", "--name", "container1", "busybox", "top")
idA := strings.TrimSpace(out)
out, _, _ = dockerCmd(t, "run", "-d", "--name", "container2", "busybox", "top")
out, _ = dockerCmd(t, "run", "-d", "--name", "container2", "busybox", "top")
idB := strings.TrimSpace(out)
dockerCmd(t, "rename", "container1", "container_new")
dockerCmd(t, "run", "--rm", "--link", "container_new:alias1", "--link", "container2:alias2", "busybox", "sh", "-c", "ping -c 1 alias1 -W 1 && ping -c 1 alias2 -W 1")

4
integration-cli/docker_cli_pause_test.go
View File

@ -12,7 +12,7 @@ func TestPause(t *testing.T) {
defer unpauseAllContainers()
name := "testeventpause"
out, _, _ := dockerCmd(t, "images", "-q")
out, _ := dockerCmd(t, "images", "-q")
image := strings.Split(out, "\n")[0]
dockerCmd(t, "run", "-d", "--name", name, image, "top")
@ -55,7 +55,7 @@ func TestPauseMultipleContainers(t *testing.T) {
"testpausewithmorecontainers1",
"testpausewithmorecontainers2",
}
out, _, _ := dockerCmd(t, "images", "-q")
out, _ := dockerCmd(t, "images", "-q")
image := strings.Split(out, "\n")[0]
for _, name := range containers {
dockerCmd(t, "run", "-d", "--name", name, image, "top")

20
integration-cli/docker_cli_rmi_test.go
View File

@ -29,7 +29,7 @@ func TestRmiWithContainerFails(t *testing.T) {
}
// make sure it didn't delete the busybox name
images, _, _ := dockerCmd(t, "images")
images, _ := dockerCmd(t, "images")
if !strings.Contains(images, "busybox") {
t.Fatalf("The name 'busybox' should not have been removed from images: %q", images)
}
@ -40,19 +40,19 @@ func TestRmiWithContainerFails(t *testing.T) {
}
func TestRmiTag(t *testing.T) {
imagesBefore, _, _ := dockerCmd(t, "images", "-a")
imagesBefore, _ := dockerCmd(t, "images", "-a")
dockerCmd(t, "tag", "busybox", "utest:tag1")
dockerCmd(t, "tag", "busybox", "utest/docker:tag2")
dockerCmd(t, "tag", "busybox", "utest:5000/docker:tag3")
{
imagesAfter, _, _ := dockerCmd(t, "images", "-a")
imagesAfter, _ := dockerCmd(t, "images", "-a")
if strings.Count(imagesAfter, "\n") != strings.Count(imagesBefore, "\n")+3 {
t.Fatalf("before: %q\n\nafter: %q\n", imagesBefore, imagesAfter)
}
}
dockerCmd(t, "rmi", "utest/docker:tag2")
{
imagesAfter, _, _ := dockerCmd(t, "images", "-a")
imagesAfter, _ := dockerCmd(t, "images", "-a")
if strings.Count(imagesAfter, "\n") != strings.Count(imagesBefore, "\n")+2 {
t.Fatalf("before: %q\n\nafter: %q\n", imagesBefore, imagesAfter)
}
@ -60,7 +60,7 @@ func TestRmiTag(t *testing.T) {
}
dockerCmd(t, "rmi", "utest:5000/docker:tag3")
{
imagesAfter, _, _ := dockerCmd(t, "images", "-a")
imagesAfter, _ := dockerCmd(t, "images", "-a")
if strings.Count(imagesAfter, "\n") != strings.Count(imagesBefore, "\n")+1 {
t.Fatalf("before: %q\n\nafter: %q\n", imagesBefore, imagesAfter)
}
@ -68,7 +68,7 @@ func TestRmiTag(t *testing.T) {
}
dockerCmd(t, "rmi", "utest:tag1")
{
imagesAfter, _, _ := dockerCmd(t, "images", "-a")
imagesAfter, _ := dockerCmd(t, "images", "-a")
if strings.Count(imagesAfter, "\n") != strings.Count(imagesBefore, "\n")+0 {
t.Fatalf("before: %q\n\nafter: %q\n", imagesBefore, imagesAfter)
}
@ -90,22 +90,22 @@ func TestRmiImgIDForce(t *testing.T) {
t.Fatalf("failed to commit a new busybox-test:%s, %v", out, err)
}
imagesBefore, _, _ := dockerCmd(t, "images", "-a")
imagesBefore, _ := dockerCmd(t, "images", "-a")
dockerCmd(t, "tag", "busybox-test", "utest:tag1")
dockerCmd(t, "tag", "busybox-test", "utest:tag2")
dockerCmd(t, "tag", "busybox-test", "utest/docker:tag3")
dockerCmd(t, "tag", "busybox-test", "utest:5000/docker:tag4")
{
imagesAfter, _, _ := dockerCmd(t, "images", "-a")
imagesAfter, _ := dockerCmd(t, "images", "-a")
if strings.Count(imagesAfter, "\n") != strings.Count(imagesBefore, "\n")+4 {
t.Fatalf("tag busybox to create 4 more images with same imageID; docker images shows: %q\n", imagesAfter)
}
}
out, _, _ = dockerCmd(t, "inspect", "-f", "{{.Id}}", "busybox-test")
out, _ = dockerCmd(t, "inspect", "-f", "{{.Id}}", "busybox-test")
imgID := strings.TrimSpace(out)
dockerCmd(t, "rmi", "-f", imgID)
{
imagesAfter, _, _ := dockerCmd(t, "images", "-a")
imagesAfter, _ := dockerCmd(t, "images", "-a")
if strings.Contains(imagesAfter, imgID[:12]) {
t.Fatalf("rmi -f %s failed, image still exists: %q\n\n", imgID, imagesAfter)
}

18
integration-cli/docker_cli_run_test.go
View File

@ -501,9 +501,7 @@ func TestRunCreateVolumesInSymlinkDir(t *testing.T) {
}
defer deleteImages(name)
if out, _, err := dockerCmd(t, "run", "-v", "/test/test", name); err != nil {
t.Fatal(err, out)
}
dockerCmd(t, "run", "-v", "/test/test", name)
logDone("run - create volume in symlink directory")
}
@ -1058,9 +1056,9 @@ func TestRunLoopbackWhenNetworkDisabled(t *testing.T) {
func TestRunNetHostNotAllowedWithLinks(t *testing.T) {
defer deleteAllContainers()
_, _, err := dockerCmd(t, "run", "--name", "linked", "busybox", "true")
_, _ = dockerCmd(t, "run", "--name", "linked", "busybox", "true")
cmd := exec.Command(dockerBinary, "run", "--net=host", "--link", "linked:linked", "busybox", "true")
_, _, err = runCommandWithOutput(cmd)
_, _, err := runCommandWithOutput(cmd)
if err == nil {
t.Fatal("Expected error")
}
@ -1493,10 +1491,7 @@ func TestRunModeHostname(t *testing.T) {
func TestRunRootWorkdir(t *testing.T) {
defer deleteAllContainers()
s, _, err := dockerCmd(t, "run", "--workdir", "/", "busybox", "pwd")
if err != nil {
t.Fatal(s, err)
}
s, _ := dockerCmd(t, "run", "--workdir", "/", "busybox", "pwd")
if s != "/\n" {
t.Fatalf("pwd returned %q (expected /\\n)", s)
}
@ -1507,10 +1502,7 @@ func TestRunRootWorkdir(t *testing.T) {
func TestRunAllowBindMountingRoot(t *testing.T) {
defer deleteAllContainers()
s, _, err := dockerCmd(t, "run", "-v", "/:/host", "busybox", "ls", "/host")
if err != nil {
t.Fatal(s, err)
}
_, _ = dockerCmd(t, "run", "-v", "/:/host", "busybox", "ls", "/host")
logDone("run - bind mount / as volume")
}

2
integration-cli/docker_cli_start_test.go
View File

@ -157,7 +157,7 @@ func TestStartVolumesFromFailsCleanly(t *testing.T) {
dockerCmd(t, "start", "consumer")
// Check that we have the volumes we want
out, _, _ := dockerCmd(t, "inspect", "--format='{{ len .Volumes }}'", "consumer")
out, _ := dockerCmd(t, "inspect", "--format='{{ len .Volumes }}'", "consumer")
nVolumes := strings.Trim(out, " \r\n'")
if nVolumes != "2" {
t.Fatalf("Missing volumes: expected 2, got %s", nVolumes)

10
integration-cli/docker_utils.go
View File

@ -478,12 +478,12 @@ func pullImageIfNotExist(image string) (err error) {
return
}
func dockerCmd(t *testing.T, args ...string) (string, int, error) {
func dockerCmd(t *testing.T, args ...string) (string, int) {
out, status, err := runCommandWithOutput(exec.Command(dockerBinary, args...))
if err != nil {
t.Fatalf("%q failed with errors: %s, %v", strings.Join(args, " "), out, err)
}
return out, status, err
return out, status
}
// execute a docker command with a timeout
@ -784,9 +784,9 @@ func getContainerState(t *testing.T, id string) (int, bool, error) {
exitStatus int
running bool
)
out, exitCode, err := dockerCmd(t, "inspect", "--format={{.State.Running}} {{.State.ExitCode}}", id)
if err != nil || exitCode != 0 {
return 0, false, fmt.Errorf("%q doesn't exist: %s", id, err)
out, exitCode := dockerCmd(t, "inspect", "--format={{.State.Running}} {{.State.ExitCode}}", id)
if exitCode != 0 {
return 0, false, fmt.Errorf("%q doesn't exist: %s", id, out)
}
out = strings.Trim(out, "\n")