Bumping k8s dependencies to 1.13

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/BUILD

@@ -8,18 +8,13 @@ load(
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "images.go",
-        "interface.go",
-    ],
+    srcs = ["images.go"],
     importpath = "k8s.io/kubernetes/cmd/kubeadm/app/images",
     deps = [
         "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
-        "//cmd/kubeadm/app/apis/kubeadm/v1alpha2:go_default_library",
         "//cmd/kubeadm/app/constants:go_default_library",
         "//cmd/kubeadm/app/features:go_default_library",
         "//cmd/kubeadm/app/util:go_default_library",
-        "//vendor/k8s.io/utils/exec:go_default_library",
     ],
 )
 
@@ -45,13 +40,3 @@ filegroup(
     srcs = [":package-srcs"],
     tags = ["automanaged"],
 )
-
-go_test(
-    name = "go_default_xtest",
-    srcs = ["interface_test.go"],
-    deps = [
-        ":go_default_library",
-        "//cmd/kubeadm/app/apis/kubeadm/v1alpha2:go_default_library",
-        "//vendor/k8s.io/utils/exec:go_default_library",
-    ],
-)

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/images.go

@@ -18,7 +18,6 @@ package images
 
 import (
 	"fmt"
-	"runtime"
 
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
@@ -26,46 +25,58 @@ import (
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
 )
 
-// GetCoreImage generates and returns the image for the core Kubernetes components or returns overrideImage if specified
-func GetCoreImage(image, repoPrefix, k8sVersion, overrideImage string) string {
-	if overrideImage != "" {
-		return overrideImage
+// GetGenericImage generates and returns a platform agnostic image (backed by manifest list)
+func GetGenericImage(prefix, image, tag string) string {
+	return fmt.Sprintf("%s/%s:%s", prefix, image, tag)
+}
+
+// GetKubeControlPlaneImage generates and returns the image for the core Kubernetes components or returns the unified control plane image if specified
+func GetKubeControlPlaneImage(image string, cfg *kubeadmapi.ClusterConfiguration) string {
+	if cfg.UnifiedControlPlaneImage != "" {
+		return cfg.UnifiedControlPlaneImage
+	}
+	repoPrefix := cfg.GetControlPlaneImageRepository()
+	kubernetesImageTag := kubeadmutil.KubernetesVersionToImageTag(cfg.KubernetesVersion)
+	return GetGenericImage(repoPrefix, image, kubernetesImageTag)
+}
+
+// GetEtcdImage generates and returns the image for etcd or returns cfg.Etcd.Local.Image if specified
+func GetEtcdImage(cfg *kubeadmapi.ClusterConfiguration) string {
+	if cfg.Etcd.Local != nil && cfg.Etcd.Local.Image != "" {
+		return cfg.Etcd.Local.Image
 	}
-	kubernetesImageTag := kubeadmutil.KubernetesVersionToImageTag(k8sVersion)
 	etcdImageTag := constants.DefaultEtcdVersion
-	etcdImageVersion, err := constants.EtcdSupportedVersion(k8sVersion)
+	etcdImageVersion, err := constants.EtcdSupportedVersion(cfg.KubernetesVersion)
 	if err == nil {
 		etcdImageTag = etcdImageVersion.String()
 	}
-	return map[string]string{
-		constants.Etcd:                  fmt.Sprintf("%s/%s-%s:%s", repoPrefix, "etcd", runtime.GOARCH, etcdImageTag),
-		constants.KubeAPIServer:         fmt.Sprintf("%s/%s-%s:%s", repoPrefix, "kube-apiserver", runtime.GOARCH, kubernetesImageTag),
-		constants.KubeControllerManager: fmt.Sprintf("%s/%s-%s:%s", repoPrefix, "kube-controller-manager", runtime.GOARCH, kubernetesImageTag),
-		constants.KubeScheduler:         fmt.Sprintf("%s/%s-%s:%s", repoPrefix, "kube-scheduler", runtime.GOARCH, kubernetesImageTag),
-	}[image]
+	return GetGenericImage(cfg.ImageRepository, constants.Etcd, etcdImageTag)
 }
 
 // GetAllImages returns a list of container images kubeadm expects to use on a control plane node
-func GetAllImages(cfg *kubeadmapi.MasterConfiguration) []string {
-	repoPrefix := cfg.GetControlPlaneImageRepository()
+func GetAllImages(cfg *kubeadmapi.ClusterConfiguration) []string {
 	imgs := []string{}
-	imgs = append(imgs, GetCoreImage(constants.KubeAPIServer, repoPrefix, cfg.KubernetesVersion, cfg.UnifiedControlPlaneImage))
-	imgs = append(imgs, GetCoreImage(constants.KubeControllerManager, repoPrefix, cfg.KubernetesVersion, cfg.UnifiedControlPlaneImage))
-	imgs = append(imgs, GetCoreImage(constants.KubeScheduler, repoPrefix, cfg.KubernetesVersion, cfg.UnifiedControlPlaneImage))
-	imgs = append(imgs, fmt.Sprintf("%v/%v-%v:%v", repoPrefix, constants.KubeProxy, runtime.GOARCH, kubeadmutil.KubernetesVersionToImageTag(cfg.KubernetesVersion)))
+	imgs = append(imgs, GetKubeControlPlaneImage(constants.KubeAPIServer, cfg))
+	imgs = append(imgs, GetKubeControlPlaneImage(constants.KubeControllerManager, cfg))
+	imgs = append(imgs, GetKubeControlPlaneImage(constants.KubeScheduler, cfg))
+	imgs = append(imgs, GetKubeControlPlaneImage(constants.KubeProxy, cfg))
 
 	// pause, etcd and kube-dns are not available on the ci image repository so use the default image repository.
-	imgs = append(imgs, fmt.Sprintf("%v/pause-%v:%v", cfg.ImageRepository, runtime.GOARCH, "3.1"))
+	imgs = append(imgs, GetGenericImage(cfg.ImageRepository, "pause", "3.1"))
 
 	// if etcd is not external then add the image as it will be required
 	if cfg.Etcd.Local != nil {
-		imgs = append(imgs, GetCoreImage(constants.Etcd, cfg.ImageRepository, cfg.KubernetesVersion, cfg.Etcd.Local.Image))
+		imgs = append(imgs, GetEtcdImage(cfg))
 	}
 
-	dnsImage := fmt.Sprintf("%v/k8s-dns-kube-dns-%v:%v", cfg.ImageRepository, runtime.GOARCH, constants.KubeDNSVersion)
+	// Append the appropriate DNS images
 	if features.Enabled(cfg.FeatureGates, features.CoreDNS) {
-		dnsImage = fmt.Sprintf("%v/coredns:%v", cfg.ImageRepository, constants.CoreDNSVersion)
+		imgs = append(imgs, GetGenericImage(cfg.ImageRepository, constants.CoreDNS, constants.CoreDNSVersion))
+	} else {
+		imgs = append(imgs, GetGenericImage(cfg.ImageRepository, "k8s-dns-kube-dns", constants.KubeDNSVersion))
+		imgs = append(imgs, GetGenericImage(cfg.ImageRepository, "k8s-dns-sidecar", constants.KubeDNSVersion))
+		imgs = append(imgs, GetGenericImage(cfg.ImageRepository, "k8s-dns-dnsmasq-nanny", constants.KubeDNSVersion))
 	}
-	imgs = append(imgs, dnsImage)
+
 	return imgs
 }

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/images_test.go

@@ -18,7 +18,6 @@ package images
 
 import (
 	"fmt"
-	"runtime"
 	"strings"
 	"testing"
 
@@ -32,43 +31,96 @@ const (
 	gcrPrefix   = "k8s.gcr.io"
 )
 
-func TestGetCoreImage(t *testing.T) {
+func TestGetGenericImage(t *testing.T) {
+	const (
+		prefix = "foo"
+		image  = "bar"
+		tag    = "baz"
+	)
+	expected := fmt.Sprintf("%s/%s:%s", prefix, image, tag)
+	actual := GetGenericImage(prefix, image, tag)
+	if actual != expected {
+		t.Errorf("failed GetGenericImage:\n\texpected: %s\n\t  actual: %s", expected, actual)
+	}
+}
+
+func TestGetKubeControlPlaneImage(t *testing.T) {
 	var tests = []struct {
-		image, repo, version, override, expected string
+		image    string
+		expected string
+		cfg      *kubeadmapi.ClusterConfiguration
 	}{
 		{
-			override: "override",
 			expected: "override",
-		},
-		{
-			image:    constants.Etcd,
-			repo:     gcrPrefix,
-			expected: fmt.Sprintf("%s/%s-%s:%s", gcrPrefix, "etcd", runtime.GOARCH, constants.DefaultEtcdVersion),
+			cfg: &kubeadmapi.ClusterConfiguration{
+				UnifiedControlPlaneImage: "override",
+			},
 		},
 		{
 			image:    constants.KubeAPIServer,
-			repo:     gcrPrefix,
-			version:  testversion,
-			expected: fmt.Sprintf("%s/%s-%s:%s", gcrPrefix, "kube-apiserver", runtime.GOARCH, expected),
+			expected: GetGenericImage(gcrPrefix, "kube-apiserver", expected),
+			cfg: &kubeadmapi.ClusterConfiguration{
+				ImageRepository:   gcrPrefix,
+				KubernetesVersion: testversion,
+			},
 		},
 		{
 			image:    constants.KubeControllerManager,
-			repo:     gcrPrefix,
-			version:  testversion,
-			expected: fmt.Sprintf("%s/%s-%s:%s", gcrPrefix, "kube-controller-manager", runtime.GOARCH, expected),
+			expected: GetGenericImage(gcrPrefix, "kube-controller-manager", expected),
+			cfg: &kubeadmapi.ClusterConfiguration{
+				ImageRepository:   gcrPrefix,
+				KubernetesVersion: testversion,
+			},
 		},
 		{
 			image:    constants.KubeScheduler,
-			repo:     gcrPrefix,
-			version:  testversion,
-			expected: fmt.Sprintf("%s/%s-%s:%s", gcrPrefix, "kube-scheduler", runtime.GOARCH, expected),
+			expected: GetGenericImage(gcrPrefix, "kube-scheduler", expected),
+			cfg: &kubeadmapi.ClusterConfiguration{
+				ImageRepository:   gcrPrefix,
+				KubernetesVersion: testversion,
+			},
 		},
 	}
 	for _, rt := range tests {
-		actual := GetCoreImage(rt.image, rt.repo, rt.version, rt.override)
+		actual := GetKubeControlPlaneImage(rt.image, rt.cfg)
 		if actual != rt.expected {
 			t.Errorf(
-				"failed GetCoreImage:\n\texpected: %s\n\t  actual: %s",
+				"failed GetKubeControlPlaneImage:\n\texpected: %s\n\t  actual: %s",
+				rt.expected,
+				actual,
+			)
+		}
+	}
+}
+
+func TestGetEtcdImage(t *testing.T) {
+	var tests = []struct {
+		expected string
+		cfg      *kubeadmapi.ClusterConfiguration
+	}{
+		{
+			expected: "override",
+			cfg: &kubeadmapi.ClusterConfiguration{
+				Etcd: kubeadmapi.Etcd{
+					Local: &kubeadmapi.LocalEtcd{
+						Image: "override",
+					},
+				},
+			},
+		},
+		{
+			expected: GetGenericImage(gcrPrefix, "etcd", constants.DefaultEtcdVersion),
+			cfg: &kubeadmapi.ClusterConfiguration{
+				ImageRepository:   gcrPrefix,
+				KubernetesVersion: testversion,
+			},
+		},
+	}
+	for _, rt := range tests {
+		actual := GetEtcdImage(rt.cfg)
+		if actual != rt.expected {
+			t.Errorf(
+				"failed GetEtcdImage:\n\texpected: %s\n\t  actual: %s",
 				rt.expected,
 				actual,
 			)
@@ -79,32 +131,68 @@ func TestGetCoreImage(t *testing.T) {
 func TestGetAllImages(t *testing.T) {
 	testcases := []struct {
 		name   string
-		cfg    *kubeadmapi.MasterConfiguration
 		expect string
+		cfg    *kubeadmapi.ClusterConfiguration
 	}{
 		{
 			name: "defined CIImageRepository",
-			cfg: &kubeadmapi.MasterConfiguration{
+			cfg: &kubeadmapi.ClusterConfiguration{
 				CIImageRepository: "test.repo",
 			},
 			expect: "test.repo",
 		},
 		{
 			name: "undefined CIImagerRepository should contain the default image prefix",
-			cfg: &kubeadmapi.MasterConfiguration{
+			cfg: &kubeadmapi.ClusterConfiguration{
 				ImageRepository: "real.repo",
 			},
 			expect: "real.repo",
 		},
 		{
 			name: "test that etcd is returned when it is not external",
-			cfg: &kubeadmapi.MasterConfiguration{
+			cfg: &kubeadmapi.ClusterConfiguration{
 				Etcd: kubeadmapi.Etcd{
 					Local: &kubeadmapi.LocalEtcd{},
 				},
 			},
 			expect: constants.Etcd,
 		},
+		{
+			name: "CoreDNS image is returned",
+			cfg: &kubeadmapi.ClusterConfiguration{
+				FeatureGates: map[string]bool{
+					"CoreDNS": true,
+				},
+			},
+			expect: constants.CoreDNS,
+		},
+		{
+			name: "main kube-dns image is returned",
+			cfg: &kubeadmapi.ClusterConfiguration{
+				FeatureGates: map[string]bool{
+					"CoreDNS": false,
+				},
+			},
+			expect: "k8s-dns-kube-dns",
+		},
+		{
+			name: "kube-dns sidecar image is returned",
+			cfg: &kubeadmapi.ClusterConfiguration{
+				FeatureGates: map[string]bool{
+					"CoreDNS": false,
+				},
+			},
+			expect: "k8s-dns-sidecar",
+		},
+		{
+			name: "kube-dns dnsmasq-nanny image is returned",
+			cfg: &kubeadmapi.ClusterConfiguration{
+				FeatureGates: map[string]bool{
+					"CoreDNS": false,
+				},
+			},
+			expect: "k8s-dns-dnsmasq-nanny",
+		},
 	}
 	for _, tc := range testcases {
 		t.Run(tc.name, func(t *testing.T) {

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/interface.go

@@ -1,89 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package images
-
-import (
-	"fmt"
-
-	kubeadmapiv1alpha2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha2"
-	utilsexec "k8s.io/utils/exec"
-)
-
-// Puller is an interface for pulling images
-type Puller interface {
-	Pull(string) error
-}
-
-// Existence is an interface to determine if an image exists on the system
-// A nil error means the image was found
-type Existence interface {
-	Exists(string) error
-}
-
-// Images defines the set of behaviors needed for images relating to the CRI
-type Images interface {
-	Puller
-	Existence
-}
-
-// CRInterfacer is a struct that interfaces with the container runtime
-type CRInterfacer struct {
-	criSocket  string
-	exec       utilsexec.Interface
-	crictlPath string
-	dockerPath string
-}
-
-// NewCRInterfacer sets up and returns a CRInterfacer
-func NewCRInterfacer(execer utilsexec.Interface, criSocket string) (*CRInterfacer, error) {
-	var crictlPath, dockerPath string
-	var err error
-	if criSocket != kubeadmapiv1alpha2.DefaultCRISocket {
-		if crictlPath, err = execer.LookPath("crictl"); err != nil {
-			return nil, fmt.Errorf("crictl is required for non docker container runtimes: %v", err)
-		}
-	} else {
-		// use the dockershim
-		if dockerPath, err = execer.LookPath("docker"); err != nil {
-			return nil, fmt.Errorf("`docker` is required when docker is the container runtime and the kubelet is not running: %v", err)
-		}
-	}
-
-	return &CRInterfacer{
-		exec:       execer,
-		criSocket:  criSocket,
-		crictlPath: crictlPath,
-		dockerPath: dockerPath,
-	}, nil
-}
-
-// Pull pulls the actual image using either crictl or docker
-func (cri *CRInterfacer) Pull(image string) error {
-	if cri.criSocket != kubeadmapiv1alpha2.DefaultCRISocket {
-		return cri.exec.Command(cri.crictlPath, "-r", cri.criSocket, "pull", image).Run()
-	}
-	return cri.exec.Command(cri.dockerPath, "pull", image).Run()
-}
-
-// Exists checks to see if the image exists on the system already
-// Returns an error if the image is not found.
-func (cri *CRInterfacer) Exists(image string) error {
-	if cri.criSocket != kubeadmapiv1alpha2.DefaultCRISocket {
-		return cri.exec.Command(cri.crictlPath, "-r", cri.criSocket, "inspecti", image).Run()
-	}
-	return cri.exec.Command(cri.dockerPath, "inspect", image).Run()
-}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/interface_test.go

@@ -1,266 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package images_test
-
-import (
-	"context"
-	"errors"
-	"io"
-	"testing"
-
-	kubeadmapiv1alpha2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha2"
-	"k8s.io/kubernetes/cmd/kubeadm/app/images"
-	"k8s.io/utils/exec"
-)
-
-type fakeCmd struct {
-	err error
-}
-
-func (f *fakeCmd) Run() error {
-	return f.err
-}
-func (f *fakeCmd) CombinedOutput() ([]byte, error) { return nil, nil }
-func (f *fakeCmd) Output() ([]byte, error)         { return nil, nil }
-func (f *fakeCmd) SetDir(dir string)               {}
-func (f *fakeCmd) SetStdin(in io.Reader)           {}
-func (f *fakeCmd) SetStdout(out io.Writer)         {}
-func (f *fakeCmd) SetStderr(out io.Writer)         {}
-func (f *fakeCmd) Stop()                           {}
-
-type fakeExecer struct {
-	cmd        exec.Cmd
-	findCrictl bool
-	findDocker bool
-}
-
-func (f *fakeExecer) Command(cmd string, args ...string) exec.Cmd { return f.cmd }
-func (f *fakeExecer) CommandContext(ctx context.Context, cmd string, args ...string) exec.Cmd {
-	return f.cmd
-}
-func (f *fakeExecer) LookPath(file string) (string, error) {
-	if file == "crictl" {
-		if f.findCrictl {
-			return "/path", nil
-		}
-		return "", errors.New("no crictl for you")
-	}
-	if file == "docker" {
-		if f.findDocker {
-			return "/path", nil
-		}
-		return "", errors.New("no docker for you")
-	}
-	return "", errors.New("unknown binary")
-}
-
-func TestNewCRInterfacer(t *testing.T) {
-	testcases := []struct {
-		name        string
-		criSocket   string
-		findCrictl  bool
-		findDocker  bool
-		expectError bool
-	}{
-		{
-			name:        "need crictl but can only find docker should return an error",
-			criSocket:   "/not/docker",
-			findCrictl:  false,
-			findDocker:  true,
-			expectError: true,
-		},
-		{
-			name:        "need crictl and cannot find either should return an error",
-			criSocket:   "/not/docker",
-			findCrictl:  false,
-			findDocker:  false,
-			expectError: true,
-		},
-		{
-			name:        "need crictl and cannot find docker should return no error",
-			criSocket:   "/not/docker",
-			findCrictl:  true,
-			findDocker:  false,
-			expectError: false,
-		},
-		{
-			name:        "need crictl and can find both should return no error",
-			criSocket:   "/not/docker",
-			findCrictl:  true,
-			findDocker:  true,
-			expectError: false,
-		},
-		{
-			name:        "need docker and cannot find crictl should return no error",
-			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
-			findCrictl:  false,
-			findDocker:  true,
-			expectError: false,
-		},
-		{
-			name:        "need docker and cannot find docker should return an error",
-			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
-			findCrictl:  false,
-			findDocker:  false,
-			expectError: true,
-		},
-		{
-			name:        "need docker and can find both should return no error",
-			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
-			findCrictl:  true,
-			findDocker:  true,
-			expectError: false,
-		},
-		{
-			name:        "need docker and can only find crictl should return an error",
-			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
-			findCrictl:  true,
-			findDocker:  false,
-			expectError: true,
-		},
-	}
-
-	for _, tc := range testcases {
-		t.Run(tc.name, func(t *testing.T) {
-			fe := &fakeExecer{
-				findCrictl: tc.findCrictl,
-				findDocker: tc.findDocker,
-			}
-			_, err := images.NewCRInterfacer(fe, tc.criSocket)
-			if tc.expectError && err == nil {
-				t.Fatal("expected an error but did not get one")
-			}
-			if !tc.expectError && err != nil {
-				t.Fatalf("did not expedt an error but got an error: %v", err)
-			}
-		})
-	}
-}
-
-func TestImagePuller(t *testing.T) {
-	testcases := []struct {
-		name          string
-		criSocket     string
-		pullFails     bool
-		errorExpected bool
-	}{
-		{
-			name:          "using docker and pull fails",
-			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
-			pullFails:     true,
-			errorExpected: true,
-		},
-		{
-			name:          "using docker and pull succeeds",
-			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
-			pullFails:     false,
-			errorExpected: false,
-		},
-		{
-			name:          "using crictl pull fails",
-			criSocket:     "/not/default",
-			pullFails:     true,
-			errorExpected: true,
-		},
-		{
-			name:          "using crictl and pull succeeds",
-			criSocket:     "/not/default",
-			pullFails:     false,
-			errorExpected: false,
-		},
-	}
-	for _, tc := range testcases {
-		t.Run(tc.name, func(t *testing.T) {
-			var err error
-			if tc.pullFails {
-				err = errors.New("error")
-			}
-
-			fe := &fakeExecer{
-				cmd:        &fakeCmd{err},
-				findCrictl: true,
-				findDocker: true,
-			}
-			ip, _ := images.NewCRInterfacer(fe, tc.criSocket)
-
-			err = ip.Pull("imageName")
-			if tc.errorExpected && err == nil {
-				t.Fatal("expected an error and did not get one")
-			}
-			if !tc.errorExpected && err != nil {
-				t.Fatalf("expected no error but got one: %v", err)
-			}
-		})
-	}
-}
-
-func TestImageExists(t *testing.T) {
-	testcases := []struct {
-		name          string
-		criSocket     string
-		existFails    bool
-		errorExpected bool
-	}{
-		{
-			name:          "using docker and exist fails",
-			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
-			existFails:    true,
-			errorExpected: true,
-		},
-		{
-			name:          "using docker and exist succeeds",
-			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
-			existFails:    false,
-			errorExpected: false,
-		},
-		{
-			name:          "using crictl exist fails",
-			criSocket:     "/not/default",
-			existFails:    true,
-			errorExpected: true,
-		},
-		{
-			name:          "using crictl and exist succeeds",
-			criSocket:     "/not/default",
-			existFails:    false,
-			errorExpected: false,
-		},
-	}
-	for _, tc := range testcases {
-		t.Run(tc.name, func(t *testing.T) {
-			var err error
-			if tc.existFails {
-				err = errors.New("error")
-			}
-
-			fe := &fakeExecer{
-				cmd:        &fakeCmd{err},
-				findCrictl: true,
-				findDocker: true,
-			}
-			ip, _ := images.NewCRInterfacer(fe, tc.criSocket)
-
-			err = ip.Exists("imageName")
-			if tc.errorExpected && err == nil {
-				t.Fatal("expected an error and did not get one")
-			}
-			if !tc.errorExpected && err != nil {
-				t.Fatalf("expected no error but got one: %v", err)
-			}
-		})
-	}
-}