use temp kubeconfig for fake factory

pkg/kubectl/cmd/annotate_test.go

@@ -417,29 +417,33 @@ func TestAnnotateErrors(t *testing.T) {
 	}
 
 	for k, testCase := range testCases {
-		tf := cmdtesting.NewTestFactory()
-		tf.Namespace = "test"
-		tf.ClientConfigVal = defaultClientConfig()
+		t.Run(k, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
 
-		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdAnnotate(tf, buf)
-		cmd.SetOutput(buf)
+			tf.Namespace = "test"
+			tf.ClientConfigVal = defaultClientConfig()
 
-		for k, v := range testCase.flags {
-			cmd.Flags().Set(k, v)
-		}
-		options := &AnnotateOptions{}
-		err := options.Complete(buf, cmd, testCase.args)
-		if err == nil {
-			err = options.Validate()
-		}
-		if !testCase.errFn(err) {
-			t.Errorf("%s: unexpected error: %v", k, err)
-			continue
-		}
-		if buf.Len() > 0 {
-			t.Errorf("buffer should be empty: %s", string(buf.Bytes()))
-		}
+			buf := bytes.NewBuffer([]byte{})
+			cmd := NewCmdAnnotate(tf, buf)
+			cmd.SetOutput(buf)
+
+			for k, v := range testCase.flags {
+				cmd.Flags().Set(k, v)
+			}
+			options := &AnnotateOptions{}
+			err := options.Complete(buf, cmd, testCase.args)
+			if err == nil {
+				err = options.Validate()
+			}
+			if !testCase.errFn(err) {
+				t.Errorf("%s: unexpected error: %v", k, err)
+				return
+			}
+			if buf.Len() > 0 {
+				t.Errorf("buffer should be empty: %s", string(buf.Bytes()))
+			}
+		})
 	}
 }
 
@@ -447,6 +451,8 @@ func TestAnnotateObject(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -499,6 +505,8 @@ func TestAnnotateObjectFromFile(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -550,6 +558,8 @@ func TestAnnotateObjectFromFile(t *testing.T) {
 
 func TestAnnotateLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.UnstructuredClient = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Group: "testgroup", Version: "v1"},
 		NegotiatedSerializer: unstructuredSerializer,
@@ -581,6 +591,8 @@ func TestAnnotateMultipleObjects(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	tf.UnstructuredClient = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Group: "testgroup", Version: "v1"},

pkg/kubectl/cmd/auth/cani_test.go

@@ -117,64 +117,68 @@ func TestRunAccessCheck(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		test.o.Out = ioutil.Discard
-		test.o.Err = ioutil.Discard
-
-		tf := cmdtesting.NewTestFactory()
-		ns := legacyscheme.Codecs
-
-		tf.Client = &fake.RESTClient{
-			GroupVersion:         schema.GroupVersion{Group: "", Version: "v1"},
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				expectPath := "/apis/authorization.k8s.io/v1/selfsubjectaccessreviews"
-				if req.URL.Path != expectPath {
-					t.Errorf("%s: expected %v, got %v", test.name, expectPath, req.URL.Path)
-					return nil, nil
-				}
-				bodyBits, err := ioutil.ReadAll(req.Body)
-				if err != nil {
-					t.Errorf("%s: %v", test.name, err)
-					return nil, nil
-				}
-				body := string(bodyBits)
-
-				for _, expectedBody := range test.expectedBodyStrings {
-					if !strings.Contains(body, expectedBody) {
-						t.Errorf("%s expecting %s in %s", test.name, expectedBody, body)
+		t.Run(test.name, func(t *testing.T) {
+			test.o.Out = ioutil.Discard
+			test.o.Err = ioutil.Discard
+
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			ns := legacyscheme.Codecs
+
+			tf.Client = &fake.RESTClient{
+				GroupVersion:         schema.GroupVersion{Group: "", Version: "v1"},
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					expectPath := "/apis/authorization.k8s.io/v1/selfsubjectaccessreviews"
+					if req.URL.Path != expectPath {
+						t.Errorf("%s: expected %v, got %v", test.name, expectPath, req.URL.Path)
+						return nil, nil
 					}
-				}
-
-				return &http.Response{
-						StatusCode: http.StatusOK,
-						Body: ioutil.NopCloser(bytes.NewBufferString(
-							fmt.Sprintf(`{"kind":"SelfSubjectAccessReview","apiVersion":"authorization.k8s.io/v1","status":{"allowed":%v}}`, test.allowed),
-						)),
-					},
-					test.serverErr
-			}),
-		}
-		tf.Namespace = "test"
-		tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}}
-
-		if err := test.o.Complete(tf, test.args); err != nil {
-			t.Errorf("%s: %v", test.name, err)
-			continue
-		}
-
-		actualAllowed, err := test.o.RunAccessCheck()
-		switch {
-		case test.serverErr == nil && err == nil:
-			// pass
-		case err != nil && test.serverErr != nil && strings.Contains(err.Error(), test.serverErr.Error()):
-			// pass
-		default:
-			t.Errorf("%s: expected %v, got %v", test.name, test.serverErr, err)
-			continue
-		}
-		if actualAllowed != test.allowed {
-			t.Errorf("%s: expected %v, got %v", test.name, test.allowed, actualAllowed)
-			continue
-		}
+					bodyBits, err := ioutil.ReadAll(req.Body)
+					if err != nil {
+						t.Errorf("%s: %v", test.name, err)
+						return nil, nil
+					}
+					body := string(bodyBits)
+
+					for _, expectedBody := range test.expectedBodyStrings {
+						if !strings.Contains(body, expectedBody) {
+							t.Errorf("%s expecting %s in %s", test.name, expectedBody, body)
+						}
+					}
+
+					return &http.Response{
+							StatusCode: http.StatusOK,
+							Body: ioutil.NopCloser(bytes.NewBufferString(
+								fmt.Sprintf(`{"kind":"SelfSubjectAccessReview","apiVersion":"authorization.k8s.io/v1","status":{"allowed":%v}}`, test.allowed),
+							)),
+						},
+						test.serverErr
+				}),
+			}
+			tf.Namespace = "test"
+			tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}}
+
+			if err := test.o.Complete(tf, test.args); err != nil {
+				t.Errorf("%s: %v", test.name, err)
+				return
+			}
+
+			actualAllowed, err := test.o.RunAccessCheck()
+			switch {
+			case test.serverErr == nil && err == nil:
+				// pass
+			case err != nil && test.serverErr != nil && strings.Contains(err.Error(), test.serverErr.Error()):
+				// pass
+			default:
+				t.Errorf("%s: expected %v, got %v", test.name, test.serverErr, err)
+				return
+			}
+			if actualAllowed != test.allowed {
+				t.Errorf("%s: expected %v, got %v", test.name, test.allowed, actualAllowed)
+				return
+			}
+		})
 	}
 }

pkg/kubectl/cmd/clusterinfo_dump_test.go

@@ -31,6 +31,8 @@ func TestSetupOutputWriterNoOp(t *testing.T) {
 	for _, test := range tests {
 		out := &bytes.Buffer{}
 		f := cmdtesting.NewTestFactory()
+		defer f.Cleanup()
+
 		cmd := NewCmdClusterInfoDump(f, os.Stdout)
 		cmd.Flag("output-directory").Value.Set(test)
 		writer := setupOutputWriter(cmd, out, "/some/file/that/should/be/ignored")
@@ -51,6 +53,8 @@ func TestSetupOutputWriterFile(t *testing.T) {
 
 	out := &bytes.Buffer{}
 	f := cmdtesting.NewTestFactory()
+	defer f.Cleanup()
+
 	cmd := NewCmdClusterInfoDump(f, os.Stdout)
 	cmd.Flag("output-directory").Value.Set(dir)
 	writer := setupOutputWriter(cmd, out, file)

pkg/kubectl/cmd/cmd_test.go

@@ -178,6 +178,8 @@ func stringBody(body string) io.ReadCloser {
 
 func Example_printMultiContainersReplicationControllerWithWide() {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -228,6 +230,8 @@ func Example_printMultiContainersReplicationControllerWithWide() {
 
 func Example_printReplicationController() {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -277,6 +281,8 @@ func Example_printReplicationController() {
 
 func Example_printPodWithWideFormat() {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -315,6 +321,8 @@ func Example_printPodWithWideFormat() {
 
 func Example_printPodWithShowLabels() {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -448,6 +456,8 @@ func newAllPhasePodList() *api.PodList {
 
 func Example_printPodShowTerminated() {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -484,6 +494,8 @@ func Example_printPodShowTerminated() {
 
 func Example_printPodShowAll() {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -507,6 +519,8 @@ func Example_printPodShowAll() {
 
 func Example_printServiceWithLabels() {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{

pkg/kubectl/cmd/convert_test.go

@@ -102,6 +102,8 @@ func TestConvertObject(t *testing.T) {
 		for _, field := range tc.fields {
 			t.Run(fmt.Sprintf("%s %s", tc.name, field), func(t *testing.T) {
 				tf := cmdtesting.NewTestFactory()
+				defer tf.Cleanup()
+
 				tf.UnstructuredClient = &fake.RESTClient{
 					Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
 						t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)

pkg/kubectl/cmd/create_clusterrole_test.go

@@ -33,6 +33,8 @@ func TestCreateClusterRole(t *testing.T) {
 	clusterRoleName := "my-cluster-role"
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.Namespace = "test"
 	tf.Client = &fake.RESTClient{}
 	tf.ClientConfigVal = defaultClientConfig()
@@ -148,6 +150,8 @@ func TestCreateClusterRole(t *testing.T) {
 
 func TestClusterRoleValidate(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.Namespace = "test"
 
 	tests := map[string]struct {

pkg/kubectl/cmd/create_clusterrolebinding_test.go

@@ -68,6 +68,8 @@ func TestCreateClusterRoleBinding(t *testing.T) {
 	}
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	info, _ := runtime.SerializerInfoForMediaType(ns.SupportedMediaTypes(), runtime.ContentTypeJSON)

pkg/kubectl/cmd/create_configmap_test.go

@@ -33,6 +33,8 @@ func TestCreateConfigMap(t *testing.T) {
 	configMap := &v1.ConfigMap{}
 	configMap.Name = "my-configmap"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 

pkg/kubectl/cmd/create_deployment_test.go

@@ -75,6 +75,8 @@ func Test_generatorFromName(t *testing.T) {
 func TestCreateDeployment(t *testing.T) {
 	depName := "jonny-dep"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -104,6 +106,8 @@ func TestCreateDeployment(t *testing.T) {
 func TestCreateDeploymentNoImage(t *testing.T) {
 	depName := "jonny-dep"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{

pkg/kubectl/cmd/create_job_test.go

@@ -82,6 +82,8 @@ func TestCreateJobFromCronJob(t *testing.T) {
 		return true, expectJob, nil
 	})
 	f := cmdtesting.NewTestFactory()
+	defer f.Cleanup()
+
 	buf := bytes.NewBuffer([]byte{})
 	cmdOptions := &CreateJobOptions{
 		Name:      testJobName,

pkg/kubectl/cmd/create_namespace_test.go

@@ -33,6 +33,8 @@ func TestCreateNamespace(t *testing.T) {
 	namespaceObject := &v1.Namespace{}
 	namespaceObject.Name = "my-namespace"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 

pkg/kubectl/cmd/create_pdb_test.go

@@ -32,6 +32,8 @@ import (
 func TestCreatePdb(t *testing.T) {
 	pdbName := "my-pdb"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{

pkg/kubectl/cmd/create_priorityclass_test.go

@@ -32,6 +32,8 @@ import (
 func TestCreatePriorityClass(t *testing.T) {
 	pcName := "my-pc"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{

pkg/kubectl/cmd/create_quota_test.go

@@ -33,6 +33,8 @@ func TestCreateQuota(t *testing.T) {
 	resourceQuotaObject := &v1.ResourceQuota{}
 	resourceQuotaObject.Name = "my-quota"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 

pkg/kubectl/cmd/create_role_test.go

@@ -35,6 +35,8 @@ func TestCreateRole(t *testing.T) {
 	roleName := "my-role"
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.Namespace = "test"
 	tf.Client = &fake.RESTClient{}
 	tf.ClientConfigVal = defaultClientConfig()
@@ -147,6 +149,8 @@ func TestCreateRole(t *testing.T) {
 
 func TestValidate(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.Namespace = "test"
 
 	tests := map[string]struct {
@@ -346,6 +350,8 @@ func TestComplete(t *testing.T) {
 	roleName := "my-role"
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.Namespace = "test"
 	tf.Client = &fake.RESTClient{}
 	tf.ClientConfigVal = defaultClientConfig()

pkg/kubectl/cmd/create_rolebinding_test.go

@@ -70,6 +70,8 @@ func TestCreateRoleBinding(t *testing.T) {
 	}
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	info, _ := runtime.SerializerInfoForMediaType(ns.SupportedMediaTypes(), runtime.ContentTypeJSON)

pkg/kubectl/cmd/create_secret_test.go

@@ -38,6 +38,8 @@ func TestCreateSecretGeneric(t *testing.T) {
 	}
 	secretObject.Name = "my-secret"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 

pkg/kubectl/cmd/create_service_test.go

@@ -33,6 +33,8 @@ func TestCreateService(t *testing.T) {
 	service := &v1.Service{}
 	service.Name = "my-service"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	negSer := legacyscheme.Codecs
 
@@ -65,6 +67,8 @@ func TestCreateServiceNodePort(t *testing.T) {
 	service := &v1.Service{}
 	service.Name = "my-node-port-service"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	negSer := legacyscheme.Codecs
 
@@ -97,6 +101,8 @@ func TestCreateServiceExternalName(t *testing.T) {
 	service := &v1.Service{}
 	service.Name = "my-external-name-service"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	negSer := legacyscheme.Codecs
 

pkg/kubectl/cmd/create_serviceaccount_test.go

@@ -33,6 +33,8 @@ func TestCreateServiceAccount(t *testing.T) {
 	serviceAccountObject := &v1.ServiceAccount{}
 	serviceAccountObject.Name = "my-service-account"
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 

pkg/kubectl/cmd/create_test.go

@@ -34,6 +34,8 @@ func TestExtraArgsFail(t *testing.T) {
 	errBuf := bytes.NewBuffer([]byte{})
 
 	f := cmdtesting.NewTestFactory()
+	defer f.Cleanup()
+
 	c := NewCmdCreate(f, buf, errBuf)
 	options := CreateOptions{}
 	if options.ValidateArgs(c, []string{"rc"}) == nil {
@@ -47,6 +49,8 @@ func TestCreateObject(t *testing.T) {
 	rc.Items[0].Name = "redis-master-controller"
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -82,6 +86,8 @@ func TestCreateMultipleObject(t *testing.T) {
 	_, svc, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -121,6 +127,8 @@ func TestCreateDirectory(t *testing.T) {
 	rc.Items[0].Name = "name"
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{

pkg/kubectl/cmd/delete_test.go

@@ -57,6 +57,8 @@ func TestDeleteObjectByTuple(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -121,6 +123,8 @@ func TestOrphanDependentsInDeleteObject(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	var expectedOrphanDependents *bool
@@ -171,6 +175,8 @@ func TestDeleteNamedObject(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -222,6 +228,8 @@ func TestDeleteObject(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -281,6 +289,8 @@ func TestDeleteObjectGraceZero(t *testing.T) {
 	objectDeletionWaitInterval = time.Millisecond
 	count := 0
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -331,6 +341,8 @@ func TestDeleteObjectGraceZero(t *testing.T) {
 func TestDeleteObjectNotFound(t *testing.T) {
 	initTestErrorHandler(t)
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -367,6 +379,8 @@ func TestDeleteObjectNotFound(t *testing.T) {
 func TestDeleteObjectIgnoreNotFound(t *testing.T) {
 	initTestErrorHandler(t)
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -402,6 +416,8 @@ func TestDeleteAllNotFound(t *testing.T) {
 	notFoundError := &errors.NewNotFound(api.Resource("services"), "foo").ErrStatus
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -447,6 +463,8 @@ func TestDeleteAllIgnoreNotFound(t *testing.T) {
 	_, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	// Add an item to the list which will result in a 404 on delete
@@ -488,6 +506,8 @@ func TestDeleteMultipleObject(t *testing.T) {
 	_, svc, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -524,6 +544,8 @@ func TestDeleteMultipleObjectContinueOnMissing(t *testing.T) {
 	_, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -569,6 +591,8 @@ func TestDeleteMultipleResourcesWithTheSameName(t *testing.T) {
 	initTestErrorHandler(t)
 	_, svc, rc := testData()
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -608,6 +632,8 @@ func TestDeleteDirectory(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -641,6 +667,8 @@ func TestDeleteMultipleSelector(t *testing.T) {
 	pods, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -706,26 +734,30 @@ func TestResourceErrors(t *testing.T) {
 	}
 
 	for k, testCase := range testCases {
-		tf := cmdtesting.NewTestFactory()
-		tf.Namespace = "test"
-		tf.ClientConfigVal = defaultClientConfig()
-
-		buf, errBuf := bytes.NewBuffer([]byte{}), bytes.NewBuffer([]byte{})
-
-		options := &DeleteOptions{
-			FilenameOptions: resource.FilenameOptions{},
-			GracePeriod:     -1,
-			Cascade:         false,
-			Output:          "name",
-		}
-		err := options.Complete(tf, buf, errBuf, testCase.args, fakecmd)
-		if !testCase.errFn(err) {
-			t.Errorf("%s: unexpected error: %v", k, err)
-			continue
-		}
-
-		if buf.Len() > 0 {
-			t.Errorf("buffer should be empty: %s", string(buf.Bytes()))
-		}
+		t.Run(k, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			tf.Namespace = "test"
+			tf.ClientConfigVal = defaultClientConfig()
+
+			buf, errBuf := bytes.NewBuffer([]byte{}), bytes.NewBuffer([]byte{})
+
+			options := &DeleteOptions{
+				FilenameOptions: resource.FilenameOptions{},
+				GracePeriod:     -1,
+				Cascade:         false,
+				Output:          "name",
+			}
+			err := options.Complete(tf, buf, errBuf, testCase.args, fakecmd)
+			if !testCase.errFn(err) {
+				t.Errorf("%s: unexpected error: %v", k, err)
+				return
+			}
+
+			if buf.Len() > 0 {
+				t.Errorf("buffer should be empty: %s", string(buf.Bytes()))
+			}
+		})
 	}
 }

pkg/kubectl/cmd/describe_test.go

@@ -33,6 +33,7 @@ import (
 func TestDescribeUnknownSchemaObject(t *testing.T) {
 	d := &testDescriber{Output: "test output"}
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	_, _, codec := cmdtesting.NewExternalScheme()
 	tf.DescriberVal = d
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -58,6 +59,7 @@ func TestDescribeUnknownSchemaObject(t *testing.T) {
 func TestDescribeUnknownNamespacedSchemaObject(t *testing.T) {
 	d := &testDescriber{Output: "test output"}
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	_, _, codec := cmdtesting.NewExternalScheme()
 
 	tf.DescriberVal = d
@@ -83,6 +85,7 @@ func TestDescribeUnknownNamespacedSchemaObject(t *testing.T) {
 func TestDescribeObject(t *testing.T) {
 	_, _, rc := testData()
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
@@ -118,6 +121,7 @@ func TestDescribeObject(t *testing.T) {
 func TestDescribeListObjects(t *testing.T) {
 	pods, _, _ := testData()
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
@@ -140,6 +144,7 @@ func TestDescribeListObjects(t *testing.T) {
 func TestDescribeObjectShowEvents(t *testing.T) {
 	pods, _, _ := testData()
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
@@ -163,6 +168,7 @@ func TestDescribeObjectShowEvents(t *testing.T) {
 func TestDescribeObjectSkipEvents(t *testing.T) {
 	pods, _, _ := testData()
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
@@ -185,6 +191,7 @@ func TestDescribeObjectSkipEvents(t *testing.T) {
 
 func TestDescribeHelpMessage(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})

pkg/kubectl/cmd/edit_test.go

@@ -207,6 +207,8 @@ func TestEdit(t *testing.T) {
 			}
 
 			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
 			tf.UnstructuredClientForMappingFunc = func(mapping *meta.RESTMapping) (resource.RESTClient, error) {
 				versionedAPIPath := ""
 				if mapping.GroupVersionKind.Group == "" {

pkg/kubectl/cmd/exec_test.go

@@ -130,38 +130,42 @@ func TestPodAndContainer(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		tf := cmdtesting.NewTestFactory()
-		ns := legacyscheme.Codecs
-
-		tf.Client = &fake.RESTClient{
-			NegotiatedSerializer: ns,
-			Client:               fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return nil, nil }),
-		}
-		tf.Namespace = "test"
-		tf.ClientConfigVal = defaultClientConfig()
-
-		cmd := &cobra.Command{}
-		options := test.p
-		options.Err = bytes.NewBuffer([]byte{})
-		err := options.Complete(tf, cmd, test.args, test.argsLenAtDash)
-		if test.expectError && err == nil {
-			t.Errorf("%s: unexpected non-error", test.name)
-		}
-		if !test.expectError && err != nil {
-			t.Errorf("%s: unexpected error: %v", test.name, err)
-		}
-		if err != nil {
-			continue
-		}
-		if options.PodName != test.expectedPod {
-			t.Errorf("%s: expected: %s, got: %s", test.name, test.expectedPod, options.PodName)
-		}
-		if options.ContainerName != test.expectedContainer {
-			t.Errorf("%s: expected: %s, got: %s", test.name, test.expectedContainer, options.ContainerName)
-		}
-		if !reflect.DeepEqual(test.expectedArgs, options.Command) {
-			t.Errorf("%s: expected: %v, got %v", test.name, test.expectedArgs, options.Command)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			ns := legacyscheme.Codecs
+
+			tf.Client = &fake.RESTClient{
+				NegotiatedSerializer: ns,
+				Client:               fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return nil, nil }),
+			}
+			tf.Namespace = "test"
+			tf.ClientConfigVal = defaultClientConfig()
+
+			cmd := &cobra.Command{}
+			options := test.p
+			options.Err = bytes.NewBuffer([]byte{})
+			err := options.Complete(tf, cmd, test.args, test.argsLenAtDash)
+			if test.expectError && err == nil {
+				t.Errorf("%s: unexpected non-error", test.name)
+			}
+			if !test.expectError && err != nil {
+				t.Errorf("%s: unexpected error: %v", test.name, err)
+			}
+			if err != nil {
+				return
+			}
+			if options.PodName != test.expectedPod {
+				t.Errorf("%s: expected: %s, got: %s", test.name, test.expectedPod, options.PodName)
+			}
+			if options.ContainerName != test.expectedContainer {
+				t.Errorf("%s: expected: %s, got: %s", test.name, test.expectedContainer, options.ContainerName)
+			}
+			if !reflect.DeepEqual(test.expectedArgs, options.Command) {
+				t.Errorf("%s: expected: %v, got %v", test.name, test.expectedArgs, options.Command)
+			}
+		})
 	}
 }
 
@@ -187,67 +191,71 @@ func TestExec(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		tf := cmdtesting.NewTestFactory()
-		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
-		ns := legacyscheme.Codecs
-
-		tf.Client = &fake.RESTClient{
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				switch p, m := req.URL.Path, req.Method; {
-				case p == test.podPath && m == "GET":
-					body := objBody(codec, test.pod)
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
-				default:
-					// Ensures no GET is performed when deleting by name
-					t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req)
-					return nil, fmt.Errorf("unexpected request")
-				}
-			}),
-		}
-		tf.Namespace = "test"
-		tf.ClientConfigVal = defaultClientConfig()
-		bufOut := bytes.NewBuffer([]byte{})
-		bufErr := bytes.NewBuffer([]byte{})
-		bufIn := bytes.NewBuffer([]byte{})
-		ex := &fakeRemoteExecutor{}
-		if test.execErr {
-			ex.execErr = fmt.Errorf("exec error")
-		}
-		params := &ExecOptions{
-			StreamOptions: StreamOptions{
-				PodName:       "foo",
-				ContainerName: "bar",
-				In:            bufIn,
-				Out:           bufOut,
-				Err:           bufErr,
-			},
-			Executor: ex,
-		}
-		cmd := &cobra.Command{}
-		args := []string{"test", "command"}
-		if err := params.Complete(tf, cmd, args, -1); err != nil {
-			t.Fatal(err)
-		}
-		err := params.Run()
-		if test.execErr && err != ex.execErr {
-			t.Errorf("%s: Unexpected exec error: %v", test.name, err)
-			continue
-		}
-		if !test.execErr && err != nil {
-			t.Errorf("%s: Unexpected error: %v", test.name, err)
-			continue
-		}
-		if test.execErr {
-			continue
-		}
-		if ex.url.Path != test.execPath {
-			t.Errorf("%s: Did not get expected path for exec request", test.name)
-			continue
-		}
-		if ex.method != "POST" {
-			t.Errorf("%s: Did not get method for exec request: %s", test.name, ex.method)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
+			ns := legacyscheme.Codecs
+
+			tf.Client = &fake.RESTClient{
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					switch p, m := req.URL.Path, req.Method; {
+					case p == test.podPath && m == "GET":
+						body := objBody(codec, test.pod)
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+					default:
+						// Ensures no GET is performed when deleting by name
+						t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req)
+						return nil, fmt.Errorf("unexpected request")
+					}
+				}),
+			}
+			tf.Namespace = "test"
+			tf.ClientConfigVal = defaultClientConfig()
+			bufOut := bytes.NewBuffer([]byte{})
+			bufErr := bytes.NewBuffer([]byte{})
+			bufIn := bytes.NewBuffer([]byte{})
+			ex := &fakeRemoteExecutor{}
+			if test.execErr {
+				ex.execErr = fmt.Errorf("exec error")
+			}
+			params := &ExecOptions{
+				StreamOptions: StreamOptions{
+					PodName:       "foo",
+					ContainerName: "bar",
+					In:            bufIn,
+					Out:           bufOut,
+					Err:           bufErr,
+				},
+				Executor: ex,
+			}
+			cmd := &cobra.Command{}
+			args := []string{"test", "command"}
+			if err := params.Complete(tf, cmd, args, -1); err != nil {
+				t.Fatal(err)
+			}
+			err := params.Run()
+			if test.execErr && err != ex.execErr {
+				t.Errorf("%s: Unexpected exec error: %v", test.name, err)
+				return
+			}
+			if !test.execErr && err != nil {
+				t.Errorf("%s: Unexpected error: %v", test.name, err)
+				return
+			}
+			if test.execErr {
+				return
+			}
+			if ex.url.Path != test.execPath {
+				t.Errorf("%s: Did not get expected path for exec request", test.name)
+				return
+			}
+			if ex.method != "POST" {
+				t.Errorf("%s: Did not get method for exec request: %s", test.name, ex.method)
+			}
+		})
 	}
 }
 

pkg/kubectl/cmd/expose_test.go

@@ -466,42 +466,46 @@ func TestRunExposeService(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		tf := cmdtesting.NewTestFactory()
-		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
-		ns := legacyscheme.Codecs
+		t.Run(test.name, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
 
-		tf.Client = &fake.RESTClient{
-			GroupVersion:         schema.GroupVersion{Version: "v1"},
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				switch p, m := req.URL.Path, req.Method; {
-				case p == test.calls[m] && m == "GET":
-					return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.input)}, nil
-				case p == test.calls[m] && m == "POST":
-					return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.output)}, nil
-				default:
-					t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
-					return nil, nil
-				}
-			}),
-		}
-		tf.Namespace = test.ns
-		buf := bytes.NewBuffer([]byte{})
+			codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
+			ns := legacyscheme.Codecs
 
-		cmd := NewCmdExposeService(tf, buf)
-		cmd.SetOutput(buf)
-		for flag, value := range test.flags {
-			cmd.Flags().Set(flag, value)
-		}
-		cmd.Run(cmd, test.args)
+			tf.Client = &fake.RESTClient{
+				GroupVersion:         schema.GroupVersion{Version: "v1"},
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					switch p, m := req.URL.Path, req.Method; {
+					case p == test.calls[m] && m == "GET":
+						return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.input)}, nil
+					case p == test.calls[m] && m == "POST":
+						return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.output)}, nil
+					default:
+						t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+						return nil, nil
+					}
+				}),
+			}
+			tf.Namespace = test.ns
+			buf := bytes.NewBuffer([]byte{})
 
-		out := buf.String()
-		if _, ok := test.flags["dry-run"]; ok {
-			test.expected = fmt.Sprintf("service %q exposed (dry run)", test.flags["name"])
-		}
+			cmd := NewCmdExposeService(tf, buf)
+			cmd.SetOutput(buf)
+			for flag, value := range test.flags {
+				cmd.Flags().Set(flag, value)
+			}
+			cmd.Run(cmd, test.args)
 
-		if !strings.Contains(out, test.expected) {
-			t.Errorf("%s: Unexpected output! Expected\n%s\ngot\n%s", test.name, test.expected, out)
-		}
+			out := buf.String()
+			if _, ok := test.flags["dry-run"]; ok {
+				test.expected = fmt.Sprintf("service %q exposed (dry run)", test.flags["name"])
+			}
+
+			if !strings.Contains(out, test.expected) {
+				t.Errorf("%s: Unexpected output! Expected\n%s\ngot\n%s", test.name, test.expected, out)
+			}
+		})
 	}
 }

pkg/kubectl/cmd/label_test.go

@@ -321,38 +321,44 @@ func TestLabelErrors(t *testing.T) {
 	}
 
 	for k, testCase := range testCases {
-		tf := cmdtesting.NewTestFactory()
-		tf.Namespace = "test"
-		tf.ClientConfigVal = defaultClientConfig()
+		t.Run(k, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
 
-		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdLabel(tf, buf)
-		cmd.SetOutput(buf)
+			tf.Namespace = "test"
+			tf.ClientConfigVal = defaultClientConfig()
 
-		for k, v := range testCase.flags {
-			cmd.Flags().Set(k, v)
-		}
-		opts := LabelOptions{}
-		err := opts.Complete(buf, cmd, testCase.args)
-		if err == nil {
-			err = opts.Validate()
-		}
-		if err == nil {
-			err = opts.RunLabel(tf, cmd)
-		}
-		if !testCase.errFn(err) {
-			t.Errorf("%s: unexpected error: %v", k, err)
-			continue
-		}
-		if buf.Len() > 0 {
-			t.Errorf("buffer should be empty: %s", string(buf.Bytes()))
-		}
+			buf := bytes.NewBuffer([]byte{})
+			cmd := NewCmdLabel(tf, buf)
+			cmd.SetOutput(buf)
+
+			for k, v := range testCase.flags {
+				cmd.Flags().Set(k, v)
+			}
+			opts := LabelOptions{}
+			err := opts.Complete(buf, cmd, testCase.args)
+			if err == nil {
+				err = opts.Validate()
+			}
+			if err == nil {
+				err = opts.RunLabel(tf, cmd)
+			}
+			if !testCase.errFn(err) {
+				t.Errorf("%s: unexpected error: %v", k, err)
+				return
+			}
+			if buf.Len() > 0 {
+				t.Errorf("buffer should be empty: %s", string(buf.Bytes()))
+			}
+		})
 	}
 }
 
 func TestLabelForResourceFromFile(t *testing.T) {
 	pods, _, _ := testData()
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -405,6 +411,8 @@ func TestLabelForResourceFromFile(t *testing.T) {
 
 func TestLabelLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -438,6 +446,8 @@ func TestLabelLocal(t *testing.T) {
 func TestLabelMultipleObjects(t *testing.T) {
 	pods, _, _ := testData()
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{

pkg/kubectl/cmd/logs_test.go

@@ -48,39 +48,43 @@ func TestLog(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		logContent := "test log content"
-		tf := cmdtesting.NewTestFactory()
-		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
-		ns := legacyscheme.Codecs
-
-		tf.Client = &fake.RESTClient{
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				switch p, m := req.URL.Path, req.Method; {
-				case p == test.podPath && m == "GET":
-					body := objBody(codec, test.pod)
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
-				case p == test.logPath && m == "GET":
-					body := ioutil.NopCloser(bytes.NewBufferString(logContent))
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
-				default:
-					// Ensures no GET is performed when deleting by name
-					t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req)
-					return nil, nil
-				}
-			}),
-		}
-		tf.Namespace = "test"
-		tf.ClientConfigVal = defaultClientConfig()
-		buf := bytes.NewBuffer([]byte{})
-
-		cmd := NewCmdLogs(tf, buf, buf)
-		cmd.Flags().Set("namespace", "test")
-		cmd.Run(cmd, []string{"foo"})
-
-		if buf.String() != logContent {
-			t.Errorf("%s: did not get expected log content. Got: %s", test.name, buf.String())
-		}
+		t.Run(test.name, func(t *testing.T) {
+			logContent := "test log content"
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
+			ns := legacyscheme.Codecs
+
+			tf.Client = &fake.RESTClient{
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					switch p, m := req.URL.Path, req.Method; {
+					case p == test.podPath && m == "GET":
+						body := objBody(codec, test.pod)
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+					case p == test.logPath && m == "GET":
+						body := ioutil.NopCloser(bytes.NewBufferString(logContent))
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+					default:
+						// Ensures no GET is performed when deleting by name
+						t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req)
+						return nil, nil
+					}
+				}),
+			}
+			tf.Namespace = "test"
+			tf.ClientConfigVal = defaultClientConfig()
+			buf := bytes.NewBuffer([]byte{})
+
+			cmd := NewCmdLogs(tf, buf, buf)
+			cmd.Flags().Set("namespace", "test")
+			cmd.Run(cmd, []string{"foo"})
+
+			if buf.String() != logContent {
+				t.Errorf("%s: did not get expected log content. Got: %s", test.name, buf.String())
+			}
+		})
 	}
 }
 
@@ -101,6 +105,7 @@ func testPod() *api.Pod {
 
 func TestValidateLogFlags(t *testing.T) {
 	f := cmdtesting.NewTestFactory()
+	defer f.Cleanup()
 
 	tests := []struct {
 		name     string
@@ -152,6 +157,7 @@ func TestValidateLogFlags(t *testing.T) {
 
 func TestLogComplete(t *testing.T) {
 	f := cmdtesting.NewTestFactory()
+	defer f.Cleanup()
 
 	tests := []struct {
 		name     string

pkg/kubectl/cmd/patch_test.go

@@ -32,6 +32,8 @@ func TestPatchObject(t *testing.T) {
 	_, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -72,6 +74,8 @@ func TestPatchObjectFromFile(t *testing.T) {
 	_, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -108,6 +112,8 @@ func TestPatchNoop(t *testing.T) {
 	patchObject := &svc.Items[0]
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -154,6 +160,8 @@ func TestPatchObjectFromFileOutput(t *testing.T) {
 	svcCopy.Labels["post-patch"] = "post-patch-value"
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{

pkg/kubectl/cmd/plugin_test.go

@@ -80,34 +80,38 @@ func TestPluginCmd(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		inBuf := bytes.NewBuffer([]byte{})
-		outBuf := bytes.NewBuffer([]byte{})
-		errBuf := bytes.NewBuffer([]byte{})
+		t.Run(test.name, func(t *testing.T) {
+			inBuf := bytes.NewBuffer([]byte{})
+			outBuf := bytes.NewBuffer([]byte{})
+			errBuf := bytes.NewBuffer([]byte{})
 
-		cmdutil.BehaviorOnFatal(func(str string, code int) {
-			errBuf.Write([]byte(str))
-		})
+			cmdutil.BehaviorOnFatal(func(str string, code int) {
+				errBuf.Write([]byte(str))
+			})
+
+			runner := &mockPluginRunner{
+				success: test.expectedSuccess,
+			}
 
-		runner := &mockPluginRunner{
-			success: test.expectedSuccess,
-		}
+			f := cmdtesting.NewTestFactory()
+			defer f.Cleanup()
 
-		f := cmdtesting.NewTestFactory()
-		cmd := NewCmdForPlugin(f, test.plugin, runner, inBuf, outBuf, errBuf)
-		if cmd == nil {
-			if !test.expectedNilCmd {
-				t.Fatalf("%s: command was unexpectedly not registered", test.name)
+			cmd := NewCmdForPlugin(f, test.plugin, runner, inBuf, outBuf, errBuf)
+			if cmd == nil {
+				if !test.expectedNilCmd {
+					t.Fatalf("%s: command was unexpectedly not registered", test.name)
+				}
+				return
 			}
-			continue
-		}
-		cmd.Run(cmd, []string{})
+			cmd.Run(cmd, []string{})
 
-		if test.expectedSuccess && outBuf.String() != fmt.Sprintf("ok: %s", test.plugin.Name) {
-			t.Errorf("%s: unexpected output: %q", test.name, outBuf.String())
-		}
+			if test.expectedSuccess && outBuf.String() != fmt.Sprintf("ok: %s", test.plugin.Name) {
+				t.Errorf("%s: unexpected output: %q", test.name, outBuf.String())
+			}
 
-		if !test.expectedSuccess && errBuf.String() != fmt.Sprintf("error: oops %s", test.plugin.Name) {
-			t.Errorf("%s: unexpected err output: %q", test.name, errBuf.String())
-		}
+			if !test.expectedSuccess && errBuf.String() != fmt.Sprintf("error: oops %s", test.plugin.Name) {
+				t.Errorf("%s: unexpected err output: %q", test.name, errBuf.String())
+			}
+		})
 	}
 }

pkg/kubectl/cmd/portforward_test.go

@@ -71,68 +71,72 @@ func testPortForward(t *testing.T, flags map[string]string, args []string) {
 		},
 	}
 	for _, test := range tests {
-		var err error
-		tf := cmdtesting.NewTestFactory()
-		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
-		ns := legacyscheme.Codecs
+		t.Run(test.name, func(t *testing.T) {
+			var err error
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
 
-		tf.Client = &fake.RESTClient{
-			VersionedAPIPath:     "/api/v1",
-			GroupVersion:         schema.GroupVersion{Group: ""},
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				switch p, m := req.URL.Path, req.Method; {
-				case p == test.podPath && m == "GET":
-					body := objBody(codec, test.pod)
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
-				default:
-					// Ensures no GET is performed when deleting by name
-					t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req)
-					return nil, nil
-				}
-			}),
-		}
-		tf.Namespace = "test"
-		tf.ClientConfigVal = defaultClientConfig()
-		ff := &fakePortForwarder{}
-		if test.pfErr {
-			ff.pfErr = fmt.Errorf("pf error")
-		}
+			codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
+			ns := legacyscheme.Codecs
 
-		opts := &PortForwardOptions{}
-		cmd := NewCmdPortForward(tf, os.Stdout, os.Stderr)
-		cmd.Run = func(cmd *cobra.Command, args []string) {
-			if err = opts.Complete(tf, cmd, args); err != nil {
-				return
+			tf.Client = &fake.RESTClient{
+				VersionedAPIPath:     "/api/v1",
+				GroupVersion:         schema.GroupVersion{Group: ""},
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					switch p, m := req.URL.Path, req.Method; {
+					case p == test.podPath && m == "GET":
+						body := objBody(codec, test.pod)
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
+					default:
+						// Ensures no GET is performed when deleting by name
+						t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req)
+						return nil, nil
+					}
+				}),
 			}
-			opts.PortForwarder = ff
-			if err = opts.Validate(); err != nil {
-				return
+			tf.Namespace = "test"
+			tf.ClientConfigVal = defaultClientConfig()
+			ff := &fakePortForwarder{}
+			if test.pfErr {
+				ff.pfErr = fmt.Errorf("pf error")
 			}
-			err = opts.RunPortForward()
-		}
 
-		for name, value := range flags {
-			cmd.Flags().Set(name, value)
-		}
-		cmd.Run(cmd, args)
+			opts := &PortForwardOptions{}
+			cmd := NewCmdPortForward(tf, os.Stdout, os.Stderr)
+			cmd.Run = func(cmd *cobra.Command, args []string) {
+				if err = opts.Complete(tf, cmd, args); err != nil {
+					return
+				}
+				opts.PortForwarder = ff
+				if err = opts.Validate(); err != nil {
+					return
+				}
+				err = opts.RunPortForward()
+			}
 
-		if test.pfErr && err != ff.pfErr {
-			t.Errorf("%s: Unexpected port-forward error: %v", test.name, err)
-		}
-		if !test.pfErr && err != nil {
-			t.Errorf("%s: Unexpected error: %v", test.name, err)
-		}
-		if test.pfErr {
-			continue
-		}
+			for name, value := range flags {
+				cmd.Flags().Set(name, value)
+			}
+			cmd.Run(cmd, args)
 
-		if ff.url.Path != test.pfPath {
-			t.Errorf("%s: Did not get expected path for portforward request", test.name)
-		}
-		if ff.method != "POST" {
-			t.Errorf("%s: Did not get method for attach request: %s", test.name, ff.method)
-		}
+			if test.pfErr && err != ff.pfErr {
+				t.Errorf("%s: Unexpected port-forward error: %v", test.name, err)
+			}
+			if !test.pfErr && err != nil {
+				t.Errorf("%s: Unexpected error: %v", test.name, err)
+			}
+			if test.pfErr {
+				return
+			}
+
+			if ff.url == nil || ff.url.Path != test.pfPath {
+				t.Errorf("%s: Did not get expected path for portforward request", test.name)
+			}
+			if ff.method != "POST" {
+				t.Errorf("%s: Did not get method for attach request: %s", test.name, ff.method)
+			}
+		})
 	}
 }
 

pkg/kubectl/cmd/replace_test.go

@@ -33,6 +33,7 @@ func TestReplaceObject(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	deleted := false
@@ -89,6 +90,7 @@ func TestReplaceMultipleObject(t *testing.T) {
 	_, svc, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	redisMasterDeleted := false
@@ -159,6 +161,7 @@ func TestReplaceDirectory(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	created := map[string]bool{}
@@ -216,6 +219,7 @@ func TestForceReplaceObjectNotFound(t *testing.T) {
 	_, _, rc := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{

pkg/kubectl/cmd/resource/get_test.go

@@ -198,6 +198,7 @@ func testComponentStatusData() *api.ComponentStatusList {
 func TestGetUnknownSchemaObject(t *testing.T) {
 	t.Skip("This test is completely broken.  The first thing it does is add the object to the scheme!")
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	_, _, codec := cmdtesting.NewExternalScheme()
 	tf.OpenAPISchemaFunc = openapitesting.CreateOpenAPISchemaFunc(openapiSchemaPath)
 
@@ -272,6 +273,7 @@ func TestGetUnknownSchemaObject(t *testing.T) {
 // Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get.
 func TestGetSchemaObject(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := testapi.Default.Codec()
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
@@ -294,6 +296,7 @@ func TestGetObjectsWithOpenAPIOutputFormatPresent(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	// overide the openAPISchema function to return custom output
@@ -351,6 +354,7 @@ func TestGetObjects(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -417,6 +421,8 @@ func TestGetObjectsFiltered(t *testing.T) {
 	for i, test := range testCases {
 		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
 			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+			defer tf.Cleanup()
 			codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 			tf.UnstructuredClient = &fake.RESTClient{
@@ -458,6 +464,7 @@ func TestGetObjectIgnoreNotFound(t *testing.T) {
 	}
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -511,6 +518,7 @@ func TestGetSortedObjects(t *testing.T) {
 	}
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -544,6 +552,7 @@ func TestGetObjectsIdentifiedByFile(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -571,6 +580,7 @@ func TestGetListObjects(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -598,6 +608,7 @@ func TestGetAllListObjects(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -626,6 +637,7 @@ func TestGetListComponentStatus(t *testing.T) {
 	statuses := testComponentStatusData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -667,6 +679,7 @@ func TestGetMixedGenericObjects(t *testing.T) {
 	}
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -717,6 +730,7 @@ func TestGetMultipleTypeObjects(t *testing.T) {
 	pods, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -756,6 +770,7 @@ func TestGetMultipleTypeObjectsAsList(t *testing.T) {
 	pods, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -858,6 +873,7 @@ func TestGetMultipleTypeObjectsWithLabelSelector(t *testing.T) {
 	pods, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -902,6 +918,7 @@ func TestGetMultipleTypeObjectsWithFieldSelector(t *testing.T) {
 	pods, svc, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -954,6 +971,7 @@ func TestGetMultipleTypeObjectsWithDirectReference(t *testing.T) {
 	}
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -993,6 +1011,7 @@ func TestGetByFormatForcesFlag(t *testing.T) {
 	pods, _, _ := testData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -1089,6 +1108,7 @@ func TestWatchLabelSelector(t *testing.T) {
 	pods, events := watchTestData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	podList := &api.PodList{
@@ -1141,6 +1161,7 @@ func TestWatchFieldSelector(t *testing.T) {
 	pods, events := watchTestData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	podList := &api.PodList{
@@ -1193,6 +1214,7 @@ func TestWatchResource(t *testing.T) {
 	pods, events := watchTestData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -1237,6 +1259,7 @@ func TestWatchResourceIdentifiedByFile(t *testing.T) {
 	pods, events := watchTestData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -1282,6 +1305,7 @@ func TestWatchOnlyResource(t *testing.T) {
 	pods, events := watchTestData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -1325,6 +1349,7 @@ func TestWatchOnlyList(t *testing.T) {
 	pods, events := watchTestData()
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	podList := &api.PodList{

pkg/kubectl/cmd/rollingupdate_test.go

@@ -25,6 +25,7 @@ import (
 
 func TestValidateArgs(t *testing.T) {
 	f := cmdtesting.NewTestFactory()
+	defer f.Cleanup()
 
 	tests := []struct {
 		testName  string

pkg/kubectl/cmd/set/set_env_test.go

@@ -47,6 +47,8 @@ import (
 
 func TestSetEnvLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 	tf.Client = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Version: ""},
@@ -83,6 +85,8 @@ func TestSetEnvLocal(t *testing.T) {
 
 func TestSetMultiResourcesEnvLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -122,12 +126,14 @@ func TestSetMultiResourcesEnvLocal(t *testing.T) {
 
 func TestSetEnvRemote(t *testing.T) {
 	inputs := []struct {
+		name                            string
 		object                          runtime.Object
 		apiPrefix, apiGroup, apiVersion string
 		testAPIGroup                    string
 		args                            []string
 	}{
 		{
+			name: "test extensions.v1beta1 replicaset",
 			object: &extensionsv1beta1.ReplicaSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: extensionsv1beta1.ReplicaSetSpec{
@@ -148,6 +154,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"replicaset", "nginx", "env=prod"},
 		},
 		{
+			name: "test apps.v1beta2 replicaset",
 			object: &appsv1beta2.ReplicaSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.ReplicaSetSpec{
@@ -168,6 +175,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"replicaset", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1 replicaset",
 			object: &appsv1.ReplicaSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.ReplicaSetSpec{
@@ -188,6 +196,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"replicaset", "nginx", "env=prod"},
 		},
 		{
+			name: "test extensions.v1beta1 daemonset",
 			object: &extensionsv1beta1.DaemonSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: extensionsv1beta1.DaemonSetSpec{
@@ -208,6 +217,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"daemonset", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1beta2 daemonset",
 			object: &appsv1beta2.DaemonSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.DaemonSetSpec{
@@ -228,6 +238,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"daemonset", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1 daemonset",
 			object: &appsv1.DaemonSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.DaemonSetSpec{
@@ -248,6 +259,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"daemonset", "nginx", "env=prod"},
 		},
 		{
+			name: "test extensions.v1beta1 deployment",
 			object: &extensionsv1beta1.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: extensionsv1beta1.DeploymentSpec{
@@ -268,6 +280,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1bta1 deployment",
 			object: &appsv1beta1.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta1.DeploymentSpec{
@@ -288,6 +301,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1beta2n deployment",
 			object: &appsv1beta2.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.DeploymentSpec{
@@ -308,6 +322,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1 deployment",
 			object: &appsv1.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.DeploymentSpec{
@@ -328,6 +343,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1beta1 statefulset",
 			object: &appsv1beta1.StatefulSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta1.StatefulSetSpec{
@@ -348,6 +364,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"statefulset", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1beta2 statefulset",
 			object: &appsv1beta2.StatefulSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.StatefulSetSpec{
@@ -368,6 +385,7 @@ func TestSetEnvRemote(t *testing.T) {
 			args: []string{"statefulset", "nginx", "env=prod"},
 		},
 		{
+			name: "test appsv1 statefulset",
 			object: &appsv1.StatefulSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.StatefulSetSpec{
@@ -429,48 +447,52 @@ func TestSetEnvRemote(t *testing.T) {
 		},
 	}
 	for _, input := range inputs {
-		groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
-		testapi.Default = testapi.Groups[input.testAPIGroup]
-		tf := cmdtesting.NewTestFactory()
-		codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
-		ns := legacyscheme.Codecs
-		tf.Namespace = "test"
-		tf.Client = &fake.RESTClient{
-			GroupVersion:         groupVersion,
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				resourcePath := testapi.Default.ResourcePath(input.args[0]+"s", tf.Namespace, input.args[1])
-				switch p, m := req.URL.Path, req.Method; {
-				case p == resourcePath && m == http.MethodGet:
-					return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
-				case p == resourcePath && m == http.MethodPatch:
-					stream, err := req.GetBody()
-					if err != nil {
-						return nil, err
-					}
-					bytes, err := ioutil.ReadAll(stream)
-					if err != nil {
-						return nil, err
+		t.Run(input.name, func(t *testing.T) {
+			groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
+			testapi.Default = testapi.Groups[input.testAPIGroup]
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
+			ns := legacyscheme.Codecs
+			tf.Namespace = "test"
+			tf.Client = &fake.RESTClient{
+				GroupVersion:         groupVersion,
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					resourcePath := testapi.Default.ResourcePath(input.args[0]+"s", tf.Namespace, input.args[1])
+					switch p, m := req.URL.Path, req.Method; {
+					case p == resourcePath && m == http.MethodGet:
+						return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
+					case p == resourcePath && m == http.MethodPatch:
+						stream, err := req.GetBody()
+						if err != nil {
+							return nil, err
+						}
+						bytes, err := ioutil.ReadAll(stream)
+						if err != nil {
+							return nil, err
+						}
+						assert.Contains(t, string(bytes), `"value":`+`"`+"prod"+`"`, fmt.Sprintf("env not updated for %#v", input.object))
+						return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
+					default:
+						t.Errorf("%s: unexpected request: %s %#v\n%#v", "image", req.Method, req.URL, req)
+						return nil, fmt.Errorf("unexpected request")
 					}
-					assert.Contains(t, string(bytes), `"value":`+`"`+"prod"+`"`, fmt.Sprintf("env not updated for %#v", input.object))
-					return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
-				default:
-					t.Errorf("%s: unexpected request: %s %#v\n%#v", "image", req.Method, req.URL, req)
-					return nil, fmt.Errorf("unexpected request")
-				}
-			}),
-			VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
-		}
-		out := new(bytes.Buffer)
-		cmd := NewCmdEnv(tf, out, out, out)
-		cmd.SetOutput(out)
-		cmd.Flags().Set("output", "yaml")
-		opts := EnvOptions{
-			Out:   out,
-			Local: false}
-		err := opts.Complete(tf, cmd, input.args)
-		assert.NoError(t, err)
-		err = opts.RunEnv(tf)
-		assert.NoError(t, err)
+				}),
+				VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
+			}
+			out := new(bytes.Buffer)
+			cmd := NewCmdEnv(tf, out, out, out)
+			cmd.SetOutput(out)
+			cmd.Flags().Set("output", "yaml")
+			opts := EnvOptions{
+				Out:   out,
+				Local: false}
+			err := opts.Complete(tf, cmd, input.args)
+			assert.NoError(t, err)
+			err = opts.RunEnv(tf)
+			assert.NoError(t, err)
+		})
 	}
 }

pkg/kubectl/cmd/set/set_image_test.go

@@ -46,6 +46,8 @@ import (
 
 func TestImageLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -149,6 +151,8 @@ func TestSetImageValidation(t *testing.T) {
 
 func TestSetMultiResourcesImageLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -190,12 +194,14 @@ func TestSetMultiResourcesImageLocal(t *testing.T) {
 
 func TestSetImageRemote(t *testing.T) {
 	inputs := []struct {
+		name                            string
 		object                          runtime.Object
 		apiPrefix, apiGroup, apiVersion string
 		testAPIGroup                    string
 		args                            []string
 	}{
 		{
+			name: "set image extensionsv1beta1 ReplicaSet",
 			object: &extensionsv1beta1.ReplicaSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: extensionsv1beta1.ReplicaSetSpec{
@@ -216,6 +222,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"replicaset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1beta2 ReplicaSet",
 			object: &appsv1beta2.ReplicaSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.ReplicaSetSpec{
@@ -236,6 +243,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"replicaset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1 ReplicaSet",
 			object: &appsv1.ReplicaSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.ReplicaSetSpec{
@@ -256,6 +264,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"replicaset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image extensionsv1beta1 DaemonSet",
 			object: &extensionsv1beta1.DaemonSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: extensionsv1beta1.DaemonSetSpec{
@@ -276,6 +285,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"daemonset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1beta2 DaemonSet",
 			object: &appsv1beta2.DaemonSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.DaemonSetSpec{
@@ -296,6 +306,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"daemonset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1 DaemonSet",
 			object: &appsv1.DaemonSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.DaemonSetSpec{
@@ -316,6 +327,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"daemonset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image extensionsv1beta1 Deployment",
 			object: &extensionsv1beta1.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: extensionsv1beta1.DeploymentSpec{
@@ -336,6 +348,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1beta1 Deployment",
 			object: &appsv1beta1.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta1.DeploymentSpec{
@@ -356,6 +369,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1beta2 Deployment",
 			object: &appsv1beta2.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.DeploymentSpec{
@@ -376,6 +390,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1 Deployment",
 			object: &appsv1.Deployment{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.DeploymentSpec{
@@ -396,6 +411,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"deployment", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1beta1 StatefulSet",
 			object: &appsv1beta1.StatefulSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta1.StatefulSetSpec{
@@ -416,6 +432,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"statefulset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1beta2 StatefulSet",
 			object: &appsv1beta2.StatefulSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1beta2.StatefulSetSpec{
@@ -436,6 +453,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"statefulset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image appsv1 StatefulSet",
 			object: &appsv1.StatefulSet{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: appsv1.StatefulSetSpec{
@@ -456,6 +474,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"statefulset", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image batchv1 Job",
 			object: &batchv1.Job{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: batchv1.JobSpec{
@@ -476,6 +495,7 @@ func TestSetImageRemote(t *testing.T) {
 			args: []string{"job", "nginx", "*=thingy"},
 		},
 		{
+			name: "set image v1.ReplicationController",
 			object: &v1.ReplicationController{
 				ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
 				Spec: v1.ReplicationControllerSpec{
@@ -497,48 +517,52 @@ func TestSetImageRemote(t *testing.T) {
 		},
 	}
 	for _, input := range inputs {
-		groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
-		testapi.Default = testapi.Groups[input.testAPIGroup]
-		tf := cmdtesting.NewTestFactory()
-		codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
-		ns := legacyscheme.Codecs
-		tf.Namespace = "test"
-		tf.Client = &fake.RESTClient{
-			GroupVersion:         groupVersion,
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				resourcePath := testapi.Default.ResourcePath(input.args[0]+"s", tf.Namespace, input.args[1])
-				switch p, m := req.URL.Path, req.Method; {
-				case p == resourcePath && m == http.MethodGet:
-					return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
-				case p == resourcePath && m == http.MethodPatch:
-					stream, err := req.GetBody()
-					if err != nil {
-						return nil, err
-					}
-					bytes, err := ioutil.ReadAll(stream)
-					if err != nil {
-						return nil, err
+		t.Run(input.name, func(t *testing.T) {
+			groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
+			testapi.Default = testapi.Groups[input.testAPIGroup]
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
+			ns := legacyscheme.Codecs
+			tf.Namespace = "test"
+			tf.Client = &fake.RESTClient{
+				GroupVersion:         groupVersion,
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					resourcePath := testapi.Default.ResourcePath(input.args[0]+"s", tf.Namespace, input.args[1])
+					switch p, m := req.URL.Path, req.Method; {
+					case p == resourcePath && m == http.MethodGet:
+						return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
+					case p == resourcePath && m == http.MethodPatch:
+						stream, err := req.GetBody()
+						if err != nil {
+							return nil, err
+						}
+						bytes, err := ioutil.ReadAll(stream)
+						if err != nil {
+							return nil, err
+						}
+						assert.Contains(t, string(bytes), `"image":`+`"`+"thingy"+`"`, fmt.Sprintf("image not updated for %#v", input.object))
+						return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
+					default:
+						t.Errorf("%s: unexpected request: %s %#v\n%#v", "image", req.Method, req.URL, req)
+						return nil, fmt.Errorf("unexpected request")
 					}
-					assert.Contains(t, string(bytes), `"image":`+`"`+"thingy"+`"`, fmt.Sprintf("image not updated for %#v", input.object))
-					return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
-				default:
-					t.Errorf("%s: unexpected request: %s %#v\n%#v", "image", req.Method, req.URL, req)
-					return nil, fmt.Errorf("unexpected request")
-				}
-			}),
-			VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
-		}
-		out := new(bytes.Buffer)
-		cmd := NewCmdImage(tf, out, out)
-		cmd.SetOutput(out)
-		cmd.Flags().Set("output", "yaml")
-		opts := ImageOptions{
-			Out:   out,
-			Local: false}
-		err := opts.Complete(tf, cmd, input.args)
-		assert.NoError(t, err)
-		err = opts.Run()
-		assert.NoError(t, err)
+				}),
+				VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
+			}
+			out := new(bytes.Buffer)
+			cmd := NewCmdImage(tf, out, out)
+			cmd.SetOutput(out)
+			cmd.Flags().Set("output", "yaml")
+			opts := ImageOptions{
+				Out:   out,
+				Local: false}
+			err := opts.Complete(tf, cmd, input.args)
+			assert.NoError(t, err)
+			err = opts.Run()
+			assert.NoError(t, err)
+		})
 	}
 }

pkg/kubectl/cmd/set/set_resources_test.go

@@ -46,6 +46,7 @@ import (
 
 func TestResourcesLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -90,6 +91,7 @@ func TestResourcesLocal(t *testing.T) {
 
 func TestSetMultiResourcesLimitsLocal(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -446,6 +448,7 @@ func TestSetResourcesRemote(t *testing.T) {
 			groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
 			testapi.Default = testapi.Groups[input.testAPIGroup]
 			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
 			codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
 			ns := legacyscheme.Codecs
 			tf.Namespace = "test"

pkg/kubectl/cmd/set/set_selector_test.go

@@ -317,6 +317,8 @@ func TestGetResourcesAndSelector(t *testing.T) {
 
 func TestSelectorTest(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 	tf.Client = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Version: ""},

pkg/kubectl/cmd/set/set_serviceaccount_test.go

@@ -68,6 +68,8 @@ func TestSetServiceAccountLocal(t *testing.T) {
 	for i, input := range inputs {
 		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
 			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
 			tf.Client = &fake.RESTClient{
 				GroupVersion: schema.GroupVersion{Version: "v1"},
 				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -98,6 +100,8 @@ func TestSetServiceAccountLocal(t *testing.T) {
 func TestSetServiceAccountMultiLocal(t *testing.T) {
 	testapi.Default = testapi.Groups[""]
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	ns := legacyscheme.Codecs
 	tf.Client = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Version: ""},
@@ -310,77 +314,86 @@ func TestSetServiceAccountRemote(t *testing.T) {
 		},
 	}
 	for _, input := range inputs {
-		groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
-		testapi.Default = testapi.Groups[input.testAPIGroup]
-		tf := cmdtesting.NewTestFactory()
-		codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
-		ns := legacyscheme.Codecs
-		tf.Namespace = "test"
-		tf.Client = &fake.RESTClient{
-			GroupVersion:         groupVersion,
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				resourcePath := testapi.Default.ResourcePath(input.args[0]+"s", tf.Namespace, input.args[1])
-				switch p, m := req.URL.Path, req.Method; {
-				case p == resourcePath && m == http.MethodGet:
-					return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
-				case p == resourcePath && m == http.MethodPatch:
-					stream, err := req.GetBody()
-					if err != nil {
-						return nil, err
-					}
-					bytes, err := ioutil.ReadAll(stream)
-					if err != nil {
-						return nil, err
+		t.Run(input.apiPrefix, func(t *testing.T) {
+			groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
+			testapi.Default = testapi.Groups[input.testAPIGroup]
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
+			ns := legacyscheme.Codecs
+			tf.Namespace = "test"
+			tf.Client = &fake.RESTClient{
+				GroupVersion:         groupVersion,
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					resourcePath := testapi.Default.ResourcePath(input.args[0]+"s", tf.Namespace, input.args[1])
+					switch p, m := req.URL.Path, req.Method; {
+					case p == resourcePath && m == http.MethodGet:
+						return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
+					case p == resourcePath && m == http.MethodPatch:
+						stream, err := req.GetBody()
+						if err != nil {
+							return nil, err
+						}
+						bytes, err := ioutil.ReadAll(stream)
+						if err != nil {
+							return nil, err
+						}
+						assert.Contains(t, string(bytes), `"serviceAccountName":`+`"`+serviceAccount+`"`, fmt.Sprintf("serviceaccount not updated for %#v", input.object))
+						return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
+					default:
+						t.Errorf("%s: unexpected request: %s %#v\n%#v", "serviceaccount", req.Method, req.URL, req)
+						return nil, fmt.Errorf("unexpected request")
 					}
-					assert.Contains(t, string(bytes), `"serviceAccountName":`+`"`+serviceAccount+`"`, fmt.Sprintf("serviceaccount not updated for %#v", input.object))
-					return &http.Response{StatusCode: http.StatusOK, Header: defaultHeader(), Body: objBody(codec, input.object)}, nil
-				default:
-					t.Errorf("%s: unexpected request: %s %#v\n%#v", "serviceaccount", req.Method, req.URL, req)
-					return nil, fmt.Errorf("unexpected request")
-				}
-			}),
-			VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
-		}
-		out := new(bytes.Buffer)
-		cmd := NewCmdServiceAccount(tf, out, out)
-		cmd.SetOutput(out)
-		cmd.Flags().Set("output", "yaml")
-		saConfig := serviceAccountConfig{
-			out:   out,
-			local: false}
-		err := saConfig.Complete(tf, cmd, input.args)
-		assert.NoError(t, err)
-		err = saConfig.Run()
-		assert.NoError(t, err)
+				}),
+				VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
+			}
+			out := new(bytes.Buffer)
+			cmd := NewCmdServiceAccount(tf, out, out)
+			cmd.SetOutput(out)
+			cmd.Flags().Set("output", "yaml")
+			saConfig := serviceAccountConfig{
+				out:   out,
+				local: false}
+			err := saConfig.Complete(tf, cmd, input.args)
+			assert.NoError(t, err)
+			err = saConfig.Run()
+			assert.NoError(t, err)
+		})
 	}
 }
 
 func TestServiceAccountValidation(t *testing.T) {
 	inputs := []struct {
+		name        string
 		args        []string
 		errorString string
 	}{
-		{args: []string{}, errorString: serviceAccountMissingErrString},
-		{args: []string{serviceAccount}, errorString: resourceMissingErrString},
+		{name: "test service account missing", args: []string{}, errorString: serviceAccountMissingErrString},
+		{name: "test service account resource missing", args: []string{serviceAccount}, errorString: resourceMissingErrString},
 	}
 	for _, input := range inputs {
-		tf := cmdtesting.NewTestFactory()
-		tf.Client = &fake.RESTClient{
-			GroupVersion: schema.GroupVersion{Version: "v1"},
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				t.Fatalf("unexpected request: %s %#v\n%#v", req.Method, req.URL, req)
-				return nil, nil
-			}),
-		}
-		tf.Namespace = "test"
-		out := bytes.NewBuffer([]byte{})
-		cmd := NewCmdServiceAccount(tf, out, out)
-		cmd.SetOutput(out)
+		t.Run(input.name, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
+
+			tf.Client = &fake.RESTClient{
+				GroupVersion: schema.GroupVersion{Version: "v1"},
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					t.Fatalf("unexpected request: %s %#v\n%#v", req.Method, req.URL, req)
+					return nil, nil
+				}),
+			}
+			tf.Namespace = "test"
+			out := bytes.NewBuffer([]byte{})
+			cmd := NewCmdServiceAccount(tf, out, out)
+			cmd.SetOutput(out)
 
-		saConfig := &serviceAccountConfig{}
-		err := saConfig.Complete(tf, cmd, input.args)
-		assert.EqualError(t, err, input.errorString)
+			saConfig := &serviceAccountConfig{}
+			err := saConfig.Complete(tf, cmd, input.args)
+			assert.EqualError(t, err, input.errorString)
+		})
 	}
 }
 

pkg/kubectl/cmd/set/set_subject_test.go

@@ -29,6 +29,8 @@ import (
 
 func TestValidate(t *testing.T) {
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	tf.Namespace = "test"
 
 	tests := map[string]struct {

pkg/kubectl/cmd/taint_test.go

@@ -236,102 +236,106 @@ func TestTaint(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		oldNode, expectNewNode := generateNodeAndTaintedNode(test.oldTaints, test.newTaints)
-		new_node := &v1.Node{}
-		tainted := false
-		tf := cmdtesting.NewTestFactory()
-		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
-		ns := legacyscheme.Codecs
+		t.Run(test.description, func(t *testing.T) {
+			oldNode, expectNewNode := generateNodeAndTaintedNode(test.oldTaints, test.newTaints)
+			new_node := &v1.Node{}
+			tainted := false
+			tf := cmdtesting.NewTestFactory()
+			defer tf.Cleanup()
 
-		tf.Client = &fake.RESTClient{
-			NegotiatedSerializer: ns,
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				m := &MyReq{req}
-				switch {
-				case m.isFor("GET", "/nodes"):
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, oldNode)}, nil
-				case m.isFor("GET", "/nodes/node-name"):
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, oldNode)}, nil
-				case m.isFor("PATCH", "/nodes/node-name"):
-					tainted = true
-					data, err := ioutil.ReadAll(req.Body)
-					if err != nil {
-						t.Fatalf("%s: unexpected error: %v", test.description, err)
-					}
-					defer req.Body.Close()
+			codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
+			ns := legacyscheme.Codecs
 
-					// apply the patch
-					oldJSON, err := runtime.Encode(codec, oldNode)
-					if err != nil {
-						t.Fatalf("%s: unexpected error: %v", test.description, err)
-					}
-					appliedPatch, err := strategicpatch.StrategicMergePatch(oldJSON, data, &v1.Node{})
-					if err != nil {
-						t.Fatalf("%s: unexpected error: %v", test.description, err)
-					}
+			tf.Client = &fake.RESTClient{
+				NegotiatedSerializer: ns,
+				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					m := &MyReq{req}
+					switch {
+					case m.isFor("GET", "/nodes"):
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, oldNode)}, nil
+					case m.isFor("GET", "/nodes/node-name"):
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, oldNode)}, nil
+					case m.isFor("PATCH", "/nodes/node-name"):
+						tainted = true
+						data, err := ioutil.ReadAll(req.Body)
+						if err != nil {
+							t.Fatalf("%s: unexpected error: %v", test.description, err)
+						}
+						defer req.Body.Close()
 
-					// decode the patch
-					if err := runtime.DecodeInto(codec, appliedPatch, new_node); err != nil {
-						t.Fatalf("%s: unexpected error: %v", test.description, err)
-					}
-					if !equalTaints(expectNewNode.Spec.Taints, new_node.Spec.Taints) {
-						t.Fatalf("%s: expected:\n%v\nsaw:\n%v\n", test.description, expectNewNode.Spec.Taints, new_node.Spec.Taints)
-					}
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, new_node)}, nil
-				case m.isFor("PUT", "/nodes/node-name"):
-					tainted = true
-					data, err := ioutil.ReadAll(req.Body)
-					if err != nil {
-						t.Fatalf("%s: unexpected error: %v", test.description, err)
-					}
-					defer req.Body.Close()
-					if err := runtime.DecodeInto(codec, data, new_node); err != nil {
-						t.Fatalf("%s: unexpected error: %v", test.description, err)
-					}
-					if !equalTaints(expectNewNode.Spec.Taints, new_node.Spec.Taints) {
-						t.Fatalf("%s: expected:\n%v\nsaw:\n%v\n", test.description, expectNewNode.Spec.Taints, new_node.Spec.Taints)
+						// apply the patch
+						oldJSON, err := runtime.Encode(codec, oldNode)
+						if err != nil {
+							t.Fatalf("%s: unexpected error: %v", test.description, err)
+						}
+						appliedPatch, err := strategicpatch.StrategicMergePatch(oldJSON, data, &v1.Node{})
+						if err != nil {
+							t.Fatalf("%s: unexpected error: %v", test.description, err)
+						}
+
+						// decode the patch
+						if err := runtime.DecodeInto(codec, appliedPatch, new_node); err != nil {
+							t.Fatalf("%s: unexpected error: %v", test.description, err)
+						}
+						if !equalTaints(expectNewNode.Spec.Taints, new_node.Spec.Taints) {
+							t.Fatalf("%s: expected:\n%v\nsaw:\n%v\n", test.description, expectNewNode.Spec.Taints, new_node.Spec.Taints)
+						}
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, new_node)}, nil
+					case m.isFor("PUT", "/nodes/node-name"):
+						tainted = true
+						data, err := ioutil.ReadAll(req.Body)
+						if err != nil {
+							t.Fatalf("%s: unexpected error: %v", test.description, err)
+						}
+						defer req.Body.Close()
+						if err := runtime.DecodeInto(codec, data, new_node); err != nil {
+							t.Fatalf("%s: unexpected error: %v", test.description, err)
+						}
+						if !equalTaints(expectNewNode.Spec.Taints, new_node.Spec.Taints) {
+							t.Fatalf("%s: expected:\n%v\nsaw:\n%v\n", test.description, expectNewNode.Spec.Taints, new_node.Spec.Taints)
+						}
+						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, new_node)}, nil
+					default:
+						t.Fatalf("%s: unexpected request: %v %#v\n%#v", test.description, req.Method, req.URL, req)
+						return nil, nil
 					}
-					return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, new_node)}, nil
-				default:
-					t.Fatalf("%s: unexpected request: %v %#v\n%#v", test.description, req.Method, req.URL, req)
-					return nil, nil
-				}
-			}),
-		}
-		tf.ClientConfigVal = defaultClientConfig()
+				}),
+			}
+			tf.ClientConfigVal = defaultClientConfig()
 
-		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdTaint(tf, buf)
+			buf := bytes.NewBuffer([]byte{})
+			cmd := NewCmdTaint(tf, buf)
 
-		saw_fatal := false
-		func() {
-			defer func() {
-				// Recover from the panic below.
-				_ = recover()
-				// Restore cmdutil behavior
-				cmdutil.DefaultBehaviorOnFatal()
+			saw_fatal := false
+			func() {
+				defer func() {
+					// Recover from the panic below.
+					_ = recover()
+					// Restore cmdutil behavior
+					cmdutil.DefaultBehaviorOnFatal()
+				}()
+				cmdutil.BehaviorOnFatal(func(e string, code int) { saw_fatal = true; panic(e) })
+				cmd.SetArgs(test.args)
+				cmd.Execute()
 			}()
-			cmdutil.BehaviorOnFatal(func(e string, code int) { saw_fatal = true; panic(e) })
-			cmd.SetArgs(test.args)
-			cmd.Execute()
-		}()
 
-		if test.expectFatal {
-			if !saw_fatal {
-				t.Fatalf("%s: unexpected non-error", test.description)
+			if test.expectFatal {
+				if !saw_fatal {
+					t.Fatalf("%s: unexpected non-error", test.description)
+				}
 			}
-		}
 
-		if test.expectTaint {
-			if !tainted {
-				t.Fatalf("%s: node not tainted", test.description)
+			if test.expectTaint {
+				if !tainted {
+					t.Fatalf("%s: node not tainted", test.description)
+				}
 			}
-		}
-		if !test.expectTaint {
-			if tainted {
-				t.Fatalf("%s: unexpected taint", test.description)
+			if !test.expectTaint {
+				if tainted {
+					t.Fatalf("%s: unexpected taint", test.description)
+				}
 			}
-		}
+		})
 	}
 }
 

pkg/kubectl/cmd/testing/BUILD

@@ -37,6 +37,8 @@ go_library(
         "//vendor/k8s.io/client-go/kubernetes:go_default_library",
         "//vendor/k8s.io/client-go/rest:go_default_library",
         "//vendor/k8s.io/client-go/rest/fake:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd/api:go_default_library",
     ],
 )
 

pkg/kubectl/cmd/testing/fake.go

@@ -17,8 +17,11 @@ limitations under the License.
 package testing
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
+	"io/ioutil"
+	"os"
 	"path/filepath"
 	"time"
 
@@ -34,6 +37,8 @@ import (
 	"k8s.io/client-go/kubernetes"
 	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/rest/fake"
+	"k8s.io/client-go/tools/clientcmd"
+	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
@@ -240,14 +245,53 @@ type TestFactory struct {
 	ClientConfigVal    *restclient.Config
 	CommandVal         string
 
+	tempConfigFile *os.File
+
 	UnstructuredClientForMappingFunc func(mapping *meta.RESTMapping) (resource.RESTClient, error)
 	OpenAPISchemaFunc                func() (openapi.Resources, error)
 }
 
 func NewTestFactory() *TestFactory {
+	// specify an optionalClientConfig to explicitly use in testing
+	// to avoid polluting an existing user config.
+	config, configFile := defaultFakeClientConfig()
 	return &TestFactory{
-		Factory: cmdutil.NewFactory(nil),
+		Factory:        cmdutil.NewFactory(config),
+		tempConfigFile: configFile,
+	}
+}
+
+func (f *TestFactory) Cleanup() {
+	if f.tempConfigFile == nil {
+		return
+	}
+
+	os.Remove(f.tempConfigFile.Name())
+}
+
+func defaultFakeClientConfig() (clientcmd.ClientConfig, *os.File) {
+	loadingRules, tmpFile, err := newDefaultFakeClientConfigLoadingRules()
+	if err != nil {
+		panic(fmt.Sprintf("unable to create a fake client config: %v", err))
+	}
+
+	overrides := &clientcmd.ConfigOverrides{ClusterDefaults: clientcmdapi.Cluster{Server: "http://localhost:8080"}}
+	fallbackReader := bytes.NewBuffer([]byte{})
+
+	clientConfig := clientcmd.NewInteractiveDeferredLoadingClientConfig(loadingRules, overrides, fallbackReader)
+	return clientConfig, tmpFile
+}
+
+func newDefaultFakeClientConfigLoadingRules() (*clientcmd.ClientConfigLoadingRules, *os.File, error) {
+	tmpFile, err := ioutil.TempFile("", "cmdtests_temp")
+	if err != nil {
+		return nil, nil, err
 	}
+
+	return &clientcmd.ClientConfigLoadingRules{
+		Precedence:     []string{tmpFile.Name()},
+		MigrationRules: map[string]string{},
+	}, tmpFile, nil
 }
 
 func (f *TestFactory) CategoryExpander() categories.CategoryExpander {

pkg/kubectl/cmd/top_node_test.go

@@ -50,6 +50,8 @@ func TestTopNodeAllMetrics(t *testing.T) {
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -101,6 +103,8 @@ func TestTopNodeAllMetricsCustomDefaults(t *testing.T) {
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -162,6 +166,8 @@ func TestTopNodeWithNameMetrics(t *testing.T) {
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes/%s", apiPrefix, apiVersion, expectedMetrics.Name)
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -227,6 +233,8 @@ func TestTopNodeWithLabelSelectorMetrics(t *testing.T) {
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -280,6 +288,8 @@ func TestTopNodeAllMetricsFromMetricsServer(t *testing.T) {
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -344,6 +354,8 @@ func TestTopNodeWithNameMetricsFromMetricsServer(t *testing.T) {
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes/%s", apiPrefix, apiVersion, expectedMetrics.Name)
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -418,6 +430,8 @@ func TestTopNodeWithLabelSelectorMetricsFromMetricsServer(t *testing.T) {
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
 	tf := cmdtesting.NewTestFactory()
+	defer tf.Cleanup()
+
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 

pkg/kubectl/cmd/top_test.go

@@ -44,6 +44,8 @@ func TestTopSubcommandsExist(t *testing.T) {
 	initTestErrorHandler(t)
 
 	f := cmdtesting.NewTestFactory()
+	defer f.Cleanup()
+
 	buf := bytes.NewBuffer([]byte{})
 
 	cmd := NewCmdTop(f, buf, buf)