0ct0pu5/moby
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #46191 from thaJeztah/integration_testutil_improvements

Browse source 
integration/container: refactor some test-utilities and fix var-names shadowing imports
This commit is contained in:
Sebastiaan van Stijn 2023-08-11 17:49:42 +02:00 • committed by GitHub
commit 896f246888
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
39 changed files with 501 additions and 493 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
integration/container/attach_test.go
View file

@ -13,7 +13,7 @@ import (
func TestAttach(t *testing.T) {
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
tests := []struct {
doc string
@ -34,7 +34,7 @@ func TestAttach(t *testing.T) {
tc := tc
t.Run(tc.doc, func(t *testing.T) {
t.Parallel()
resp, err := client.ContainerCreate(context.Background(),
resp, err := apiClient.ContainerCreate(context.Background(),
&container.Config{
Image: "busybox",
Cmd: []string{"echo", "hello"},
@ -46,7 +46,7 @@ func TestAttach(t *testing.T) {
"",
)
assert.NilError(t, err)
attach, err := client.ContainerAttach(context.Background(), resp.ID, types.ContainerAttachOptions{
attach, err := apiClient.ContainerAttach(context.Background(), resp.ID, types.ContainerAttachOptions{
Stdout: true,
Stderr: true,
})

10
integration/container/cdi_test.go
View file

@ -30,16 +30,16 @@ func TestCreateWithCDIDevices(t *testing.T) {
d.StartWithBusybox(t, "--cdi-spec-dir="+filepath.Join(cwd, "testdata", "cdi"))
defer d.Stop(t)
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
ctx := context.Background()
id := container.Run(ctx, t, client,
id := container.Run(ctx, t, apiClient,
container.WithCmd("/bin/sh", "-c", "env"),
container.WithCDIDevices("vendor1.com/device=foo"),
)
defer client.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
defer apiClient.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
inspect, err := client.ContainerInspect(ctx, id)
inspect, err := apiClient.ContainerInspect(ctx, id)
assert.NilError(t, err)
expectedRequests := []containertypes.DeviceRequest{
@ -50,7 +50,7 @@ func TestCreateWithCDIDevices(t *testing.T) {
}
assert.Check(t, is.DeepEqual(inspect.HostConfig.DeviceRequests, expectedRequests))
reader, err := client.ContainerLogs(ctx, id, types.ContainerLogsOptions{
reader, err := apiClient.ContainerLogs(ctx, id, types.ContainerLogsOptions{
ShowStdout: true,
})
assert.NilError(t, err)

30
integration/container/checkpoint_test.go
View file

@ -42,7 +42,7 @@ func TestCheckpoint(t *testing.T) {
assert.NilError(t, err)
ctx := context.Background()
client := request.NewAPIClient(t)
apiClient := request.NewAPIClient(t)
mnt := mounttypes.Mount{
Type: mounttypes.TypeTmpfs,
@ -50,9 +50,9 @@ func TestCheckpoint(t *testing.T) {
}
t.Log("Start a container")
cID := container.Run(ctx, t, client, container.WithMount(mnt))
cID := container.Run(ctx, t, apiClient, container.WithMount(mnt))
poll.WaitOn(t,
container.IsInState(ctx, client, cID, "running"),
container.IsInState(ctx, apiClient, cID, "running"),
poll.WithDelay(100*time.Millisecond),
)
@ -80,7 +80,7 @@ func TestCheckpoint(t *testing.T) {
}()
}
t.Log("Do a checkpoint and leave the container running")
err = client.CheckpointCreate(ctx, cID, cptOpt)
err = apiClient.CheckpointCreate(ctx, cID, cptOpt)
if err != nil {
// An error can contain a path to a dump file
t.Log(err)
@ -96,17 +96,17 @@ func TestCheckpoint(t *testing.T) {
}
assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(true, inspect.State.Running))
checkpoints, err := client.CheckpointList(ctx, cID, types.CheckpointListOptions{})
checkpoints, err := apiClient.CheckpointList(ctx, cID, types.CheckpointListOptions{})
assert.NilError(t, err)
assert.Equal(t, len(checkpoints), 1)
assert.Equal(t, checkpoints[0].Name, "test")
// Create a test file on a tmpfs mount.
containerExec(t, client, cID, []string{"touch", "/tmp/test-file"})
containerExec(t, apiClient, cID, []string{"touch", "/tmp/test-file"})
// Do a second checkpoint
cptOpt = types.CheckpointCreateOptions{
@ -114,20 +114,20 @@ func TestCheckpoint(t *testing.T) {
CheckpointID: "test2",
}
t.Log("Do a checkpoint and stop the container")
err = client.CheckpointCreate(ctx, cID, cptOpt)
err = apiClient.CheckpointCreate(ctx, cID, cptOpt)
assert.NilError(t, err)
poll.WaitOn(t,
container.IsInState(ctx, client, cID, "exited"),
container.IsInState(ctx, apiClient, cID, "exited"),
poll.WithDelay(100*time.Millisecond),
)
inspect, err = client.ContainerInspect(ctx, cID)
inspect, err = apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(false, inspect.State.Running))
// Check that both checkpoints are listed.
checkpoints, err = client.CheckpointList(ctx, cID, types.CheckpointListOptions{})
checkpoints, err = apiClient.CheckpointList(ctx, cID, types.CheckpointListOptions{})
assert.NilError(t, err)
assert.Equal(t, len(checkpoints), 2)
cptNames := make([]string, 2)
@ -143,22 +143,22 @@ func TestCheckpoint(t *testing.T) {
CheckpointID: "test2",
}
t.Log("Restore the container")
err = client.ContainerStart(ctx, cID, startOpt)
err = apiClient.ContainerStart(ctx, cID, startOpt)
assert.NilError(t, err)
inspect, err = client.ContainerInspect(ctx, cID)
inspect, err = apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(true, inspect.State.Running))
// Check that the test file has been restored.
containerExec(t, client, cID, []string{"test", "-f", "/tmp/test-file"})
containerExec(t, apiClient, cID, []string{"test", "-f", "/tmp/test-file"})
for _, id := range []string{"test", "test2"} {
cptDelOpt := types.CheckpointDeleteOptions{
CheckpointID: id,
}
err = client.CheckpointDelete(ctx, cID, cptDelOpt)
err = apiClient.CheckpointDelete(ctx, cID, cptDelOpt)
assert.NilError(t, err)
}
}

36
integration/container/copy_test.go
View file

@ -25,10 +25,10 @@ func TestCopyFromContainerPathDoesNotExist(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
apiclient := testEnv.APIClient()
cid := container.Create(ctx, t, apiclient)
apiClient := testEnv.APIClient()
cid := container.Create(ctx, t, apiClient)
_, _, err := apiclient.CopyFromContainer(ctx, cid, "/dne")
_, _, err := apiClient.CopyFromContainer(ctx, cid, "/dne")
assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
assert.Check(t, is.ErrorContains(err, "Could not find the file /dne in container "+cid))
}
@ -37,8 +37,8 @@ func TestCopyFromContainerPathIsNotDir(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
apiclient := testEnv.APIClient()
cid := container.Create(ctx, t, apiclient)
apiClient := testEnv.APIClient()
cid := container.Create(ctx, t, apiClient)
path := "/etc/passwd/"
expected := "not a directory"
@ -46,7 +46,7 @@ func TestCopyFromContainerPathIsNotDir(t *testing.T) {
path = "c:/windows/system32/drivers/etc/hosts/"
expected = "The filename, directory name, or volume label syntax is incorrect."
}
_, _, err := apiclient.CopyFromContainer(ctx, cid, path)
_, _, err := apiClient.CopyFromContainer(ctx, cid, path)
assert.Assert(t, is.ErrorContains(err, expected))
}
@ -54,10 +54,10 @@ func TestCopyToContainerPathDoesNotExist(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
apiclient := testEnv.APIClient()
cid := container.Create(ctx, t, apiclient)
apiClient := testEnv.APIClient()
cid := container.Create(ctx, t, apiClient)
err := apiclient.CopyToContainer(ctx, cid, "/dne", nil, types.CopyToContainerOptions{})
err := apiClient.CopyToContainer(ctx, cid, "/dne", nil, types.CopyToContainerOptions{})
assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
assert.Check(t, is.ErrorContains(err, "Could not find the file /dne in container "+cid))
}
@ -66,28 +66,28 @@ func TestCopyEmptyFile(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
apiclient := testEnv.APIClient()
cid := container.Create(ctx, t, apiclient)
apiClient := testEnv.APIClient()
cid := container.Create(ctx, t, apiClient)
// empty content
dstDir, _ := makeEmptyArchive(t)
err := apiclient.CopyToContainer(ctx, cid, dstDir, bytes.NewReader([]byte("")), types.CopyToContainerOptions{})
err := apiClient.CopyToContainer(ctx, cid, dstDir, bytes.NewReader([]byte("")), types.CopyToContainerOptions{})
assert.NilError(t, err)
// tar with empty file
dstDir, preparedArchive := makeEmptyArchive(t)
err = apiclient.CopyToContainer(ctx, cid, dstDir, preparedArchive, types.CopyToContainerOptions{})
err = apiClient.CopyToContainer(ctx, cid, dstDir, preparedArchive, types.CopyToContainerOptions{})
assert.NilError(t, err)
// tar with empty file archive mode
dstDir, preparedArchive = makeEmptyArchive(t)
err = apiclient.CopyToContainer(ctx, cid, dstDir, preparedArchive, types.CopyToContainerOptions{
err = apiClient.CopyToContainer(ctx, cid, dstDir, preparedArchive, types.CopyToContainerOptions{
CopyUIDGID: true,
})
assert.NilError(t, err)
// copy from empty file
rdr, _, err := apiclient.CopyFromContainer(ctx, cid, dstDir)
rdr, _, err := apiClient.CopyFromContainer(ctx, cid, dstDir)
assert.NilError(t, err)
defer rdr.Close()
}
@ -123,14 +123,14 @@ func TestCopyToContainerPathIsNotDir(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
apiclient := testEnv.APIClient()
cid := container.Create(ctx, t, apiclient)
apiClient := testEnv.APIClient()
cid := container.Create(ctx, t, apiClient)
path := "/etc/passwd/"
if testEnv.DaemonInfo.OSType == "windows" {
path = "c:/windows/system32/drivers/etc/hosts/"
}
err := apiclient.CopyToContainer(ctx, cid, path, nil, types.CopyToContainerOptions{})
err := apiClient.CopyToContainer(ctx, cid, path, nil, types.CopyToContainerOptions{})
assert.Check(t, is.ErrorContains(err, "not a directory"))
}

68
integration/container/create_test.go
View file

@ -25,7 +25,7 @@ import (
func TestCreateFailsWhenIdentifierDoesNotExist(t *testing.T) {
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
testCases := []struct {
doc string
@ -53,7 +53,7 @@ func TestCreateFailsWhenIdentifierDoesNotExist(t *testing.T) {
tc := tc
t.Run(tc.doc, func(t *testing.T) {
t.Parallel()
_, err := client.ContainerCreate(context.Background(),
_, err := apiClient.ContainerCreate(context.Background(),
&container.Config{Image: tc.image},
&container.HostConfig{},
&network.NetworkingConfig{},
@ -72,9 +72,9 @@ func TestCreateFailsWhenIdentifierDoesNotExist(t *testing.T) {
func TestCreateLinkToNonExistingContainer(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "legacy links are not supported on windows")
defer setupTest(t)()
c := testEnv.APIClient()
apiClient := testEnv.APIClient()
_, err := c.ContainerCreate(context.Background(),
_, err := apiClient.ContainerCreate(context.Background(),
&container.Config{
Image: "busybox",
},
@ -91,7 +91,7 @@ func TestCreateLinkToNonExistingContainer(t *testing.T) {
func TestCreateWithInvalidEnv(t *testing.T) {
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
testCases := []struct {
env string
@ -115,7 +115,7 @@ func TestCreateWithInvalidEnv(t *testing.T) {
tc := tc
t.Run(strconv.Itoa(index), func(t *testing.T) {
t.Parallel()
_, err := client.ContainerCreate(context.Background(),
_, err := apiClient.ContainerCreate(context.Background(),
&container.Config{
Image: "busybox",
Env: []string{tc.env},
@ -136,7 +136,7 @@ func TestCreateTmpfsMountsTarget(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
testCases := []struct {
target string
@ -161,7 +161,7 @@ func TestCreateTmpfsMountsTarget(t *testing.T) {
}
for _, tc := range testCases {
_, err := client.ContainerCreate(context.Background(),
_, err := apiClient.ContainerCreate(context.Background(),
&container.Config{
Image: "busybox",
},
@ -181,7 +181,7 @@ func TestCreateWithCustomMaskedPaths(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType != "linux")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
testCases := []struct {
@ -203,7 +203,7 @@ func TestCreateWithCustomMaskedPaths(t *testing.T) {
}
checkInspect := func(t *testing.T, ctx context.Context, name string, expected []string) {
_, b, err := client.ContainerInspectWithRaw(ctx, name, false)
_, b, err := apiClient.ContainerInspectWithRaw(ctx, name, false)
assert.NilError(t, err)
var inspectJSON map[string]interface{}
@ -236,7 +236,7 @@ func TestCreateWithCustomMaskedPaths(t *testing.T) {
}
// Create the container.
c, err := client.ContainerCreate(context.Background(),
c, err := apiClient.ContainerCreate(context.Background(),
&config,
&hc,
&network.NetworkingConfig{},
@ -248,10 +248,10 @@ func TestCreateWithCustomMaskedPaths(t *testing.T) {
checkInspect(t, ctx, name, tc.expected)
// Start the container.
err = client.ContainerStart(ctx, c.ID, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, c.ID, types.ContainerStartOptions{})
assert.NilError(t, err)
poll.WaitOn(t, ctr.IsInState(ctx, client, c.ID, "exited"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, ctr.IsInState(ctx, apiClient, c.ID, "exited"), poll.WithDelay(100*time.Millisecond))
checkInspect(t, ctx, name, tc.expected)
}
@ -261,7 +261,7 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType != "linux")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
testCases := []struct {
@ -283,7 +283,7 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {
}
checkInspect := func(t *testing.T, ctx context.Context, name string, expected []string) {
_, b, err := client.ContainerInspectWithRaw(ctx, name, false)
_, b, err := apiClient.ContainerInspectWithRaw(ctx, name, false)
assert.NilError(t, err)
var inspectJSON map[string]interface{}
@ -315,7 +315,7 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {
}
// Create the container.
c, err := client.ContainerCreate(context.Background(),
c, err := apiClient.ContainerCreate(context.Background(),
&config,
&hc,
&network.NetworkingConfig{},
@ -327,10 +327,10 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {
checkInspect(t, ctx, name, tc.expected)
// Start the container.
err = client.ContainerStart(ctx, c.ID, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, c.ID, types.ContainerStartOptions{})
assert.NilError(t, err)
poll.WaitOn(t, ctr.IsInState(ctx, client, c.ID, "exited"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, ctr.IsInState(ctx, apiClient, c.ID, "exited"), poll.WithDelay(100*time.Millisecond))
checkInspect(t, ctx, name, tc.expected)
}
@ -338,7 +338,7 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {
func TestCreateWithInvalidHealthcheckParams(t *testing.T) {
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
testCases := []struct {
@ -403,7 +403,7 @@ func TestCreateWithInvalidHealthcheckParams(t *testing.T) {
cfg.Healthcheck.StartPeriod = tc.startPeriod
}
resp, err := client.ContainerCreate(ctx, &cfg, &container.HostConfig{}, nil, nil, "")
resp, err := apiClient.ContainerCreate(ctx, &cfg, &container.HostConfig{}, nil, nil, "")
assert.Check(t, is.Equal(len(resp.Warnings), 0))
if versions.LessThan(testEnv.DaemonAPIVersion(), "1.32") {
@ -421,10 +421,10 @@ func TestCreateWithInvalidHealthcheckParams(t *testing.T) {
func TestCreateTmpfsOverrideAnonymousVolume(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "windows does not support tmpfs")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
id := ctr.Create(ctx, t, client,
id := ctr.Create(ctx, t, apiClient,
ctr.WithVolume("/foo"),
ctr.WithTmpfs("/foo"),
ctr.WithVolume("/bar"),
@ -433,18 +433,18 @@ func TestCreateTmpfsOverrideAnonymousVolume(t *testing.T) {
)
defer func() {
err := client.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
err := apiClient.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
assert.NilError(t, err)
}()
inspect, err := client.ContainerInspect(ctx, id)
inspect, err := apiClient.ContainerInspect(ctx, id)
assert.NilError(t, err)
// tmpfs do not currently get added to inspect.Mounts
// Normally an anonymous volume would, except now tmpfs should prevent that.
assert.Assert(t, is.Len(inspect.Mounts, 0))
chWait, chErr := client.ContainerWait(ctx, id, container.WaitConditionNextExit)
assert.NilError(t, client.ContainerStart(ctx, id, types.ContainerStartOptions{}))
chWait, chErr := apiClient.ContainerWait(ctx, id, container.WaitConditionNextExit)
assert.NilError(t, apiClient.ContainerStart(ctx, id, types.ContainerStartOptions{}))
timeout := time.NewTimer(30 * time.Second)
defer timeout.Stop()
@ -467,10 +467,10 @@ func TestCreateTmpfsOverrideAnonymousVolume(t *testing.T) {
// error.
func TestCreateDifferentPlatform(t *testing.T) {
defer setupTest(t)()
c := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
img, _, err := c.ImageInspectWithRaw(ctx, "busybox:latest")
img, _, err := apiClient.ImageInspectWithRaw(ctx, "busybox:latest")
assert.NilError(t, err)
assert.Assert(t, img.Architecture != "")
@ -480,7 +480,7 @@ func TestCreateDifferentPlatform(t *testing.T) {
Architecture: img.Architecture,
Variant: img.Variant,
}
_, err := c.ContainerCreate(ctx, &containertypes.Config{Image: "busybox:latest"}, &containertypes.HostConfig{}, nil, &p, "")
_, err := apiClient.ContainerCreate(ctx, &containertypes.Config{Image: "busybox:latest"}, &containertypes.HostConfig{}, nil, &p, "")
assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
})
t.Run("different cpu arch", func(t *testing.T) {
@ -489,16 +489,16 @@ func TestCreateDifferentPlatform(t *testing.T) {
Architecture: img.Architecture + "DifferentArch",
Variant: img.Variant,
}
_, err := c.ContainerCreate(ctx, &containertypes.Config{Image: "busybox:latest"}, &containertypes.HostConfig{}, nil, &p, "")
_, err := apiClient.ContainerCreate(ctx, &containertypes.Config{Image: "busybox:latest"}, &containertypes.HostConfig{}, nil, &p, "")
assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
})
}
func TestCreateVolumesFromNonExistingContainer(t *testing.T) {
defer setupTest(t)()
cli := testEnv.APIClient()
apiClient := testEnv.APIClient()
_, err := cli.ContainerCreate(
_, err := apiClient.ContainerCreate(
context.Background(),
&container.Config{Image: "busybox"},
&container.HostConfig{VolumesFrom: []string{"nosuchcontainer"}},
@ -516,9 +516,9 @@ func TestCreatePlatformSpecificImageNoPlatform(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.Architecture == "arm", "test only makes sense to run on non-arm systems")
skip.If(t, testEnv.DaemonInfo.OSType != "linux", "test image is only available on linux")
cli := testEnv.APIClient()
apiClient := testEnv.APIClient()
_, err := cli.ContainerCreate(
_, err := apiClient.ContainerCreate(
context.Background(),
&container.Config{Image: "arm32v7/hello-world"},
&container.HostConfig{},

20
integration/container/daemon_linux_test.go
View file

@ -194,12 +194,12 @@ func TestRestartDaemonWithRestartingContainer(t *testing.T) {
defer d.Stop(t)
ctx := context.Background()
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
// Just create the container, no need to start it to be started.
// We really want to make sure there is no process running when docker starts back up.
// We will manipulate the on disk state later
id := container.Create(ctx, t, client, container.WithRestartPolicy("always"), container.WithCmd("/bin/sh", "-c", "exit 1"))
id := container.Create(ctx, t, apiClient, container.WithRestartPolicy("always"), container.WithCmd("/bin/sh", "-c", "exit 1"))
d.Stop(t)
@ -212,7 +212,7 @@ func TestRestartDaemonWithRestartingContainer(t *testing.T) {
ctxTimeout, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
chOk, chErr := client.ContainerWait(ctxTimeout, id, containerapi.WaitConditionNextExit)
chOk, chErr := apiClient.ContainerWait(ctxTimeout, id, containerapi.WaitConditionNextExit)
select {
case <-chOk:
case err := <-chErr:
@ -239,17 +239,17 @@ func TestHardRestartWhenContainerIsRunning(t *testing.T) {
defer d.Stop(t)
ctx := context.Background()
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
// Just create the containers, no need to start them.
// We really want to make sure there is no process running when docker starts back up.
// We will manipulate the on disk state later.
nopolicy := container.Create(ctx, t, client, container.WithCmd("/bin/sh", "-c", "exit 1"))
onfailure := container.Create(ctx, t, client, container.WithRestartPolicy("on-failure"), container.WithCmd("/bin/sh", "-c", "sleep 60"))
noPolicy := container.Create(ctx, t, apiClient, container.WithCmd("/bin/sh", "-c", "exit 1"))
onFailure := container.Create(ctx, t, apiClient, container.WithRestartPolicy("on-failure"), container.WithCmd("/bin/sh", "-c", "sleep 60"))
d.Stop(t)
for _, id := range []string{nopolicy, onfailure} {
for _, id := range []string{noPolicy, onFailure} {
d.TamperWithContainerConfig(t, id, func(c *realcontainer.Container) {
c.SetRunning(nil, nil, true)
c.HasBeenStartedBefore = true
@ -261,7 +261,7 @@ func TestHardRestartWhenContainerIsRunning(t *testing.T) {
t.Run("RestartPolicy=none", func(t *testing.T) {
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
inspect, err := client.ContainerInspect(ctx, nopolicy)
inspect, err := apiClient.ContainerInspect(ctx, noPolicy)
assert.NilError(t, err)
assert.Check(t, is.Equal(inspect.State.Status, "exited"))
assert.Check(t, is.Equal(inspect.State.ExitCode, 255))
@ -274,7 +274,7 @@ func TestHardRestartWhenContainerIsRunning(t *testing.T) {
t.Run("RestartPolicy=on-failure", func(t *testing.T) {
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
inspect, err := client.ContainerInspect(ctx, onfailure)
inspect, err := apiClient.ContainerInspect(ctx, onFailure)
assert.NilError(t, err)
assert.Check(t, is.Equal(inspect.State.Status, "running"))
assert.Check(t, is.Equal(inspect.State.ExitCode, 0))
@ -284,6 +284,6 @@ func TestHardRestartWhenContainerIsRunning(t *testing.T) {
}
stopTimeout := 0
assert.Assert(t, client.ContainerStop(ctx, onfailure, containerapi.StopOptions{Timeout: &stopTimeout}))
assert.Assert(t, apiClient.ContainerStop(ctx, onFailure, containerapi.StopOptions{Timeout: &stopTimeout}))
})
}

10
integration/container/daemon_test.go
View file

@ -27,25 +27,25 @@ func TestContainerKillOnDaemonStart(t *testing.T) {
d.StartWithBusybox(t, "--iptables=false")
defer d.Stop(t)
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
ctx := context.Background()
// The intention of this container is to ignore stop signals.
// Sadly this means the test will take longer, but at least this test can be parallelized.
id := container.Run(ctx, t, client, container.WithCmd("/bin/sh", "-c", "while true; do echo hello; sleep 1; done"))
id := container.Run(ctx, t, apiClient, container.WithCmd("/bin/sh", "-c", "while true; do echo hello; sleep 1; done"))
defer func() {
err := client.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
err := apiClient.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
assert.NilError(t, err)
}()
inspect, err := client.ContainerInspect(ctx, id)
inspect, err := apiClient.ContainerInspect(ctx, id)
assert.NilError(t, err)
assert.Assert(t, inspect.State.Running)
assert.NilError(t, d.Kill())
d.Start(t, "--iptables=false")
inspect, err = client.ContainerInspect(ctx, id)
inspect, err = apiClient.ContainerInspect(ctx, id)
assert.Check(t, is.Nil(err))
assert.Assert(t, !inspect.State.Running)
}

10
integration/container/devices_windows_test.go
View file

@ -19,7 +19,7 @@ import (
func TestWindowsDevices(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType != "windows")
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
testData := []struct {
@ -95,14 +95,14 @@ func TestWindowsDevices(t *testing.T) {
deviceOptions = append(deviceOptions, container.WithWindowsDevice(deviceName))
}
id := container.Create(ctx, t, client, deviceOptions...)
id := container.Create(ctx, t, apiClient, deviceOptions...)
// Hyper-V isolation is failing even with no actual devices added.
// TODO: Once https://github.com/moby/moby/issues/43395 is resolved,
// remove this skip.If and validate the expected behaviour under Hyper-V.
skip.If(t, d.isolation == containertypes.IsolationHyperV && !d.expectedStartFailure, "FIXME. HyperV isolation setup is probably incorrect in the test")
err := client.ContainerStart(ctx, id, types.ContainerStartOptions{})
err := apiClient.ContainerStart(ctx, id, types.ContainerStartOptions{})
if d.expectedStartFailure {
assert.ErrorContains(t, err, d.expectedStartFailureMessage)
return
@ -110,11 +110,11 @@ func TestWindowsDevices(t *testing.T) {
assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, id, "running"), poll.WithDelay(100*time.Millisecond))
// /Windows/System32/HostDriverStore is mounted from the host when class GUID 5B45201D-F2F2-4F3B-85BB-30FF1F953599
// is mounted. See `C:\windows\System32\containers\devices.def` on a Windows host for (slightly more) details.
res, err := container.Exec(ctx, client, id, []string{
res, err := container.Exec(ctx, apiClient, id, []string{
"sh", "-c",
"ls -d /Windows/System32/HostDriverStore/* | grep /Windows/System32/HostDriverStore/FileRepository",
})

8
integration/container/diff_test.go
View file

@ -15,10 +15,10 @@ import (
func TestDiff(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", `mkdir /foo; echo xyzzy > /foo/bar`))
cID := container.Run(ctx, t, apiClient, container.WithCmd("sh", "-c", `mkdir /foo; echo xyzzy > /foo/bar`))
// 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
@ -29,14 +29,14 @@ func TestDiff(t *testing.T) {
{Kind: containertypes.ChangeAdd, Path: "/foo/bar"},
}
if testEnv.DaemonInfo.OSType == "windows" {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond), poll.WithTimeout(60*time.Second))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond), poll.WithTimeout(60*time.Second))
expected = []containertypes.FilesystemChange{
{Kind: containertypes.ChangeModify, Path: "Files/foo"},
{Kind: containertypes.ChangeModify, Path: "Files/foo/bar"},
}
}
items, err := client.ContainerDiff(ctx, cID)
items, err := apiClient.ContainerDiff(ctx, cID)
assert.NilError(t, err)
assert.DeepEqual(t, expected, items)
}

6
integration/container/exec_linux_test.go
View file

@ -17,12 +17,12 @@ func TestExecConsoleSize(t *testing.T) {
skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.42"), "skip test from new feature")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithImage("busybox"))
cID := container.Run(ctx, t, apiClient, container.WithImage("busybox"))
result, err := container.Exec(ctx, client, cID, []string{"stty", "size"},
result, err := container.Exec(ctx, apiClient, cID, []string{"stty", "size"},
func(ec *types.ExecConfig) {
ec.Tty = true
ec.ConsoleSize = &[2]uint{57, 123}

24
integration/container/exec_test.go
View file

@ -22,13 +22,13 @@ func TestExecWithCloseStdin(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
// run top with detached mode
cID := container.Run(ctx, t, client)
cID := container.Run(ctx, t, apiClient)
expected := "closeIO"
execResp, err := client.ContainerExecCreate(ctx, cID,
execResp, err := apiClient.ContainerExecCreate(ctx, cID,
types.ExecConfig{
AttachStdin: true,
AttachStdout: true,
@ -37,7 +37,7 @@ func TestExecWithCloseStdin(t *testing.T) {
)
assert.NilError(t, err)
resp, err := client.ContainerExecAttach(ctx, execResp.ID,
resp, err := apiClient.ContainerExecAttach(ctx, execResp.ID,
types.ExecStartCheck{
Detach: false,
Tty: false,
@ -88,11 +88,11 @@ func TestExec(t *testing.T) {
skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.35"), "broken in earlier versions")
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
cID := container.Run(ctx, t, client, container.WithTty(true), container.WithWorkingDir("/root"))
cID := container.Run(ctx, t, apiClient, container.WithTty(true), container.WithWorkingDir("/root"))
id, err := client.ContainerExecCreate(ctx, cID,
id, err := apiClient.ContainerExecCreate(ctx, cID,
types.ExecConfig{
WorkingDir: "/tmp",
Env: strslice.StrSlice([]string{"FOO=BAR"}),
@ -102,11 +102,11 @@ func TestExec(t *testing.T) {
)
assert.NilError(t, err)
inspect, err := client.ContainerExecInspect(ctx, id.ID)
inspect, err := apiClient.ContainerExecInspect(ctx, id.ID)
assert.NilError(t, err)
assert.Check(t, is.Equal(inspect.ExecID, id.ID))
resp, err := client.ContainerExecAttach(ctx, id.ID,
resp, err := apiClient.ContainerExecAttach(ctx, id.ID,
types.ExecStartCheck{
Detach: false,
Tty: false,
@ -131,11 +131,11 @@ func TestExecUser(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME. Probably needs to wait for container to be in running state.")
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
cID := container.Run(ctx, t, client, container.WithTty(true), container.WithUser("1:1"))
cID := container.Run(ctx, t, apiClient, container.WithTty(true), container.WithUser("1:1"))
result, err := container.Exec(ctx, client, cID, []string{"id"})
result, err := container.Exec(ctx, apiClient, cID, []string{"id"})
assert.NilError(t, err)
assert.Assert(t, is.Contains(result.Stdout(), "uid=1(daemon) gid=1(daemon)"), "exec command not running as uid/gid 1")

12
integration/container/export_test.go
View file

@ -23,16 +23,16 @@ func TestExportContainerAndImportImage(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithCmd("true"))
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient, container.WithCmd("true"))
poll.WaitOn(t, container.IsStopped(ctx, apiClient, cID), poll.WithDelay(100*time.Millisecond))
reference := "repo/" + strings.ToLower(t.Name()) + ":v1"
exportResp, err := client.ContainerExport(ctx, cID)
exportResp, err := apiClient.ContainerExport(ctx, cID)
assert.NilError(t, err)
importResp, err := client.ImageImport(ctx, types.ImageImportSource{
importResp, err := apiClient.ImageImport(ctx, types.ImageImportSource{
Source: exportResp,
SourceName: "-",
}, reference, types.ImageImportOptions{})
@ -46,7 +46,7 @@ func TestExportContainerAndImportImage(t *testing.T) {
err = dec.Decode(&jm)
assert.NilError(t, err)
images, err := client.ImageList(ctx, types.ImageListOptions{
images, err := apiClient.ImageList(ctx, types.ImageListOptions{
Filters: filters.NewArgs(filters.Arg("reference", reference)),
})
assert.NilError(t, err)

28
integration/container/health_test.go
View file

@ -21,9 +21,9 @@ func TestHealthCheckWorkdir(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME")
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
cID := container.Run(ctx, t, client, container.WithTty(true), container.WithWorkingDir("/foo"), func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, container.WithTty(true), container.WithWorkingDir("/foo"), func(c *container.TestContainerConfig) {
c.Config.Healthcheck = &containertypes.HealthConfig{
Test: []string{"CMD-SHELL", "if [ \"$PWD\" = \"/foo\" ]; then exit 0; else exit 1; fi;"},
Interval: 50 * time.Millisecond,
@ -31,7 +31,7 @@ func TestHealthCheckWorkdir(t *testing.T) {
}
})
poll.WaitOn(t, pollForHealthStatus(ctx, client, cID, types.Healthy), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, pollForHealthStatus(ctx, apiClient, cID, types.Healthy), poll.WithDelay(100*time.Millisecond))
}
// GitHub #37263
@ -41,9 +41,9 @@ func TestHealthKillContainer(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
id := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
id := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
cmd := `
# Set the initial HEALTH value so the healthcheck passes
HEALTH="1"
@ -77,21 +77,21 @@ while true; do sleep 1; done
ctxPoll, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
poll.WaitOn(t, pollForHealthStatus(ctxPoll, client, id, "healthy"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, pollForHealthStatus(ctxPoll, apiClient, id, "healthy"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerKill(ctx, id, "SIGUSR1")
err := apiClient.ContainerKill(ctx, id, "SIGUSR1")
assert.NilError(t, err)
ctxPoll, cancel = context.WithTimeout(ctx, 30*time.Second)
defer cancel()
poll.WaitOn(t, pollForHealthStatus(ctxPoll, client, id, "unhealthy"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, pollForHealthStatus(ctxPoll, apiClient, id, "unhealthy"), poll.WithDelay(100*time.Millisecond))
err = client.ContainerKill(ctx, id, "SIGUSR1")
err = apiClient.ContainerKill(ctx, id, "SIGUSR1")
assert.NilError(t, err)
ctxPoll, cancel = context.WithTimeout(ctx, 30*time.Second)
defer cancel()
poll.WaitOn(t, pollForHealthStatus(ctxPoll, client, id, "healthy"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, pollForHealthStatus(ctxPoll, apiClient, id, "healthy"), poll.WithDelay(100*time.Millisecond))
}
// TestHealthCheckProcessKilled verifies that health-checks exec get killed on time-out.
@ -115,10 +115,10 @@ func TestHealthStartInterval(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "The shell commands used in the test healthcheck do not work on Windows")
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
// Note: Windows is much slower than linux so this use longer intervals/timeouts
id := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
id := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.Config.Healthcheck = &containertypes.HealthConfig{
Test: []string{"CMD-SHELL", `count="$(cat /tmp/health)"; if [ -z "${count}" ]; then let count=0; fi; let count=${count}+1; echo -n ${count} | tee /tmp/health; if [ ${count} -lt 3 ]; then exit 1; fi`},
Interval: 30 * time.Second,
@ -136,7 +136,7 @@ func TestHealthStartInterval(t *testing.T) {
if ctxPoll.Err() != nil {
return poll.Error(ctxPoll.Err())
}
inspect, err := client.ContainerInspect(ctxPoll, id)
inspect, err := apiClient.ContainerInspect(ctxPoll, id)
if err != nil {
return poll.Error(err)
}
@ -155,7 +155,7 @@ func TestHealthStartInterval(t *testing.T) {
dl, _ = ctxPoll.Deadline()
poll.WaitOn(t, func(log poll.LogT) poll.Result {
inspect, err := client.ContainerInspect(ctxPoll, id)
inspect, err := apiClient.ContainerInspect(ctxPoll, id)
if err != nil {
return poll.Error(err)
}

12
integration/container/inspect_test.go
View file

@ -20,7 +20,7 @@ func TestInspectCpusetInConfigPre120(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows" || !testEnv.DaemonInfo.CPUSet)
defer setupTest(t)()
client := request.NewAPIClient(t, client.WithVersion("1.19"))
apiClient := request.NewAPIClient(t, client.WithVersion("1.19"))
ctx := context.Background()
name := strings.ToLower(t.Name())
@ -31,9 +31,9 @@ func TestInspectCpusetInConfigPre120(t *testing.T) {
c.HostConfig.Resources.CpusetCpus = "0"
},
)
poll.WaitOn(t, container.IsInState(ctx, client, name, "exited"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, name, "exited"), poll.WithDelay(100*time.Millisecond))
_, body, err := client.ContainerInspectWithRaw(ctx, name, false)
_, body, err := apiClient.ContainerInspectWithRaw(ctx, name, false)
assert.NilError(t, err)
var inspectJSON map[string]interface{}
@ -50,7 +50,7 @@ func TestInspectCpusetInConfigPre120(t *testing.T) {
func TestInspectAnnotations(t *testing.T) {
defer setupTest(t)()
client := request.NewAPIClient(t)
apiClient := request.NewAPIClient(t)
ctx := context.Background()
annotations := map[string]string{
@ -59,7 +59,7 @@ func TestInspectAnnotations(t *testing.T) {
}
name := strings.ToLower(t.Name())
id := container.Create(ctx, t, client,
id := container.Create(ctx, t, apiClient,
container.WithName(name),
container.WithCmd("true"),
func(c *container.TestContainerConfig) {
@ -67,7 +67,7 @@ func TestInspectAnnotations(t *testing.T) {
},
)
inspect, err := client.ContainerInspect(ctx, id)
inspect, err := apiClient.ContainerInspect(ctx, id)
assert.NilError(t, err)
assert.Check(t, is.DeepEqual(inspect.HostConfig.Annotations, annotations))
}

46
integration/container/ipcmode_linux_test.go
View file

@ -62,19 +62,19 @@ func testIpcNonePrivateShareable(t *testing.T, mode string, mustBeMounted bool,
hostCfg := containertypes.HostConfig{
IpcMode: containertypes.IpcMode(mode),
}
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
resp, err := client.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
resp, err := apiClient.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
assert.NilError(t, err)
assert.Check(t, is.Equal(len(resp.Warnings), 0))
err = client.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
assert.NilError(t, err)
// get major:minor pair for /dev/shm from container's /proc/self/mountinfo
cmd := "awk '($5 == \"/dev/shm\") {printf $3}' /proc/self/mountinfo"
result, err := container.Exec(ctx, client, resp.ID, []string{"sh", "-c", cmd})
result, err := container.Exec(ctx, apiClient, resp.ID, []string{"sh", "-c", cmd})
assert.NilError(t, err)
mm := result.Combined()
if !mustBeMounted {
@ -134,25 +134,25 @@ func testIpcContainer(t *testing.T, donorMode string, mustWork bool) {
IpcMode: containertypes.IpcMode(donorMode),
}
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
// create and start the "donor" container
resp, err := client.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
resp, err := apiClient.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
assert.NilError(t, err)
assert.Check(t, is.Equal(len(resp.Warnings), 0))
name1 := resp.ID
err = client.ContainerStart(ctx, name1, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, name1, types.ContainerStartOptions{})
assert.NilError(t, err)
// create and start the second container
hostCfg.IpcMode = containertypes.IpcMode("container:" + name1)
resp, err = client.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
resp, err = apiClient.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
assert.NilError(t, err)
assert.Check(t, is.Equal(len(resp.Warnings), 0))
name2 := resp.ID
err = client.ContainerStart(ctx, name2, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, name2, types.ContainerStartOptions{})
if !mustWork {
// start should fail with a specific error
assert.Check(t, is.ErrorContains(err, "non-shareable IPC"))
@ -165,10 +165,10 @@ func testIpcContainer(t *testing.T, donorMode string, mustWork bool) {
// check that IPC is shared
// 1. create a file in the first container
_, err = container.Exec(ctx, client, name1, []string{"sh", "-c", "printf covfefe > /dev/shm/bar"})
_, err = container.Exec(ctx, apiClient, name1, []string{"sh", "-c", "printf covfefe > /dev/shm/bar"})
assert.NilError(t, err)
// 2. check it's the same file in the second one
result, err := container.Exec(ctx, client, name2, []string{"cat", "/dev/shm/bar"})
result, err := container.Exec(ctx, apiClient, name2, []string{"cat", "/dev/shm/bar"})
assert.NilError(t, err)
out := result.Combined()
assert.Check(t, is.Equal(true, regexp.MustCompile("^covfefe$").MatchString(out)))
@ -201,25 +201,25 @@ func TestAPIIpcModeHost(t *testing.T) {
}
ctx := context.Background()
client := testEnv.APIClient()
resp, err := client.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
apiClient := testEnv.APIClient()
resp, err := apiClient.ContainerCreate(ctx, &cfg, &hostCfg, nil, nil, "")
assert.NilError(t, err)
assert.Check(t, is.Equal(len(resp.Warnings), 0))
name := resp.ID
err = client.ContainerStart(ctx, name, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, name, types.ContainerStartOptions{})
assert.NilError(t, err)
// check that IPC is shared
// 1. create a file inside container
_, err = container.Exec(ctx, client, name, []string{"sh", "-c", "printf covfefe > /dev/shm/." + name})
_, err = container.Exec(ctx, apiClient, name, []string{"sh", "-c", "printf covfefe > /dev/shm/." + name})
assert.NilError(t, err)
// 2. check it's the same on the host
bytes, err := os.ReadFile("/dev/shm/." + name)
assert.NilError(t, err)
assert.Check(t, is.Equal("covfefe", string(bytes)))
// 3. clean up
_, err = container.Exec(ctx, client, name, []string{"rm", "-f", "/dev/shm/." + name})
_, err = container.Exec(ctx, apiClient, name, []string{"rm", "-f", "/dev/shm/." + name})
assert.NilError(t, err)
}
@ -303,25 +303,25 @@ func TestDaemonIpcModeShareableFromConfig(t *testing.T) {
// by default, even when the daemon default is private.
func TestIpcModeOlderClient(t *testing.T) {
skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.40"), "requires a daemon with DefaultIpcMode: private")
c := testEnv.APIClient()
skip.If(t, versions.LessThan(c.ClientVersion(), "1.40"), "requires client API >= 1.40")
apiClient := testEnv.APIClient()
skip.If(t, versions.LessThan(apiClient.ClientVersion(), "1.40"), "requires client API >= 1.40")
t.Parallel()
ctx := context.Background()
// pre-check: default ipc mode in daemon is private
cID := container.Create(ctx, t, c, container.WithAutoRemove)
cID := container.Create(ctx, t, apiClient, container.WithAutoRemove)
inspect, err := c.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "private"))
// main check: using older client creates "shareable" container
c = request.NewAPIClient(t, client.WithVersion("1.39"))
cID = container.Create(ctx, t, c, container.WithAutoRemove)
apiClient = request.NewAPIClient(t, client.WithVersion("1.39"))
cID = container.Create(ctx, t, apiClient, container.WithAutoRemove)
inspect, err = c.ContainerInspect(ctx, cID)
inspect, err = apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "shareable"))
}

66
integration/container/kill_test.go
View file

@ -17,24 +17,24 @@ import (
func TestKillContainerInvalidSignal(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
id := container.Run(ctx, t, client)
id := container.Run(ctx, t, apiClient)
err := client.ContainerKill(ctx, id, "0")
err := apiClient.ContainerKill(ctx, id, "0")
assert.ErrorContains(t, err, "Error response from daemon:")
assert.ErrorContains(t, err, "nvalid signal: 0") // match "(I|i)nvalid" case-insensitive to allow testing against older daemons.
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, id, "running"), poll.WithDelay(100*time.Millisecond))
err = client.ContainerKill(ctx, id, "SIG42")
err = apiClient.ContainerKill(ctx, id, "SIG42")
assert.ErrorContains(t, err, "Error response from daemon:")
assert.ErrorContains(t, err, "nvalid signal: SIG42") // match "(I|i)nvalid" case-insensitive to allow testing against older daemons.
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, id, "running"), poll.WithDelay(100*time.Millisecond))
}
func TestKillContainer(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
testCases := []struct {
doc string
@ -72,18 +72,18 @@ func TestKillContainer(t *testing.T) {
t.Run(tc.doc, func(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == tc.skipOs, "Windows does not support SIGWINCH")
ctx := context.Background()
id := container.Run(ctx, t, client)
err := client.ContainerKill(ctx, id, tc.signal)
id := container.Run(ctx, t, apiClient)
err := apiClient.ContainerKill(ctx, id, tc.signal)
assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, id, tc.status), pollOpts...)
poll.WaitOn(t, container.IsInState(ctx, apiClient, id, tc.status), pollOpts...)
})
}
}
func TestKillWithStopSignalAndRestartPolicies(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
testCases := []struct {
doc string
@ -111,15 +111,15 @@ func TestKillWithStopSignalAndRestartPolicies(t *testing.T) {
tc := tc
t.Run(tc.doc, func(t *testing.T) {
ctx := context.Background()
id := container.Run(ctx, t, client,
id := container.Run(ctx, t, apiClient,
container.WithRestartPolicy("always"),
func(c *container.TestContainerConfig) {
c.Config.StopSignal = tc.stopsignal
})
err := client.ContainerKill(ctx, id, "TERM")
err := apiClient.ContainerKill(ctx, id, "TERM")
assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, id, tc.status), pollOpts...)
poll.WaitOn(t, container.IsInState(ctx, apiClient, id, tc.status), pollOpts...)
})
}
}
@ -127,9 +127,9 @@ func TestKillWithStopSignalAndRestartPolicies(t *testing.T) {
func TestKillStoppedContainer(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
id := container.Create(ctx, t, client)
err := client.ContainerKill(ctx, id, "SIGKILL")
apiClient := testEnv.APIClient()
id := container.Create(ctx, t, apiClient)
err := apiClient.ContainerKill(ctx, id, "SIGKILL")
assert.Assert(t, is.ErrorContains(err, ""))
assert.Assert(t, is.Contains(err.Error(), "is not running"))
}
@ -138,9 +138,9 @@ func TestKillStoppedContainerAPIPre120(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "Windows only supports 1.25 or later")
defer setupTest(t)()
ctx := context.Background()
client := request.NewAPIClient(t, client.WithVersion("1.19"))
id := container.Create(ctx, t, client)
err := client.ContainerKill(ctx, id, "SIGKILL")
apiClient := request.NewAPIClient(t, client.WithVersion("1.19"))
id := container.Create(ctx, t, apiClient)
err := apiClient.ContainerKill(ctx, id, "SIGKILL")
assert.NilError(t, err)
}
@ -150,16 +150,16 @@ func TestKillDifferentUserContainer(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := request.NewAPIClient(t, client.WithVersion("1.19"))
apiClient := request.NewAPIClient(t, client.WithVersion("1.19"))
id := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
id := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.Config.User = "daemon"
})
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, id, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerKill(ctx, id, "SIGKILL")
err := apiClient.ContainerKill(ctx, id, "SIGKILL")
assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, id, "exited"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, id, "exited"), poll.WithDelay(100*time.Millisecond))
}
func TestInspectOomKilledTrue(t *testing.T) {
@ -170,15 +170,15 @@ func TestInspectOomKilledTrue(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
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) {
cID := container.Run(ctx, t, apiClient, 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
})
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(true, inspect.State.OOMKilled))
}
@ -188,13 +188,13 @@ func TestInspectOomKilledFalse(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", "echo hello world"))
cID := container.Run(ctx, t, apiClient, 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, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(false, inspect.State.OOMKilled))
}

14
integration/container/links_linux_test.go
View file

@ -21,11 +21,11 @@ func TestLinksEtcHostsContentMatch(t *testing.T) {
skip.If(t, os.IsNotExist(err))
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithNetworkMode("host"))
res, err := container.Exec(ctx, client, cID, []string{"cat", "/etc/hosts"})
cID := container.Run(ctx, t, apiClient, container.WithNetworkMode("host"))
res, err := container.Exec(ctx, apiClient, cID, []string{"cat", "/etc/hosts"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
assert.Equal(t, 0, res.ExitCode)
@ -37,15 +37,15 @@ func TestLinksContainerNames(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
containerA := "first_" + t.Name()
containerB := "second_" + t.Name()
container.Run(ctx, t, client, container.WithName(containerA))
container.Run(ctx, t, client, container.WithName(containerB), container.WithLinks(containerA+":"+containerA))
container.Run(ctx, t, apiClient, container.WithName(containerA))
container.Run(ctx, t, apiClient, container.WithName(containerB), container.WithLinks(containerA+":"+containerA))
containers, err := client.ContainerList(ctx, types.ContainerListOptions{
containers, err := apiClient.ContainerList(ctx, types.ContainerListOptions{
Filters: filters.NewArgs(filters.Arg("name", containerA)),
})
assert.NilError(t, err)

16
integration/container/logs_test.go
View file

@ -26,12 +26,12 @@ func TestLogsFollowTailEmpty(t *testing.T) {
// FIXME(vdemeester) fails on a e2e run on linux...
skip.If(t, testEnv.IsRemoteDaemon)
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
id := container.Run(ctx, t, client, container.WithCmd("sleep", "100000"))
id := container.Run(ctx, t, apiClient, container.WithCmd("sleep", "100000"))
logs, err := client.ContainerLogs(ctx, id, types.ContainerLogsOptions{ShowStdout: true, Tail: "2"})
logs, err := apiClient.ContainerLogs(ctx, id, types.ContainerLogsOptions{ShowStdout: true, Tail: "2"})
if logs != nil {
defer logs.Close()
}
@ -53,7 +53,7 @@ func TestLogs(t *testing.T) {
func testLogs(t *testing.T, logDriver string) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
testCases := []struct {
@ -134,18 +134,18 @@ func testLogs(t *testing.T, logDriver string) {
t.Run(tC.desc, func(t *testing.T) {
t.Parallel()
tty := tC.tty
id := container.Run(ctx, t, client,
id := container.Run(ctx, t, apiClient,
container.WithCmd("sh", "-c", "echo -n this is fine; echo -n accidents happen >&2"),
container.WithTty(tty),
container.WithLogDriver(logDriver),
)
defer client.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
defer apiClient.ContainerRemove(ctx, id, types.ContainerRemoveOptions{Force: true})
poll.WaitOn(t, container.IsStopped(ctx, client, id),
poll.WaitOn(t, container.IsStopped(ctx, apiClient, id),
poll.WithDelay(time.Millisecond*100),
poll.WithTimeout(pollTimeout))
logs, err := client.ContainerLogs(ctx, id, tC.logOps)
logs, err := apiClient.ContainerLogs(ctx, id, tC.logOps)
assert.NilError(t, err)
defer logs.Close()

52
integration/container/mounts_linux_test.go
View file

@ -92,9 +92,9 @@ func TestMountDaemonRoot(t *testing.T) {
skip.If(t, testEnv.IsRemoteDaemon)
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
info, err := client.Info(ctx)
info, err := apiClient.Info(ctx)
if err != nil {
t.Fatal(err)
}
@ -175,7 +175,7 @@ func TestMountDaemonRoot(t *testing.T) {
hc := hc
t.Parallel()
c, err := client.ContainerCreate(ctx, &containertypes.Config{
c, err := apiClient.ContainerCreate(ctx, &containertypes.Config{
Image: "busybox",
Cmd: []string{"true"},
}, hc, nil, nil, "")
@ -191,12 +191,12 @@ func TestMountDaemonRoot(t *testing.T) {
}
defer func() {
if err := client.ContainerRemove(ctx, c.ID, types.ContainerRemoveOptions{Force: true}); err != nil {
if err := apiClient.ContainerRemove(ctx, c.ID, types.ContainerRemoveOptions{Force: true}); err != nil {
panic(err)
}
}()
inspect, err := client.ContainerInspect(ctx, c.ID)
inspect, err := apiClient.ContainerInspect(ctx, c.ID)
if err != nil {
t.Fatal(err)
}
@ -258,15 +258,15 @@ func TestContainerBindMountNonRecursive(t *testing.T) {
nonRecursiveVerifier := []string{"test", "!", "-f", "/foo/mnt/file"}
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
containers := []string{
container.Run(ctx, t, client, container.WithMount(implicit), container.WithCmd(recursiveVerifier...)),
container.Run(ctx, t, client, container.WithMount(recursive), container.WithCmd(recursiveVerifier...)),
container.Run(ctx, t, client, container.WithMount(nonRecursive), container.WithCmd(nonRecursiveVerifier...)),
container.Run(ctx, t, apiClient, container.WithMount(implicit), container.WithCmd(recursiveVerifier...)),
container.Run(ctx, t, apiClient, container.WithMount(recursive), container.WithCmd(recursiveVerifier...)),
container.Run(ctx, t, apiClient, container.WithMount(nonRecursive), container.WithCmd(nonRecursiveVerifier...)),
}
for _, c := range containers {
poll.WaitOn(t, container.IsSuccessful(ctx, client, c), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsSuccessful(ctx, apiClient, c), poll.WithDelay(100*time.Millisecond))
}
}
@ -311,9 +311,9 @@ func TestContainerVolumesMountedAsShared(t *testing.T) {
bindMountCmd := []string{"mount", "--bind", "/volume-dest/mnt1", "/volume-dest/mnt1"}
ctx := context.Background()
client := testEnv.APIClient()
containerID := container.Run(ctx, t, client, container.WithPrivileged(true), container.WithMount(sharedMount), container.WithCmd(bindMountCmd...))
poll.WaitOn(t, container.IsSuccessful(ctx, client, containerID), poll.WithDelay(100*time.Millisecond))
apiClient := testEnv.APIClient()
containerID := container.Run(ctx, t, apiClient, container.WithPrivileged(true), container.WithMount(sharedMount), container.WithCmd(bindMountCmd...))
poll.WaitOn(t, container.IsSuccessful(ctx, apiClient, containerID), poll.WithDelay(100*time.Millisecond))
// Make sure a bind mount under a shared volume propagated to host.
if mounted, _ := mountinfo.Mounted(tmpDir1Mnt); !mounted {
@ -368,8 +368,8 @@ func TestContainerVolumesMountedAsSlave(t *testing.T) {
topCmd := []string{"top"}
ctx := context.Background()
client := testEnv.APIClient()
containerID := container.Run(ctx, t, client, container.WithTty(true), container.WithMount(slaveMount), container.WithCmd(topCmd...))
apiClient := testEnv.APIClient()
containerID := container.Run(ctx, t, apiClient, container.WithTty(true), container.WithMount(slaveMount), container.WithCmd(topCmd...))
// Bind mount tmpDir2/ onto tmpDir1/mnt1. If mount propagates inside
// container then contents of tmpDir2/slave-testfile should become
@ -385,7 +385,7 @@ func TestContainerVolumesMountedAsSlave(t *testing.T) {
mountCmd := []string{"cat", "/volume-dest/mnt1/slave-testfile"}
if result, err := container.Exec(ctx, client, containerID, mountCmd); err == nil {
if result, err := container.Exec(ctx, apiClient, containerID, mountCmd); err == nil {
if result.Stdout() != "Test" {
t.Fatalf("Bind mount under slave volume did not propagate to container")
}
@ -408,12 +408,12 @@ func TestContainerCopyLeaksMounts(t *testing.T) {
}
ctx := context.Background()
client := testEnv.APIClient()
cid := container.Run(ctx, t, client, container.WithMount(bindMount), container.WithCmd("sleep", "120s"))
apiClient := testEnv.APIClient()
cid := container.Run(ctx, t, apiClient, container.WithMount(bindMount), container.WithCmd("sleep", "120s"))
getMounts := func() string {
t.Helper()
res, err := container.Exec(ctx, client, cid, []string{"cat", "/proc/self/mountinfo"})
res, err := container.Exec(ctx, apiClient, cid, []string{"cat", "/proc/self/mountinfo"})
assert.NilError(t, err)
assert.Equal(t, res.ExitCode, 0)
return res.Stdout()
@ -421,7 +421,7 @@ func TestContainerCopyLeaksMounts(t *testing.T) {
mountsBefore := getMounts()
_, _, err := client.CopyFromContainer(ctx, cid, "/etc/passwd")
_, _, err := apiClient.CopyFromContainer(ctx, cid, "/etc/passwd")
assert.NilError(t, err)
mountsAfter := getMounts()
@ -489,22 +489,22 @@ func TestContainerBindMountRecursivelyReadOnly(t *testing.T) {
}
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
containers := []string{
container.Run(ctx, t, client, container.WithMount(ro), container.WithCmd(roVerifier...)),
container.Run(ctx, t, client, container.WithBindRaw(roAsStr), container.WithCmd(roVerifier...)),
container.Run(ctx, t, apiClient, container.WithMount(ro), container.WithCmd(roVerifier...)),
container.Run(ctx, t, apiClient, container.WithBindRaw(roAsStr), container.WithCmd(roVerifier...)),
container.Run(ctx, t, client, container.WithMount(nonRecursive), container.WithCmd(nonRecursiveVerifier...)),
container.Run(ctx, t, apiClient, container.WithMount(nonRecursive), container.WithCmd(nonRecursiveVerifier...)),
}
if rroSupported {
containers = append(containers,
container.Run(ctx, t, client, container.WithMount(forceRecursive), container.WithCmd(forceRecursiveVerifier...)),
container.Run(ctx, t, apiClient, container.WithMount(forceRecursive), container.WithCmd(forceRecursiveVerifier...)),
)
}
for _, c := range containers {
poll.WaitOn(t, container.IsSuccessful(ctx, client, c), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsSuccessful(ctx, apiClient, c), poll.WithDelay(100*time.Millisecond))
}
}

14
integration/container/nat_test.go
View file

@ -67,18 +67,18 @@ func TestNetworkLoopbackNat(t *testing.T) {
endpoint := getExternalAddress(t)
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client,
cID := container.Run(ctx, t, apiClient,
container.WithCmd("sh", "-c", fmt.Sprintf("stty raw && nc -w 1 %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, apiClient, cID), poll.WithDelay(100*time.Millisecond))
body, err := client.ContainerLogs(ctx, cID, types.ContainerLogsOptions{
body, err := apiClient.ContainerLogs(ctx, cID, types.ContainerLogsOptions{
ShowStdout: true,
})
assert.NilError(t, err)
@ -93,10 +93,10 @@ func TestNetworkLoopbackNat(t *testing.T) {
func startServerContainer(t *testing.T, msg string, port int) string {
t.Helper()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client,
cID := container.Run(ctx, t, apiClient,
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)),
@ -110,7 +110,7 @@ func startServerContainer(t *testing.T, msg string, port int) string {
}
})
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
return cID
}

38
integration/container/pause_test.go
View file

@ -25,27 +25,27 @@ func TestPause(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.CgroupDriver == "none")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient)
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
since := request.DaemonUnixTime(ctx, t, client, testEnv)
since := request.DaemonUnixTime(ctx, t, apiClient, testEnv)
err := client.ContainerPause(ctx, cID)
err := apiClient.ContainerPause(ctx, cID)
assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(true, inspect.State.Paused))
err = client.ContainerUnpause(ctx, cID)
err = apiClient.ContainerUnpause(ctx, cID)
assert.NilError(t, err)
until := request.DaemonUnixTime(ctx, t, client, testEnv)
until := request.DaemonUnixTime(ctx, t, apiClient, testEnv)
messages, errs := client.Events(ctx, types.EventsOptions{
messages, errs := apiClient.Events(ctx, types.EventsOptions{
Since: since,
Until: until,
Filters: filters.NewArgs(filters.Arg("container", cID)),
@ -57,13 +57,13 @@ func TestPauseFailsOnWindowsServerContainers(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType != "windows" || testEnv.DaemonInfo.Isolation != "process")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient)
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerPause(ctx, cID)
err := apiClient.ContainerPause(ctx, cID)
assert.Check(t, is.ErrorContains(err, cerrdefs.ErrNotImplemented.Error()))
}
@ -72,19 +72,19 @@ func TestPauseStopPausedContainer(t *testing.T) {
skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.31"), "broken in earlier versions")
skip.If(t, testEnv.DaemonInfo.CgroupDriver == "none")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient)
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerPause(ctx, cID)
err := apiClient.ContainerPause(ctx, cID)
assert.NilError(t, err)
err = client.ContainerStop(ctx, cID, containertypes.StopOptions{})
err = apiClient.ContainerStop(ctx, cID, containertypes.StopOptions{})
assert.NilError(t, err)
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsStopped(ctx, apiClient, cID), poll.WithDelay(100*time.Millisecond))
}
func getEventActions(t *testing.T, messages <-chan events.Message, errs <-chan error) []string {

14
integration/container/pidmode_linux_test.go
View file

@ -20,18 +20,18 @@ func TestPidHost(t *testing.T) {
assert.NilError(t, err)
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.HostConfig.PidMode = "host"
})
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cPid := container.GetContainerNS(ctx, t, client, cID, "pid")
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
cPid := container.GetContainerNS(ctx, t, apiClient, cID, "pid")
assert.Assert(t, hostPid == cPid)
cID = container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cPid = container.GetContainerNS(ctx, t, client, cID, "pid")
cID = container.Run(ctx, t, apiClient)
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
cPid = container.GetContainerNS(ctx, t, apiClient, cID, "pid")
assert.Assert(t, hostPid != cPid)
}

12
integration/container/ps_test.go
View file

@ -13,12 +13,12 @@ import (
func TestPsFilter(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
prev := container.Create(ctx, t, client)
top := container.Create(ctx, t, client)
next := container.Create(ctx, t, client)
prev := container.Create(ctx, t, apiClient)
top := container.Create(ctx, t, apiClient)
next := container.Create(ctx, t, apiClient)
containerIDs := func(containers []types.Container) []string {
var entries []string
@ -29,7 +29,7 @@ func TestPsFilter(t *testing.T) {
}
t.Run("since", func(t *testing.T) {
results, err := client.ContainerList(ctx, types.ContainerListOptions{
results, err := apiClient.ContainerList(ctx, types.ContainerListOptions{
All: true,
Filters: filters.NewArgs(filters.Arg("since", top)),
})
@ -38,7 +38,7 @@ func TestPsFilter(t *testing.T) {
})
t.Run("before", func(t *testing.T) {
results, err := client.ContainerList(ctx, types.ContainerListOptions{
results, err := apiClient.ContainerList(ctx, types.ContainerListOptions{
All: true,
Filters: filters.NewArgs(filters.Arg("before", top)),
})

38
integration/container/remove_test.go
View file

@ -30,25 +30,25 @@ func TestRemoveContainerWithRemovedVolume(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
prefix, slash := getPrefixAndSlashFromDaemonPlatform()
tempDir := fs.NewDir(t, "test-rm-container-with-removed-volume", fs.WithMode(0o755))
defer tempDir.Remove()
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))
cID := container.Run(ctx, t, apiClient, container.WithCmd("true"), container.WithBind(tempDir.Path(), prefix+slash+"test"))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond))
err := os.RemoveAll(tempDir.Path())
assert.NilError(t, err)
err = client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
err = apiClient.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
RemoveVolumes: true,
})
assert.NilError(t, err)
_, _, err = client.ContainerInspectWithRaw(ctx, cID, true)
_, _, err = apiClient.ContainerInspectWithRaw(ctx, cID, true)
assert.Check(t, is.ErrorContains(err, "No such container"))
}
@ -56,24 +56,24 @@ func TestRemoveContainerWithRemovedVolume(t *testing.T) {
func TestRemoveContainerWithVolume(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
prefix, slash := getPrefixAndSlashFromDaemonPlatform()
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))
cID := container.Run(ctx, t, apiClient, container.WithCmd("true"), container.WithVolume(prefix+slash+"srv"))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond))
insp, _, err := client.ContainerInspectWithRaw(ctx, cID, true)
insp, _, err := apiClient.ContainerInspectWithRaw(ctx, cID, true)
assert.NilError(t, err)
assert.Check(t, is.Equal(1, len(insp.Mounts)))
volName := insp.Mounts[0].Name
err = client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
err = apiClient.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
RemoveVolumes: true,
})
assert.NilError(t, err)
volumes, err := client.VolumeList(ctx, volume.ListOptions{
volumes, err := apiClient.VolumeList(ctx, volume.ListOptions{
Filters: filters.NewArgs(filters.Arg("name", volName)),
})
assert.NilError(t, err)
@ -83,22 +83,22 @@ func TestRemoveContainerWithVolume(t *testing.T) {
func TestRemoveContainerRunning(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
cID := container.Run(ctx, t, client)
cID := container.Run(ctx, t, apiClient)
err := client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{})
err := apiClient.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{})
assert.Check(t, is.ErrorContains(err, "cannot remove a running container"))
}
func TestRemoveContainerForceRemoveRunning(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
cID := container.Run(ctx, t, client)
cID := container.Run(ctx, t, apiClient)
err := client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
err := apiClient.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
Force: true,
})
assert.NilError(t, err)
@ -107,8 +107,8 @@ func TestRemoveContainerForceRemoveRunning(t *testing.T) {
func TestRemoveInvalidContainer(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
err := client.ContainerRemove(ctx, "unknown", types.ContainerRemoveOptions{})
err := apiClient.ContainerRemove(ctx, "unknown", types.ContainerRemoveOptions{})
assert.Check(t, is.ErrorContains(err, "No such container"))
}

100
integration/container/rename_test.go
View file

@ -26,24 +26,24 @@ func TestRenameLinkedContainer(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME")
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
aName := "a0" + t.Name()
bName := "b0" + t.Name()
aID := container.Run(ctx, t, client, container.WithName(aName))
bID := container.Run(ctx, t, client, container.WithName(bName), container.WithLinks(aName))
aID := container.Run(ctx, t, apiClient, container.WithName(aName))
bID := container.Run(ctx, t, apiClient, container.WithName(bName), container.WithLinks(aName))
err := client.ContainerRename(ctx, aID, "a1"+t.Name())
err := apiClient.ContainerRename(ctx, aID, "a1"+t.Name())
assert.NilError(t, err)
container.Run(ctx, t, client, container.WithName(aName))
container.Run(ctx, t, apiClient, container.WithName(aName))
err = client.ContainerRemove(ctx, bID, types.ContainerRemoveOptions{Force: true})
err = apiClient.ContainerRemove(ctx, bID, types.ContainerRemoveOptions{Force: true})
assert.NilError(t, err)
bID = container.Run(ctx, t, client, container.WithName(bName), container.WithLinks(aName))
bID = container.Run(ctx, t, apiClient, container.WithName(bName), container.WithLinks(aName))
inspect, err := client.ContainerInspect(ctx, bID)
inspect, err := apiClient.ContainerInspect(ctx, bID)
assert.NilError(t, err)
assert.Check(t, is.DeepEqual([]string{"/" + aName + ":/" + bName + "/" + aName}, inspect.HostConfig.Links))
}
@ -51,21 +51,21 @@ func TestRenameLinkedContainer(t *testing.T) {
func TestRenameStoppedContainer(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
oldName := "first_name" + t.Name()
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))
cID := container.Run(ctx, t, apiClient, container.WithName(oldName), container.WithCmd("sh"))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal("/"+oldName, inspect.Name))
newName := "new_name" + stringid.GenerateRandomID()
err = client.ContainerRename(ctx, oldName, newName)
err = apiClient.ContainerRename(ctx, oldName, newName)
assert.NilError(t, err)
inspect, err = client.ContainerInspect(ctx, cID)
inspect, err = apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal("/"+newName, inspect.Name))
}
@ -73,27 +73,27 @@ func TestRenameStoppedContainer(t *testing.T) {
func TestRenameRunningContainerAndReuse(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
oldName := "first_name" + t.Name()
cID := container.Run(ctx, t, client, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
newName := "new_name" + stringid.GenerateRandomID()
err := client.ContainerRename(ctx, oldName, newName)
err := apiClient.ContainerRename(ctx, oldName, newName)
assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal("/"+newName, inspect.Name))
_, err = client.ContainerInspect(ctx, oldName)
_, err = apiClient.ContainerInspect(ctx, oldName)
assert.Check(t, is.ErrorContains(err, "No such container: "+oldName))
cID = container.Run(ctx, t, client, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID = container.Run(ctx, t, apiClient, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
inspect, err = client.ContainerInspect(ctx, cID)
inspect, err = apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal("/"+oldName, inspect.Name))
}
@ -101,16 +101,16 @@ func TestRenameRunningContainerAndReuse(t *testing.T) {
func TestRenameInvalidName(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
oldName := "first_name" + t.Name()
cID := container.Run(ctx, t, client, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerRename(ctx, oldName, "new:invalid")
err := apiClient.ContainerRename(ctx, oldName, "new:invalid")
assert.Check(t, is.ErrorContains(err, "Invalid container name"))
inspect, err := client.ContainerInspect(ctx, oldName)
inspect, err := apiClient.ContainerInspect(ctx, oldName)
assert.NilError(t, err)
assert.Check(t, is.Equal(cID, inspect.ID))
}
@ -125,13 +125,13 @@ func TestRenameInvalidName(t *testing.T) {
func TestRenameAnonymousContainer(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
networkName := "network1" + t.Name()
_, err := client.NetworkCreate(ctx, networkName, types.NetworkCreate{})
_, err := apiClient.NetworkCreate(ctx, networkName, types.NetworkCreate{})
assert.NilError(t, err)
cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.NetworkingConfig.EndpointsConfig = map[string]*network.EndpointSettings{
networkName: {},
}
@ -139,30 +139,30 @@ func TestRenameAnonymousContainer(t *testing.T) {
})
container1Name := "container1" + t.Name()
err = client.ContainerRename(ctx, cID, container1Name)
err = apiClient.ContainerRename(ctx, cID, container1Name)
assert.NilError(t, err)
// Stop/Start the container to get registered
// FIXME(vdemeester) this is a really weird behavior as it fails otherwise
err = client.ContainerStop(ctx, container1Name, containertypes.StopOptions{})
err = apiClient.ContainerStop(ctx, container1Name, containertypes.StopOptions{})
assert.NilError(t, err)
err = client.ContainerStart(ctx, container1Name, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, container1Name, types.ContainerStartOptions{})
assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
count := "-c"
if testEnv.DaemonInfo.OSType == "windows" {
count = "-n"
}
cID = container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
cID = container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.NetworkingConfig.EndpointsConfig = map[string]*network.EndpointSettings{
networkName: {},
}
c.HostConfig.NetworkMode = containertypes.NetworkMode(networkName)
}, container.WithCmd("ping", count, "1", container1Name))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(0, inspect.State.ExitCode), "container %s exited with the wrong exitcode: %s", cID, inspect.State.Error)
}
@ -171,15 +171,15 @@ func TestRenameAnonymousContainer(t *testing.T) {
func TestRenameContainerWithSameName(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
oldName := "old" + t.Name()
cID := container.Run(ctx, t, client, container.WithName(oldName))
cID := container.Run(ctx, t, apiClient, container.WithName(oldName))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerRename(ctx, oldName, oldName)
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := apiClient.ContainerRename(ctx, oldName, oldName)
assert.Check(t, is.ErrorContains(err, "Renaming a container with the same name"))
err = client.ContainerRename(ctx, cID, oldName)
err = apiClient.ContainerRename(ctx, cID, oldName)
assert.Check(t, is.ErrorContains(err, "Renaming a container with the same name"))
}
@ -194,21 +194,21 @@ func TestRenameContainerWithLinkedContainer(t *testing.T) {
defer setupTest(t)()
ctx := context.Background()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
db1Name := "db1" + t.Name()
db1ID := container.Run(ctx, t, client, container.WithName(db1Name))
poll.WaitOn(t, container.IsInState(ctx, client, db1ID, "running"), poll.WithDelay(100*time.Millisecond))
db1ID := container.Run(ctx, t, apiClient, container.WithName(db1Name))
poll.WaitOn(t, container.IsInState(ctx, apiClient, db1ID, "running"), poll.WithDelay(100*time.Millisecond))
app1Name := "app1" + t.Name()
app2Name := "app2" + t.Name()
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))
app1ID := container.Run(ctx, t, apiClient, container.WithName(app1Name), container.WithLinks(db1Name+":/mysql"))
poll.WaitOn(t, container.IsInState(ctx, apiClient, app1ID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerRename(ctx, app1Name, app2Name)
err := apiClient.ContainerRename(ctx, app1Name, app2Name)
assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, app2Name+"/mysql")
inspect, err := apiClient.ContainerInspect(ctx, app2Name+"/mysql")
assert.NilError(t, err)
assert.Check(t, is.Equal(db1ID, inspect.ID))
}

22
integration/container/resize_test.go
View file

@ -18,14 +18,14 @@ import (
func TestResize(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithTty(true))
cID := container.Run(ctx, t, apiClient, container.WithTty(true))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerResize(ctx, cID, types.ResizeOptions{
err := apiClient.ContainerResize(ctx, cID, types.ResizeOptions{
Height: 40,
Width: 40,
})
@ -35,12 +35,12 @@ func TestResize(t *testing.T) {
func TestResizeWithInvalidSize(t *testing.T) {
skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.32"), "broken in earlier versions")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client)
cID := container.Run(ctx, t, apiClient)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
endpoint := "/containers/" + cID + "/resize?h=foo&w=bar"
res, _, err := req.Post(endpoint)
@ -50,14 +50,14 @@ func TestResizeWithInvalidSize(t *testing.T) {
func TestResizeWhenContainerNotStarted(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithCmd("echo"))
cID := container.Run(ctx, t, apiClient, container.WithCmd("echo"))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerResize(ctx, cID, types.ResizeOptions{
err := apiClient.ContainerResize(ctx, cID, types.ResizeOptions{
Height: 40,
Width: 40,
})

30
integration/container/restart_test.go
View file

@ -84,7 +84,7 @@ func TestDaemonRestartKillContainers(t *testing.T) {
t.Parallel()
d := daemon.New(t)
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
args := []string{"--iptables=false"}
if liveRestoreEnabled {
@ -95,12 +95,12 @@ func TestDaemonRestartKillContainers(t *testing.T) {
defer d.Stop(t)
ctx := context.Background()
resp, err := client.ContainerCreate(ctx, tc.config, tc.hostConfig, nil, nil, "")
resp, err := apiClient.ContainerCreate(ctx, tc.config, tc.hostConfig, nil, nil, "")
assert.NilError(t, err)
defer client.ContainerRemove(ctx, resp.ID, types.ContainerRemoveOptions{Force: true})
defer apiClient.ContainerRemove(ctx, resp.ID, types.ContainerRemoveOptions{Force: true})
if tc.xStart {
err = client.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
assert.NilError(t, err)
}
@ -114,7 +114,7 @@ func TestDaemonRestartKillContainers(t *testing.T) {
var running bool
for i := 0; i < 30; i++ {
inspect, err := client.ContainerInspect(ctx, resp.ID)
inspect, err := apiClient.ContainerInspect(ctx, resp.ID)
assert.NilError(t, err)
running = inspect.State.Running
@ -129,7 +129,7 @@ func TestDaemonRestartKillContainers(t *testing.T) {
startTime := time.Now()
ctxPoll, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
poll.WaitOn(t, pollForNewHealthCheck(ctxPoll, client, startTime, resp.ID), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, pollForNewHealthCheck(ctxPoll, apiClient, startTime, resp.ID), poll.WithDelay(100*time.Millisecond))
}
// TODO(cpuguy83): test pause states... this seems to be rather undefined currently
})
@ -158,7 +158,7 @@ func pollForNewHealthCheck(ctx context.Context, client *client.Client, startTime
// It should be removed only if killed or stopped
func TestContainerWithAutoRemoveCanBeRestarted(t *testing.T) {
defer setupTest(t)()
cli := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
noWaitTimeout := 0
@ -170,42 +170,42 @@ func TestContainerWithAutoRemoveCanBeRestarted(t *testing.T) {
{
desc: "kill",
doSth: func(ctx context.Context, containerID string) error {
return cli.ContainerKill(ctx, containerID, "SIGKILL")
return apiClient.ContainerKill(ctx, containerID, "SIGKILL")
},
},
{
desc: "stop",
doSth: func(ctx context.Context, containerID string) error {
return cli.ContainerStop(ctx, containerID, container.StopOptions{Timeout: &noWaitTimeout})
return apiClient.ContainerStop(ctx, containerID, container.StopOptions{Timeout: &noWaitTimeout})
},
},
} {
tc := tc
t.Run(tc.desc, func(t *testing.T) {
cID := testContainer.Run(ctx, t, cli,
cID := testContainer.Run(ctx, t, apiClient,
testContainer.WithName("autoremove-restart-and-"+tc.desc),
testContainer.WithAutoRemove,
)
defer func() {
err := cli.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})
err := apiClient.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})
if t.Failed() && err != nil {
t.Logf("Cleaning up test container failed with error: %v", err)
}
}()
err := cli.ContainerRestart(ctx, cID, container.StopOptions{Timeout: &noWaitTimeout})
err := apiClient.ContainerRestart(ctx, cID, container.StopOptions{Timeout: &noWaitTimeout})
assert.NilError(t, err)
inspect, err := cli.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Assert(t, inspect.State.Status != "removing", "Container should not be removing yet")
poll.WaitOn(t, testContainer.IsInState(ctx, cli, cID, "running"))
poll.WaitOn(t, testContainer.IsInState(ctx, apiClient, cID, "running"))
err = tc.doSth(ctx, cID)
assert.NilError(t, err)
poll.WaitOn(t, testContainer.IsRemoved(ctx, cli, cID))
poll.WaitOn(t, testContainer.IsRemoved(ctx, apiClient, cID))
})
}
}

21
integration/container/run_cgroupns_linux_test.go
View file

@ -17,17 +17,17 @@ import (
// Bring up a daemon with the specified default cgroup namespace mode, and then create a container with the container options
func testRunWithCgroupNs(t *testing.T, daemonNsMode string, containerOpts ...func(*container.TestContainerConfig)) (string, string) {
d := daemon.New(t, daemon.WithDefaultCgroupNamespaceMode(daemonNsMode))
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
ctx := context.Background()
d.StartWithBusybox(t)
defer d.Stop(t)
cID := container.Run(ctx, t, client, containerOpts...)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient, containerOpts...)
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
daemonCgroup := d.CgroupNamespace(t)
containerCgroup := container.GetContainerNS(ctx, t, client, cID, "cgroup")
containerCgroup := container.GetContainerNS(ctx, t, apiClient, cID, "cgroup")
return containerCgroup, daemonCgroup
}
@ -35,12 +35,13 @@ func testRunWithCgroupNs(t *testing.T, daemonNsMode string, containerOpts ...fun
// expecting an error with the specified string
func testCreateFailureWithCgroupNs(t *testing.T, daemonNsMode string, errStr string, containerOpts ...func(*container.TestContainerConfig)) {
d := daemon.New(t, daemon.WithDefaultCgroupNamespaceMode(daemonNsMode))
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
ctx := context.Background()
d.StartWithBusybox(t)
defer d.Stop(t)
container.CreateExpectingErr(ctx, t, client, errStr, containerOpts...)
_, err := container.CreateFromConfig(ctx, apiClient, container.NewTestConfig(containerOpts...))
assert.ErrorContains(t, err, errStr)
}
func TestCgroupNamespacesRun(t *testing.T) {
@ -126,17 +127,17 @@ func TestCgroupNamespacesRunOlderClient(t *testing.T) {
skip.If(t, !requirement.CgroupNamespacesEnabled())
d := daemon.New(t, daemon.WithDefaultCgroupNamespaceMode("private"))
client := d.NewClientT(t, client.WithVersion("1.39"))
apiClient := d.NewClientT(t, client.WithVersion("1.39"))
ctx := context.Background()
d.StartWithBusybox(t)
defer d.Stop(t)
cID := container.Run(ctx, t, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
cID := container.Run(ctx, t, apiClient)
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
daemonCgroup := d.CgroupNamespace(t)
containerCgroup := container.GetContainerNS(ctx, t, client, cID, "cgroup")
containerCgroup := container.GetContainerNS(ctx, t, apiClient, cID, "cgroup")
if testEnv.DaemonInfo.CgroupVersion != "2" {
assert.Assert(t, daemonCgroup == containerCgroup)
} else {

66
integration/container/run_linux_test.go
View file

@ -38,7 +38,7 @@ func TestNISDomainname(t *testing.T) {
skip.If(t, testEnv.IsRootless, "rootless mode doesn't support setting Domainname (TODO: https://github.com/moby/moby/issues/40632)")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
const (
@ -46,20 +46,20 @@ func TestNISDomainname(t *testing.T) {
domainname = "baz.cyphar.com"
)
cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.Config.Hostname = hostname
c.Config.Domainname = domainname
})
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(hostname, inspect.Config.Hostname))
assert.Check(t, is.Equal(domainname, inspect.Config.Domainname))
// Check hostname.
res, err := container.Exec(ctx, client, cID,
res, err := container.Exec(ctx, apiClient, cID,
[]string{"cat", "/proc/sys/kernel/hostname"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
@ -67,7 +67,7 @@ func TestNISDomainname(t *testing.T) {
assert.Check(t, is.Equal(hostname, strings.TrimSpace(res.Stdout())))
// Check domainname.
res, err = container.Exec(ctx, client, cID,
res, err = container.Exec(ctx, apiClient, cID,
[]string{"cat", "/proc/sys/kernel/domainname"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
@ -79,7 +79,7 @@ func TestHostnameDnsResolution(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType != "linux")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
const (
@ -88,21 +88,21 @@ func TestHostnameDnsResolution(t *testing.T) {
// using user defined network as we want to use internal DNS
netName := "foobar-net"
net.CreateNoError(context.Background(), t, client, netName, net.WithDriver("bridge"))
net.CreateNoError(context.Background(), t, apiClient, netName, net.WithDriver("bridge"))
cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.Config.Hostname = hostname
c.HostConfig.NetworkMode = containertypes.NetworkMode(netName)
})
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(hostname, inspect.Config.Hostname))
// Clear hosts file so ping will use DNS for hostname resolution
res, err := container.Exec(ctx, client, cID,
res, err := container.Exec(ctx, apiClient, cID,
[]string{"sh", "-c", "echo 127.0.0.1 localhost | tee /etc/hosts && ping -c 1 foobar"})
assert.NilError(t, err)
assert.Check(t, is.Equal("", res.Stderr()))
@ -114,24 +114,24 @@ func TestUnprivilegedPortsAndPing(t *testing.T) {
skip.If(t, testEnv.IsRootless, "rootless mode doesn't support setting net.ipv4.ping_group_range and net.ipv4.ip_unprivileged_port_start")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.Config.User = "1000:1000"
})
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
// Check net.ipv4.ping_group_range.
res, err := container.Exec(ctx, client, cID, []string{"cat", "/proc/sys/net/ipv4/ping_group_range"})
res, err := container.Exec(ctx, apiClient, cID, []string{"cat", "/proc/sys/net/ipv4/ping_group_range"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
assert.Equal(t, 0, res.ExitCode)
assert.Equal(t, `0 2147483647`, strings.TrimSpace(res.Stdout()))
// Check net.ipv4.ip_unprivileged_port_start.
res, err = container.Exec(ctx, client, cID, []string{"cat", "/proc/sys/net/ipv4/ip_unprivileged_port_start"})
res, err = container.Exec(ctx, apiClient, cID, []string{"cat", "/proc/sys/net/ipv4/ip_unprivileged_port_start"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
assert.Equal(t, 0, res.ExitCode)
@ -145,7 +145,7 @@ func TestPrivilegedHostDevices(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType != "linux")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
const (
@ -167,18 +167,18 @@ func TestPrivilegedHostDevices(t *testing.T) {
}
defer os.Remove(devRootOnlyTest)
cID := container.Run(ctx, t, client, container.WithPrivileged(true))
cID := container.Run(ctx, t, apiClient, container.WithPrivileged(true))
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
// Check test device.
res, err := container.Exec(ctx, client, cID, []string{"ls", devTest})
res, err := container.Exec(ctx, apiClient, cID, []string{"ls", devTest})
assert.NilError(t, err)
assert.Equal(t, 0, res.ExitCode)
assert.Check(t, is.Equal(strings.TrimSpace(res.Stdout()), devTest))
// Check root-only test device.
res, err = container.Exec(ctx, client, cID, []string{"ls", devRootOnlyTest})
res, err = container.Exec(ctx, apiClient, cID, []string{"ls", devRootOnlyTest})
assert.NilError(t, err)
if testEnv.IsRootless() {
assert.Equal(t, 1, res.ExitCode)
@ -194,19 +194,19 @@ func TestRunConsoleSize(t *testing.T) {
skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.42"), "skip test from new feature")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client,
cID := container.Run(ctx, t, apiClient,
container.WithTty(true),
container.WithImage("busybox"),
container.WithCmd("stty", "size"),
container.WithConsoleSize(57, 123),
)
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsStopped(ctx, apiClient, cID), poll.WithDelay(100*time.Millisecond))
out, err := client.ContainerLogs(ctx, cID, types.ContainerLogsOptions{ShowStdout: true})
out, err := apiClient.ContainerLogs(ctx, cID, types.ContainerLogsOptions{ShowStdout: true})
assert.NilError(t, err)
defer out.Close()
@ -249,18 +249,18 @@ func TestRunWithAlternativeContainerdShim(t *testing.T) {
d.StartWithBusybox(t)
defer d.Stop(t)
client := d.NewClientT(t)
apiClient := d.NewClientT(t)
ctx := context.Background()
cID := container.Run(ctx, t, client,
cID := container.Run(ctx, t, apiClient,
container.WithImage("busybox"),
container.WithCmd("sh", "-c", `echo 'Hello, world!'`),
container.WithRuntime("io.containerd.realfake.v42"),
)
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsStopped(ctx, apiClient, cID), poll.WithDelay(100*time.Millisecond))
out, err := client.ContainerLogs(ctx, cID, types.ContainerLogsOptions{ShowStdout: true})
out, err := apiClient.ContainerLogs(ctx, cID, types.ContainerLogsOptions{ShowStdout: true})
assert.NilError(t, err)
defer out.Close()
@ -273,14 +273,14 @@ func TestRunWithAlternativeContainerdShim(t *testing.T) {
d.Stop(t)
d.Start(t, "--default-runtime="+"io.containerd.realfake.v42")
cID = container.Run(ctx, t, client,
cID = container.Run(ctx, t, apiClient,
container.WithImage("busybox"),
container.WithCmd("sh", "-c", `echo 'Hello, world!'`),
)
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsStopped(ctx, apiClient, cID), poll.WithDelay(100*time.Millisecond))
out, err = client.ContainerLogs(ctx, cID, types.ContainerLogsOptions{ShowStdout: true})
out, err = apiClient.ContainerLogs(ctx, cID, types.ContainerLogsOptions{ShowStdout: true})
assert.NilError(t, err)
defer out.Close()

12
integration/container/stats_test.go
View file

@ -21,17 +21,17 @@ func TestStats(t *testing.T) {
skip.If(t, !testEnv.DaemonInfo.MemoryLimit)
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
info, err := client.Info(ctx)
info, err := apiClient.Info(ctx)
assert.NilError(t, err)
cID := container.Run(ctx, t, client)
cID := container.Run(ctx, t, apiClient)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
resp, err := client.ContainerStats(ctx, cID, false)
resp, err := apiClient.ContainerStats(ctx, cID, false)
assert.NilError(t, err)
defer resp.Body.Close()
@ -43,7 +43,7 @@ func TestStats(t *testing.T) {
err = json.NewDecoder(resp.Body).Decode(&v)
assert.Assert(t, is.ErrorContains(err, ""), io.EOF)
resp, err = client.ContainerStatsOneShot(ctx, cID)
resp, err = apiClient.ContainerStatsOneShot(ctx, cID)
assert.NilError(t, err)
defer resp.Body.Close()

10
integration/container/stop_linux_test.go
View file

@ -25,7 +25,7 @@ import (
// waiting is not limited (issue #35311).
func TestStopContainerWithTimeout(t *testing.T) {
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
testCmd := container.WithCmd("sh", "-c", "sleep 2 && exit 42")
@ -58,15 +58,15 @@ func TestStopContainerWithTimeout(t *testing.T) {
d := d
t.Run(strconv.Itoa(d.timeout), func(t *testing.T) {
t.Parallel()
id := container.Run(ctx, t, client, testCmd)
id := container.Run(ctx, t, apiClient, testCmd)
err := client.ContainerStop(ctx, id, containertypes.StopOptions{Timeout: &d.timeout})
err := apiClient.ContainerStop(ctx, id, containertypes.StopOptions{Timeout: &d.timeout})
assert.NilError(t, err)
poll.WaitOn(t, container.IsStopped(ctx, client, id),
poll.WaitOn(t, container.IsStopped(ctx, apiClient, id),
poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, id)
inspect, err := apiClient.ContainerInspect(ctx, id)
assert.NilError(t, err)
assert.Equal(t, inspect.State.ExitCode, d.expectedExitCode)
})

10
integration/container/stop_test.go
View file

@ -16,12 +16,12 @@ const StopContainerWindowsPollTimeout = 75 * time.Second
func TestStopContainerWithRestartPolicyAlways(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
names := []string{"verifyRestart1-" + t.Name(), "verifyRestart2-" + t.Name()}
for _, name := range names {
container.Run(ctx, t, client,
container.Run(ctx, t, apiClient,
container.WithName(name),
container.WithCmd("false"),
container.WithRestartPolicy("always"),
@ -29,15 +29,15 @@ func TestStopContainerWithRestartPolicyAlways(t *testing.T) {
}
for _, name := range names {
poll.WaitOn(t, container.IsInState(ctx, client, name, "running", "restarting"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, name, "running", "restarting"), poll.WithDelay(100*time.Millisecond))
}
for _, name := range names {
err := client.ContainerStop(ctx, name, containertypes.StopOptions{})
err := apiClient.ContainerStop(ctx, name, containertypes.StopOptions{})
assert.NilError(t, err)
}
for _, name := range names {
poll.WaitOn(t, container.IsStopped(ctx, client, name), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsStopped(ctx, apiClient, name), poll.WithDelay(100*time.Millisecond))
}
}

10
integration/container/stop_windows_test.go
View file

@ -19,7 +19,7 @@ import (
func TestStopContainerWithTimeout(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.OSType == "windows")
t.Cleanup(setupTest(t))
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
testCmd := container.WithCmd("sh", "-c", "sleep 2 && exit 42")
@ -52,15 +52,15 @@ func TestStopContainerWithTimeout(t *testing.T) {
d := d
t.Run(strconv.Itoa(d.timeout), func(t *testing.T) {
t.Parallel()
id := container.Run(ctx, t, client, testCmd)
id := container.Run(ctx, t, apiClient, testCmd)
err := client.ContainerStop(ctx, id, containertypes.StopOptions{Timeout: &d.timeout})
err := apiClient.ContainerStop(ctx, id, containertypes.StopOptions{Timeout: &d.timeout})
assert.NilError(t, err)
poll.WaitOn(t, container.IsStopped(ctx, client, id),
poll.WaitOn(t, container.IsStopped(ctx, apiClient, id),
poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, id)
inspect, err := apiClient.ContainerInspect(ctx, id)
assert.NilError(t, err)
assert.Equal(t, inspect.State.ExitCode, d.expectedExitCode)
})

34
integration/container/update_linux_test.go
View file

@ -24,23 +24,23 @@ func TestUpdateMemory(t *testing.T) {
skip.If(t, !testEnv.DaemonInfo.SwapLimit)
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, func(c *container.TestContainerConfig) {
c.HostConfig.Resources = containertypes.Resources{
Memory: 200 * 1024 * 1024,
}
})
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "running"), poll.WithDelay(100*time.Millisecond))
const (
setMemory int64 = 314572800
setMemorySwap int64 = 524288000
)
_, err := client.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
_, err := apiClient.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
Resources: containertypes.Resources{
Memory: setMemory,
MemorySwap: setMemorySwap,
@ -48,7 +48,7 @@ func TestUpdateMemory(t *testing.T) {
})
assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(setMemory, inspect.HostConfig.Memory))
assert.Check(t, is.Equal(setMemorySwap, inspect.HostConfig.MemorySwap))
@ -57,7 +57,7 @@ func TestUpdateMemory(t *testing.T) {
if testEnv.DaemonInfo.CgroupVersion == "2" {
memoryFile = "/sys/fs/cgroup/memory.max"
}
res, err := container.Exec(ctx, client, cID,
res, err := container.Exec(ctx, apiClient, cID,
[]string{"cat", memoryFile})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
@ -67,14 +67,14 @@ func TestUpdateMemory(t *testing.T) {
// see ConvertMemorySwapToCgroupV2Value() for the convention:
// https://github.com/opencontainers/runc/commit/c86be8a2c118ca7bad7bbe9eaf106c659a83940d
if testEnv.DaemonInfo.CgroupVersion == "2" {
res, err = container.Exec(ctx, client, cID,
res, err = container.Exec(ctx, apiClient, cID,
[]string{"cat", "/sys/fs/cgroup/memory.swap.max"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
assert.Equal(t, 0, res.ExitCode)
assert.Check(t, is.Equal(strconv.FormatInt(setMemorySwap-setMemory, 10), strings.TrimSpace(res.Stdout())))
} else {
res, err = container.Exec(ctx, client, cID,
res, err = container.Exec(ctx, apiClient, cID,
[]string{"cat", "/sys/fs/cgroup/memory/memory.memsw.limit_in_bytes"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
@ -86,10 +86,10 @@ func TestUpdateMemory(t *testing.T) {
func TestUpdateCPUQuota(t *testing.T) {
skip.If(t, testEnv.DaemonInfo.CgroupDriver == "none")
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client)
cID := container.Run(ctx, t, apiClient)
for _, test := range []struct {
desc string
@ -104,7 +104,7 @@ func TestUpdateCPUQuota(t *testing.T) {
// On v2, specifying CPUQuota without CPUPeriod is currently broken:
// https://github.com/opencontainers/runc/issues/2456
// As a workaround we set them together.
_, err := client.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
_, err := apiClient.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
Resources: containertypes.Resources{
CPUQuota: test.update,
CPUPeriod: 100000,
@ -112,7 +112,7 @@ func TestUpdateCPUQuota(t *testing.T) {
})
assert.NilError(t, err)
} else {
_, err := client.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
_, err := apiClient.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
Resources: containertypes.Resources{
CPUQuota: test.update,
},
@ -120,12 +120,12 @@ func TestUpdateCPUQuota(t *testing.T) {
assert.NilError(t, err)
}
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(test.update, inspect.HostConfig.CPUQuota))
if testEnv.DaemonInfo.CgroupVersion == "2" {
res, err := container.Exec(ctx, client, cID,
res, err := container.Exec(ctx, apiClient, cID,
[]string{"/bin/cat", "/sys/fs/cgroup/cpu.max"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
@ -139,7 +139,7 @@ func TestUpdateCPUQuota(t *testing.T) {
assert.Check(t, is.Equal(strconv.FormatInt(test.update, 10), quota))
}
} else {
res, err := container.Exec(ctx, client, cID,
res, err := container.Exec(ctx, apiClient, cID,
[]string{"/bin/cat", "/sys/fs/cgroup/cpu/cpu.cfs_quota_us"})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
@ -157,7 +157,7 @@ func TestUpdatePidsLimit(t *testing.T) {
defer setupTest(t)()
apiClient := testEnv.APIClient()
oldAPIclient := request.NewAPIClient(t, client.WithVersion("1.24"))
oldAPIClient := request.NewAPIClient(t, client.WithVersion("1.24"))
ctx := context.Background()
intPtr := func(i int64) *int64 {
@ -182,7 +182,7 @@ func TestUpdatePidsLimit(t *testing.T) {
} {
c := apiClient
if test.oldAPI {
c = oldAPIclient
c = oldAPIClient
}
t.Run(test.desc, func(t *testing.T) {

16
integration/container/update_test.go
View file

@ -14,17 +14,17 @@ import (
func TestUpdateRestartPolicy(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithCmd("sh", "-c", "sleep 1 && false"), func(c *container.TestContainerConfig) {
cID := container.Run(ctx, t, apiClient, container.WithCmd("sh", "-c", "sleep 1 && false"), func(c *container.TestContainerConfig) {
c.HostConfig.RestartPolicy = containertypes.RestartPolicy{
Name: "on-failure",
MaximumRetryCount: 3,
}
})
_, err := client.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
_, err := apiClient.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
RestartPolicy: containertypes.RestartPolicy{
Name: "on-failure",
MaximumRetryCount: 5,
@ -37,9 +37,9 @@ func TestUpdateRestartPolicy(t *testing.T) {
timeout = 180 * time.Second
}
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond), poll.WithTimeout(timeout))
poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, "exited"), poll.WithDelay(100*time.Millisecond), poll.WithTimeout(timeout))
inspect, err := client.ContainerInspect(ctx, cID)
inspect, err := apiClient.ContainerInspect(ctx, cID)
assert.NilError(t, err)
assert.Check(t, is.Equal(inspect.RestartCount, 5))
assert.Check(t, is.Equal(inspect.HostConfig.RestartPolicy.MaximumRetryCount, 5))
@ -47,12 +47,12 @@ func TestUpdateRestartPolicy(t *testing.T) {
func TestUpdateRestartWithAutoRemove(t *testing.T) {
defer setupTest(t)()
client := testEnv.APIClient()
apiClient := testEnv.APIClient()
ctx := context.Background()
cID := container.Run(ctx, t, client, container.WithAutoRemove)
cID := container.Run(ctx, t, apiClient, container.WithAutoRemove)
_, err := client.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
_, err := apiClient.ContainerUpdate(ctx, cID, containertypes.UpdateConfig{
RestartPolicy: containertypes.RestartPolicy{
Name: "always",
},

45
integration/internal/container/container.go
View file

@ -27,9 +27,11 @@ type TestContainerConfig struct {
Platform *ocispec.Platform
}
// create creates a container with the specified options
func create(ctx context.Context, t *testing.T, client client.APIClient, ops ...func(*TestContainerConfig)) (container.CreateResponse, error) {
t.Helper()
// NewTestConfig creates a new TestContainerConfig with the provided options.
//
// If no options are passed, it creates a default config, which is a busybox
// container running "top" (on Linux) or "sleep" (on Windows).
func NewTestConfig(ops ...func(*TestContainerConfig)) *TestContainerConfig {
cmd := []string{"top"}
if runtime.GOOS == "windows" {
cmd = []string{"sleep", "240"}
@ -47,30 +49,35 @@ func create(ctx context.Context, t *testing.T, client client.APIClient, ops ...f
op(config)
}
return client.ContainerCreate(ctx, config.Config, config.HostConfig, config.NetworkingConfig, config.Platform, config.Name)
return config
}
// Create creates a container with the specified options, asserting that there was no error
func Create(ctx context.Context, t *testing.T, client client.APIClient, ops ...func(*TestContainerConfig)) string {
// Create creates a container with the specified options, asserting that there was no error.
func Create(ctx context.Context, t *testing.T, apiClient client.APIClient, ops ...func(*TestContainerConfig)) string {
t.Helper()
c, err := create(ctx, t, client, ops...)
config := NewTestConfig(ops...)
c, err := apiClient.ContainerCreate(ctx, config.Config, config.HostConfig, config.NetworkingConfig, config.Platform, config.Name)
assert.NilError(t, err)
return c.ID
}
// CreateExpectingErr creates a container, expecting an error with the specified message
func CreateExpectingErr(ctx context.Context, t *testing.T, client client.APIClient, errMsg string, ops ...func(*TestContainerConfig)) {
_, err := create(ctx, t, client, ops...)
assert.ErrorContains(t, err, errMsg)
// CreateFromConfig creates a container from the given TestContainerConfig.
//
// Example use:
//
// ctr, err := container.CreateFromConfig(ctx, apiClient, container.NewTestConfig(container.WithAutoRemove))
// assert.Check(t, err)
func CreateFromConfig(ctx context.Context, apiClient client.APIClient, config *TestContainerConfig) (container.CreateResponse, error) {
return apiClient.ContainerCreate(ctx, config.Config, config.HostConfig, config.NetworkingConfig, config.Platform, config.Name)
}
// Run creates and start a container with the specified options
func Run(ctx context.Context, t *testing.T, client client.APIClient, ops ...func(*TestContainerConfig)) string {
func Run(ctx context.Context, t *testing.T, apiClient client.APIClient, ops ...func(*TestContainerConfig)) string {
t.Helper()
id := Create(ctx, t, client, ops...)
id := Create(ctx, t, apiClient, ops...)
err := client.ContainerStart(ctx, id, types.ContainerStartOptions{})
err := apiClient.ContainerStart(ctx, id, types.ContainerStartOptions{})
assert.NilError(t, err)
return id
@ -83,23 +90,23 @@ type RunResult struct {
Stderr *bytes.Buffer
}
func RunAttach(ctx context.Context, t *testing.T, client client.APIClient, ops ...func(config *TestContainerConfig)) RunResult {
func RunAttach(ctx context.Context, t *testing.T, apiClient client.APIClient, ops ...func(config *TestContainerConfig)) RunResult {
t.Helper()
ops = append(ops, func(c *TestContainerConfig) {
c.Config.AttachStdout = true
c.Config.AttachStderr = true
})
id := Create(ctx, t, client, ops...)
id := Create(ctx, t, apiClient, ops...)
aresp, err := client.ContainerAttach(ctx, id, types.ContainerAttachOptions{
aresp, err := apiClient.ContainerAttach(ctx, id, types.ContainerAttachOptions{
Stream: true,
Stdout: true,
Stderr: true,
})
assert.NilError(t, err)
err = client.ContainerStart(ctx, id, types.ContainerStartOptions{})
err = apiClient.ContainerStart(ctx, id, types.ContainerStartOptions{})
assert.NilError(t, err)
s, err := demultiplexStreams(ctx, aresp)
@ -109,7 +116,7 @@ func RunAttach(ctx context.Context, t *testing.T, client client.APIClient, ops .
// Inspect to get the exit code. A new context is used here to make sure that if the context passed as argument as
// reached timeout during the demultiplexStream call, we still return a RunResult.
resp, err := client.ContainerInspect(context.Background(), id)
resp, err := apiClient.ContainerInspect(context.Background(), id)
assert.NilError(t, err)
return RunResult{ContainerID: id, ExitCode: resp.State.ExitCode, Stdout: &s.stdout, Stderr: &s.stderr}

8
integration/internal/container/exec.go
View file

@ -34,7 +34,7 @@ func (res *ExecResult) Combined() string {
// containing stdout, stderr, and exit code. Note:
// - this is a synchronous operation;
// - cmd stdin is closed.
func Exec(ctx context.Context, cli client.APIClient, id string, cmd []string, ops ...func(*types.ExecConfig)) (ExecResult, error) {
func Exec(ctx context.Context, apiClient client.APIClient, id string, cmd []string, ops ...func(*types.ExecConfig)) (ExecResult, error) {
// prepare exec
execConfig := types.ExecConfig{
AttachStdout: true,
@ -46,14 +46,14 @@ func Exec(ctx context.Context, cli client.APIClient, id string, cmd []string, op
op(&execConfig)
}
cresp, err := cli.ContainerExecCreate(ctx, id, execConfig)
cresp, err := apiClient.ContainerExecCreate(ctx, id, execConfig)
if err != nil {
return ExecResult{}, err
}
execID := cresp.ID
// run it, with stdout/stderr attached
aresp, err := cli.ContainerExecAttach(ctx, execID, types.ExecStartCheck{})
aresp, err := apiClient.ContainerExecAttach(ctx, execID, types.ExecStartCheck{})
if err != nil {
return ExecResult{}, err
}
@ -65,7 +65,7 @@ func Exec(ctx context.Context, cli client.APIClient, id string, cmd []string, op
}
// get the exit code
iresp, err := cli.ContainerExecInspect(ctx, execID)
iresp, err := apiClient.ContainerExecInspect(ctx, execID)
if err != nil {
return ExecResult{}, err
}

4
integration/internal/container/ns.go
View file

@ -11,9 +11,9 @@ import (
)
// GetContainerNS gets the value of the specified namespace of a container
func GetContainerNS(ctx context.Context, t *testing.T, client client.APIClient, cID, nsName string) string {
func GetContainerNS(ctx context.Context, t *testing.T, apiClient client.APIClient, cID, nsName string) string {
t.Helper()
res, err := Exec(ctx, client, cID, []string{"readlink", "/proc/self/ns/" + nsName})
res, err := Exec(ctx, apiClient, cID, []string{"readlink", "/proc/self/ns/" + nsName})
assert.NilError(t, err)
assert.Assert(t, is.Len(res.Stderr(), 0))
assert.Equal(t, 0, res.ExitCode)

16
integration/internal/container/states.go
View file

@ -11,9 +11,9 @@ import (
)
// IsStopped verifies the container is in stopped state.
func IsStopped(ctx context.Context, client client.APIClient, containerID string) func(log poll.LogT) poll.Result {
func IsStopped(ctx context.Context, apiClient client.APIClient, containerID string) func(log poll.LogT) poll.Result {
return func(log poll.LogT) poll.Result {
inspect, err := client.ContainerInspect(ctx, containerID)
inspect, err := apiClient.ContainerInspect(ctx, containerID)
switch {
case err != nil:
@ -27,9 +27,9 @@ func IsStopped(ctx context.Context, client client.APIClient, containerID string)
}
// IsInState verifies the container is in one of the specified state, e.g., "running", "exited", etc.
func IsInState(ctx context.Context, client client.APIClient, containerID string, state ...string) func(log poll.LogT) poll.Result {
func IsInState(ctx context.Context, apiClient client.APIClient, containerID string, state ...string) func(log poll.LogT) poll.Result {
return func(log poll.LogT) poll.Result {
inspect, err := client.ContainerInspect(ctx, containerID)
inspect, err := apiClient.ContainerInspect(ctx, containerID)
if err != nil {
return poll.Error(err)
}
@ -43,9 +43,9 @@ func IsInState(ctx context.Context, client client.APIClient, containerID string,
}
// IsSuccessful verifies state.Status == "exited" && state.ExitCode == 0
func IsSuccessful(ctx context.Context, client client.APIClient, containerID string) func(log poll.LogT) poll.Result {
func IsSuccessful(ctx context.Context, apiClient client.APIClient, containerID string) func(log poll.LogT) poll.Result {
return func(log poll.LogT) poll.Result {
inspect, err := client.ContainerInspect(ctx, containerID)
inspect, err := apiClient.ContainerInspect(ctx, containerID)
if err != nil {
return poll.Error(err)
}
@ -60,9 +60,9 @@ func IsSuccessful(ctx context.Context, client client.APIClient, containerID stri
}
// IsRemoved verifies the container has been removed
func IsRemoved(ctx context.Context, cli client.APIClient, containerID string) func(log poll.LogT) poll.Result {
func IsRemoved(ctx context.Context, apiClient client.APIClient, containerID string) func(log poll.LogT) poll.Result {
return func(log poll.LogT) poll.Result {
inspect, err := cli.ContainerInspect(ctx, containerID)
inspect, err := apiClient.ContainerInspect(ctx, containerID)
if err != nil {
if errdefs.IsNotFound(err) {
return poll.Success()