From 981665b02c2a90ae7fc6c03b099d2af1fd27b8a5 Mon Sep 17 00:00:00 2001 From: Guillaume Tardif Date: Mon, 24 Aug 2020 10:23:14 +0200 Subject: [PATCH] Better renaming Signed-off-by: Guillaume Tardif --- local/e2e/backend_test.go | 20 +++--- tests/aci-e2e/e2e-aci_test.go | 86 +++++++++++------------ tests/e2e/e2e_test.go | 126 +++++++++++++++++----------------- tests/ecs-e2e/e2e-ecs_test.go | 24 +++---- tests/framework/e2e.go | 10 +-- 5 files changed, 133 insertions(+), 133 deletions(-) diff --git a/local/e2e/backend_test.go b/local/e2e/backend_test.go index 2d77d357d..e028057e4 100644 --- a/local/e2e/backend_test.go +++ b/local/e2e/backend_test.go @@ -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", diff --git a/tests/aci-e2e/e2e-aci_test.go b/tests/aci-e2e/e2e-aci_test.go index 126f2ec20..86fd762ce 100644 --- a/tests/aci-e2e/e2e-aci_test.go +++ b/tests/aci-e2e/e2e-aci_test.go @@ -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 { diff --git a/tests/e2e/e2e_test.go b/tests/e2e/e2e_test.go index 256365545..cefd5e611 100644 --- a/tests/e2e/e2e_test.go +++ b/tests/e2e/e2e_test.go @@ -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`, }) diff --git a/tests/ecs-e2e/e2e-ecs_test.go b/tests/ecs-e2e/e2e-ecs_test.go index 9c2b6ec05..e206257ed 100644 --- a/tests/ecs-e2e/e2e-ecs_test.go +++ b/tests/ecs-e2e/e2e-ecs_test.go @@ -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 diff --git a/tests/framework/e2e.go b/tests/framework/e2e.go index 17dcf459b..f92795a2f 100644 --- a/tests/framework/e2e.go +++ b/tests/framework/e2e.go @@ -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 }