"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "components/engine/integration-cli/docker_cli_start_test.go" between
docker-ce-19.03.2.tar.gz and docker-ce-19.03.3.tar.gz

About: Docker CE is a project to pack, ship and run any application as a lightweight container. Docker containers can run anywhere, on a laptop or at scale, in production, on VMs, bare metal, OpenStack clusters, public clouds and more. Community edition.

docker_cli_start_test.go  (docker-ce-19.03.2):docker_cli_start_test.go  (docker-ce-19.03.3)
package main package main
import ( import (
"fmt" "fmt"
"strings" "strings"
"testing"
"time" "time"
"github.com/docker/docker/integration-cli/checker"
"github.com/docker/docker/integration-cli/cli" "github.com/docker/docker/integration-cli/cli"
"github.com/go-check/check"
"gotest.tools/assert" "gotest.tools/assert"
"gotest.tools/icmd" "gotest.tools/icmd"
) )
// Regression test for https://github.com/docker/docker/issues/7843 // Regression test for https://github.com/docker/docker/issues/7843
func (s *DockerSuite) TestStartAttachReturnsOnError(c *check.C) { func (s *DockerSuite) TestStartAttachReturnsOnError(c *testing.T) {
// Windows does not support link // Windows does not support link
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
dockerCmd(c, "run", "--name", "test", "busybox") dockerCmd(c, "run", "--name", "test", "busybox")
// Expect this to fail because the above container is stopped, this is wh at we want // Expect this to fail because the above container is stopped, this is wh at we want
out, _, err := dockerCmdWithError("run", "--name", "test2", "--link", "te st:test", "busybox") out, _, err := dockerCmdWithError("run", "--name", "test2", "--link", "te st:test", "busybox")
// err shouldn't be nil because container test2 try to link to stopped co ntainer // err shouldn't be nil because container test2 try to link to stopped co ntainer
c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) assert.Assert(c, err != nil, "out: %s", out)
ch := make(chan error) ch := make(chan error)
go func() { go func() {
// Attempt to start attached to the container that won't start // Attempt to start attached to the container that won't start
// This should return an error immediately since the container ca n't be started // This should return an error immediately since the container ca n't be started
if out, _, err := dockerCmdWithError("start", "-a", "test2"); err == nil { if out, _, err := dockerCmdWithError("start", "-a", "test2"); err == nil {
ch <- fmt.Errorf("Expected error but got none:\n%s", out) ch <- fmt.Errorf("Expected error but got none:\n%s", out)
} }
close(ch) close(ch)
}() }()
select { select {
case err := <-ch: case err := <-ch:
assert.NilError(c, err) assert.NilError(c, err)
case <-time.After(5 * time.Second): case <-time.After(5 * time.Second):
c.Fatalf("Attach did not exit properly") c.Fatalf("Attach did not exit properly")
} }
} }
// gh#8555: Exit code should be passed through when using start -a // gh#8555: Exit code should be passed through when using start -a
func (s *DockerSuite) TestStartAttachCorrectExitCode(c *check.C) { func (s *DockerSuite) TestStartAttachCorrectExitCode(c *testing.T) {
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
out := cli.DockerCmd(c, "run", "-d", "busybox", "sh", "-c", "sleep 2; exi t 1").Stdout() out := cli.DockerCmd(c, "run", "-d", "busybox", "sh", "-c", "sleep 2; exi t 1").Stdout()
out = strings.TrimSpace(out) out = strings.TrimSpace(out)
// make sure the container has exited before trying the "start -a" // make sure the container has exited before trying the "start -a"
cli.DockerCmd(c, "wait", out) cli.DockerCmd(c, "wait", out)
cli.Docker(cli.Args("start", "-a", out)).Assert(c, icmd.Expected{ cli.Docker(cli.Args("start", "-a", out)).Assert(c, icmd.Expected{
ExitCode: 1, ExitCode: 1,
}) })
} }
func (s *DockerSuite) TestStartAttachSilent(c *check.C) { func (s *DockerSuite) TestStartAttachSilent(c *testing.T) {
name := "teststartattachcorrectexitcode" name := "teststartattachcorrectexitcode"
dockerCmd(c, "run", "--name", name, "busybox", "echo", "test") dockerCmd(c, "run", "--name", name, "busybox", "echo", "test")
// make sure the container has exited before trying the "start -a" // make sure the container has exited before trying the "start -a"
dockerCmd(c, "wait", name) dockerCmd(c, "wait", name)
startOut, _ := dockerCmd(c, "start", "-a", name) startOut, _ := dockerCmd(c, "start", "-a", name)
// start -a produced unexpected output // start -a produced unexpected output
c.Assert(startOut, checker.Equals, "test\n") assert.Equal(c, startOut, "test\n")
} }
func (s *DockerSuite) TestStartRecordError(c *check.C) { func (s *DockerSuite) TestStartRecordError(c *testing.T) {
// TODO Windows CI: Requires further porting work. Should be possible. // TODO Windows CI: Requires further porting work. Should be possible.
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
// when container runs successfully, we should not have state.Error // when container runs successfully, we should not have state.Error
dockerCmd(c, "run", "-d", "-p", "9999:9999", "--name", "test", "busybox", "top") dockerCmd(c, "run", "-d", "-p", "9999:9999", "--name", "test", "busybox", "top")
stateErr := inspectField(c, "test", "State.Error") stateErr := inspectField(c, "test", "State.Error")
// Expected to not have state error // Expected to not have state error
c.Assert(stateErr, checker.Equals, "") assert.Equal(c, stateErr, "")
// Expect this to fail and records error because of ports conflict // Expect this to fail and records error because of ports conflict
out, _, err := dockerCmdWithError("run", "-d", "--name", "test2", "-p", " 9999:9999", "busybox", "top") out, _, err := dockerCmdWithError("run", "-d", "--name", "test2", "-p", " 9999:9999", "busybox", "top")
// err shouldn't be nil because docker run will fail // err shouldn't be nil because docker run will fail
c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) assert.Assert(c, err != nil, "out: %s", out)
stateErr = inspectField(c, "test2", "State.Error") stateErr = inspectField(c, "test2", "State.Error")
c.Assert(stateErr, checker.Contains, "port is already allocated") assert.Assert(c, strings.Contains(stateErr, "port is already allocated"))
// Expect the conflict to be resolved when we stop the initial container // Expect the conflict to be resolved when we stop the initial container
dockerCmd(c, "stop", "test") dockerCmd(c, "stop", "test")
dockerCmd(c, "start", "test2") dockerCmd(c, "start", "test2")
stateErr = inspectField(c, "test2", "State.Error") stateErr = inspectField(c, "test2", "State.Error")
// Expected to not have state error but got one // Expected to not have state error but got one
c.Assert(stateErr, checker.Equals, "") assert.Equal(c, stateErr, "")
} }
func (s *DockerSuite) TestStartPausedContainer(c *check.C) { func (s *DockerSuite) TestStartPausedContainer(c *testing.T) {
// Windows does not support pausing containers // Windows does not support pausing containers
testRequires(c, IsPausable) testRequires(c, IsPausable)
runSleepingContainer(c, "-d", "--name", "testing") runSleepingContainer(c, "-d", "--name", "testing")
dockerCmd(c, "pause", "testing") dockerCmd(c, "pause", "testing")
out, _, err := dockerCmdWithError("start", "testing") out, _, err := dockerCmdWithError("start", "testing")
// an error should have been shown that you cannot start paused container // an error should have been shown that you cannot start paused container
c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) assert.Assert(c, err != nil, "out: %s", out)
// an error should have been shown that you cannot start paused container // an error should have been shown that you cannot start paused container
c.Assert(strings.ToLower(out), checker.Contains, "cannot start a paused c ontainer, try unpause instead") assert.Assert(c, strings.Contains(strings.ToLower(out), "cannot start a p aused container, try unpause instead"))
} }
func (s *DockerSuite) TestStartMultipleContainers(c *check.C) { func (s *DockerSuite) TestStartMultipleContainers(c *testing.T) {
// Windows does not support --link // Windows does not support --link
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
// run a container named 'parent' and create two container link to `paren t` // run a container named 'parent' and create two container link to `paren t`
dockerCmd(c, "run", "-d", "--name", "parent", "busybox", "top") dockerCmd(c, "run", "-d", "--name", "parent", "busybox", "top")
for _, container := range []string{"child_first", "child_second"} { for _, container := range []string{"child_first", "child_second"} {
dockerCmd(c, "create", "--name", container, "--link", "parent:par ent", "busybox", "top") dockerCmd(c, "create", "--name", container, "--link", "parent:par ent", "busybox", "top")
} }
// stop 'parent' container // stop 'parent' container
skipping to change at line 133 skipping to change at line 131
out := inspectField(c, "parent", "State.Running") out := inspectField(c, "parent", "State.Running")
// Container should be stopped // Container should be stopped
assert.Equal(c, out, "false") assert.Equal(c, out, "false")
// start all the three containers, container `child_first` start first wh ich should be failed // start all the three containers, container `child_first` start first wh ich should be failed
// container 'parent' start second and then start container 'child_second ' // container 'parent' start second and then start container 'child_second '
expOut := "Cannot link to a non running container" expOut := "Cannot link to a non running container"
expErr := "failed to start containers: [child_first]" expErr := "failed to start containers: [child_first]"
out, _, err := dockerCmdWithError("start", "child_first", "parent", "chil d_second") out, _, err := dockerCmdWithError("start", "child_first", "parent", "chil d_second")
// err shouldn't be nil because start will fail // err shouldn't be nil because start will fail
c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) assert.Assert(c, err != nil, "out: %s", out)
// output does not correspond to what was expected // output does not correspond to what was expected
if !(strings.Contains(out, expOut) || strings.Contains(err.Error(), expEr r)) { if !(strings.Contains(out, expOut) || strings.Contains(err.Error(), expEr r)) {
c.Fatalf("Expected out: %v with err: %v but got out: %v with err : %v", expOut, expErr, out, err) c.Fatalf("Expected out: %v with err: %v but got out: %v with err : %v", expOut, expErr, out, err)
} }
for container, expected := range map[string]string{"parent": "true", "chi ld_first": "false", "child_second": "true"} { for container, expected := range map[string]string{"parent": "true", "chi ld_first": "false", "child_second": "true"} {
out := inspectField(c, container, "State.Running") out := inspectField(c, container, "State.Running")
// Container running state wrong // Container running state wrong
assert.Equal(c, out, expected) assert.Equal(c, out, expected)
} }
} }
func (s *DockerSuite) TestStartAttachMultipleContainers(c *check.C) { func (s *DockerSuite) TestStartAttachMultipleContainers(c *testing.T) {
// run multiple containers to test // run multiple containers to test
for _, container := range []string{"test1", "test2", "test3"} { for _, container := range []string{"test1", "test2", "test3"} {
runSleepingContainer(c, "--name", container) runSleepingContainer(c, "--name", container)
} }
// stop all the containers // stop all the containers
for _, container := range []string{"test1", "test2", "test3"} { for _, container := range []string{"test1", "test2", "test3"} {
dockerCmd(c, "stop", container) dockerCmd(c, "stop", container)
} }
// test start and attach multiple containers at once, expected error // test start and attach multiple containers at once, expected error
for _, option := range []string{"-a", "-i", "-ai"} { for _, option := range []string{"-a", "-i", "-ai"} {
out, _, err := dockerCmdWithError("start", option, "test1", "test 2", "test3") out, _, err := dockerCmdWithError("start", option, "test1", "test 2", "test3")
// err shouldn't be nil because start will fail // err shouldn't be nil because start will fail
c.Assert(err, checker.NotNil, check.Commentf("out: %s", out)) assert.Assert(c, err != nil, "out: %s", out)
// output does not correspond to what was expected // output does not correspond to what was expected
c.Assert(out, checker.Contains, "you cannot start and attach mult iple containers at once") assert.Assert(c, strings.Contains(out, "you cannot start and atta ch multiple containers at once"))
} }
// confirm the state of all the containers be stopped // confirm the state of all the containers be stopped
for container, expected := range map[string]string{"test1": "false", "tes t2": "false", "test3": "false"} { for container, expected := range map[string]string{"test1": "false", "tes t2": "false", "test3": "false"} {
out := inspectField(c, container, "State.Running") out := inspectField(c, container, "State.Running")
// Container running state wrong // Container running state wrong
assert.Equal(c, out, expected) assert.Equal(c, out, expected)
} }
} }
// Test case for #23716 // Test case for #23716
func (s *DockerSuite) TestStartAttachWithRename(c *check.C) { func (s *DockerSuite) TestStartAttachWithRename(c *testing.T) {
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
cli.DockerCmd(c, "create", "-t", "--name", "before", "busybox") cli.DockerCmd(c, "create", "-t", "--name", "before", "busybox")
go func() { go func() {
cli.WaitRun(c, "before") cli.WaitRun(c, "before")
cli.DockerCmd(c, "rename", "before", "after") cli.DockerCmd(c, "rename", "before", "after")
cli.DockerCmd(c, "stop", "--time=2", "after") cli.DockerCmd(c, "stop", "--time=2", "after")
}() }()
// FIXME(vdemeester) the intent is not clear and potentially racey // FIXME(vdemeester) the intent is not clear and potentially racey
result := cli.Docker(cli.Args("start", "-a", "before")).Assert(c, icmd.Ex pected{ result := cli.Docker(cli.Args("start", "-a", "before")).Assert(c, icmd.Ex pected{
ExitCode: 137, ExitCode: 137,
}) })
c.Assert(result.Stderr(), checker.Not(checker.Contains), "No such contain er") assert.Assert(c, !strings.Contains(result.Stderr(), "No such container"))
} }
func (s *DockerSuite) TestStartReturnCorrectExitCode(c *check.C) { func (s *DockerSuite) TestStartReturnCorrectExitCode(c *testing.T) {
dockerCmd(c, "create", "--restart=on-failure:2", "--name", "withRestart", "busybox", "sh", "-c", "exit 11") dockerCmd(c, "create", "--restart=on-failure:2", "--name", "withRestart", "busybox", "sh", "-c", "exit 11")
dockerCmd(c, "create", "--rm", "--name", "withRm", "busybox", "sh", "-c", "exit 12") dockerCmd(c, "create", "--rm", "--name", "withRm", "busybox", "sh", "-c", "exit 12")
out, exitCode, err := dockerCmdWithError("start", "-a", "withRestart") out, exitCode, err := dockerCmdWithError("start", "-a", "withRestart")
assert.ErrorContains(c, err, "") assert.ErrorContains(c, err, "")
c.Assert(exitCode, checker.Equals, 11, check.Commentf("out: %s", out)) assert.Equal(c, exitCode, 11, fmt.Sprintf("out: %s", out))
out, exitCode, err = dockerCmdWithError("start", "-a", "withRm") out, exitCode, err = dockerCmdWithError("start", "-a", "withRm")
assert.ErrorContains(c, err, "") assert.ErrorContains(c, err, "")
c.Assert(exitCode, checker.Equals, 12, check.Commentf("out: %s", out)) assert.Equal(c, exitCode, 12, fmt.Sprintf("out: %s", out))
} }
 End of changes. 26 change blocks. 
26 lines changed or deleted 24 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)