mirror of https://github.com/docker/compose.git
Renaming, expect commands to succeed by default (removed a bunch of res.Assert(success) )
Signed-off-by: Guillaume Tardif <guillaume.tardif@docker.com>
This commit is contained in:
Guillaume Tardif
parent
d6c8039562
commit
da6334f415
|
|
@ -43,38 +43,33 @@ func TestMain(m *testing.M) {
|
|||
|
||||
func TestLocalBackend(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
c.RunDockerCmd("context", "create", "local", "test-context").Assert(t, icmd.Success)
|
||||
c.RunDockerCmd("context", "use", "test-context").Assert(t, icmd.Success)
|
||||
c.RunDocker( "context", "create", "local", "test-context").Assert(t, icmd.Success)
|
||||
c.RunDocker("context", "use", "test-context").Assert(t, icmd.Success)
|
||||
|
||||
t.Run("run", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("run", "-d", "nginx")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker( "run", "-d", "nginx")
|
||||
containerName := strings.TrimSpace(res.Combined())
|
||||
t.Cleanup(func() {
|
||||
_ = c.RunDockerCmd("rm", "-f", containerName)
|
||||
_ = c.RunDockerOrFail("rm", "-f", containerName)
|
||||
})
|
||||
res = c.RunDockerCmd("inspect", containerName)
|
||||
res = c.RunDocker("inspect", containerName)
|
||||
res.Assert(t, icmd.Expected{Out: `"Status": "running"`})
|
||||
})
|
||||
|
||||
t.Run("run with ports", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("run", "-d", "-p", "8080:80", "nginx")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker( "run", "-d", "-p", "8080:80", "nginx")
|
||||
containerName := strings.TrimSpace(res.Combined())
|
||||
t.Cleanup(func() {
|
||||
_ = c.RunDockerCmd("rm", "-f", containerName)
|
||||
_ = c.RunDockerOrFail("rm", "-f", containerName)
|
||||
})
|
||||
res = c.RunDockerCmd("inspect", containerName)
|
||||
res = c.RunDocker( "inspect", containerName)
|
||||
res.Assert(t, icmd.Expected{Out: `"Status": "running"`})
|
||||
res = c.RunDockerCmd("ps")
|
||||
res = c.RunDocker( "ps")
|
||||
res.Assert(t, icmd.Expected{Out: "0.0.0.0:8080->80/tcp"})
|
||||
})
|
||||
|
||||
t.Run("inspect not found", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("inspect", "nonexistentcontainer")
|
||||
res := c.RunDockerOrFail("inspect", "nonexistentcontainer")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "Error: No such container: nonexistentcontainer",
|
||||
|
|
|
|||
|
|
@ -87,26 +87,25 @@ func TestLoginLogout(t *testing.T) {
|
|||
_ = deleteResourceGroup(rg)
|
||||
})
|
||||
|
||||
res := c.RunDockerCmd("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rg, "--location", location)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDockerCmd("context", "use", contextName)
|
||||
res := c.RunDocker("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rg, "--location", location)
|
||||
res = c.RunDocker("context", "use", contextName)
|
||||
res.Assert(t, icmd.Expected{Out: contextName})
|
||||
res = c.RunDockerCmd("context", "ls")
|
||||
res = c.RunDocker("context", "ls")
|
||||
res.Assert(t, icmd.Expected{Out: contextName + " *"})
|
||||
})
|
||||
|
||||
t.Run("delete context", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("context", "use", "default")
|
||||
res := c.RunDocker("context", "use", "default")
|
||||
res.Assert(t, icmd.Expected{Out: "default"})
|
||||
|
||||
res = c.RunDockerCmd("context", "rm", contextName)
|
||||
res = c.RunDocker("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.RunDockerCmd("logout", "azure")
|
||||
res := c.RunDocker("logout", "azure")
|
||||
res.Assert(t, icmd.Expected{Out: "Removing login credentials for Azure"})
|
||||
_, err = os.Stat(login.GetTokenStorePath())
|
||||
errMsg := "no such file or directory"
|
||||
|
|
@ -117,7 +116,7 @@ func TestLoginLogout(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("create context fail", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("context", "create", "aci", "fail-context")
|
||||
res := c.RunDockerOrFail("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`,
|
||||
|
|
@ -163,20 +162,18 @@ func TestContainerRun(t *testing.T) {
|
|||
|
||||
t.Run("run", func(t *testing.T) {
|
||||
mountTarget := "/usr/share/nginx/html"
|
||||
res := c.RunDockerCmd(
|
||||
res := c.RunDocker(
|
||||
"run", "-d",
|
||||
"-v", fmt.Sprintf("%s@%s:%s", saName, testShareName, mountTarget),
|
||||
"-p", "80:80",
|
||||
"nginx",
|
||||
)
|
||||
res.Assert(t, icmd.Success)
|
||||
container = getContainerName(res.Stdout())
|
||||
t.Logf("Container name: %q", container)
|
||||
})
|
||||
|
||||
t.Run("inspect", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("inspect", container)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("inspect", container)
|
||||
|
||||
containerInspect, err := ParseContainerInspect(res.Stdout())
|
||||
assert.NilError(t, err)
|
||||
|
|
@ -191,8 +188,7 @@ func TestContainerRun(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("ps", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("ps")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("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)
|
||||
|
|
@ -211,15 +207,15 @@ func TestContainerRun(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("logs", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("logs", container)
|
||||
res := c.RunDocker("logs", container)
|
||||
res.Assert(t, icmd.Expected{Out: "GET"})
|
||||
})
|
||||
|
||||
t.Run("exec", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("exec", container, "pwd")
|
||||
res := c.RunDocker("exec", container, "pwd")
|
||||
res.Assert(t, icmd.Expected{Out: "/"})
|
||||
|
||||
res = c.RunDockerCmd("exec", container, "echo", "fail_with_argument")
|
||||
res = c.RunDockerOrFail("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",
|
||||
|
|
@ -266,7 +262,7 @@ func TestContainerRun(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("rm a running container", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("rm", container)
|
||||
res := c.RunDockerOrFail("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,
|
||||
|
|
@ -274,14 +270,11 @@ func TestContainerRun(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("force rm", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("rm", "-f", container)
|
||||
res.Assert(t, icmd.Expected{
|
||||
Out: container,
|
||||
ExitCode: 0,
|
||||
})
|
||||
res := c.RunDocker("rm", "-f", container)
|
||||
res.Assert(t, icmd.Expected{Out: container})
|
||||
|
||||
checkStopped := func(t poll.LogT) poll.Result {
|
||||
res := c.RunDockerCmd("inspect", container)
|
||||
res := c.RunDockerOrFail("inspect", container)
|
||||
if res.ExitCode == 1 {
|
||||
return poll.Success()
|
||||
}
|
||||
|
|
@ -315,7 +308,7 @@ func TestContainerRunAttached(t *testing.T) {
|
|||
runRes := icmd.StartCmd(cmd)
|
||||
|
||||
checkRunning := func(t poll.LogT) poll.Result {
|
||||
res := c.RunDockerCmd("inspect", container)
|
||||
res := c.RunDockerOrFail("inspect", container)
|
||||
if res.ExitCode == 0 {
|
||||
return poll.Success()
|
||||
}
|
||||
|
|
@ -323,8 +316,7 @@ func TestContainerRunAttached(t *testing.T) {
|
|||
}
|
||||
poll.WaitOn(t, checkRunning, poll.WithDelay(5*time.Second), poll.WithTimeout(60*time.Second))
|
||||
|
||||
inspectRes := c.RunDockerCmd("inspect", container)
|
||||
inspectRes.Assert(t, icmd.Success)
|
||||
inspectRes := c.RunDocker("inspect", container)
|
||||
|
||||
containerInspect, err := ParseContainerInspect(inspectRes.Stdout())
|
||||
assert.NilError(t, err)
|
||||
|
|
@ -361,7 +353,7 @@ func TestContainerRunAttached(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("stop wrong container", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("stop", "unknown-container")
|
||||
res := c.RunDockerOrFail("stop", "unknown-container")
|
||||
res.Assert(t, icmd.Expected{
|
||||
Err: "Error: container unknown-container not found",
|
||||
ExitCode: 1,
|
||||
|
|
@ -369,34 +361,32 @@ func TestContainerRunAttached(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("stop container", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("stop", container)
|
||||
res := c.RunDocker("stop", container)
|
||||
res.Assert(t, icmd.Expected{Out: container})
|
||||
})
|
||||
|
||||
t.Run("ps stopped container with --all", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("ps", container)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("ps", container)
|
||||
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
|
||||
assert.Assert(t, is.Len(out, 1))
|
||||
|
||||
res = c.RunDockerCmd("ps", "--all", container)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("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.RunDockerCmd("start", container)
|
||||
res := c.RunDocker("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.RunDockerCmd("stop", container)
|
||||
res := c.RunDocker("stop", container)
|
||||
res.Assert(t, icmd.Expected{Out: container})
|
||||
waitForStatus(t, c, container, "Terminated", "Node Stopped")
|
||||
|
||||
res = c.RunDockerCmd("rm", container)
|
||||
res = c.RunDocker("rm", container)
|
||||
res.Assert(t, icmd.Expected{Out: container})
|
||||
})
|
||||
}
|
||||
|
|
@ -415,11 +405,9 @@ func TestCompose(t *testing.T) {
|
|||
|
||||
t.Run("compose up", func(t *testing.T) {
|
||||
// Name of Compose project is taken from current folder "acie2e"
|
||||
res := c.RunDockerCmd("compose", "up", "-f", composeFile)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("compose", "up", "-f", composeFile)
|
||||
|
||||
res = c.RunDockerCmd("ps")
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("ps")
|
||||
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
|
||||
// Check three containers are running
|
||||
assert.Assert(t, is.Len(out, 4))
|
||||
|
|
@ -432,8 +420,7 @@ func TestCompose(t *testing.T) {
|
|||
}
|
||||
assert.Assert(t, webRunning, "web container not running")
|
||||
|
||||
res = c.RunDockerCmd("inspect", serverContainer)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("inspect", serverContainer)
|
||||
|
||||
containerInspect, err := ParseContainerInspect(res.Stdout())
|
||||
assert.NilError(t, err)
|
||||
|
|
@ -450,23 +437,20 @@ func TestCompose(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("logs web", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("logs", serverContainer)
|
||||
res := c.RunDocker("logs", serverContainer)
|
||||
res.Assert(t, icmd.Expected{Out: "Listening on port 80"})
|
||||
})
|
||||
|
||||
t.Run("update", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("compose", "up", "-f", composeFileMultiplePorts, "--project-name", composeProjectName)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("compose", "up", "-f", composeFileMultiplePorts, "--project-name", composeProjectName)
|
||||
|
||||
res = c.RunDockerCmd("ps")
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("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.RunDockerCmd("inspect", cName)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("inspect", cName)
|
||||
|
||||
containerInspect, err := ParseContainerInspect(res.Stdout())
|
||||
assert.NilError(t, err)
|
||||
|
|
@ -493,7 +477,7 @@ func TestCompose(t *testing.T) {
|
|||
}
|
||||
poll.WaitOn(t, checkUp, poll.WithDelay(1*time.Second), poll.WithTimeout(60*time.Second))
|
||||
|
||||
res = c.RunDockerCmd("ps")
|
||||
res = c.RunDocker("ps")
|
||||
p := containerInspect.Ports[0]
|
||||
res.Assert(t, icmd.Expected{
|
||||
Out: fmt.Sprintf("%s:%d->%d/tcp", p.HostIP, p.HostPort, p.ContainerPort),
|
||||
|
|
@ -502,11 +486,9 @@ func TestCompose(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("down", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("compose", "down", "--project-name", composeProjectName)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("compose", "down", "--project-name", composeProjectName)
|
||||
|
||||
res = c.RunDockerCmd("ps")
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("ps")
|
||||
out := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
|
||||
assert.Equal(t, len(out), 1)
|
||||
})
|
||||
|
|
@ -532,15 +514,14 @@ func TestRunEnvVars(t *testing.T) {
|
|||
container := strings.TrimSpace(out[len(out)-1])
|
||||
t.Logf("Container name: %q", container)
|
||||
|
||||
res = c.RunDockerCmd("inspect", container)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("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.RunDockerCmd("logs", container)
|
||||
res := c.RunDockerOrFail("logs", container)
|
||||
if strings.Contains(res.Stdout(), "Giving user user1 access to schema mytestdb") {
|
||||
return poll.Success()
|
||||
}
|
||||
|
|
@ -565,8 +546,7 @@ func setupTestResourceGroup(t *testing.T, c *E2eCLI, tName string) (string, stri
|
|||
})
|
||||
createAciContextAndUseIt(t, c, sID, rg)
|
||||
// Check nothing is running
|
||||
res := c.RunDockerCmd("ps")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("ps")
|
||||
assert.Assert(t, is.Len(strings.Split(strings.TrimSpace(res.Stdout()), "\n"), 1))
|
||||
return sID, rg
|
||||
}
|
||||
|
|
@ -593,8 +573,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")
|
||||
res := c.RunDockerCmd("login", "azure", "--client-id", clientID, "--client-secret", clientSecret, "--tenant-id", tenantID)
|
||||
res.Assert(t, icmd.Success)
|
||||
c.RunDocker("login", "azure", "--client-id", clientID, "--client-secret", clientSecret, "--tenant-id", tenantID)
|
||||
}
|
||||
|
||||
func getSubscriptionID(t *testing.T) string {
|
||||
|
|
@ -614,11 +593,10 @@ func createResourceGroup(sID, rgName string) error {
|
|||
|
||||
func createAciContextAndUseIt(t *testing.T, c *E2eCLI, sID, rgName string) {
|
||||
t.Log("Create ACI context")
|
||||
res := c.RunDockerCmd("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rgName, "--location", location)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDockerCmd("context", "use", contextName)
|
||||
res := c.RunDocker("context", "create", "aci", contextName, "--subscription-id", sID, "--resource-group", rgName, "--location", location)
|
||||
res = c.RunDocker("context", "use", contextName)
|
||||
res.Assert(t, icmd.Expected{Out: contextName})
|
||||
res = c.RunDockerCmd("context", "ls")
|
||||
res = c.RunDocker("context", "ls")
|
||||
res.Assert(t, icmd.Expected{Out: contextName + " *"})
|
||||
}
|
||||
|
||||
|
|
@ -669,7 +647,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.RunDockerCmd("inspect", containerID)
|
||||
res := c.RunDocker("inspect", containerID)
|
||||
containerInspect, err := ParseContainerInspect(res.Stdout())
|
||||
assert.NilError(t, err)
|
||||
for _, status := range statuses {
|
||||
|
|
|
|||
|
|
@ -49,9 +49,9 @@ func TestMain(m *testing.M) {
|
|||
|
||||
func TestComposeNotImplemented(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
res := c.RunDockerCmd("context", "show")
|
||||
res := c.RunDocker("context", "show")
|
||||
res.Assert(t, icmd.Expected{Out: "default"})
|
||||
res = c.RunDockerCmd("compose", "up")
|
||||
res = c.RunDockerOrFail("compose", "up")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: `Command "compose up" not available in current context (default)`,
|
||||
|
|
@ -62,67 +62,58 @@ func TestContextDefault(t *testing.T) {
|
|||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
t.Run("show", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "show")
|
||||
res := c.RunDocker("context", "show")
|
||||
res.Assert(t, icmd.Expected{Out: "default"})
|
||||
})
|
||||
|
||||
t.Run("ls", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "ls")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("context", "ls")
|
||||
golden.Assert(t, res.Stdout(), GoldenFile("ls-out-default"))
|
||||
})
|
||||
|
||||
t.Run("inspect", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "inspect", "default")
|
||||
res := c.RunDocker("context", "inspect", "default")
|
||||
res.Assert(t, icmd.Expected{Out: `"Name": "default"`})
|
||||
})
|
||||
|
||||
t.Run("inspect current", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "inspect")
|
||||
res := c.RunDocker("context", "inspect")
|
||||
res.Assert(t, icmd.Expected{Out: `"Name": "default"`})
|
||||
})
|
||||
}
|
||||
|
||||
func TestContextCreateDocker(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
res := c.RunDockerCmd("context", "create", "test-docker", "--from", "default")
|
||||
res := c.RunDocker("context", "create", "test-docker", "--from", "default")
|
||||
res.Assert(t, icmd.Expected{Out: "test-docker"})
|
||||
|
||||
t.Run("ls", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "ls")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("context", "ls")
|
||||
golden.Assert(t, res.Stdout(), GoldenFile("ls-out-test-docker"))
|
||||
})
|
||||
|
||||
t.Run("ls quiet", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "ls", "-q")
|
||||
res := c.RunDocker("context", "ls", "-q")
|
||||
golden.Assert(t, res.Stdout(), "ls-out-test-docker-quiet.golden")
|
||||
})
|
||||
|
||||
t.Run("ls format", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "ls", "--format", "{{ json . }}")
|
||||
res := c.RunDocker("context", "ls", "--format", "{{ json . }}")
|
||||
res.Assert(t, icmd.Expected{Out: `"Name":"default"`})
|
||||
})
|
||||
}
|
||||
|
||||
func TestContextInspect(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
res := c.RunDockerCmd("context", "create", "test-docker", "--from", "default")
|
||||
res := c.RunDocker("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.RunDockerCmd("context", "use", "test-docker")
|
||||
res := c.RunDocker("context", "use", "test-docker")
|
||||
res.Assert(t, icmd.Expected{Out: "test-docker"})
|
||||
|
||||
res = c.RunDockerCmd("context", "inspect")
|
||||
res = c.RunDocker("context", "inspect")
|
||||
res.Assert(t, icmd.Expected{Out: `"Name": "test-docker"`})
|
||||
})
|
||||
}
|
||||
|
|
@ -131,8 +122,7 @@ func TestContextHelpACI(t *testing.T) {
|
|||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
t.Run("help", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "create", "aci", "--help")
|
||||
res := c.RunDocker("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"})
|
||||
|
|
@ -141,8 +131,7 @@ func TestContextHelpACI(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("check exec", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "create", "aci", "--subscription-id", "invalid-id")
|
||||
res := c.RunDockerOrFail("context", "create", "aci", "--subscription-id", "invalid-id")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "accepts 1 arg(s), received 0",
|
||||
|
|
@ -154,8 +143,8 @@ func TestContextHelpACI(t *testing.T) {
|
|||
func TestContextDuplicateACI(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
c.RunDockerCmd("context", "create", "mycontext", "--from", "default").Assert(t, icmd.Success)
|
||||
res := c.RunDockerCmd("context", "create", "aci", "mycontext")
|
||||
c.RunDocker("context", "create", "mycontext", "--from", "default")
|
||||
res := c.RunDockerOrFail("context", "create", "aci", "mycontext")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "context mycontext: already exists",
|
||||
|
|
@ -167,10 +156,10 @@ func TestContextRemove(t *testing.T) {
|
|||
t.Run("remove current", func(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
c.RunDockerCmd("context", "create", "test-context-rm", "--from", "default").Assert(t, icmd.Success)
|
||||
res := c.RunDockerCmd("context", "use", "test-context-rm")
|
||||
c.RunDocker("context", "create", "test-context-rm", "--from", "default")
|
||||
res := c.RunDocker("context", "use", "test-context-rm")
|
||||
res.Assert(t, icmd.Expected{Out: "test-context-rm"})
|
||||
res = c.RunDockerCmd("context", "rm", "test-context-rm")
|
||||
res = c.RunDockerOrFail("context", "rm", "test-context-rm")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "cannot delete current context",
|
||||
|
|
@ -180,11 +169,11 @@ func TestContextRemove(t *testing.T) {
|
|||
t.Run("force remove current", func(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
c.RunDockerCmd("context", "create", "test-context-rmf").Assert(t, icmd.Success)
|
||||
c.RunDockerCmd("context", "use", "test-context-rmf").Assert(t, icmd.Success)
|
||||
res := c.RunDockerCmd("context", "rm", "-f", "test-context-rmf")
|
||||
c.RunDocker("context", "create", "test-context-rmf")
|
||||
c.RunDocker("context", "use", "test-context-rmf")
|
||||
res := c.RunDocker("context", "rm", "-f", "test-context-rmf")
|
||||
res.Assert(t, icmd.Expected{Out: "test-context-rmf"})
|
||||
res = c.RunDockerCmd("context", "ls")
|
||||
res = c.RunDocker("context", "ls")
|
||||
res.Assert(t, icmd.Expected{Out: "default *"})
|
||||
})
|
||||
}
|
||||
|
|
@ -195,8 +184,7 @@ func TestLoginCommandDelegation(t *testing.T) {
|
|||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
t.Run("default context", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("login", "-u", "nouser", "-p", "wrongpasword")
|
||||
res := c.RunDockerOrFail("login", "-u", "nouser", "-p", "wrongpasword")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "unauthorized: incorrect username or password",
|
||||
|
|
@ -204,8 +192,7 @@ func TestLoginCommandDelegation(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("interactive", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("login", "someregistry.docker.io")
|
||||
res := c.RunDockerOrFail("login", "someregistry.docker.io")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "Cannot perform an interactive login from a non TTY device",
|
||||
|
|
@ -213,16 +200,14 @@ func TestLoginCommandDelegation(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("logout", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("logout", "someregistry.docker.io")
|
||||
res := c.RunDocker("logout", "someregistry.docker.io")
|
||||
res.Assert(t, icmd.Expected{Out: "someregistry.docker.io"})
|
||||
})
|
||||
|
||||
t.Run("existing context", func(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
c.RunDockerCmd("context", "create", "local", "local").Assert(t, icmd.Success)
|
||||
c.RunDockerCmd("context", "use", "local").Assert(t, icmd.Success)
|
||||
res := c.RunDockerCmd("login", "-u", "nouser", "-p", "wrongpasword")
|
||||
c.RunDocker("context", "create", "local", "local")
|
||||
c.RunDocker("context", "use", "local")
|
||||
res := c.RunDockerOrFail("login", "-u", "nouser", "-p", "wrongpasword")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "unauthorized: incorrect username or password",
|
||||
|
|
@ -234,8 +219,7 @@ func TestCloudLogin(t *testing.T) {
|
|||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
t.Run("unknown backend", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("login", "mycloudbackend")
|
||||
res := c.RunDockerOrFail("login", "mycloudbackend")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "unknown backend type for cloud login: mycloudbackend",
|
||||
|
|
@ -282,14 +266,12 @@ func TestLegacy(t *testing.T) {
|
|||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
t.Run("help", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("--help")
|
||||
res := c.RunDocker("--help")
|
||||
res.Assert(t, icmd.Expected{Out: "swarm"})
|
||||
})
|
||||
|
||||
t.Run("swarm", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("swarm", "join")
|
||||
res := c.RunDockerOrFail("swarm", "join")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: `"docker swarm join" requires exactly 1 argument.`,
|
||||
|
|
@ -297,7 +279,6 @@ func TestLegacy(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("local run", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
cmd := c.NewDockerCmd("run", "--rm", "hello-world")
|
||||
cmd.Timeout = 40 * time.Second
|
||||
res := icmd.RunCmd(cmd)
|
||||
|
|
@ -305,8 +286,7 @@ func TestLegacy(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("error messages", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("foo")
|
||||
res := c.RunDockerOrFail("foo")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "docker: 'foo' is not a docker command.",
|
||||
|
|
@ -314,12 +294,11 @@ func TestLegacy(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("host flag", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
stderr := "Cannot connect to the Docker daemon at tcp://localhost:123"
|
||||
if runtime.GOOS == "windows" {
|
||||
stderr = "error during connect: Get http://localhost:123"
|
||||
}
|
||||
res := c.RunDockerCmd("-H", "tcp://localhost:123", "version")
|
||||
res := c.RunDockerOrFail("-H", "tcp://localhost:123", "version")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: stderr,
|
||||
|
|
@ -327,10 +306,9 @@ func TestLegacy(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("existing contexts delegate", func(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
c.RunDockerCmd("context", "create", "moby-ctx", "--from=default").Assert(t, icmd.Success)
|
||||
c.RunDockerCmd("context", "use", "moby-ctx").Assert(t, icmd.Success)
|
||||
res := c.RunDockerCmd("swarm", "join")
|
||||
c.RunDocker("context", "create", "moby-ctx", "--from=default")
|
||||
c.RunDocker("context", "use", "moby-ctx")
|
||||
res := c.RunDockerOrFail("swarm", "join")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: `"docker swarm join" requires exactly 1 argument.`,
|
||||
|
|
@ -338,15 +316,13 @@ func TestLegacy(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("host flag overrides context", func(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
c.RunDockerCmd("context", "create", "example", "test-example").Assert(t, icmd.Success)
|
||||
c.RunDockerCmd("context", "use", "test-example").Assert(t, icmd.Success)
|
||||
c.RunDocker("context", "create", "example", "test-example")
|
||||
c.RunDocker("context", "use", "test-example")
|
||||
endpoint := "unix:///var/run/docker.sock"
|
||||
if runtime.GOOS == "windows" {
|
||||
endpoint = "npipe:////./pipe/docker_engine"
|
||||
}
|
||||
res := c.RunDockerCmd("-H", endpoint, "ps")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("-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"))
|
||||
|
|
@ -357,8 +333,7 @@ func TestLegacyLogin(t *testing.T) {
|
|||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
t.Run("host flag login", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("-H", "tcp://localhost:123", "login", "-u", "nouser", "-p", "wrongpasword")
|
||||
res := c.RunDockerOrFail("-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.",
|
||||
|
|
@ -366,8 +341,7 @@ func TestLegacyLogin(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("log level flag login", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("--log-level", "debug", "login", "-u", "nouser", "-p", "wrongpasword")
|
||||
res := c.RunDockerOrFail("--log-level", "debug", "login", "-u", "nouser", "-p", "wrongpasword")
|
||||
res.Assert(t, icmd.Expected{
|
||||
ExitCode: 1,
|
||||
Err: "WARNING! Using --password via the CLI is insecure",
|
||||
|
|
@ -375,9 +349,7 @@ func TestLegacyLogin(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("login help global flags", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("login", "--help")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("login", "--help")
|
||||
assert.Assert(t, !strings.Contains(res.Combined(), "--log-level"))
|
||||
})
|
||||
}
|
||||
|
|
@ -385,9 +357,8 @@ func TestLegacyLogin(t *testing.T) {
|
|||
func TestUnsupportedCommand(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
res := c.RunDockerCmd("context", "create", "example", "test-example")
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDockerCmd("--context", "test-example", "images")
|
||||
res := c.RunDocker("context", "create", "example", "test-example")
|
||||
res = c.RunDockerOrFail("--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`,
|
||||
|
|
@ -398,73 +369,60 @@ func TestVersion(t *testing.T) {
|
|||
c := NewParallelE2eCLI(t, binDir)
|
||||
|
||||
t.Run("azure version", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("version")
|
||||
res := c.RunDocker("version")
|
||||
res.Assert(t, icmd.Expected{Out: "Azure integration"})
|
||||
})
|
||||
|
||||
t.Run("format", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("version", "-f", "{{ json . }}")
|
||||
res := c.RunDocker("version", "-f", "{{ json . }}")
|
||||
res.Assert(t, icmd.Expected{Out: `"Client":`})
|
||||
res = c.RunDockerCmd("version", "--format", "{{ json . }}")
|
||||
res = c.RunDocker("version", "--format", "{{ json . }}")
|
||||
res.Assert(t, icmd.Expected{Out: `"Client":`})
|
||||
})
|
||||
|
||||
t.Run("delegate version flag", func(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
c.RunDockerCmd("context", "create", "example", "test-example").Assert(t, icmd.Success)
|
||||
c.RunDockerCmd("context", "use", "test-example").Assert(t, icmd.Success)
|
||||
res := c.RunDockerCmd("-v")
|
||||
c.RunDocker("context", "create", "example", "test-example")
|
||||
c.RunDocker("context", "use", "test-example")
|
||||
res := c.RunDocker("-v")
|
||||
res.Assert(t, icmd.Expected{Out: "Docker version"})
|
||||
})
|
||||
}
|
||||
|
||||
func TestMockBackend(t *testing.T) {
|
||||
c := NewParallelE2eCLI(t, binDir)
|
||||
c.RunDockerCmd("context", "create", "example", "test-example").Assert(t, icmd.Success)
|
||||
res := c.RunDockerCmd("context", "use", "test-example")
|
||||
c.RunDocker("context", "create", "example", "test-example")
|
||||
res := c.RunDocker("context", "use", "test-example")
|
||||
res.Assert(t, icmd.Expected{Out: "test-example"})
|
||||
|
||||
t.Run("use", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("context", "show")
|
||||
res := c.RunDocker("context", "show")
|
||||
res.Assert(t, icmd.Expected{Out: "test-example"})
|
||||
res = c.RunDockerCmd("context", "ls")
|
||||
res = c.RunDocker("context", "ls")
|
||||
golden.Assert(t, res.Stdout(), GoldenFile("ls-out-test-example"))
|
||||
})
|
||||
|
||||
t.Run("ps", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("ps")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("ps")
|
||||
golden.Assert(t, res.Stdout(), "ps-out-example.golden")
|
||||
})
|
||||
|
||||
t.Run("ps quiet", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("ps", "-q")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("ps", "-q")
|
||||
golden.Assert(t, res.Stdout(), "ps-quiet-out-example.golden")
|
||||
})
|
||||
|
||||
t.Run("ps quiet all", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("ps", "-q", "--all")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("ps", "-q", "--all")
|
||||
golden.Assert(t, res.Stdout(), "ps-quiet-all-out-example.golden")
|
||||
})
|
||||
|
||||
t.Run("inspect", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("inspect", "id")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("inspect", "id")
|
||||
golden.Assert(t, res.Stdout(), "inspect-id.golden")
|
||||
})
|
||||
|
||||
t.Run("run", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
res := c.RunDockerCmd("run", "-d", "nginx", "-p", "80:80")
|
||||
res := c.RunDocker("run", "-d", "nginx", "-p", "80:80")
|
||||
res.Assert(t, icmd.Expected{
|
||||
Out: `Running container "nginx" with name`,
|
||||
})
|
||||
|
|
|
|||
|
|
@ -49,35 +49,30 @@ func TestMain(m *testing.M) {
|
|||
}
|
||||
|
||||
func TestSecrets(t *testing.T) {
|
||||
c, testID := setupTest(t)
|
||||
cmd, testID := setupTest(t)
|
||||
secretName := "secret" + testID
|
||||
description := "description " + testID
|
||||
|
||||
t.Run("create secret", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("secret", "create", secretName, "-u", "user1", "-p", "pass1", "-d", description)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := cmd.RunDocker("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 := c.RunDockerCmd("secret", "list")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := cmd.RunDocker("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 := c.RunDockerCmd("secret", "inspect", secretName)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := cmd.RunDocker("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) {
|
||||
res := c.RunDockerCmd("secret", "rm", secretName)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDockerCmd("secret", "list")
|
||||
res.Assert(t, icmd.Success)
|
||||
res := cmd.RunDocker("secret", "rm", secretName)
|
||||
res = cmd.RunDocker("secret", "list")
|
||||
assert.Check(t, !strings.Contains(res.Stdout(), secretName))
|
||||
})
|
||||
}
|
||||
|
|
@ -86,14 +81,12 @@ func TestCompose(t *testing.T) {
|
|||
c, stack := setupTest(t)
|
||||
|
||||
t.Run("compose up", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("compose", "up", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
|
||||
res.Assert(t, icmd.Success)
|
||||
c.RunDocker("compose", "up", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
|
||||
})
|
||||
|
||||
var url string
|
||||
t.Run("compose ps", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("compose", "ps", "--project-name", stack)
|
||||
res.Assert(t, icmd.Success)
|
||||
res := c.RunDocker("compose", "ps", "--project-name", stack)
|
||||
lines := strings.Split(res.Stdout(), "\n")
|
||||
|
||||
assert.Equal(t, 3, len(lines))
|
||||
|
|
@ -124,8 +117,7 @@ func TestCompose(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("compose down", func(t *testing.T) {
|
||||
res := c.RunDockerCmd("compose", "down", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
|
||||
res.Assert(t, icmd.Success)
|
||||
c.RunDocker("compose", "down", "--project-name", stack, "-f", "../composefiles/nginx.yaml")
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -140,8 +132,7 @@ func setupTest(t *testing.T) (*E2eCLI, string) {
|
|||
if localTestProfile != "" {
|
||||
region := os.Getenv("TEST_AWS_REGION")
|
||||
assert.Check(t, region != "")
|
||||
res = c.RunDockerCmd("context", "create", "ecs", contextName, "--profile", localTestProfile, "--region", region)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("context", "create", "ecs", contextName, "--profile", localTestProfile, "--region", region)
|
||||
} else {
|
||||
profile := contextName
|
||||
region := os.Getenv("AWS_DEFAULT_REGION")
|
||||
|
|
@ -150,12 +141,11 @@ func setupTest(t *testing.T) (*E2eCLI, string) {
|
|||
assert.Check(t, keyID != "")
|
||||
assert.Check(t, secretKey != "")
|
||||
assert.Check(t, region != "")
|
||||
res = c.RunDockerCmd("context", "create", "ecs", contextName, "--profile", profile, "--region", region, "--secret-key", secretKey, "--key-id", keyID)
|
||||
res.Assert(t, icmd.Success)
|
||||
res = c.RunDocker("context", "create", "ecs", contextName, "--profile", profile, "--region", region, "--secret-key", secretKey, "--key-id", keyID)
|
||||
}
|
||||
res = c.RunDockerCmd("context", "use", contextName)
|
||||
res = c.RunDocker("context", "use", contextName)
|
||||
res.Assert(t, icmd.Expected{Out: contextName})
|
||||
res = c.RunDockerCmd("context", "ls")
|
||||
res = c.RunDocker("context", "ls")
|
||||
res.Assert(t, icmd.Expected{Out: contextName + " *"})
|
||||
})
|
||||
return c, stack
|
||||
|
|
|
|||
|
|
@ -51,6 +51,7 @@ func init() {
|
|||
type E2eCLI struct {
|
||||
BinDir string
|
||||
ConfigDir string
|
||||
test *testing.T
|
||||
}
|
||||
|
||||
// NewParallelE2eCLI returns a configured TestE2eCLI with t.Parallel() set
|
||||
|
|
@ -80,7 +81,7 @@ func newE2eCLI(t *testing.T, binDir string) *E2eCLI {
|
|||
_ = os.RemoveAll(d)
|
||||
})
|
||||
|
||||
return &E2eCLI{binDir, d}
|
||||
return &E2eCLI{binDir, d, t}
|
||||
}
|
||||
|
||||
func dirContents(dir string) []string {
|
||||
|
|
@ -158,11 +159,18 @@ func (c *E2eCLI) NewDockerCmd(args ...string) icmd.Cmd {
|
|||
return c.NewCmd(filepath.Join(c.BinDir, DockerExecutableName), args...)
|
||||
}
|
||||
|
||||
// RunDockerCmd runs a docker command and returns a result
|
||||
func (c *E2eCLI) RunDockerCmd(args ...string) *icmd.Result {
|
||||
// RunDockerOrFail runs a docker command and returns a result
|
||||
func (c *E2eCLI) RunDockerOrFail(args ...string) *icmd.Result {
|
||||
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...)
|
||||
res.Assert(c.test, icmd.Success)
|
||||
return res
|
||||
}
|
||||
|
||||
// GoldenFile golden file specific to platform
|
||||
func GoldenFile(name string) string {
|
||||
if runtime.GOOS == "windows" {
|
||||
|
|
|
|||
Loading…
Reference in New Issue