integration/container: use consistent name for api-client

The `client` variable was colliding with the `client` import in various
files. While it didn't conflict in all files, there was inconsistency
in the naming, sometimes using the confusing `cli` name (it's not the
"cli"), and such names can easily start spreading (through copy/paste,
or "code by example").

Let's make a one-time pass through all of them in this package to use
the same name.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

integration/container/attach_test.go

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

integration/container/cdi_test.go

@@ -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)

integration/container/checkpoint_test.go

@@ -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)
 	}
 }

integration/container/copy_test.go

@@ -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"))
 }
 

integration/container/create_test.go

@@ -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{},

integration/container/daemon_linux_test.go

@@ -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}))
 	})
 }

integration/container/daemon_test.go

@@ -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)
 }

integration/container/devices_windows_test.go

@@ -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",
 			})

integration/container/diff_test.go

@@ -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)
 }

integration/container/exec_linux_test.go

@@ -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}

integration/container/exec_test.go

@@ -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")

integration/container/export_test.go

@@ -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)

integration/container/health_test.go

@@ -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)
 		}

integration/container/inspect_test.go

@@ -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))
 }

integration/container/ipcmode_linux_test.go

@@ -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"))
 }

integration/container/kill_test.go

@@ -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))
 }

integration/container/links_linux_test.go

@@ -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)

integration/container/logs_test.go

@@ -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()
 

integration/container/mounts_linux_test.go

@@ -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))
 	}
 }

integration/container/nat_test.go

@@ -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
 }

integration/container/pause_test.go

@@ -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 {

integration/container/pidmode_linux_test.go

@@ -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)
 }

integration/container/ps_test.go

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

integration/container/remove_test.go

@@ -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"))
 }

integration/container/rename_test.go

@@ -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))
 }

integration/container/resize_test.go

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

integration/container/restart_test.go

@@ -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))
 		})
 	}
 }

integration/container/run_cgroupns_linux_test.go

@@ -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,12 @@ 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...)
+	container.CreateExpectingErr(ctx, t, apiClient, errStr, containerOpts...)
 }
 
 func TestCgroupNamespacesRun(t *testing.T) {
@@ -126,17 +126,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 {

integration/container/run_linux_test.go

@@ -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()
 

integration/container/stats_test.go

@@ -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()
 

integration/container/stop_linux_test.go

@@ -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)
 		})

integration/container/stop_test.go

@@ -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))
 	}
 }

integration/container/stop_windows_test.go

@@ -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)
 		})

integration/container/update_linux_test.go

@@ -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) {

integration/container/update_test.go

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