diff --git a/client/image_build_test.go b/client/image_build_test.go
index b63a027eb6..235cc8addd 100644
--- a/client/image_build_test.go
+++ b/client/image_build_test.go
@@ -19,10 +19,9 @@ import (
 )
 
 func TestImageBuildError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
-	_, err := client.ImageBuild(context.Background(), nil, build.ImageBuildOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
+	_, err = client.ImageBuild(context.Background(), nil, build.ImageBuildOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -158,47 +157,46 @@ func TestImageBuild(t *testing.T) {
 	}
 	for _, buildCase := range buildCases {
 		expectedURL := "/build"
-		client := &Client{
-			client: newMockClient(func(r *http.Request) (*http.Response, error) {
-				if !strings.HasPrefix(r.URL.Path, expectedURL) {
-					return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, r.URL)
-				}
-				// Check request headers
-				registryConfig := r.Header.Get("X-Registry-Config")
-				if registryConfig != buildCase.expectedRegistryConfig {
-					return nil, fmt.Errorf("X-Registry-Config header not properly set in the request. Expected '%s', got %s", buildCase.expectedRegistryConfig, registryConfig)
-				}
-				contentType := r.Header.Get("Content-Type")
-				if contentType != "application/x-tar" {
-					return nil, fmt.Errorf("Content-type header not properly set in the request. Expected 'application/x-tar', got %s", contentType)
-				}
+		client, err := NewClientWithOpts(WithMockClient(func(r *http.Request) (*http.Response, error) {
+			if !strings.HasPrefix(r.URL.Path, expectedURL) {
+				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, r.URL)
+			}
+			// Check request headers
+			registryConfig := r.Header.Get("X-Registry-Config")
+			if registryConfig != buildCase.expectedRegistryConfig {
+				return nil, fmt.Errorf("X-Registry-Config header not properly set in the request. Expected '%s', got %s", buildCase.expectedRegistryConfig, registryConfig)
+			}
+			contentType := r.Header.Get("Content-Type")
+			if contentType != "application/x-tar" {
+				return nil, fmt.Errorf("Content-type header not properly set in the request. Expected 'application/x-tar', got %s", contentType)
+			}
 
-				// Check query parameters
-				query := r.URL.Query()
-				for key, expected := range buildCase.expectedQueryParams {
-					actual := query.Get(key)
-					if actual != expected {
-						return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
-					}
+			// Check query parameters
+			query := r.URL.Query()
+			for key, expected := range buildCase.expectedQueryParams {
+				actual := query.Get(key)
+				if actual != expected {
+					return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
 				}
+			}
 
-				// Check tags
-				if len(buildCase.expectedTags) > 0 {
-					tags := query["t"]
-					if !reflect.DeepEqual(tags, buildCase.expectedTags) {
-						return nil, fmt.Errorf("t (tags) not set in URL query properly. Expected '%s', got %s", buildCase.expectedTags, tags)
-					}
+			// Check tags
+			if len(buildCase.expectedTags) > 0 {
+				tags := query["t"]
+				if !reflect.DeepEqual(tags, buildCase.expectedTags) {
+					return nil, fmt.Errorf("t (tags) not set in URL query properly. Expected '%s', got %s", buildCase.expectedTags, tags)
 				}
+			}
 
-				headers := http.Header{}
-				headers.Add("Ostype", "MyOS")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewReader([]byte("body"))),
-					Header:     headers,
-				}, nil
-			}),
-		}
+			headers := http.Header{}
+			headers.Add("Ostype", "MyOS")
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewReader([]byte("body"))),
+				Header:     headers,
+			}, nil
+		}))
+		assert.NilError(t, err)
 		buildResponse, err := client.ImageBuild(context.Background(), nil, buildCase.buildOptions)
 		assert.NilError(t, err)
 		assert.Check(t, is.Equal(buildResponse.OSType, "MyOS"))
diff --git a/client/image_create_test.go b/client/image_create_test.go
index 13d819daaa..306ef89040 100644
--- a/client/image_create_test.go
+++ b/client/image_create_test.go
@@ -16,10 +16,9 @@ import (
 )
 
 func TestImageCreateError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
-	_, err := client.ImageCreate(context.Background(), "reference", ImageCreateOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
+	_, err = client.ImageCreate(context.Background(), "reference", ImageCreateOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -32,33 +31,32 @@ func TestImageCreate(t *testing.T) {
 		expectedRegistryAuth = "eyJodHRwczovL2luZGV4LmRvY2tlci5pby92MS8iOnsiYXV0aCI6ImRHOTBid289IiwiZW1haWwiOiJqb2huQGRvZS5jb20ifX0="
 	)
 
-	client := &Client{
-		client: newMockClient(func(r *http.Request) (*http.Response, error) {
-			if !strings.HasPrefix(r.URL.Path, expectedURL) {
-				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, r.URL)
-			}
-			registryAuth := r.Header.Get(registry.AuthHeader)
-			if registryAuth != expectedRegistryAuth {
-				return nil, fmt.Errorf("%s header not properly set in the request. Expected '%s', got %s", registry.AuthHeader, expectedRegistryAuth, registryAuth)
-			}
+	client, err := NewClientWithOpts(WithMockClient(func(r *http.Request) (*http.Response, error) {
+		if !strings.HasPrefix(r.URL.Path, expectedURL) {
+			return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, r.URL)
+		}
+		registryAuth := r.Header.Get(registry.AuthHeader)
+		if registryAuth != expectedRegistryAuth {
+			return nil, fmt.Errorf("%s header not properly set in the request. Expected '%s', got %s", registry.AuthHeader, expectedRegistryAuth, registryAuth)
+		}
 
-			query := r.URL.Query()
-			fromImage := query.Get("fromImage")
-			if fromImage != expectedImage {
-				return nil, fmt.Errorf("fromImage not set in URL query properly. Expected '%s', got %s", expectedImage, fromImage)
-			}
+		query := r.URL.Query()
+		fromImage := query.Get("fromImage")
+		if fromImage != expectedImage {
+			return nil, fmt.Errorf("fromImage not set in URL query properly. Expected '%s', got %s", expectedImage, fromImage)
+		}
 
-			tag := query.Get("tag")
-			if tag != expectedTag {
-				return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", expectedTag, tag)
-			}
+		tag := query.Get("tag")
+		if tag != expectedTag {
+			return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", expectedTag, tag)
+		}
 
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewReader([]byte("body"))),
-			}, nil
-		}),
-	}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader([]byte("body"))),
+		}, nil
+	}))
+	assert.NilError(t, err)
 
 	createResponse, err := client.ImageCreate(context.Background(), specifiedReference, ImageCreateOptions{
 		RegistryAuth: expectedRegistryAuth,
diff --git a/client/image_history_test.go b/client/image_history_test.go
index 8e2b6c9b0b..e0fd1ae298 100644
--- a/client/image_history_test.go
+++ b/client/image_history_test.go
@@ -15,10 +15,9 @@ import (
 )
 
 func TestImageHistoryError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
-	_, err := client.ImageHistory(context.Background(), "nothing")
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
+	_, err = client.ImageHistory(context.Background(), "nothing")
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -28,16 +27,15 @@ func TestImageHistory(t *testing.T) {
 		historyResponse  = `[{"Comment":"","Created":0,"CreatedBy":"","Id":"image_id1","Size":0,"Tags":["tag1","tag2"]},{"Comment":"","Created":0,"CreatedBy":"","Id":"image_id2","Size":0,"Tags":["tag1","tag2"]}]`
 		expectedPlatform = `{"architecture":"arm64","os":"linux","variant":"v8"}`
 	)
-	client := &Client{
-		client: newMockClient(func(r *http.Request) (*http.Response, error) {
-			assert.Check(t, is.Equal(r.URL.Path, expectedURL))
-			assert.Check(t, is.Equal(r.URL.Query().Get("platform"), expectedPlatform))
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(historyResponse)),
-			}, nil
-		}),
-	}
+	client, err := NewClientWithOpts(WithMockClient(func(r *http.Request) (*http.Response, error) {
+		assert.Check(t, is.Equal(r.URL.Path, expectedURL))
+		assert.Check(t, is.Equal(r.URL.Query().Get("platform"), expectedPlatform))
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(strings.NewReader(historyResponse)),
+		}, nil
+	}))
+	assert.NilError(t, err)
 	expected := []image.HistoryResponseItem{
 		{
 			ID:   "image_id1",
diff --git a/client/image_import_test.go b/client/image_import_test.go
index cc50adda70..4733d21174 100644
--- a/client/image_import_test.go
+++ b/client/image_import_test.go
@@ -15,10 +15,9 @@ import (
 )
 
 func TestImageImportError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
-	_, err := client.ImageImport(context.Background(), ImageImportSource{}, "image:tag", ImageImportOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
+	_, err = client.ImageImport(context.Background(), ImageImportSource{}, "image:tag", ImageImportOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -68,17 +67,16 @@ func TestImageImport(t *testing.T) {
 	}
 	for _, tc := range tests {
 		t.Run(tc.doc, func(t *testing.T) {
-			client := &Client{
-				client: newMockClient(func(req *http.Request) (*http.Response, error) {
-					assert.Check(t, is.Equal(req.URL.Path, expectedURL))
-					query := req.URL.Query()
-					assert.Check(t, is.DeepEqual(query, tc.expectedQueryParams))
-					return &http.Response{
-						StatusCode: http.StatusOK,
-						Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
-					}, nil
-				}),
-			}
+			client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+				assert.Check(t, is.Equal(req.URL.Path, expectedURL))
+				query := req.URL.Query()
+				assert.Check(t, is.DeepEqual(query, tc.expectedQueryParams))
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
+				}, nil
+			}))
+			assert.NilError(t, err)
 			resp, err := client.ImageImport(context.Background(), ImageImportSource{
 				Source:     strings.NewReader("source"),
 				SourceName: "image_source",
diff --git a/client/image_inspect_test.go b/client/image_inspect_test.go
index 9cc9814fff..9e6dd64d1e 100644
--- a/client/image_inspect_test.go
+++ b/client/image_inspect_test.go
@@ -19,54 +19,50 @@ import (
 )
 
 func TestImageInspectError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
 
-	_, err := client.ImageInspect(context.Background(), "nothing")
+	_, err = client.ImageInspect(context.Background(), "nothing")
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
 func TestImageInspectImageNotFound(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusNotFound, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusNotFound, "Server error")))
+	assert.NilError(t, err)
 
-	_, err := client.ImageInspect(context.Background(), "unknown")
+	_, err = client.ImageInspect(context.Background(), "unknown")
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
 }
 
 func TestImageInspectWithEmptyID(t *testing.T) {
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			return nil, errors.New("should not make request")
-		}),
-	}
-	_, err := client.ImageInspect(context.Background(), "")
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		return nil, errors.New("should not make request")
+	}))
+	assert.NilError(t, err)
+	_, err = client.ImageInspect(context.Background(), "")
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
 }
 
 func TestImageInspect(t *testing.T) {
 	expectedURL := "/images/image_id/json"
 	expectedTags := []string{"tag1", "tag2"}
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			if !strings.HasPrefix(req.URL.Path, expectedURL) {
-				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-			}
-			content, err := json.Marshal(image.InspectResponse{
-				ID:       "image_id",
-				RepoTags: expectedTags,
-			})
-			if err != nil {
-				return nil, err
-			}
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewReader(content)),
-			}, nil
-		}),
-	}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		if !strings.HasPrefix(req.URL.Path, expectedURL) {
+			return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+		}
+		content, err := json.Marshal(image.InspectResponse{
+			ID:       "image_id",
+			RepoTags: expectedTags,
+		})
+		if err != nil {
+			return nil, err
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader(content)),
+		}, nil
+	}))
+	assert.NilError(t, err)
 
 	imageInspect, err := client.ImageInspect(context.Background(), "image_id")
 	assert.NilError(t, err)
@@ -84,32 +80,31 @@ func TestImageInspectWithPlatform(t *testing.T) {
 	expectedPlatform, err := encodePlatform(requestedPlatform)
 	assert.NilError(t, err)
 
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			if !strings.HasPrefix(req.URL.Path, expectedURL) {
-				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-			}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		if !strings.HasPrefix(req.URL.Path, expectedURL) {
+			return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+		}
 
-			// Check if platform parameter is passed correctly
-			platform := req.URL.Query().Get("platform")
-			if platform != expectedPlatform {
-				return nil, fmt.Errorf("Expected platform '%s', got '%s'", expectedPlatform, platform)
-			}
+		// Check if platform parameter is passed correctly
+		platform := req.URL.Query().Get("platform")
+		if platform != expectedPlatform {
+			return nil, fmt.Errorf("Expected platform '%s', got '%s'", expectedPlatform, platform)
+		}
 
-			content, err := json.Marshal(image.InspectResponse{
-				ID:           "image_id",
-				Architecture: "arm64",
-				Os:           "linux",
-			})
-			if err != nil {
-				return nil, err
-			}
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewReader(content)),
-			}, nil
-		}),
-	}
+		content, err := json.Marshal(image.InspectResponse{
+			ID:           "image_id",
+			Architecture: "arm64",
+			Os:           "linux",
+		})
+		if err != nil {
+			return nil, err
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader(content)),
+		}, nil
+	}))
+	assert.NilError(t, err)
 
 	imageInspect, err := client.ImageInspect(context.Background(), "image_id", ImageInspectWithPlatform(requestedPlatform))
 	assert.NilError(t, err)
diff --git a/client/image_list_test.go b/client/image_list_test.go
index 4b92011087..dceb720522 100644
--- a/client/image_list_test.go
+++ b/client/image_list_test.go
@@ -19,11 +19,10 @@ import (
 )
 
 func TestImageListError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
 
-	_, err := client.ImageList(context.Background(), ImageListOptions{})
+	_, err = client.ImageList(context.Background(), ImageListOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -80,54 +79,16 @@ func TestImageList(t *testing.T) {
 		},
 	}
 	for _, listCase := range listCases {
-		client := &Client{
-			client: newMockClient(func(req *http.Request) (*http.Response, error) {
-				if !strings.HasPrefix(req.URL.Path, expectedURL) {
-					return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-				}
-				query := req.URL.Query()
-				for key, expected := range listCase.expectedQueryParams {
-					actual := query.Get(key)
-					if actual != expected {
-						return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
-					}
-				}
-				content, err := json.Marshal([]image.Summary{
-					{
-						ID: "image_id2",
-					},
-					{
-						ID: "image_id2",
-					},
-				})
-				if err != nil {
-					return nil, err
-				}
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewReader(content)),
-				}, nil
-			}),
-		}
-
-		images, err := client.ImageList(context.Background(), listCase.options)
-		assert.NilError(t, err)
-		assert.Check(t, is.Len(images, 2))
-	}
-}
-
-func TestImageListApiBefore125(t *testing.T) {
-	expectedFilter := "image:tag"
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			query := req.URL.Query()
-			actualFilter := query.Get("filter")
-			if actualFilter != expectedFilter {
-				return nil, fmt.Errorf("filter not set in URL query properly. Expected '%s', got %s", expectedFilter, actualFilter)
+		client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+			if !strings.HasPrefix(req.URL.Path, expectedURL) {
+				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
 			}
-			actualFilters := query.Get("filters")
-			if actualFilters != "" {
-				return nil, fmt.Errorf("filters should have not been present, were with value: %s", actualFilters)
+			query := req.URL.Query()
+			for key, expected := range listCase.expectedQueryParams {
+				actual := query.Get(key)
+				if actual != expected {
+					return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
+				}
 			}
 			content, err := json.Marshal([]image.Summary{
 				{
@@ -144,9 +105,44 @@ func TestImageListApiBefore125(t *testing.T) {
 				StatusCode: http.StatusOK,
 				Body:       io.NopCloser(bytes.NewReader(content)),
 			}, nil
-		}),
-		version: "1.24",
+		}))
+		assert.NilError(t, err)
+
+		images, err := client.ImageList(context.Background(), listCase.options)
+		assert.NilError(t, err)
+		assert.Check(t, is.Len(images, 2))
 	}
+}
+
+func TestImageListApiBefore125(t *testing.T) {
+	expectedFilter := "image:tag"
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		query := req.URL.Query()
+		actualFilter := query.Get("filter")
+		if actualFilter != expectedFilter {
+			return nil, fmt.Errorf("filter not set in URL query properly. Expected '%s', got %s", expectedFilter, actualFilter)
+		}
+		actualFilters := query.Get("filters")
+		if actualFilters != "" {
+			return nil, fmt.Errorf("filters should have not been present, were with value: %s", actualFilters)
+		}
+		content, err := json.Marshal([]image.Summary{
+			{
+				ID: "image_id2",
+			},
+			{
+				ID: "image_id2",
+			},
+		})
+		if err != nil {
+			return nil, err
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader(content)),
+		}, nil
+	}), WithVersion("1.24"))
+	assert.NilError(t, err)
 
 	options := ImageListOptions{
 		Filters: filters.NewArgs(filters.Arg("reference", "image:tag")),
@@ -175,17 +171,15 @@ func TestImageListWithSharedSize(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			var query url.Values
-			client := &Client{
-				client: newMockClient(func(req *http.Request) (*http.Response, error) {
-					query = req.URL.Query()
-					return &http.Response{
-						StatusCode: http.StatusOK,
-						Body:       io.NopCloser(strings.NewReader("[]")),
-					}, nil
-				}),
-				version: tc.version,
-			}
-			_, err := client.ImageList(context.Background(), tc.options)
+			client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+				query = req.URL.Query()
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(strings.NewReader("[]")),
+				}, nil
+			}), WithVersion(tc.version))
+			assert.NilError(t, err)
+			_, err = client.ImageList(context.Background(), tc.options)
 			assert.NilError(t, err)
 			expectedSet := tc.sharedSize != ""
 			assert.Check(t, is.Equal(query.Has(sharedSize), expectedSet))
diff --git a/client/image_load_test.go b/client/image_load_test.go
index ae418ee76b..b5dbf7ccc7 100644
--- a/client/image_load_test.go
+++ b/client/image_load_test.go
@@ -15,11 +15,10 @@ import (
 )
 
 func TestImageLoadError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
 
-	_, err := client.ImageLoad(context.Background(), nil, ImageLoadWithQuiet(true))
+	_, err = client.ImageLoad(context.Background(), nil, ImageLoadWithQuiet(true))
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -82,18 +81,17 @@ func TestImageLoad(t *testing.T) {
 	}
 	for _, tc := range tests {
 		t.Run(tc.doc, func(t *testing.T) {
-			client := &Client{
-				client: newMockClient(func(req *http.Request) (*http.Response, error) {
-					assert.Check(t, is.Equal(req.URL.Path, expectedURL))
-					assert.Check(t, is.Equal(req.Header.Get("Content-Type"), expectedContentType))
-					assert.Check(t, is.DeepEqual(req.URL.Query(), tc.expectedQueryParams))
-					return &http.Response{
-						StatusCode: http.StatusOK,
-						Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
-						Header:     http.Header{"Content-Type": []string{tc.responseContentType}},
-					}, nil
-				}),
-			}
+			client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+				assert.Check(t, is.Equal(req.URL.Path, expectedURL))
+				assert.Check(t, is.Equal(req.Header.Get("Content-Type"), expectedContentType))
+				assert.Check(t, is.DeepEqual(req.URL.Query(), tc.expectedQueryParams))
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
+					Header:     http.Header{"Content-Type": []string{tc.responseContentType}},
+				}, nil
+			}))
+			assert.NilError(t, err)
 
 			input := bytes.NewReader([]byte(expectedInput))
 			imageLoadResponse, err := client.ImageLoad(context.Background(), input,
diff --git a/client/image_prune_test.go b/client/image_prune_test.go
index 7327f6bb65..4d111ff6c1 100644
--- a/client/image_prune_test.go
+++ b/client/image_prune_test.go
@@ -19,12 +19,10 @@ import (
 )
 
 func TestImagesPruneError(t *testing.T) {
-	client := &Client{
-		client:  newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-		version: "1.25",
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")), WithVersion("1.25"))
+	assert.NilError(t, err)
 
-	_, err := client.ImagesPrune(context.Background(), filters.NewArgs())
+	_, err = client.ImagesPrune(context.Background(), filters.NewArgs())
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -73,37 +71,35 @@ func TestImagesPrune(t *testing.T) {
 		},
 	}
 	for _, listCase := range listCases {
-		client := &Client{
-			client: newMockClient(func(req *http.Request) (*http.Response, error) {
-				if !strings.HasPrefix(req.URL.Path, expectedURL) {
-					return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-				}
-				query := req.URL.Query()
-				for key, expected := range listCase.expectedQueryParams {
-					actual := query.Get(key)
-					assert.Check(t, is.Equal(expected, actual))
-				}
-				content, err := json.Marshal(image.PruneReport{
-					ImagesDeleted: []image.DeleteResponse{
-						{
-							Deleted: "image_id1",
-						},
-						{
-							Deleted: "image_id2",
-						},
+		client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+			if !strings.HasPrefix(req.URL.Path, expectedURL) {
+				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+			}
+			query := req.URL.Query()
+			for key, expected := range listCase.expectedQueryParams {
+				actual := query.Get(key)
+				assert.Check(t, is.Equal(expected, actual))
+			}
+			content, err := json.Marshal(image.PruneReport{
+				ImagesDeleted: []image.DeleteResponse{
+					{
+						Deleted: "image_id1",
 					},
-					SpaceReclaimed: 9999,
-				})
-				if err != nil {
-					return nil, err
-				}
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewReader(content)),
-				}, nil
-			}),
-			version: "1.25",
-		}
+					{
+						Deleted: "image_id2",
+					},
+				},
+				SpaceReclaimed: 9999,
+			})
+			if err != nil {
+				return nil, err
+			}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewReader(content)),
+			}, nil
+		}), WithVersion("1.25"))
+		assert.NilError(t, err)
 
 		report, err := client.ImagesPrune(context.Background(), listCase.filters)
 		assert.NilError(t, err)
diff --git a/client/image_pull_test.go b/client/image_pull_test.go
index 1a6aed88bf..388615d903 100644
--- a/client/image_pull_test.go
+++ b/client/image_pull_test.go
@@ -17,37 +17,33 @@ import (
 )
 
 func TestImagePullReferenceParseError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			return nil, nil
-		}),
-	}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		return nil, nil
+	}))
+	assert.NilError(t, err)
 	// An empty reference is an invalid reference
-	_, err := client.ImagePull(context.Background(), "", ImagePullOptions{})
+	_, err = client.ImagePull(context.Background(), "", ImagePullOptions{})
 	assert.Check(t, is.ErrorContains(err, "invalid reference format"))
 }
 
 func TestImagePullAnyError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
-	_, err := client.ImagePull(context.Background(), "myimage", ImagePullOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
+	_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
 func TestImagePullStatusUnauthorizedError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
-	_, err := client.ImagePull(context.Background(), "myimage", ImagePullOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
+	_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
 }
 
 func TestImagePullWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
-	_, err := client.ImagePull(context.Background(), "myimage", ImagePullOptions{
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
+	_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{
 		PrivilegeFunc: func(_ context.Context) (string, error) {
 			return "", errors.New("error requesting privilege")
 		},
@@ -56,10 +52,9 @@ func TestImagePullWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
 }
 
 func TestImagePullWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
-	_, err := client.ImagePull(context.Background(), "myimage", ImagePullOptions{
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
+	_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{
 		PrivilegeFunc: staticAuth("a-auth-header"),
 	})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
@@ -69,36 +64,35 @@ func TestImagePullWithPrivilegedFuncNoError(t *testing.T) {
 	const expectedURL = "/images/create"
 	const invalidAuth = "NotValid"
 	const validAuth = "IAmValid"
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			if !strings.HasPrefix(req.URL.Path, expectedURL) {
-				return nil, fmt.Errorf("expected URL '%s', got '%s'", expectedURL, req.URL)
-			}
-			auth := req.Header.Get(registry.AuthHeader)
-			if auth == invalidAuth {
-				return &http.Response{
-					StatusCode: http.StatusUnauthorized,
-					Body:       io.NopCloser(bytes.NewReader([]byte("Invalid credentials"))),
-				}, nil
-			}
-			if auth != validAuth {
-				return nil, fmt.Errorf("invalid auth header: expected %s, got %s", "IAmValid", auth)
-			}
-			query := req.URL.Query()
-			fromImage := query.Get("fromImage")
-			if fromImage != "docker.io/library/myimage" {
-				return nil, fmt.Errorf("fromimage not set in URL query properly. Expected '%s', got %s", "docker.io/library/myimage", fromImage)
-			}
-			tag := query.Get("tag")
-			if tag != "latest" {
-				return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", "latest", tag)
-			}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		if !strings.HasPrefix(req.URL.Path, expectedURL) {
+			return nil, fmt.Errorf("expected URL '%s', got '%s'", expectedURL, req.URL)
+		}
+		auth := req.Header.Get(registry.AuthHeader)
+		if auth == invalidAuth {
 			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewReader([]byte("hello world"))),
+				StatusCode: http.StatusUnauthorized,
+				Body:       io.NopCloser(bytes.NewReader([]byte("Invalid credentials"))),
 			}, nil
-		}),
-	}
+		}
+		if auth != validAuth {
+			return nil, fmt.Errorf("invalid auth header: expected %s, got %s", "IAmValid", auth)
+		}
+		query := req.URL.Query()
+		fromImage := query.Get("fromImage")
+		if fromImage != "docker.io/library/myimage" {
+			return nil, fmt.Errorf("fromimage not set in URL query properly. Expected '%s', got %s", "docker.io/library/myimage", fromImage)
+		}
+		tag := query.Get("tag")
+		if tag != "latest" {
+			return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", "latest", tag)
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader([]byte("hello world"))),
+		}, nil
+	}))
+	assert.NilError(t, err)
 	resp, err := client.ImagePull(context.Background(), "myimage", ImagePullOptions{
 		RegistryAuth:  invalidAuth,
 		PrivilegeFunc: staticAuth(validAuth),
@@ -172,26 +166,25 @@ func TestImagePullWithoutErrors(t *testing.T) {
 	}
 	for _, pullCase := range pullCases {
 		t.Run(pullCase.reference, func(t *testing.T) {
-			client := &Client{
-				client: newMockClient(func(req *http.Request) (*http.Response, error) {
-					if !strings.HasPrefix(req.URL.Path, expectedURL) {
-						return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-					}
-					query := req.URL.Query()
-					fromImage := query.Get("fromImage")
-					if fromImage != pullCase.expectedImage {
-						return nil, fmt.Errorf("fromimage not set in URL query properly. Expected '%s', got %s", pullCase.expectedImage, fromImage)
-					}
-					tag := query.Get("tag")
-					if tag != pullCase.expectedTag {
-						return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", pullCase.expectedTag, tag)
-					}
-					return &http.Response{
-						StatusCode: http.StatusOK,
-						Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
-					}, nil
-				}),
-			}
+			client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+				if !strings.HasPrefix(req.URL.Path, expectedURL) {
+					return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+				}
+				query := req.URL.Query()
+				fromImage := query.Get("fromImage")
+				if fromImage != pullCase.expectedImage {
+					return nil, fmt.Errorf("fromimage not set in URL query properly. Expected '%s', got %s", pullCase.expectedImage, fromImage)
+				}
+				tag := query.Get("tag")
+				if tag != pullCase.expectedTag {
+					return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", pullCase.expectedTag, tag)
+				}
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
+				}, nil
+			}))
+			assert.NilError(t, err)
 			resp, err := client.ImagePull(context.Background(), pullCase.reference, ImagePullOptions{
 				All: pullCase.all,
 			})
diff --git a/client/image_push_test.go b/client/image_push_test.go
index db8ff00ed1..eef0074472 100644
--- a/client/image_push_test.go
+++ b/client/image_push_test.go
@@ -17,13 +17,12 @@ import (
 )
 
 func TestImagePushReferenceError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			return nil, nil
-		}),
-	}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		return nil, nil
+	}))
+	assert.NilError(t, err)
 	// An empty reference is an invalid reference
-	_, err := client.ImagePush(context.Background(), "", ImagePushOptions{})
+	_, err = client.ImagePush(context.Background(), "", ImagePushOptions{})
 	assert.Check(t, is.ErrorContains(err, "invalid reference format"))
 	// An canonical reference cannot be pushed
 	_, err = client.ImagePush(context.Background(), "repo@sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", ImagePushOptions{})
@@ -31,42 +30,38 @@ func TestImagePushReferenceError(t *testing.T) {
 }
 
 func TestImagePushAnyError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
-	_, err := client.ImagePush(context.Background(), "myimage", ImagePushOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
+	_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
 func TestImagePushStatusUnauthorizedError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
-	_, err := client.ImagePush(context.Background(), "myimage", ImagePushOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
+	_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
 }
 
 func TestImagePushWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
 	privilegeFunc := func(_ context.Context) (string, error) {
 		return "", errors.New("Error requesting privilege")
 	}
-	_, err := client.ImagePush(context.Background(), "myimage", ImagePushOptions{
+	_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{
 		PrivilegeFunc: privilegeFunc,
 	})
 	assert.Check(t, is.Error(err, "Error requesting privilege"))
 }
 
 func TestImagePushWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
 	privilegeFunc := func(_ context.Context) (string, error) {
 		return "a-auth-header", nil
 	}
-	_, err := client.ImagePush(context.Background(), "myimage", ImagePushOptions{
+	_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{
 		PrivilegeFunc: privilegeFunc,
 	})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
@@ -76,32 +71,31 @@ func TestImagePushWithPrivilegedFuncNoError(t *testing.T) {
 	const expectedURL = "/images/docker.io/myname/myimage/push"
 	const invalidAuth = "NotValid"
 	const validAuth = "IAmValid"
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			if !strings.HasPrefix(req.URL.Path, expectedURL) {
-				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-			}
-			auth := req.Header.Get(registry.AuthHeader)
-			if auth == invalidAuth {
-				return &http.Response{
-					StatusCode: http.StatusUnauthorized,
-					Body:       io.NopCloser(bytes.NewReader([]byte("Invalid credentials"))),
-				}, nil
-			}
-			if auth != validAuth {
-				return nil, fmt.Errorf("invalid auth header: expected %s, got %s", "IAmValid", auth)
-			}
-			query := req.URL.Query()
-			tag := query.Get("tag")
-			if tag != "tag" {
-				return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", "tag", tag)
-			}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		if !strings.HasPrefix(req.URL.Path, expectedURL) {
+			return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+		}
+		auth := req.Header.Get(registry.AuthHeader)
+		if auth == invalidAuth {
 			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewReader([]byte("hello world"))),
+				StatusCode: http.StatusUnauthorized,
+				Body:       io.NopCloser(bytes.NewReader([]byte("Invalid credentials"))),
 			}, nil
-		}),
-	}
+		}
+		if auth != validAuth {
+			return nil, fmt.Errorf("invalid auth header: expected %s, got %s", "IAmValid", auth)
+		}
+		query := req.URL.Query()
+		tag := query.Get("tag")
+		if tag != "tag" {
+			return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", "tag", tag)
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader([]byte("hello world"))),
+		}, nil
+	}))
+	assert.NilError(t, err)
 	resp, err := client.ImagePush(context.Background(), "myname/myimage:tag", ImagePushOptions{
 		RegistryAuth:  invalidAuth,
 		PrivilegeFunc: staticAuth(validAuth),
@@ -175,23 +169,22 @@ func TestImagePushWithoutErrors(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		t.Run(fmt.Sprintf("%s,all-tags=%t", tc.reference, tc.all), func(t *testing.T) {
-			client := &Client{
-				client: newMockClient(func(req *http.Request) (*http.Response, error) {
-					expectedURL := fmt.Sprintf(expectedURLFormat, tc.expectedImage)
-					if !strings.HasPrefix(req.URL.Path, expectedURL) {
-						return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-					}
-					query := req.URL.Query()
-					tag := query.Get("tag")
-					if tag != tc.expectedTag {
-						return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", tc.expectedTag, tag)
-					}
-					return &http.Response{
-						StatusCode: http.StatusOK,
-						Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
-					}, nil
-				}),
-			}
+			client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+				expectedURL := fmt.Sprintf(expectedURLFormat, tc.expectedImage)
+				if !strings.HasPrefix(req.URL.Path, expectedURL) {
+					return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+				}
+				query := req.URL.Query()
+				tag := query.Get("tag")
+				if tag != tc.expectedTag {
+					return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", tc.expectedTag, tag)
+				}
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
+				}, nil
+			}))
+			assert.NilError(t, err)
 			resp, err := client.ImagePush(context.Background(), tc.reference, ImagePushOptions{
 				All: tc.all,
 			})
diff --git a/client/image_remove_test.go b/client/image_remove_test.go
index b2bc446a22..dd3579394c 100644
--- a/client/image_remove_test.go
+++ b/client/image_remove_test.go
@@ -18,20 +18,18 @@ import (
 )
 
 func TestImageRemoveError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
 
-	_, err := client.ImageRemove(context.Background(), "image_id", ImageRemoveOptions{})
+	_, err = client.ImageRemove(context.Background(), "image_id", ImageRemoveOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
 func TestImageRemoveImageNotFound(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusNotFound, "no such image: unknown")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusNotFound, "no such image: unknown")))
+	assert.NilError(t, err)
 
-	_, err := client.ImageRemove(context.Background(), "unknown", ImageRemoveOptions{})
+	_, err = client.ImageRemove(context.Background(), "unknown", ImageRemoveOptions{})
 	assert.Check(t, is.ErrorContains(err, "no such image: unknown"))
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
 }
@@ -71,39 +69,38 @@ func TestImageRemove(t *testing.T) {
 		},
 	}
 	for _, removeCase := range removeCases {
-		client := &Client{
-			client: newMockClient(func(req *http.Request) (*http.Response, error) {
-				if !strings.HasPrefix(req.URL.Path, expectedURL) {
-					return nil, fmt.Errorf("expected URL '%s', got '%s'", expectedURL, req.URL)
-				}
-				if req.Method != http.MethodDelete {
-					return nil, fmt.Errorf("expected DELETE method, got %s", req.Method)
-				}
-				query := req.URL.Query()
-				for key, expected := range removeCase.expectedQueryParams {
-					actual := query.Get(key)
-					if actual != expected {
-						return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
-					}
-				}
-				b, err := json.Marshal([]image.DeleteResponse{
-					{
-						Untagged: "image_id1",
-					},
-					{
-						Deleted: "image_id",
-					},
-				})
-				if err != nil {
-					return nil, err
+		client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+			if !strings.HasPrefix(req.URL.Path, expectedURL) {
+				return nil, fmt.Errorf("expected URL '%s', got '%s'", expectedURL, req.URL)
+			}
+			if req.Method != http.MethodDelete {
+				return nil, fmt.Errorf("expected DELETE method, got %s", req.Method)
+			}
+			query := req.URL.Query()
+			for key, expected := range removeCase.expectedQueryParams {
+				actual := query.Get(key)
+				if actual != expected {
+					return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
 				}
+			}
+			b, err := json.Marshal([]image.DeleteResponse{
+				{
+					Untagged: "image_id1",
+				},
+				{
+					Deleted: "image_id",
+				},
+			})
+			if err != nil {
+				return nil, err
+			}
 
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewReader(b)),
-				}, nil
-			}),
-		}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewReader(b)),
+			}, nil
+		}))
+		assert.NilError(t, err)
 
 		opts := ImageRemoveOptions{
 			Force:         removeCase.force,
diff --git a/client/image_save_test.go b/client/image_save_test.go
index 2cb805193d..0f6b571354 100644
--- a/client/image_save_test.go
+++ b/client/image_save_test.go
@@ -15,11 +15,10 @@ import (
 )
 
 func TestImageSaveError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
 	armv64 := ocispec.Platform{Architecture: "arm64", OS: "linux", Variant: "v8"}
-	_, err := client.ImageSave(context.Background(), []string{"nothing"}, ImageSaveWithPlatforms(armv64))
+	_, err = client.ImageSave(context.Background(), []string{"nothing"}, ImageSaveWithPlatforms(armv64))
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
@@ -65,16 +64,15 @@ func TestImageSave(t *testing.T) {
 	}
 	for _, tc := range tests {
 		t.Run(tc.doc, func(t *testing.T) {
-			client := &Client{
-				client: newMockClient(func(req *http.Request) (*http.Response, error) {
-					assert.Check(t, is.Equal(req.URL.Path, expectedURL))
-					assert.Check(t, is.DeepEqual(req.URL.Query(), tc.expectedQueryParams))
-					return &http.Response{
-						StatusCode: http.StatusOK,
-						Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
-					}, nil
-				}),
-			}
+			client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+				assert.Check(t, is.Equal(req.URL.Path, expectedURL))
+				assert.Check(t, is.DeepEqual(req.URL.Query(), tc.expectedQueryParams))
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(bytes.NewReader([]byte(expectedOutput))),
+				}, nil
+			}))
+			assert.NilError(t, err)
 			resp, err := client.ImageSave(context.Background(), []string{"image_id1", "image_id2"}, tc.options...)
 			assert.NilError(t, err)
 			defer assert.NilError(t, resp.Close())
diff --git a/client/image_search_test.go b/client/image_search_test.go
index b8689d58ae..65a0229429 100644
--- a/client/image_search_test.go
+++ b/client/image_search_test.go
@@ -19,42 +19,38 @@ import (
 )
 
 func TestImageSearchAnyError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
-	_, err := client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
+	_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
 func TestImageSearchStatusUnauthorizedError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
-	_, err := client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{})
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
+	_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
 }
 
 func TestImageSearchWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
 	privilegeFunc := func(_ context.Context) (string, error) {
 		return "", errors.New("Error requesting privilege")
 	}
-	_, err := client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
+	_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
 		PrivilegeFunc: privilegeFunc,
 	})
 	assert.Check(t, is.Error(err, "Error requesting privilege"))
 }
 
 func TestImageSearchWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
+	assert.NilError(t, err)
 	privilegeFunc := func(_ context.Context) (string, error) {
 		return "a-auth-header", nil
 	}
-	_, err := client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
+	_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
 		PrivilegeFunc: privilegeFunc,
 	})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
@@ -62,40 +58,39 @@ func TestImageSearchWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.
 
 func TestImageSearchWithPrivilegedFuncNoError(t *testing.T) {
 	expectedURL := "/images/search"
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			if !strings.HasPrefix(req.URL.Path, expectedURL) {
-				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-			}
-			auth := req.Header.Get(registry.AuthHeader)
-			if auth == "NotValid" {
-				return &http.Response{
-					StatusCode: http.StatusUnauthorized,
-					Body:       io.NopCloser(bytes.NewReader([]byte("Invalid credentials"))),
-				}, nil
-			}
-			if auth != "IAmValid" {
-				return nil, fmt.Errorf("invalid auth header: expected 'IAmValid', got %s", auth)
-			}
-			query := req.URL.Query()
-			term := query.Get("term")
-			if term != "some-image" {
-				return nil, fmt.Errorf("term not set in URL query properly. Expected 'some-image', got %s", term)
-			}
-			content, err := json.Marshal([]registry.SearchResult{
-				{
-					Name: "anything",
-				},
-			})
-			if err != nil {
-				return nil, err
-			}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		if !strings.HasPrefix(req.URL.Path, expectedURL) {
+			return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+		}
+		auth := req.Header.Get(registry.AuthHeader)
+		if auth == "NotValid" {
 			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewReader(content)),
+				StatusCode: http.StatusUnauthorized,
+				Body:       io.NopCloser(bytes.NewReader([]byte("Invalid credentials"))),
 			}, nil
-		}),
-	}
+		}
+		if auth != "IAmValid" {
+			return nil, fmt.Errorf("invalid auth header: expected 'IAmValid', got %s", auth)
+		}
+		query := req.URL.Query()
+		term := query.Get("term")
+		if term != "some-image" {
+			return nil, fmt.Errorf("term not set in URL query properly. Expected 'some-image', got %s", term)
+		}
+		content, err := json.Marshal([]registry.SearchResult{
+			{
+				Name: "anything",
+			},
+		})
+		if err != nil {
+			return nil, err
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader(content)),
+		}, nil
+	}))
+	assert.NilError(t, err)
 	privilegeFunc := func(_ context.Context) (string, error) {
 		return "IAmValid", nil
 	}
@@ -111,34 +106,33 @@ func TestImageSearchWithoutErrors(t *testing.T) {
 	const expectedURL = "/images/search"
 	const expectedFilters = `{"is-automated":{"true":true},"stars":{"3":true}}`
 
-	client := &Client{
-		client: newMockClient(func(req *http.Request) (*http.Response, error) {
-			if !strings.HasPrefix(req.URL.Path, expectedURL) {
-				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
-			}
-			query := req.URL.Query()
-			term := query.Get("term")
-			if term != "some-image" {
-				return nil, fmt.Errorf("term not set in URL query properly. Expected 'some-image', got %s", term)
-			}
-			fltrs := query.Get("filters")
-			if fltrs != expectedFilters {
-				return nil, fmt.Errorf("filters not set in URL query properly. Expected '%s', got %s", expectedFilters, fltrs)
-			}
-			content, err := json.Marshal([]registry.SearchResult{
-				{
-					Name: "anything",
-				},
-			})
-			if err != nil {
-				return nil, err
-			}
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewReader(content)),
-			}, nil
-		}),
-	}
+	client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+		if !strings.HasPrefix(req.URL.Path, expectedURL) {
+			return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
+		}
+		query := req.URL.Query()
+		term := query.Get("term")
+		if term != "some-image" {
+			return nil, fmt.Errorf("term not set in URL query properly. Expected 'some-image', got %s", term)
+		}
+		fltrs := query.Get("filters")
+		if fltrs != expectedFilters {
+			return nil, fmt.Errorf("filters not set in URL query properly. Expected '%s', got %s", expectedFilters, fltrs)
+		}
+		content, err := json.Marshal([]registry.SearchResult{
+			{
+				Name: "anything",
+			},
+		})
+		if err != nil {
+			return nil, err
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(bytes.NewReader(content)),
+		}, nil
+	}))
+	assert.NilError(t, err)
 	results, err := client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
 		Filters: filters.NewArgs(
 			filters.Arg("is-automated", "true"),
diff --git a/client/image_tag_test.go b/client/image_tag_test.go
index c8a6b51f45..cc98a6b792 100644
--- a/client/image_tag_test.go
+++ b/client/image_tag_test.go
@@ -16,22 +16,20 @@ import (
 )
 
 func TestImageTagError(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
 
-	err := client.ImageTag(context.Background(), "image_id", "repo:tag")
+	err = client.ImageTag(context.Background(), "image_id", "repo:tag")
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 }
 
 // Note: this is not testing all the InvalidReference as it's the responsibility
 // of distribution/reference package.
 func TestImageTagInvalidReference(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
+	assert.NilError(t, err)
 
-	err := client.ImageTag(context.Background(), "image_id", "aa/asdf$$^/aa")
+	err = client.ImageTag(context.Background(), "image_id", "aa/asdf$$^/aa")
 	assert.Check(t, is.Error(err, `error parsing reference: "aa/asdf$$^/aa" is not a valid repository/tag: invalid reference format`))
 }
 
@@ -39,9 +37,8 @@ func TestImageTagInvalidReference(t *testing.T) {
 func TestImageTagInvalidSourceImageName(t *testing.T) {
 	ctx := context.Background()
 
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusInternalServerError, "client should not have made an API call")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "client should not have made an API call")))
+	assert.NilError(t, err)
 
 	invalidRepos := []string{"fo$z$", "Foo@3cc", "Foo$3", "Foo*3", "Fo^3", "Foo!3", "F)xcz(", "fo%asd", "aa/asdf$$^/aa"}
 	for _, repo := range invalidRepos {
@@ -92,11 +89,10 @@ func generateRandomAlphaOnlyString(n int) string {
 }
 
 func TestImageTagHexSource(t *testing.T) {
-	client := &Client{
-		client: newMockClient(errorMock(http.StatusOK, "OK")),
-	}
+	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusOK, "OK")))
+	assert.NilError(t, err)
 
-	err := client.ImageTag(context.Background(), "0d409d33b27e47423b049f7f863faa08655a8c901749c2b25b93ca67d01a470d", "repo:tag")
+	err = client.ImageTag(context.Background(), "0d409d33b27e47423b049f7f863faa08655a8c901749c2b25b93ca67d01a470d", "repo:tag")
 	assert.NilError(t, err)
 }
 
@@ -157,28 +153,27 @@ func TestImageTag(t *testing.T) {
 		},
 	}
 	for _, tagCase := range tagCases {
-		client := &Client{
-			client: newMockClient(func(req *http.Request) (*http.Response, error) {
-				if !strings.HasPrefix(req.URL.Path, expectedURL) {
-					return nil, fmt.Errorf("expected URL '%s', got '%s'", expectedURL, req.URL)
+		client, err := NewClientWithOpts(WithMockClient(func(req *http.Request) (*http.Response, error) {
+			if !strings.HasPrefix(req.URL.Path, expectedURL) {
+				return nil, fmt.Errorf("expected URL '%s', got '%s'", expectedURL, req.URL)
+			}
+			if req.Method != http.MethodPost {
+				return nil, fmt.Errorf("expected POST method, got %s", req.Method)
+			}
+			query := req.URL.Query()
+			for key, expected := range tagCase.expectedQueryParams {
+				actual := query.Get(key)
+				if actual != expected {
+					return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
 				}
-				if req.Method != http.MethodPost {
-					return nil, fmt.Errorf("expected POST method, got %s", req.Method)
-				}
-				query := req.URL.Query()
-				for key, expected := range tagCase.expectedQueryParams {
-					actual := query.Get(key)
-					if actual != expected {
-						return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual)
-					}
-				}
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewReader([]byte(""))),
-				}, nil
-			}),
-		}
-		err := client.ImageTag(context.Background(), "image_id", tagCase.reference)
+			}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewReader([]byte(""))),
+			}, nil
+		}))
+		assert.NilError(t, err)
+		err = client.ImageTag(context.Background(), "image_id", tagCase.reference)
 		assert.NilError(t, err)
 	}
 }