kotovalexarian-likes-github
/
moby--moby
mirror of https://github.com/moby/moby.git
1
0
Fork 0
Code Releases Activity

integration: change container.Run signature to fix linting 

Line 59: warning: context.Context should be the first parameter of a function (golint)

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn 2019-06-06 13:15:31 +02:00
parent b4c46b0dac
commit 9f9b4290b9
No known key found for this signature in database
GPG Key ID: 76698F39D527CE8C
35 changed files with 108 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
integration/build/build_squash_test.go
View File

@ -79,7 +79,7 @@ func TestBuildSquashParent(t *testing.T) {
resp.Body.Close() resp.Body.Close()
assert.NilError(t, err) assert.NilError(t, err)
cid := container.Run(t, ctx, client, cid := container.Run(ctx, t, client,
container.WithImage(name), container.WithImage(name),
container.WithCmd("/bin/sh", "-c", "cat /hello"), container.WithCmd("/bin/sh", "-c", "cat /hello"),
) )
@ -94,11 +94,11 @@ func TestBuildSquashParent(t *testing.T) {
assert.NilError(t, err) assert.NilError(t, err)
assert.Check(t, is.Equal(strings.TrimSpace(actualStdout.String()), "hello\nworld")) assert.Check(t, is.Equal(strings.TrimSpace(actualStdout.String()), "hello\nworld"))
container.Run(t, ctx, client, container.Run(ctx, t, client,
container.WithImage(name), container.WithImage(name),
container.WithCmd("/bin/sh", "-c", "[ ! -f /remove_me ]"), container.WithCmd("/bin/sh", "-c", "[ ! -f /remove_me ]"),
) )
container.Run(t, ctx, client, container.Run(ctx, t, client,
container.WithImage(name), container.WithImage(name),
container.WithCmd("/bin/sh", "-c", `[ "$(echo $HELLO)" == "world" ]`), container.WithCmd("/bin/sh", "-c", `[ "$(echo $HELLO)" == "world" ]`),
) )

2
integration/container/checkpoint_test.go
View File

@ -50,7 +50,7 @@ func TestCheckpoint(t *testing.T) {
} }
t.Log("Start a container") t.Log("Start a container")
cID := container.Run(t, ctx, client, container.WithMount(mnt)) cID := container.Run(ctx, t, client, container.WithMount(mnt))
poll.WaitOn(t, poll.WaitOn(t,
container.IsInState(ctx, client, cID, "running"), container.IsInState(ctx, client, cID, "running"),
poll.WithDelay(100*time.Millisecond), poll.WithDelay(100*time.Millisecond),

4
integration/container/daemon_linux_test.go
View File

@ -94,7 +94,7 @@ func TestDaemonRestartIpcMode(t *testing.T) {
ctx := context.Background() ctx := context.Background()
// check the container is created with private ipc mode as per daemon default // check the container is created with private ipc mode as per daemon default
cID := container.Run(t, ctx, c, cID := container.Run(ctx, t, c,
container.WithCmd("top"), container.WithCmd("top"),
container.WithRestartPolicy("always"), container.WithRestartPolicy("always"),
) )
@ -113,7 +113,7 @@ func TestDaemonRestartIpcMode(t *testing.T) {
assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "private")) assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "private"))
// check a new container is created with shareable ipc mode as per new daemon default // check a new container is created with shareable ipc mode as per new daemon default
cID = container.Run(t, ctx, c) cID = container.Run(ctx, t, c)
defer c.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true}) defer c.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})
inspect, err = c.ContainerInspect(ctx, cID) inspect, err = c.ContainerInspect(ctx, cID)

2
integration/container/diff_test.go
View File

@ -19,7 +19,7 @@ func TestDiff(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithCmd("sh", "-c", `mkdir /foo; echo xyzzy > /foo/bar`)) cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", `mkdir /foo; echo xyzzy > /foo/bar`))
// Wait for it to exit as cannot diff a running container on Windows, and // Wait for it to exit as cannot diff a running container on Windows, and
// it will take a few seconds to exit. Also there's no way in Windows to // it will take a few seconds to exit. Also there's no way in Windows to

6
integration/container/exec_test.go
View File

@ -24,7 +24,7 @@ func TestExecWithCloseStdin(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
// run top with detached mode // run top with detached mode
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
expected := "closeIO" expected := "closeIO"
execResp, err := client.ContainerExecCreate(ctx, cID, execResp, err := client.ContainerExecCreate(ctx, cID,
@ -90,7 +90,7 @@ func TestExec(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client, container.WithTty(true), container.WithWorkingDir("/root")) cID := container.Run(ctx, t, client, container.WithTty(true), container.WithWorkingDir("/root"))
id, err := client.ContainerExecCreate(ctx, cID, id, err := client.ContainerExecCreate(ctx, cID,
types.ExecConfig{ types.ExecConfig{
@ -125,7 +125,7 @@ func TestExecUser(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client, container.WithTty(true), container.WithUser("1:1")) cID := container.Run(ctx, t, client, container.WithTty(true), container.WithUser("1:1"))
result, err := container.Exec(ctx, client, cID, []string{"id"}) result, err := container.Exec(ctx, client, cID, []string{"id"})
assert.NilError(t, err) assert.NilError(t, err)

2
integration/container/export_test.go
View File

@ -25,7 +25,7 @@ func TestExportContainerAndImportImage(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithCmd("true")) cID := container.Run(ctx, t, client, container.WithCmd("true"))
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
reference := "repo/testexp:v1" reference := "repo/testexp:v1"

2
integration/container/health_test.go
View File

@ -21,7 +21,7 @@ func TestHealthCheckWorkdir(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client, container.WithTty(true), container.WithWorkingDir("/foo"), func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, container.WithTty(true), container.WithWorkingDir("/foo"), func(c *container.TestContainerConfig) {
c.Config.Healthcheck = &containertypes.HealthConfig{ c.Config.Healthcheck = &containertypes.HealthConfig{
Test: []string{"CMD-SHELL", "if [ \"$PWD\" = \"/foo\" ]; then exit 0; else exit 1; fi;"}, Test: []string{"CMD-SHELL", "if [ \"$PWD\" = \"/foo\" ]; then exit 0; else exit 1; fi;"},
Interval: 50 * time.Millisecond, Interval: 50 * time.Millisecond,

2
integration/container/inspect_test.go
View File

@ -24,7 +24,7 @@ func TestInspectCpusetInConfigPre120(t *testing.T) {
name := "cpusetinconfig-pre120-" + t.Name() name := "cpusetinconfig-pre120-" + t.Name()
// Create container with up to-date-API // Create container with up to-date-API
container.Run(t, ctx, request.NewAPIClient(t), container.WithName(name), container.Run(ctx, t, request.NewAPIClient(t), container.WithName(name),
container.WithCmd("true"), container.WithCmd("true"),
func(c *container.TestContainerConfig) { func(c *container.TestContainerConfig) {
c.HostConfig.Resources.CpusetCpus = "0" c.HostConfig.Resources.CpusetCpus = "0"

12
integration/container/kill_test.go
View File

@ -18,7 +18,7 @@ func TestKillContainerInvalidSignal(t *testing.T) {
defer setupTest(t)() defer setupTest(t)()
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
id := container.Run(t, ctx, client) id := container.Run(ctx, t, client)
err := client.ContainerKill(ctx, id, "0") err := client.ContainerKill(ctx, id, "0")
assert.Error(t, err, "Error response from daemon: Invalid signal: 0") assert.Error(t, err, "Error response from daemon: Invalid signal: 0")
@ -60,7 +60,7 @@ func TestKillContainer(t *testing.T) {
tc := tc tc := tc
t.Run(tc.doc, func(t *testing.T) { t.Run(tc.doc, func(t *testing.T) {
ctx := context.Background() ctx := context.Background()
id := container.Run(t, ctx, client) id := container.Run(ctx, t, client)
err := client.ContainerKill(ctx, id, tc.signal) err := client.ContainerKill(ctx, id, tc.signal)
assert.NilError(t, err) assert.NilError(t, err)
@ -95,7 +95,7 @@ func TestKillWithStopSignalAndRestartPolicies(t *testing.T) {
tc := tc tc := tc
t.Run(tc.doc, func(t *testing.T) { t.Run(tc.doc, func(t *testing.T) {
ctx := context.Background() ctx := context.Background()
id := container.Run(t, ctx, client, id := container.Run(ctx, t, client,
container.WithRestartPolicy("always"), container.WithRestartPolicy("always"),
func(c *container.TestContainerConfig) { func(c *container.TestContainerConfig) {
c.Config.StopSignal = tc.stopsignal c.Config.StopSignal = tc.stopsignal
@ -137,7 +137,7 @@ func TestKillDifferentUserContainer(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := request.NewAPIClient(t, client.WithVersion("1.19")) client := request.NewAPIClient(t, client.WithVersion("1.19"))
id := container.Run(t, ctx, client, func(c *container.TestContainerConfig) { id := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
c.Config.User = "daemon" c.Config.User = "daemon"
}) })
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
@ -154,7 +154,7 @@ func TestInspectOomKilledTrue(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client, container.WithCmd("sh", "-c", "x=a; while true; do x=$x$x$x$x; done"), func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", "x=a; while true; do x=$x$x$x$x; done"), func(c *container.TestContainerConfig) {
c.HostConfig.Resources.Memory = 32 * 1024 * 1024 c.HostConfig.Resources.Memory = 32 * 1024 * 1024
}) })
@ -172,7 +172,7 @@ func TestInspectOomKilledFalse(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client, container.WithCmd("sh", "-c", "echo hello world")) cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", "echo hello world"))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))

6
integration/container/links_linux_test.go
View File

@ -24,7 +24,7 @@ func TestLinksEtcHostsContentMatch(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithNetworkMode("host")) cID := container.Run(ctx, t, client, container.WithNetworkMode("host"))
res, err := container.Exec(ctx, client, cID, []string{"cat", "/etc/hosts"}) res, err := container.Exec(ctx, client, cID, []string{"cat", "/etc/hosts"})
assert.NilError(t, err) assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0)) assert.Assert(t, is.Len(res.Stderr(), 0))
@ -42,8 +42,8 @@ func TestLinksContainerNames(t *testing.T) {
containerA := "first_" + t.Name() containerA := "first_" + t.Name()
containerB := "second_" + t.Name() containerB := "second_" + t.Name()
container.Run(t, ctx, client, container.WithName(containerA)) container.Run(ctx, t, client, container.WithName(containerA))
container.Run(t, ctx, client, container.WithName(containerB), container.WithLinks(containerA+":"+containerA)) container.Run(ctx, t, client, container.WithName(containerB), container.WithLinks(containerA+":"+containerA))
f := filters.NewArgs(filters.Arg("name", containerA)) f := filters.NewArgs(filters.Arg("name", containerA))

2
integration/container/logs_test.go
View File

@ -21,7 +21,7 @@ func TestLogsFollowTailEmpty(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
id := container.Run(t, ctx, client, container.WithCmd("sleep", "100000")) id := container.Run(ctx, t, client, container.WithCmd("sleep", "100000"))
logs, err := client.ContainerLogs(ctx, id, types.ContainerLogsOptions{ShowStdout: true, Tail: "2"}) logs, err := client.ContainerLogs(ctx, id, types.ContainerLogsOptions{ShowStdout: true, Tail: "2"})
if logs != nil { if logs != nil {

6
integration/container/mounts_linux_test.go
View File

@ -256,9 +256,9 @@ func TestContainerBindMountNonRecursive(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
containers := []string{ containers := []string{
container.Run(t, ctx, client, container.WithMount(implicit), container.WithCmd(recursiveVerifier...)), container.Run(ctx, t, client, container.WithMount(implicit), container.WithCmd(recursiveVerifier...)),
container.Run(t, ctx, client, container.WithMount(recursive), container.WithCmd(recursiveVerifier...)), container.Run(ctx, t, client, container.WithMount(recursive), container.WithCmd(recursiveVerifier...)),
container.Run(t, ctx, client, container.WithMount(nonRecursive), container.WithCmd(nonRecursiveVerifier...)), container.Run(ctx, t, client, container.WithMount(nonRecursive), container.WithCmd(nonRecursiveVerifier...)),
} }
for _, c := range containers { for _, c := range containers {

4
integration/container/nat_test.go
View File

@ -71,7 +71,7 @@ func TestNetworkLoopbackNat(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithCmd("sh", "-c", fmt.Sprintf("stty raw && nc -w 5 %s 8080", endpoint.String())), container.WithTty(true), container.WithNetworkMode("container:"+serverContainerID)) cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", fmt.Sprintf("stty raw && nc -w 5 %s 8080", endpoint.String())), container.WithTty(true), container.WithNetworkMode("container:"+serverContainerID))
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
@ -93,7 +93,7 @@ func startServerContainer(t *testing.T, msg string, port int) string {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithName("server-"+t.Name()), container.WithCmd("sh", "-c", fmt.Sprintf("echo %q | nc -lp %d", msg, port)), container.WithExposedPorts(fmt.Sprintf("%d/tcp", port)), func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, container.WithName("server-"+t.Name()), container.WithCmd("sh", "-c", fmt.Sprintf("echo %q | nc -lp %d", msg, port)), container.WithExposedPorts(fmt.Sprintf("%d/tcp", port)), func(c *container.TestContainerConfig) {
c.HostConfig.PortBindings = nat.PortMap{ c.HostConfig.PortBindings = nat.PortMap{
nat.Port(fmt.Sprintf("%d/tcp", port)): []nat.PortBinding{ nat.Port(fmt.Sprintf("%d/tcp", port)): []nat.PortBinding{
{ {

6
integration/container/pause_test.go
View File

@ -25,7 +25,7 @@ func TestPause(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
since := request.DaemonUnixTime(ctx, t, client, testEnv) since := request.DaemonUnixTime(ctx, t, client, testEnv)
@ -57,7 +57,7 @@ func TestPauseFailsOnWindowsServerContainers(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerPause(ctx, cID) err := client.ContainerPause(ctx, cID)
@ -71,7 +71,7 @@ func TestPauseStopPausedContainer(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerPause(ctx, cID) err := client.ContainerPause(ctx, cID)

8
integration/container/remove_test.go
View File

@ -36,7 +36,7 @@ func TestRemoveContainerWithRemovedVolume(t *testing.T) {
tempDir := fs.NewDir(t, "test-rm-container-with-removed-volume", fs.WithMode(0755)) tempDir := fs.NewDir(t, "test-rm-container-with-removed-volume", fs.WithMode(0755))
defer tempDir.Remove() defer tempDir.Remove()
cID := container.Run(t, ctx, client, container.WithCmd("true"), container.WithBind(tempDir.Path(), prefix+slash+"test")) cID := container.Run(ctx, t, client, container.WithCmd("true"), container.WithBind(tempDir.Path(), prefix+slash+"test"))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
err := os.RemoveAll(tempDir.Path()) err := os.RemoveAll(tempDir.Path())
@ -59,7 +59,7 @@ func TestRemoveContainerWithVolume(t *testing.T) {
prefix, slash := getPrefixAndSlashFromDaemonPlatform() prefix, slash := getPrefixAndSlashFromDaemonPlatform()
cID := container.Run(t, ctx, client, container.WithCmd("true"), container.WithVolume(prefix+slash+"srv")) cID := container.Run(ctx, t, client, container.WithCmd("true"), container.WithVolume(prefix+slash+"srv"))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
insp, _, err := client.ContainerInspectWithRaw(ctx, cID, true) insp, _, err := client.ContainerInspectWithRaw(ctx, cID, true)
@ -82,7 +82,7 @@ func TestRemoveContainerRunning(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
err := client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{}) err := client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{})
assert.Check(t, is.ErrorContains(err, "cannot remove a running container")) assert.Check(t, is.ErrorContains(err, "cannot remove a running container"))
@ -93,7 +93,7 @@ func TestRemoveContainerForceRemoveRunning(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
err := client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{ err := client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
Force: true, Force: true,

26
integration/container/rename_test.go
View File

@ -30,18 +30,18 @@ func TestRenameLinkedContainer(t *testing.T) {
aName := "a0" + t.Name() aName := "a0" + t.Name()
bName := "b0" + t.Name() bName := "b0" + t.Name()
aID := container.Run(t, ctx, client, container.WithName(aName)) aID := container.Run(ctx, t, client, container.WithName(aName))
bID := container.Run(t, ctx, client, container.WithName(bName), container.WithLinks(aName)) bID := container.Run(ctx, t, client, container.WithName(bName), container.WithLinks(aName))
err := client.ContainerRename(ctx, aID, "a1"+t.Name()) err := client.ContainerRename(ctx, aID, "a1"+t.Name())
assert.NilError(t, err) assert.NilError(t, err)
container.Run(t, ctx, client, container.WithName(aName)) container.Run(ctx, t, client, container.WithName(aName))
err = client.ContainerRemove(ctx, bID, types.ContainerRemoveOptions{Force: true}) err = client.ContainerRemove(ctx, bID, types.ContainerRemoveOptions{Force: true})
assert.NilError(t, err) assert.NilError(t, err)
bID = container.Run(t, ctx, client, container.WithName(bName), container.WithLinks(aName)) bID = container.Run(ctx, t, client, container.WithName(bName), container.WithLinks(aName))
inspect, err := client.ContainerInspect(ctx, bID) inspect, err := client.ContainerInspect(ctx, bID)
assert.NilError(t, err) assert.NilError(t, err)
@ -54,7 +54,7 @@ func TestRenameStoppedContainer(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
oldName := "first_name" + t.Name() oldName := "first_name" + t.Name()
cID := container.Run(t, ctx, client, container.WithName(oldName), container.WithCmd("sh")) cID := container.Run(ctx, t, client, container.WithName(oldName), container.WithCmd("sh"))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID) inspect, err := client.ContainerInspect(ctx, cID)
@ -76,7 +76,7 @@ func TestRenameRunningContainerAndReuse(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
oldName := "first_name" + t.Name() oldName := "first_name" + t.Name()
cID := container.Run(t, ctx, client, container.WithName(oldName)) cID := container.Run(ctx, t, client, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
newName := "new_name" + stringid.GenerateNonCryptoID() newName := "new_name" + stringid.GenerateNonCryptoID()
@ -90,7 +90,7 @@ func TestRenameRunningContainerAndReuse(t *testing.T) {
_, err = client.ContainerInspect(ctx, oldName) _, err = client.ContainerInspect(ctx, oldName)
assert.Check(t, is.ErrorContains(err, "No such container: "+oldName)) assert.Check(t, is.ErrorContains(err, "No such container: "+oldName))
cID = container.Run(t, ctx, client, container.WithName(oldName)) cID = container.Run(ctx, t, client, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
inspect, err = client.ContainerInspect(ctx, cID) inspect, err = client.ContainerInspect(ctx, cID)
@ -104,7 +104,7 @@ func TestRenameInvalidName(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
oldName := "first_name" + t.Name() oldName := "first_name" + t.Name()
cID := container.Run(t, ctx, client, container.WithName(oldName)) cID := container.Run(ctx, t, client, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerRename(ctx, oldName, "new:invalid") err := client.ContainerRename(ctx, oldName, "new:invalid")
@ -132,7 +132,7 @@ func TestRenameAnonymousContainer(t *testing.T) {
_, err := client.NetworkCreate(ctx, networkName, types.NetworkCreate{}) _, err := client.NetworkCreate(ctx, networkName, types.NetworkCreate{})
assert.NilError(t, err) assert.NilError(t, err)
cID := container.Run(t, ctx, client, func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
c.NetworkingConfig.EndpointsConfig = map[string]*network.EndpointSettings{ c.NetworkingConfig.EndpointsConfig = map[string]*network.EndpointSettings{
networkName: {}, networkName: {},
} }
@ -155,7 +155,7 @@ func TestRenameAnonymousContainer(t *testing.T) {
if testEnv.OSType == "windows" { if testEnv.OSType == "windows" {
count = "-n" count = "-n"
} }
cID = container.Run(t, ctx, client, func(c *container.TestContainerConfig) { cID = container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
c.NetworkingConfig.EndpointsConfig = map[string]*network.EndpointSettings{ c.NetworkingConfig.EndpointsConfig = map[string]*network.EndpointSettings{
networkName: {}, networkName: {},
} }
@ -175,7 +175,7 @@ func TestRenameContainerWithSameName(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
oldName := "old" + t.Name() oldName := "old" + t.Name()
cID := container.Run(t, ctx, client, container.WithName(oldName)) cID := container.Run(ctx, t, client, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerRename(ctx, oldName, oldName) err := client.ContainerRename(ctx, oldName, oldName)
@ -198,12 +198,12 @@ func TestRenameContainerWithLinkedContainer(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
db1Name := "db1" + t.Name() db1Name := "db1" + t.Name()
db1ID := container.Run(t, ctx, client, container.WithName(db1Name)) db1ID := container.Run(ctx, t, client, container.WithName(db1Name))
poll.WaitOn(t, container.IsInState(ctx, client, db1ID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, db1ID, "running"), poll.WithDelay(100*time.Millisecond))
app1Name := "app1" + t.Name() app1Name := "app1" + t.Name()
app2Name := "app2" + t.Name() app2Name := "app2" + t.Name()
app1ID := container.Run(t, ctx, client, container.WithName(app1Name), container.WithLinks(db1Name+":/mysql")) app1ID := container.Run(ctx, t, client, container.WithName(app1Name), container.WithLinks(db1Name+":/mysql"))
poll.WaitOn(t, container.IsInState(ctx, client, app1ID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, app1ID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerRename(ctx, app1Name, app2Name) err := client.ContainerRename(ctx, app1Name, app2Name)

6
integration/container/resize_test.go
View File

@ -22,7 +22,7 @@ func TestResize(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
@ -40,7 +40,7 @@ func TestResizeWithInvalidSize(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
@ -55,7 +55,7 @@ func TestResizeWhenContainerNotStarted(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithCmd("echo")) cID := container.Run(ctx, t, client, container.WithCmd("echo"))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))

4
integration/container/run_cgroupns_linux_test.go
View File

@ -34,7 +34,7 @@ func testRunWithCgroupNs(t *testing.T, daemonNsMode string, containerOpts ...fun
d.StartWithBusybox(t) d.StartWithBusybox(t)
defer d.Stop(t) defer d.Stop(t)
cID := container.Run(t, ctx, client, containerOpts...) cID := container.Run(ctx, t, client, containerOpts...)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
daemonCgroup := d.CgroupNamespace(t) daemonCgroup := d.CgroupNamespace(t)
@ -143,7 +143,7 @@ func TestCgroupNamespacesRunOlderClient(t *testing.T) {
d.StartWithBusybox(t) d.StartWithBusybox(t)
defer d.Stop(t) defer d.Stop(t)
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
daemonCgroup := d.CgroupNamespace(t) daemonCgroup := d.CgroupNamespace(t)

6
integration/container/run_linux_test.go
View File

@ -30,7 +30,7 @@ func TestKernelTCPMemory(t *testing.T) {
kernelMemoryTCP int64 = 200 * 1024 * 1024 kernelMemoryTCP int64 = 200 * 1024 * 1024
) )
cID := container.Run(t, ctx, client, func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
c.HostConfig.Resources = containertypes.Resources{ c.HostConfig.Resources = containertypes.Resources{
KernelMemoryTCP: kernelMemoryTCP, KernelMemoryTCP: kernelMemoryTCP,
} }
@ -66,7 +66,7 @@ func TestNISDomainname(t *testing.T) {
domainname = "baz.cyphar.com" domainname = "baz.cyphar.com"
) )
cID := container.Run(t, ctx, client, func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
c.Config.Hostname = hostname c.Config.Hostname = hostname
c.Config.Domainname = domainname c.Config.Domainname = domainname
}) })
@ -110,7 +110,7 @@ func TestHostnameDnsResolution(t *testing.T) {
netName := "foobar-net" netName := "foobar-net"
net.CreateNoError(context.Background(), t, client, netName, net.WithDriver("bridge")) net.CreateNoError(context.Background(), t, client, netName, net.WithDriver("bridge"))
cID := container.Run(t, ctx, client, func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
c.Config.Hostname = hostname c.Config.Hostname = hostname
c.HostConfig.NetworkMode = containertypes.NetworkMode(netName) c.HostConfig.NetworkMode = containertypes.NetworkMode(netName)
}) })

2
integration/container/stats_test.go
View File

@ -25,7 +25,7 @@ func TestStats(t *testing.T) {
info, err := client.Info(ctx) info, err := client.Info(ctx)
assert.NilError(t, err) assert.NilError(t, err)
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))

4
integration/container/stop_linux_test.go
View File

@ -54,7 +54,7 @@ func TestStopContainerWithTimeout(t *testing.T) {
d := d d := d
t.Run(strconv.Itoa(d.timeout), func(t *testing.T) { t.Run(strconv.Itoa(d.timeout), func(t *testing.T) {
t.Parallel() t.Parallel()
id := container.Run(t, ctx, client, testCmd) id := container.Run(ctx, t, client, testCmd)
timeout := time.Duration(d.timeout) * time.Second timeout := time.Duration(d.timeout) * time.Second
err := client.ContainerStop(ctx, id, &timeout) err := client.ContainerStop(ctx, id, &timeout)
@ -78,7 +78,7 @@ func TestDeleteDevicemapper(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
id := container.Run(t, ctx, client, container.WithName("foo-"+t.Name()), container.WithCmd("echo")) id := container.Run(ctx, t, client, container.WithName("foo-"+t.Name()), container.WithCmd("echo"))
poll.WaitOn(t, container.IsStopped(ctx, client, id), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsStopped(ctx, client, id), poll.WithDelay(100*time.Millisecond))

2
integration/container/stop_test.go
View File

@ -17,7 +17,7 @@ func TestStopContainerWithRestartPolicyAlways(t *testing.T) {
names := []string{"verifyRestart1-" + t.Name(), "verifyRestart2-" + t.Name()} names := []string{"verifyRestart1-" + t.Name(), "verifyRestart2-" + t.Name()}
for _, name := range names { for _, name := range names {
container.Run(t, ctx, client, container.Run(ctx, t, client,
container.WithName(name), container.WithName(name),
container.WithCmd("false"), container.WithCmd("false"),
container.WithRestartPolicy("always"), container.WithRestartPolicy("always"),

2
integration/container/stop_windows_test.go
View File

@ -51,7 +51,7 @@ func TestStopContainerWithTimeout(t *testing.T) {
d := d d := d
t.Run(strconv.Itoa(d.timeout), func(t *testing.T) { t.Run(strconv.Itoa(d.timeout), func(t *testing.T) {
t.Parallel() t.Parallel()
id := container.Run(t, ctx, client, testCmd) id := container.Run(ctx, t, client, testCmd)
timeout := time.Duration(d.timeout) * time.Second timeout := time.Duration(d.timeout) * time.Second
err := client.ContainerStop(ctx, id, &timeout) err := client.ContainerStop(ctx, id, &timeout)

6
integration/container/update_linux_test.go
View File

@ -26,7 +26,7 @@ func TestUpdateMemory(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
c.HostConfig.Resources = containertypes.Resources{ c.HostConfig.Resources = containertypes.Resources{
Memory: 200 * 1024 * 1024, Memory: 200 * 1024 * 1024,
} }
@ -72,7 +72,7 @@ func TestUpdateCPUQuota(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
for _, test := range []struct { for _, test := range []struct {
desc string desc string
@ -140,7 +140,7 @@ func TestUpdatePidsLimit(t *testing.T) {
t.Run(test.desc, func(t *testing.T) { t.Run(test.desc, func(t *testing.T) {
// Using "network=host" to speed up creation (13.96s vs 6.54s) // Using "network=host" to speed up creation (13.96s vs 6.54s)
cID := container.Run(t, ctx, apiClient, container.WithPidsLimit(test.initial), container.WithNetworkMode("host")) cID := container.Run(ctx, t, apiClient, container.WithPidsLimit(test.initial), container.WithNetworkMode("host"))
_, err := c.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{ _, err := c.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
Resources: containertypes.Resources{ Resources: containertypes.Resources{

4
integration/container/update_test.go
View File

@ -17,7 +17,7 @@ func TestUpdateRestartPolicy(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithCmd("sh", "-c", "sleep 1 && false"), func(c *container.TestContainerConfig) { cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", "sleep 1 && false"), func(c *container.TestContainerConfig) {
c.HostConfig.RestartPolicy = containertypes.RestartPolicy{ c.HostConfig.RestartPolicy = containertypes.RestartPolicy{
Name: "on-failure", Name: "on-failure",
MaximumRetryCount: 3, MaximumRetryCount: 3,
@ -50,7 +50,7 @@ func TestUpdateRestartWithAutoRemove(t *testing.T) {
client := testEnv.APIClient() client := testEnv.APIClient()
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, client, container.WithAutoRemove) cID := container.Run(ctx, t, client, container.WithAutoRemove)
_, err := client.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{ _, err := client.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
RestartPolicy: containertypes.RestartPolicy{ RestartPolicy: containertypes.RestartPolicy{

4
integration/container/wait_test.go
View File

@ -39,7 +39,7 @@ func TestWaitNonBlocked(t *testing.T) {
t.Run(tc.doc, func(t *testing.T) { t.Run(tc.doc, func(t *testing.T) {
t.Parallel() t.Parallel()
ctx := context.Background() ctx := context.Background()
containerID := container.Run(t, ctx, cli, container.WithCmd("sh", "-c", tc.cmd)) containerID := container.Run(ctx, t, cli, container.WithCmd("sh", "-c", tc.cmd))
poll.WaitOn(t, container.IsInState(ctx, cli, containerID, "exited"), poll.WithTimeout(30*time.Second), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, cli, containerID, "exited"), poll.WithTimeout(30*time.Second), poll.WithDelay(100*time.Millisecond))
waitresC, errC := cli.ContainerWait(ctx, containerID, "") waitresC, errC := cli.ContainerWait(ctx, containerID, "")
@ -81,7 +81,7 @@ func TestWaitBlocked(t *testing.T) {
t.Run(tc.doc, func(t *testing.T) { t.Run(tc.doc, func(t *testing.T) {
t.Parallel() t.Parallel()
ctx := context.Background() ctx := context.Background()
containerID := container.Run(t, ctx, cli, container.WithCmd("sh", "-c", tc.cmd)) containerID := container.Run(ctx, t, cli, container.WithCmd("sh", "-c", tc.cmd))
poll.WaitOn(t, container.IsInState(ctx, cli, containerID, "running"), poll.WithTimeout(30*time.Second), poll.WithDelay(100*time.Millisecond)) poll.WaitOn(t, container.IsInState(ctx, cli, containerID, "running"), poll.WithTimeout(30*time.Second), poll.WithDelay(100*time.Millisecond))
waitresC, errC := cli.ContainerWait(ctx, containerID, "") waitresC, errC := cli.ContainerWait(ctx, containerID, "")

3
integration/internal/container/container.go
View File

@ -54,8 +54,7 @@ func CreateExpectingErr(ctx context.Context, t *testing.T, client client.APIClie
} }
// Run creates and start a container with the specified options // Run creates and start a container with the specified options
// nolint: golint func Run(ctx context.Context, t *testing.T, client client.APIClient, ops ...func(*TestContainerConfig)) string {
func Run(t *testing.T, ctx context.Context, client client.APIClient, ops ...func(*TestContainerConfig)) string { // nolint: golint
t.Helper() t.Helper()
id := Create(ctx, t, client, ops...) id := Create(ctx, t, client, ops...)

36
integration/network/ipvlan/ipvlan_test.go
View File

@ -150,8 +150,8 @@ func testIpvlanL2NilParent(client dclient.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netName)) assert.Check(t, n.IsNetworkAvailable(client, netName))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id1 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
id2 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id2 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
_, err := container.Exec(ctx, client, id2, []string{"ping", "-c", "1", id1}) _, err := container.Exec(ctx, client, id2, []string{"ping", "-c", "1", id1})
assert.NilError(t, err) assert.NilError(t, err)
@ -168,8 +168,8 @@ func testIpvlanL2InternalMode(client dclient.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netName)) assert.Check(t, n.IsNetworkAvailable(client, netName))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id1 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
id2 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id2 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
timeoutCtx, cancel := context.WithTimeout(context.Background(), 1*time.Second) timeoutCtx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel() defer cancel()
@ -194,11 +194,11 @@ func testIpvlanL3NilParent(client dclient.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netName)) assert.Check(t, n.IsNetworkAvailable(client, netName))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, id1 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.220.10"), container.WithIPv4(netName, "172.28.220.10"),
) )
id2 := container.Run(t, ctx, client, id2 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.230.10"), container.WithIPv4(netName, "172.28.230.10"),
) )
@ -220,11 +220,11 @@ func testIpvlanL3InternalMode(client dclient.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netName)) assert.Check(t, n.IsNetworkAvailable(client, netName))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, id1 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.220.10"), container.WithIPv4(netName, "172.28.220.10"),
) )
id2 := container.Run(t, ctx, client, id2 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.230.10"), container.WithIPv4(netName, "172.28.230.10"),
) )
@ -256,12 +256,12 @@ func testIpvlanL2MultiSubnet(client dclient.APIClient) func(*testing.T) {
// start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.100.0/24 and 2001:db8:abc2::/64 // start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.100.0/24 and 2001:db8:abc2::/64
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, id1 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.200.20"), container.WithIPv4(netName, "172.28.200.20"),
container.WithIPv6(netName, "2001:db8:abc8::20"), container.WithIPv6(netName, "2001:db8:abc8::20"),
) )
id2 := container.Run(t, ctx, client, id2 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.200.21"), container.WithIPv4(netName, "172.28.200.21"),
container.WithIPv6(netName, "2001:db8:abc8::21"), container.WithIPv6(netName, "2001:db8:abc8::21"),
@ -277,12 +277,12 @@ func testIpvlanL2MultiSubnet(client dclient.APIClient) func(*testing.T) {
assert.NilError(t, err) assert.NilError(t, err)
// start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.102.0/24 and 2001:db8:abc4::/64 // start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.102.0/24 and 2001:db8:abc4::/64
id3 := container.Run(t, ctx, client, id3 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.202.20"), container.WithIPv4(netName, "172.28.202.20"),
container.WithIPv6(netName, "2001:db8:abc6::20"), container.WithIPv6(netName, "2001:db8:abc6::20"),
) )
id4 := container.Run(t, ctx, client, id4 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.202.21"), container.WithIPv4(netName, "172.28.202.21"),
container.WithIPv6(netName, "2001:db8:abc6::21"), container.WithIPv6(netName, "2001:db8:abc6::21"),
@ -323,12 +323,12 @@ func testIpvlanL3MultiSubnet(client dclient.APIClient) func(*testing.T) {
// start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.100.0/24 and 2001:db8:abc2::/64 // start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.100.0/24 and 2001:db8:abc2::/64
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, id1 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.10.20"), container.WithIPv4(netName, "172.28.10.20"),
container.WithIPv6(netName, "2001:db8:abc9::20"), container.WithIPv6(netName, "2001:db8:abc9::20"),
) )
id2 := container.Run(t, ctx, client, id2 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.10.21"), container.WithIPv4(netName, "172.28.10.21"),
container.WithIPv6(netName, "2001:db8:abc9::21"), container.WithIPv6(netName, "2001:db8:abc9::21"),
@ -344,12 +344,12 @@ func testIpvlanL3MultiSubnet(client dclient.APIClient) func(*testing.T) {
assert.NilError(t, err) assert.NilError(t, err)
// start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.102.0/24 and 2001:db8:abc4::/64 // start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.102.0/24 and 2001:db8:abc4::/64
id3 := container.Run(t, ctx, client, id3 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.12.20"), container.WithIPv4(netName, "172.28.12.20"),
container.WithIPv6(netName, "2001:db8:abc7::20"), container.WithIPv6(netName, "2001:db8:abc7::20"),
) )
id4 := container.Run(t, ctx, client, id4 := container.Run(ctx, t, client,
container.WithNetworkMode(netName), container.WithNetworkMode(netName),
container.WithIPv4(netName, "172.28.12.21"), container.WithIPv4(netName, "172.28.12.21"),
container.WithIPv6(netName, "2001:db8:abc7::21"), container.WithIPv6(netName, "2001:db8:abc7::21"),
@ -389,7 +389,7 @@ func testIpvlanAddressing(client dclient.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netNameL2)) assert.Check(t, n.IsNetworkAvailable(client, netNameL2))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, id1 := container.Run(ctx, t, client,
container.WithNetworkMode(netNameL2), container.WithNetworkMode(netNameL2),
) )
// Validate ipvlan l2 mode defaults gateway sets the default IPAM next-hop inferred from the subnet // Validate ipvlan l2 mode defaults gateway sets the default IPAM next-hop inferred from the subnet
@ -411,7 +411,7 @@ func testIpvlanAddressing(client dclient.APIClient) func(*testing.T) {
) )
assert.Check(t, n.IsNetworkAvailable(client, netNameL3)) assert.Check(t, n.IsNetworkAvailable(client, netNameL3))
id2 := container.Run(t, ctx, client, id2 := container.Run(ctx, t, client,
container.WithNetworkMode(netNameL3), container.WithNetworkMode(netNameL3),
) )
// Validate ipvlan l3 mode sets the v4 gateway to dev eth0 and disregards any explicit or inferred next-hops // Validate ipvlan l3 mode sets the v4 gateway to dev eth0 and disregards any explicit or inferred next-hops

18
integration/network/macvlan/macvlan_test.go
View File

@ -141,8 +141,8 @@ func testMacvlanNilParent(client client.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netName)) assert.Check(t, n.IsNetworkAvailable(client, netName))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id1 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
id2 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id2 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
_, err := container.Exec(ctx, client, id2, []string{"ping", "-c", "1", id1}) _, err := container.Exec(ctx, client, id2, []string{"ping", "-c", "1", id1})
assert.Check(t, err == nil) assert.Check(t, err == nil)
@ -160,8 +160,8 @@ func testMacvlanInternalMode(client client.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netName)) assert.Check(t, n.IsNetworkAvailable(client, netName))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id1 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
id2 := container.Run(t, ctx, client, container.WithNetworkMode(netName)) id2 := container.Run(ctx, t, client, container.WithNetworkMode(netName))
timeoutCtx, cancel := context.WithTimeout(context.Background(), 1*time.Second) timeoutCtx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel() defer cancel()
@ -191,12 +191,12 @@ func testMacvlanMultiSubnet(client client.APIClient) func(*testing.T) {
// start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.100.0/24 and 2001:db8:abc2::/64 // start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.100.0/24 and 2001:db8:abc2::/64
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, id1 := container.Run(ctx, t, client,
container.WithNetworkMode("dualstackbridge"), container.WithNetworkMode("dualstackbridge"),
container.WithIPv4("dualstackbridge", "172.28.100.20"), container.WithIPv4("dualstackbridge", "172.28.100.20"),
container.WithIPv6("dualstackbridge", "2001:db8:abc2::20"), container.WithIPv6("dualstackbridge", "2001:db8:abc2::20"),
) )
id2 := container.Run(t, ctx, client, id2 := container.Run(ctx, t, client,
container.WithNetworkMode("dualstackbridge"), container.WithNetworkMode("dualstackbridge"),
container.WithIPv4("dualstackbridge", "172.28.100.21"), container.WithIPv4("dualstackbridge", "172.28.100.21"),
container.WithIPv6("dualstackbridge", "2001:db8:abc2::21"), container.WithIPv6("dualstackbridge", "2001:db8:abc2::21"),
@ -212,12 +212,12 @@ func testMacvlanMultiSubnet(client client.APIClient) func(*testing.T) {
assert.NilError(t, err) assert.NilError(t, err)
// start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.102.0/24 and 2001:db8:abc4::/64 // start dual stack containers and verify the user specified --ip and --ip6 addresses on subnets 172.28.102.0/24 and 2001:db8:abc4::/64
id3 := container.Run(t, ctx, client, id3 := container.Run(ctx, t, client,
container.WithNetworkMode("dualstackbridge"), container.WithNetworkMode("dualstackbridge"),
container.WithIPv4("dualstackbridge", "172.28.102.20"), container.WithIPv4("dualstackbridge", "172.28.102.20"),
container.WithIPv6("dualstackbridge", "2001:db8:abc4::20"), container.WithIPv6("dualstackbridge", "2001:db8:abc4::20"),
) )
id4 := container.Run(t, ctx, client, id4 := container.Run(ctx, t, client,
container.WithNetworkMode("dualstackbridge"), container.WithNetworkMode("dualstackbridge"),
container.WithIPv4("dualstackbridge", "172.28.102.21"), container.WithIPv4("dualstackbridge", "172.28.102.21"),
container.WithIPv6("dualstackbridge", "2001:db8:abc4::21"), container.WithIPv6("dualstackbridge", "2001:db8:abc4::21"),
@ -257,7 +257,7 @@ func testMacvlanAddressing(client client.APIClient) func(*testing.T) {
assert.Check(t, n.IsNetworkAvailable(client, netName)) assert.Check(t, n.IsNetworkAvailable(client, netName))
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, client, id1 := container.Run(ctx, t, client,
container.WithNetworkMode("dualstackbridge"), container.WithNetworkMode("dualstackbridge"),
) )

6
integration/network/network_test.go
View File

@ -29,14 +29,14 @@ func TestRunContainerWithBridgeNone(t *testing.T) {
c := d.NewClientT(t) c := d.NewClientT(t)
ctx := context.Background() ctx := context.Background()
id1 := container.Run(t, ctx, c) id1 := container.Run(ctx, t, c)
defer c.ContainerRemove(ctx, id1, types.ContainerRemoveOptions{Force: true}) defer c.ContainerRemove(ctx, id1, types.ContainerRemoveOptions{Force: true})
result, err := container.Exec(ctx, c, id1, []string{"ip", "l"}) result, err := container.Exec(ctx, c, id1, []string{"ip", "l"})
assert.NilError(t, err) assert.NilError(t, err)
assert.Check(t, is.Equal(false, strings.Contains(result.Combined(), "eth0")), "There shouldn't be eth0 in container in default(bridge) mode when bridge network is disabled") assert.Check(t, is.Equal(false, strings.Contains(result.Combined(), "eth0")), "There shouldn't be eth0 in container in default(bridge) mode when bridge network is disabled")
id2 := container.Run(t, ctx, c, container.WithNetworkMode("bridge")) id2 := container.Run(ctx, t, c, container.WithNetworkMode("bridge"))
defer c.ContainerRemove(ctx, id2, types.ContainerRemoveOptions{Force: true}) defer c.ContainerRemove(ctx, id2, types.ContainerRemoveOptions{Force: true})
result, err = container.Exec(ctx, c, id2, []string{"ip", "l"}) result, err = container.Exec(ctx, c, id2, []string{"ip", "l"})
@ -50,7 +50,7 @@ func TestRunContainerWithBridgeNone(t *testing.T) {
err = cmd.Run() err = cmd.Run()
assert.NilError(t, err, "Failed to get current process network namespace: %+v", err) assert.NilError(t, err, "Failed to get current process network namespace: %+v", err)
id3 := container.Run(t, ctx, c, container.WithNetworkMode("host")) id3 := container.Run(ctx, t, c, container.WithNetworkMode("host"))
defer c.ContainerRemove(ctx, id3, types.ContainerRemoveOptions{Force: true}) defer c.ContainerRemove(ctx, id3, types.ContainerRemoveOptions{Force: true})
result, err = container.Exec(ctx, c, id3, []string{"sh", "-c", nsCommand}) result, err = container.Exec(ctx, c, id3, []string{"sh", "-c", nsCommand})

8
integration/plugin/authz/authz_plugin_test.go
View File

@ -92,7 +92,7 @@ func TestAuthZPluginAllowRequest(t *testing.T) {
ctx := context.Background() ctx := context.Background()
// Ensure command successful // Ensure command successful
cID := container.Run(t, ctx, c) cID := container.Run(ctx, t, c)
assertURIRecorded(t, ctrl.requestsURIs, "/containers/create") assertURIRecorded(t, ctrl.requestsURIs, "/containers/create")
assertURIRecorded(t, ctrl.requestsURIs, fmt.Sprintf("/containers/%s/start", cID)) assertURIRecorded(t, ctrl.requestsURIs, fmt.Sprintf("/containers/%s/start", cID))
@ -224,7 +224,7 @@ func TestAuthZPluginAllowEventStream(t *testing.T) {
defer cancel() defer cancel()
// Create a container and wait for the creation events // Create a container and wait for the creation events
cID := container.Run(t, ctx, c) cID := container.Run(ctx, t, c)
poll.WaitOn(t, container.IsInState(ctx, c, cID, "running")) poll.WaitOn(t, container.IsInState(ctx, c, cID, "running"))
created := false created := false
@ -348,7 +348,7 @@ func TestAuthZPluginEnsureLoadImportWorking(t *testing.T) {
exportedImagePath := filepath.Join(tmp, "export.tar") exportedImagePath := filepath.Join(tmp, "export.tar")
cID := container.Run(t, ctx, c) cID := container.Run(ctx, t, c)
responseReader, err := c.ContainerExport(context.Background(), cID) responseReader, err := c.ContainerExport(context.Background(), cID)
assert.NilError(t, err) assert.NilError(t, err)
@ -388,7 +388,7 @@ func TestAuthzPluginEnsureContainerCopyToFrom(t *testing.T) {
c := d.NewClientT(t) c := d.NewClientT(t)
ctx := context.Background() ctx := context.Background()
cID := container.Run(t, ctx, c) cID := container.Run(ctx, t, c)
defer c.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true}) defer c.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})
_, err = f.Seek(0, io.SeekStart) _, err = f.Seek(0, io.SeekStart)

2
integration/plugin/authz/authz_plugin_v2_test.go
View File

@ -55,7 +55,7 @@ func TestAuthZPluginV2AllowNonVolumeRequest(t *testing.T) {
d.LoadBusybox(t) d.LoadBusybox(t)
// Ensure docker run command and accompanying docker ps are successful // Ensure docker run command and accompanying docker ps are successful
cID := container.Run(t, ctx, c) cID := container.Run(ctx, t, c)
_, err = c.ContainerInspect(ctx, cID) _, err = c.ContainerInspect(ctx, cID)
assert.NilError(t, err) assert.NilError(t, err)

4
integration/plugin/graphdriver/external_test.go
View File

@ -399,7 +399,7 @@ func testGraphDriverPull(c client.APIClient, d *daemon.Daemon) func(*testing.T)
_, err = io.Copy(ioutil.Discard, r) _, err = io.Copy(ioutil.Discard, r)
assert.NilError(t, err) assert.NilError(t, err)
container.Run(t, ctx, c, container.WithImage("busybox:latest@sha256:bbc3a03235220b170ba48a157dd097dd1379299370e1ed99ce976df0355d24f0")) container.Run(ctx, t, c, container.WithImage("busybox:latest@sha256:bbc3a03235220b170ba48a157dd097dd1379299370e1ed99ce976df0355d24f0"))
} }
} }
@ -439,7 +439,7 @@ func TestGraphdriverPluginV2(t *testing.T) {
// nolint: golint // nolint: golint
func testGraphDriver(t *testing.T, c client.APIClient, ctx context.Context, driverName string, afterContainerRunFn func(*testing.T)) { //nolint: golint func testGraphDriver(t *testing.T, c client.APIClient, ctx context.Context, driverName string, afterContainerRunFn func(*testing.T)) { //nolint: golint
id := container.Run(t, ctx, c, container.WithCmd("sh", "-c", "echo hello > /hello")) id := container.Run(ctx, t, c, container.WithCmd("sh", "-c", "echo hello > /hello"))
if afterContainerRunFn != nil { if afterContainerRunFn != nil {
afterContainerRunFn(t) afterContainerRunFn(t)

2
integration/plugin/logging/logging_linux_test.go
View File

@ -33,7 +33,7 @@ func TestContinueAfterPluginCrash(t *testing.T) {
ctx, cancel = context.WithTimeout(context.Background(), 60*time.Second) ctx, cancel = context.WithTimeout(context.Background(), 60*time.Second)
id := container.Run(t, ctx, client, id := container.Run(ctx, t, client,
container.WithAutoRemove, container.WithAutoRemove,
container.WithLogDriver("test"), container.WithLogDriver("test"),
container.WithCmd( container.WithCmd(

2
integration/system/event_test.go
View File

@ -30,7 +30,7 @@ func TestEventsExecDie(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := testEnv.APIClient() client := testEnv.APIClient()
cID := container.Run(t, ctx, client) cID := container.Run(ctx, t, client)
id, err := client.ContainerExecCreate(ctx, cID, id, err := client.ContainerExecCreate(ctx, cID,
types.ExecConfig{ types.ExecConfig{