tyler.durden
/
compose
mirror of https://github.com/docker/compose.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Better renaming 

Signed-off-by: Guillaume Tardif <guillaume.tardif@docker.com>
This commit is contained in:
Guillaume Tardif 2020-08-24 10:23:14 +02:00
parent 2bac8cf94e
commit 981665b02c
5 changed files with 133 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
local/e2e/backend_test.go
View File

@ -43,33 +43,33 @@ func TestMain(m *testing.M) {
func TestLocalBackend(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
c.RunDocker("context", "create", "local", "test-context").Assert(t, icmd.Success)
c.RunDocker("context", "use", "test-context").Assert(t, icmd.Success)
c.RunDockerCmd("context", "create", "local", "test-context").Assert(t, icmd.Success)
c.RunDockerCmd("context", "use", "test-context").Assert(t, icmd.Success)
t.Run("run", func(t *testing.T) {
res := c.RunDocker("run", "-d", "nginx")
res := c.RunDockerCmd("run", "-d", "nginx")
containerName := strings.TrimSpace(res.Combined())
t.Cleanup(func() {
_ = c.RunDockerOrFail("rm", "-f", containerName)
_ = c.RunDockerOrExitError("rm", "-f", containerName)
})
res = c.RunDocker("inspect", containerName)
res = c.RunDockerCmd("inspect", containerName)
res.Assert(t, icmd.Expected{Out: `"Status": "running"`})
})
t.Run("run with ports", func(t *testing.T) {
res := c.RunDocker("run", "-d", "-p", "8080:80", "nginx")
res := c.RunDockerCmd("run", "-d", "-p", "8080:80", "nginx")
containerName := strings.TrimSpace(res.Combined())
t.Cleanup(func() {
_ = c.RunDockerOrFail("rm", "-f", containerName)
_ = c.RunDockerOrExitError("rm", "-f", containerName)
})
res = c.RunDocker("inspect", containerName)
res = c.RunDockerCmd("inspect", containerName)
res.Assert(t, icmd.Expected{Out: `"Status": "running"`})
res = c.RunDocker("ps")
res = c.RunDockerCmd("ps")
res.Assert(t, icmd.Expected{Out: "0.0.0.0:8080->80/tcp"})
})
t.Run("inspect not found", func(t *testing.T) {
res := c.RunDockerOrFail("inspect", "nonexistentcontainer")
res := c.RunDockerOrExitError("inspect", "nonexistentcontainer")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "Error: No such container: nonexistentcontainer",

86
tests/aci-e2e/e2e-aci_test.go
View File

@ -87,25 +87,25 @@ func TestLoginLogout(t *testing.T) {
_ = deleteResourceGroup(rg)
})
c.RunDocker("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rg, "--location", location)
res := c.RunDocker("context", "use", contextName)
c.RunDockerCmd("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rg, "--location", location)
res := c.RunDockerCmd("context", "use", contextName)
res.Assert(t, icmd.Expected{Out: contextName})
res = c.RunDocker("context", "ls")
res = c.RunDockerCmd("context", "ls")
res.Assert(t, icmd.Expected{Out: contextName + " *"})
})
t.Run("delete context", func(t *testing.T) {
res := c.RunDocker("context", "use", "default")
res := c.RunDockerCmd("context", "use", "default")
res.Assert(t, icmd.Expected{Out: "default"})
res = c.RunDocker("context", "rm", contextName)
res = c.RunDockerCmd("context", "rm", contextName)
res.Assert(t, icmd.Expected{Out: contextName})
})
t.Run("logout", func(t *testing.T) {
_, err := os.Stat(login.GetTokenStorePath())
assert.NilError(t, err)
res := c.RunDocker("logout", "azure")
res := c.RunDockerCmd("logout", "azure")
res.Assert(t, icmd.Expected{Out: "Removing login credentials for Azure"})
_, err = os.Stat(login.GetTokenStorePath())
errMsg := "no such file or directory"
@ -116,7 +116,7 @@ func TestLoginLogout(t *testing.T) {
})
t.Run("create context fail", func(t *testing.T) {
res := c.RunDockerOrFail("context", "create", "aci", "fail-context")
res := c.RunDockerOrExitError("context", "create", "aci", "fail-context")
res.Assert(t, icmd.Expected{
ExitCode: errdefs.ExitCodeLoginRequired,
Err: `not logged in to azure, you need to run "docker login azure" first`,
@ -162,7 +162,7 @@ func TestContainerRun(t *testing.T) {
t.Run("run", func(t *testing.T) {
mountTarget := "/usr/share/nginx/html"
res := c.RunDocker(
res := c.RunDockerCmd(
"run", "-d",
"-v", fmt.Sprintf("%s@%s:%s", saName, testShareName, mountTarget),
"-p", "80:80",
@ -172,7 +172,7 @@ func TestContainerRun(t *testing.T) {
})
t.Run("inspect", func(t *testing.T) {
res := c.RunDocker("inspect", container)
res := c.RunDockerCmd("inspect", container)
containerInspect, err := ParseContainerInspect(res.Stdout())
assert.NilError(t, err)
@ -186,7 +186,7 @@ func TestContainerRun(t *testing.T) {
})
t.Run("ps", func(t *testing.T) {
res := c.RunDocker("ps")
res := c.RunDockerCmd("ps")
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
l := out[len(out)-1]
assert.Assert(t, strings.Contains(l, container), "Looking for %q in line: %s", container, l)
@ -205,15 +205,15 @@ func TestContainerRun(t *testing.T) {
})
t.Run("logs", func(t *testing.T) {
res := c.RunDocker("logs", container)
res := c.RunDockerCmd("logs", container)
res.Assert(t, icmd.Expected{Out: "GET"})
})
t.Run("exec", func(t *testing.T) {
res := c.RunDocker("exec", container, "pwd")
res := c.RunDockerCmd("exec", container, "pwd")
res.Assert(t, icmd.Expected{Out: "/"})
res = c.RunDockerOrFail("exec", container, "echo", "fail_with_argument")
res = c.RunDockerOrExitError("exec", container, "echo", "fail_with_argument")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "ACI exec command does not accept arguments to the command. Only the binary should be specified",
@ -260,7 +260,7 @@ func TestContainerRun(t *testing.T) {
})
t.Run("rm a running container", func(t *testing.T) {
res := c.RunDockerOrFail("rm", container)
res := c.RunDockerOrExitError("rm", container)
res.Assert(t, icmd.Expected{
Err: fmt.Sprintf("Error: you cannot remove a running container %s. Stop the container before attempting removal or force remove", container),
ExitCode: 1,
@ -268,11 +268,11 @@ func TestContainerRun(t *testing.T) {
})
t.Run("force rm", func(t *testing.T) {
res := c.RunDocker("rm", "-f", container)
res := c.RunDockerCmd("rm", "-f", container)
res.Assert(t, icmd.Expected{Out: container})
checkStopped := func(t poll.LogT) poll.Result {
res := c.RunDockerOrFail("inspect", container)
res := c.RunDockerOrExitError("inspect", container)
if res.ExitCode == 1 {
return poll.Success()
}
@ -306,7 +306,7 @@ func TestContainerRunAttached(t *testing.T) {
runRes := icmd.StartCmd(cmd)
checkRunning := func(t poll.LogT) poll.Result {
res := c.RunDockerOrFail("inspect", container)
res := c.RunDockerOrExitError("inspect", container)
if res.ExitCode == 0 {
return poll.Success()
}
@ -314,7 +314,7 @@ func TestContainerRunAttached(t *testing.T) {
}
poll.WaitOn(t, checkRunning, poll.WithDelay(5*time.Second), poll.WithTimeout(60*time.Second))
inspectRes := c.RunDocker("inspect", container)
inspectRes := c.RunDockerCmd("inspect", container)
containerInspect, err := ParseContainerInspect(inspectRes.Stdout())
assert.NilError(t, err)
@ -350,7 +350,7 @@ func TestContainerRunAttached(t *testing.T) {
})
t.Run("stop wrong container", func(t *testing.T) {
res := c.RunDockerOrFail("stop", "unknown-container")
res := c.RunDockerOrExitError("stop", "unknown-container")
res.Assert(t, icmd.Expected{
Err: "Error: container unknown-container not found",
ExitCode: 1,
@ -358,32 +358,32 @@ func TestContainerRunAttached(t *testing.T) {
})
t.Run("stop container", func(t *testing.T) {
res := c.RunDocker("stop", container)
res := c.RunDockerCmd("stop", container)
res.Assert(t, icmd.Expected{Out: container})
})
t.Run("ps stopped container with --all", func(t *testing.T) {
res := c.RunDocker("ps", container)
res := c.RunDockerCmd("ps", container)
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
assert.Assert(t, is.Len(out, 1))
res = c.RunDocker("ps", "--all", container)
res = c.RunDockerCmd("ps", "--all", container)
out = strings.Split(strings.TrimSpace(res.Stdout()), "\n")
assert.Assert(t, is.Len(out, 2))
})
t.Run("start container", func(t *testing.T) {
res := c.RunDocker("start", container)
res := c.RunDockerCmd("start", container)
res.Assert(t, icmd.Expected{Out: container})
waitForStatus(t, c, container, "Running")
})
t.Run("rm stopped container", func(t *testing.T) {
res := c.RunDocker("stop", container)
res := c.RunDockerCmd("stop", container)
res.Assert(t, icmd.Expected{Out: container})
waitForStatus(t, c, container, "Terminated", "Node Stopped")
res = c.RunDocker("rm", container)
res = c.RunDockerCmd("rm", container)
res.Assert(t, icmd.Expected{Out: container})
})
}
@ -402,8 +402,8 @@ func TestCompose(t *testing.T) {
t.Run("compose up", func(t *testing.T) {
// Name of Compose project is taken from current folder "acie2e"
c.RunDocker("compose", "up", "-f", composeFile)
res := c.RunDocker("ps")
c.RunDockerCmd("compose", "up", "-f", composeFile)
res := c.RunDockerCmd("ps")
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
// Check three containers are running
assert.Assert(t, is.Len(out, 4))
@ -416,7 +416,7 @@ func TestCompose(t *testing.T) {
}
assert.Assert(t, webRunning, "web container not running")
res = c.RunDocker("inspect", serverContainer)
res = c.RunDockerCmd("inspect", serverContainer)
containerInspect, err := ParseContainerInspect(res.Stdout())
assert.NilError(t, err)
@ -432,19 +432,19 @@ func TestCompose(t *testing.T) {
})
t.Run("logs web", func(t *testing.T) {
res := c.RunDocker("logs", serverContainer)
res := c.RunDockerCmd("logs", serverContainer)
res.Assert(t, icmd.Expected{Out: "Listening on port 80"})
})
t.Run("update", func(t *testing.T) {
c.RunDocker("compose", "up", "-f", composeFileMultiplePorts, "--project-name", composeProjectName)
res := c.RunDocker("ps")
c.RunDockerCmd("compose", "up", "-f", composeFileMultiplePorts, "--project-name", composeProjectName)
res := c.RunDockerCmd("ps")
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
// Check three containers are running
assert.Assert(t, is.Len(out, 4))
for _, cName := range []string{serverContainer, wordsContainer} {
res = c.RunDocker("inspect", cName)
res = c.RunDockerCmd("inspect", cName)
containerInspect, err := ParseContainerInspect(res.Stdout())
assert.NilError(t, err)
@ -470,7 +470,7 @@ func TestCompose(t *testing.T) {
}
poll.WaitOn(t, checkUp, poll.WithDelay(1*time.Second), poll.WithTimeout(60*time.Second))
res = c.RunDocker("ps")
res = c.RunDockerCmd("ps")
p := containerInspect.Ports[0]
res.Assert(t, icmd.Expected{
Out: fmt.Sprintf("%s:%d->%d/tcp", p.HostIP, p.HostPort, p.ContainerPort),
@ -479,8 +479,8 @@ func TestCompose(t *testing.T) {
})
t.Run("down", func(t *testing.T) {
c.RunDocker("compose", "down", "--project-name", composeProjectName)
res := c.RunDocker("ps")
c.RunDockerCmd("compose", "down", "--project-name", composeProjectName)
res := c.RunDockerCmd("ps")
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
assert.Equal(t, len(out), 1)
})
@ -505,14 +505,14 @@ func TestRunEnvVars(t *testing.T) {
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
container := strings.TrimSpace(out[len(out)-1])
res = c.RunDocker("inspect", container)
res = c.RunDockerCmd("inspect", container)
containerInspect, err := ParseContainerInspect(res.Stdout())
assert.NilError(t, err)
assert.Equal(t, containerInspect.Image, "mysql:5.7")
check := func(t poll.LogT) poll.Result {
res := c.RunDockerOrFail("logs", container)
res := c.RunDockerOrExitError("logs", container)
if strings.Contains(res.Stdout(), "Giving user user1 access to schema mytestdb") {
return poll.Success()
}
@ -536,7 +536,7 @@ func setupTestResourceGroup(t *testing.T, c *E2eCLI) (string, string) {
})
createAciContextAndUseIt(t, c, sID, rg)
// Check nothing is running
res := c.RunDocker("ps")
res := c.RunDockerCmd("ps")
assert.Assert(t, is.Len(strings.Split(strings.TrimSpace(res.Stdout()), "\n"), 1))
return sID, rg
}
@ -562,7 +562,7 @@ func azureLogin(t *testing.T, c *E2eCLI) {
assert.Check(t, clientID != "", "AZURE_CLIENT_ID must not be empty")
assert.Check(t, clientSecret != "", "AZURE_CLIENT_SECRET must not be empty")
assert.Check(t, tenantID != "", "AZURE_TENANT_ID must not be empty")
c.RunDocker("login", "azure", "--client-id", clientID, "--client-secret", clientSecret, "--tenant-id", tenantID)
c.RunDockerCmd("login", "azure", "--client-id", clientID, "--client-secret", clientSecret, "--tenant-id", tenantID)
}
func getSubscriptionID(t *testing.T) string {
@ -581,10 +581,10 @@ func createResourceGroup(sID, rgName string) error {
}
func createAciContextAndUseIt(t *testing.T, c *E2eCLI, sID, rgName string) {
c.RunDocker("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rgName, "--location", location)
res := c.RunDocker("context", "use", contextName)
c.RunDockerCmd("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rgName, "--location", location)
res := c.RunDockerCmd("context", "use", contextName)
res.Assert(t, icmd.Expected{Out: contextName})
res = c.RunDocker("context", "ls")
res = c.RunDockerCmd("context", "ls")
res.Assert(t, icmd.Expected{Out: contextName + " *"})
}
@ -634,7 +634,7 @@ func getContainerName(stdout string) string {
func waitForStatus(t *testing.T, c *E2eCLI, containerID string, statuses ...string) {
checkStopped := func(logt poll.LogT) poll.Result {
res := c.RunDocker("inspect", containerID)
res := c.RunDockerCmd("inspect", containerID)
containerInspect, err := ParseContainerInspect(res.Stdout())
assert.NilError(t, err)
for _, status := range statuses {

126
tests/e2e/e2e_test.go
View File

@ -49,9 +49,9 @@ func TestMain(m *testing.M) {
func TestComposeNotImplemented(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
res := c.RunDocker("context", "show")
res := c.RunDockerCmd("context", "show")
res.Assert(t, icmd.Expected{Out: "default"})
res = c.RunDockerOrFail("compose", "up")
res = c.RunDockerOrExitError("compose", "up")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: `Command "compose up" not available in current context (default)`,
@ -62,58 +62,58 @@ func TestContextDefault(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
t.Run("show", func(t *testing.T) {
res := c.RunDocker("context", "show")
res := c.RunDockerCmd("context", "show")
res.Assert(t, icmd.Expected{Out: "default"})
})
t.Run("ls", func(t *testing.T) {
res := c.RunDocker("context", "ls")
res := c.RunDockerCmd("context", "ls")
golden.Assert(t, res.Stdout(), GoldenFile("ls-out-default"))
})
t.Run("inspect", func(t *testing.T) {
res := c.RunDocker("context", "inspect", "default")
res := c.RunDockerCmd("context", "inspect", "default")
res.Assert(t, icmd.Expected{Out: `"Name": "default"`})
})
t.Run("inspect current", func(t *testing.T) {
res := c.RunDocker("context", "inspect")
res := c.RunDockerCmd("context", "inspect")
res.Assert(t, icmd.Expected{Out: `"Name": "default"`})
})
}
func TestContextCreateDocker(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
res := c.RunDocker("context", "create", "test-docker", "--from", "default")
res := c.RunDockerCmd("context", "create", "test-docker", "--from", "default")
res.Assert(t, icmd.Expected{Out: "test-docker"})
t.Run("ls", func(t *testing.T) {
res := c.RunDocker("context", "ls")
res := c.RunDockerCmd("context", "ls")
golden.Assert(t, res.Stdout(), GoldenFile("ls-out-test-docker"))
})
t.Run("ls quiet", func(t *testing.T) {
res := c.RunDocker("context", "ls", "-q")
res := c.RunDockerCmd("context", "ls", "-q")
golden.Assert(t, res.Stdout(), "ls-out-test-docker-quiet.golden")
})
t.Run("ls format", func(t *testing.T) {
res := c.RunDocker("context", "ls", "--format", "{{ json . }}")
res := c.RunDockerCmd("context", "ls", "--format", "{{ json . }}")
res.Assert(t, icmd.Expected{Out: `"Name":"default"`})
})
}
func TestContextInspect(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
res := c.RunDocker("context", "create", "test-docker", "--from", "default")
res := c.RunDockerCmd("context", "create", "test-docker", "--from", "default")
res.Assert(t, icmd.Expected{Out: "test-docker"})
t.Run("inspect current", func(t *testing.T) {
// Cannot be run in parallel because of "context use"
res := c.RunDocker("context", "use", "test-docker")
res := c.RunDockerCmd("context", "use", "test-docker")
res.Assert(t, icmd.Expected{Out: "test-docker"})
res = c.RunDocker("context", "inspect")
res = c.RunDockerCmd("context", "inspect")
res.Assert(t, icmd.Expected{Out: `"Name": "test-docker"`})
})
}
@ -122,7 +122,7 @@ func TestContextHelpACI(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
t.Run("help", func(t *testing.T) {
res := c.RunDocker("context", "create", "aci", "--help")
res := c.RunDockerCmd("context", "create", "aci", "--help")
// Can't use golden here as the help prints the config directory which changes
res.Assert(t, icmd.Expected{Out: "docker context create aci CONTEXT [flags]"})
res.Assert(t, icmd.Expected{Out: "--location"})
@ -131,7 +131,7 @@ func TestContextHelpACI(t *testing.T) {
})
t.Run("check exec", func(t *testing.T) {
res := c.RunDockerOrFail("context", "create", "aci", "--subscription-id", "invalid-id")
res := c.RunDockerOrExitError("context", "create", "aci", "--subscription-id", "invalid-id")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "accepts 1 arg(s), received 0",
@ -143,8 +143,8 @@ func TestContextHelpACI(t *testing.T) {
func TestContextDuplicateACI(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
c.RunDocker("context", "create", "mycontext", "--from", "default")
res := c.RunDockerOrFail("context", "create", "aci", "mycontext")
c.RunDockerCmd("context", "create", "mycontext", "--from", "default")
res := c.RunDockerOrExitError("context", "create", "aci", "mycontext")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "context mycontext: already exists",
@ -156,10 +156,10 @@ func TestContextRemove(t *testing.T) {
t.Run("remove current", func(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
c.RunDocker("context", "create", "test-context-rm", "--from", "default")
res := c.RunDocker("context", "use", "test-context-rm")
c.RunDockerCmd("context", "create", "test-context-rm", "--from", "default")
res := c.RunDockerCmd("context", "use", "test-context-rm")
res.Assert(t, icmd.Expected{Out: "test-context-rm"})
res = c.RunDockerOrFail("context", "rm", "test-context-rm")
res = c.RunDockerOrExitError("context", "rm", "test-context-rm")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "cannot delete current context",
@ -169,11 +169,11 @@ func TestContextRemove(t *testing.T) {
t.Run("force remove current", func(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
c.RunDocker("context", "create", "test-context-rmf")
c.RunDocker("context", "use", "test-context-rmf")
res := c.RunDocker("context", "rm", "-f", "test-context-rmf")
c.RunDockerCmd("context", "create", "test-context-rmf")
c.RunDockerCmd("context", "use", "test-context-rmf")
res := c.RunDockerCmd("context", "rm", "-f", "test-context-rmf")
res.Assert(t, icmd.Expected{Out: "test-context-rmf"})
res = c.RunDocker("context", "ls")
res = c.RunDockerCmd("context", "ls")
res.Assert(t, icmd.Expected{Out: "default *"})
})
}
@ -184,7 +184,7 @@ func TestLoginCommandDelegation(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
t.Run("default context", func(t *testing.T) {
res := c.RunDockerOrFail("login", "-u", "nouser", "-p", "wrongpasword")
res := c.RunDockerOrExitError("login", "-u", "nouser", "-p", "wrongpasword")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "unauthorized: incorrect username or password",
@ -192,7 +192,7 @@ func TestLoginCommandDelegation(t *testing.T) {
})
t.Run("interactive", func(t *testing.T) {
res := c.RunDockerOrFail("login", "someregistry.docker.io")
res := c.RunDockerOrExitError("login", "someregistry.docker.io")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "Cannot perform an interactive login from a non TTY device",
@ -200,14 +200,14 @@ func TestLoginCommandDelegation(t *testing.T) {
})
t.Run("logout", func(t *testing.T) {
res := c.RunDocker("logout", "someregistry.docker.io")
res := c.RunDockerCmd("logout", "someregistry.docker.io")
res.Assert(t, icmd.Expected{Out: "someregistry.docker.io"})
})
t.Run("existing context", func(t *testing.T) {
c.RunDocker("context", "create", "local", "local")
c.RunDocker("context", "use", "local")
res := c.RunDockerOrFail("login", "-u", "nouser", "-p", "wrongpasword")
c.RunDockerCmd("context", "create", "local", "local")
c.RunDockerCmd("context", "use", "local")
res := c.RunDockerOrExitError("login", "-u", "nouser", "-p", "wrongpasword")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "unauthorized: incorrect username or password",
@ -219,7 +219,7 @@ func TestCloudLogin(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
t.Run("unknown backend", func(t *testing.T) {
res := c.RunDockerOrFail("login", "mycloudbackend")
res := c.RunDockerOrExitError("login", "mycloudbackend")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "unknown backend type for cloud login: mycloudbackend",
@ -266,12 +266,12 @@ func TestLegacy(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
t.Run("help", func(t *testing.T) {
res := c.RunDocker("--help")
res := c.RunDockerCmd("--help")
res.Assert(t, icmd.Expected{Out: "swarm"})
})
t.Run("swarm", func(t *testing.T) {
res := c.RunDockerOrFail("swarm", "join")
res := c.RunDockerOrExitError("swarm", "join")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: `"docker swarm join" requires exactly 1 argument.`,
@ -286,7 +286,7 @@ func TestLegacy(t *testing.T) {
})
t.Run("error messages", func(t *testing.T) {
res := c.RunDockerOrFail("foo")
res := c.RunDockerOrExitError("foo")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "docker: 'foo' is not a docker command.",
@ -298,7 +298,7 @@ func TestLegacy(t *testing.T) {
if runtime.GOOS == "windows" {
stderr = "error during connect: Get http://localhost:123"
}
res := c.RunDockerOrFail("-H", "tcp://localhost:123", "version")
res := c.RunDockerOrExitError("-H", "tcp://localhost:123", "version")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: stderr,
@ -306,9 +306,9 @@ func TestLegacy(t *testing.T) {
})
t.Run("existing contexts delegate", func(t *testing.T) {
c.RunDocker("context", "create", "moby-ctx", "--from=default")
c.RunDocker("context", "use", "moby-ctx")
res := c.RunDockerOrFail("swarm", "join")
c.RunDockerCmd("context", "create", "moby-ctx", "--from=default")
c.RunDockerCmd("context", "use", "moby-ctx")
res := c.RunDockerOrExitError("swarm", "join")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: `"docker swarm join" requires exactly 1 argument.`,
@ -316,16 +316,16 @@ func TestLegacy(t *testing.T) {
})
t.Run("host flag overrides context", func(t *testing.T) {
c.RunDocker("context", "create", "example", "test-example")
c.RunDocker("context", "use", "test-example")
c.RunDockerCmd("context", "create", "example", "test-example")
c.RunDockerCmd("context", "use", "test-example")
endpoint := "unix:///var/run/docker.sock"
if runtime.GOOS == "windows" {
endpoint = "npipe:////./pipe/docker_engine"
}
res := c.RunDocker("-H", endpoint, "ps")
res := c.RunDockerCmd("-H", endpoint, "ps")
// Example backend's ps output includes these strings
assert.Assert(t, !strings.Contains(res.Stdout(), "id"))
assert.Assert(t, !strings.Contains(res.Stdout(), "1234"))
assert.Assert(t, !strings.Contains(res.Stdout(), "id"), "%q does not contains %q", res.Stdout(), "id")
assert.Assert(t, !strings.Contains(res.Stdout(), "1234"), "%q does not contains %q", res.Stdout(), "1234")
})
}
@ -333,7 +333,7 @@ func TestLegacyLogin(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
t.Run("host flag login", func(t *testing.T) {
res := c.RunDockerOrFail("-H", "tcp://localhost:123", "login", "-u", "nouser", "-p", "wrongpasword")
res := c.RunDockerOrExitError("-H", "tcp://localhost:123", "login", "-u", "nouser", "-p", "wrongpasword")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "WARNING! Using --password via the CLI is insecure. Use --password-stdin.",
@ -341,7 +341,7 @@ func TestLegacyLogin(t *testing.T) {
})
t.Run("log level flag login", func(t *testing.T) {
res := c.RunDockerOrFail("--log-level", "debug", "login", "-u", "nouser", "-p", "wrongpasword")
res := c.RunDockerOrExitError("--log-level", "debug", "login", "-u", "nouser", "-p", "wrongpasword")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: "WARNING! Using --password via the CLI is insecure",
@ -349,7 +349,7 @@ func TestLegacyLogin(t *testing.T) {
})
t.Run("login help global flags", func(t *testing.T) {
res := c.RunDocker("login", "--help")
res := c.RunDockerCmd("login", "--help")
assert.Assert(t, !strings.Contains(res.Combined(), "--log-level"))
})
}
@ -357,8 +357,8 @@ func TestLegacyLogin(t *testing.T) {
func TestUnsupportedCommand(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
c.RunDocker("context", "create", "example", "test-example")
res := c.RunDockerOrFail("--context", "test-example", "images")
c.RunDockerCmd("context", "create", "example", "test-example")
res := c.RunDockerOrExitError("--context", "test-example", "images")
res.Assert(t, icmd.Expected{
ExitCode: 1,
Err: `Command "images" not available in current context (test-example), you can use the "default" context to run this command`,
@ -369,60 +369,60 @@ func TestVersion(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
t.Run("azure version", func(t *testing.T) {
res := c.RunDocker("version")
res := c.RunDockerCmd("version")
res.Assert(t, icmd.Expected{Out: "Azure integration"})
})
t.Run("format", func(t *testing.T) {
res := c.RunDocker("version", "-f", "{{ json . }}")
res := c.RunDockerCmd("version", "-f", "{{ json . }}")
res.Assert(t, icmd.Expected{Out: `"Client":`})
res = c.RunDocker("version", "--format", "{{ json . }}")
res = c.RunDockerCmd("version", "--format", "{{ json . }}")
res.Assert(t, icmd.Expected{Out: `"Client":`})
})
t.Run("delegate version flag", func(t *testing.T) {
c.RunDocker("context", "create", "example", "test-example")
c.RunDocker("context", "use", "test-example")
res := c.RunDocker("-v")
c.RunDockerCmd("context", "create", "example", "test-example")
c.RunDockerCmd("context", "use", "test-example")
res := c.RunDockerCmd("-v")
res.Assert(t, icmd.Expected{Out: "Docker version"})
})
}
func TestMockBackend(t *testing.T) {
c := NewParallelE2eCLI(t, binDir)
c.RunDocker("context", "create", "example", "test-example")
res := c.RunDocker("context", "use", "test-example")
c.RunDockerCmd("context", "create", "example", "test-example")
res := c.RunDockerCmd("context", "use", "test-example")
res.Assert(t, icmd.Expected{Out: "test-example"})
t.Run("use", func(t *testing.T) {
res := c.RunDocker("context", "show")
res := c.RunDockerCmd("context", "show")
res.Assert(t, icmd.Expected{Out: "test-example"})
res = c.RunDocker("context", "ls")
res = c.RunDockerCmd("context", "ls")
golden.Assert(t, res.Stdout(), GoldenFile("ls-out-test-example"))
})
t.Run("ps", func(t *testing.T) {
res := c.RunDocker("ps")
res := c.RunDockerCmd("ps")
golden.Assert(t, res.Stdout(), "ps-out-example.golden")
})
t.Run("ps quiet", func(t *testing.T) {
res := c.RunDocker("ps", "-q")
res := c.RunDockerCmd("ps", "-q")
golden.Assert(t, res.Stdout(), "ps-quiet-out-example.golden")
})
t.Run("ps quiet all", func(t *testing.T) {
res := c.RunDocker("ps", "-q", "--all")
res := c.RunDockerCmd("ps", "-q", "--all")
golden.Assert(t, res.Stdout(), "ps-quiet-all-out-example.golden")
})
t.Run("inspect", func(t *testing.T) {
res := c.RunDocker("inspect", "id")
res := c.RunDockerCmd("inspect", "id")
golden.Assert(t, res.Stdout(), "inspect-id.golden")
})
t.Run("run", func(t *testing.T) {
res := c.RunDocker("run", "-d", "nginx", "-p", "80:80")
res := c.RunDockerCmd("run", "-d", "nginx", "-p", "80:80")
res.Assert(t, icmd.Expected{
Out: `Running container "nginx" with name`,
})

24
tests/ecs-e2e/e2e-ecs_test.go
View File

@ -54,25 +54,25 @@ func TestSecrets(t *testing.T) {
description := "description " + testID
t.Run("create secret", func(t *testing.T) {
res := cmd.RunDocker("secret", "create", secretName, "-u", "user1", "-p", "pass1", "-d", description)
res := cmd.RunDockerCmd("secret", "create", secretName, "-u", "user1", "-p", "pass1", "-d", description)
assert.Check(t, strings.Contains(res.Stdout(), "secret:"+secretName))
})
t.Run("list secrets", func(t *testing.T) {
res := cmd.RunDocker("secret", "list")
res := cmd.RunDockerCmd("secret", "list")
assert.Check(t, strings.Contains(res.Stdout(), secretName))
assert.Check(t, strings.Contains(res.Stdout(), description))
})
t.Run("inspect secret", func(t *testing.T) {
res := cmd.RunDocker("secret", "inspect", secretName)
res := cmd.RunDockerCmd("secret", "inspect", secretName)
assert.Check(t, strings.Contains(res.Stdout(), `"Name": "`+secretName+`"`))
assert.Check(t, strings.Contains(res.Stdout(), `"Description": "`+description+`"`))
})
t.Run("rm secret", func(t *testing.T) {
cmd.RunDocker("secret", "rm", secretName)
res := cmd.RunDocker("secret", "list")
cmd.RunDockerCmd("secret", "rm", secretName)
res := cmd.RunDockerCmd("secret", "list")
assert.Check(t, !strings.Contains(res.Stdout(), secretName))
})
}
@ -81,12 +81,12 @@ func TestCompose(t *testing.T) {
c, stack := setupTest(t)
t.Run("compose up", func(t *testing.T) {
c.RunDocker("compose", "up", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
c.RunDockerCmd("compose", "up", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
})
var url string
t.Run("compose ps", func(t *testing.T) {
res := c.RunDocker("compose", "ps", "--project-name", stack)
res := c.RunDockerCmd("compose", "ps", "--project-name", stack)
lines := strings.Split(res.Stdout(), "\n")
assert.Equal(t, 3, len(lines))
@ -117,7 +117,7 @@ func TestCompose(t *testing.T) {
})
t.Run("compose down", func(t *testing.T) {
c.RunDocker("compose", "down", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
c.RunDockerCmd("compose", "down", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
})
}
@ -132,7 +132,7 @@ func setupTest(t *testing.T) (*E2eCLI, string) {
if localTestProfile != "" {
region := os.Getenv("TEST_AWS_REGION")
assert.Check(t, region != "")
c.RunDocker("context", "create", "ecs", contextName, "--profile", localTestProfile, "--region", region)
c.RunDockerCmd("context", "create", "ecs", contextName, "--profile", localTestProfile, "--region", region)
} else {
profile := contextName
region := os.Getenv("AWS_DEFAULT_REGION")
@ -141,11 +141,11 @@ func setupTest(t *testing.T) (*E2eCLI, string) {
assert.Check(t, keyID != "")
assert.Check(t, secretKey != "")
assert.Check(t, region != "")
c.RunDocker("context", "create", "ecs", contextName, "--profile", profile, "--region", region, "--secret-key", secretKey, "--key-id", keyID)
c.RunDockerCmd("context", "create", "ecs", contextName, "--profile", profile, "--region", region, "--secret-key", secretKey, "--key-id", keyID)
}
res = c.RunDocker("context", "use", contextName)
res = c.RunDockerCmd("context", "use", contextName)
res.Assert(t, icmd.Expected{Out: contextName})
res = c.RunDocker("context", "ls")
res = c.RunDockerCmd("context", "ls")
res.Assert(t, icmd.Expected{Out: contextName + " *"})
})
return c, stack

10
tests/framework/e2e.go
View File

@ -161,15 +161,15 @@ func (c *E2eCLI) NewDockerCmd(args ...string) icmd.Cmd {
return c.NewCmd(filepath.Join(c.BinDir, DockerExecutableName), args...)
}
// RunDockerOrFail runs a docker command and returns a result
func (c *E2eCLI) RunDockerOrFail(args ...string) *icmd.Result {
// RunDockerOrExitError runs a docker command and returns a result
func (c *E2eCLI) RunDockerOrExitError(args ...string) *icmd.Result {
fmt.Printf(" [%s] docker %s\n", c.test.Name(), strings.Join(args, " "))
return icmd.RunCmd(c.NewDockerCmd(args...))
}
// RunDocker runs a docker command, expects no error and returns a result
func (c *E2eCLI) RunDocker(args ...string) *icmd.Result {
res := c.RunDockerOrFail(args...)
// RunDockerCmd runs a docker command, expects no error and returns a result
func (c *E2eCLI) RunDockerCmd(args ...string) *icmd.Result {
res := c.RunDockerOrExitError(args...)
res.Assert(c.test, icmd.Success)
return res
}