Better renaming

Signed-off-by: Guillaume Tardif <[email protected]>

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",

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 {

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`,
 		})

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

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
 }