Merge pull request #60218 from deads2k/cli-13-testfactory

pkg/kubectl/cmd/annotate_test.go

@@ -417,12 +417,12 @@ func TestAnnotateErrors(t *testing.T) {
 	}
 
 	for k, testCase := range testCases {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 
 		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdAnnotate(f, buf)
+		cmd := NewCmdAnnotate(tf, buf)
 		cmd.SetOutput(buf)
 
 		for k, v := range testCase.flags {
@@ -446,7 +446,7 @@ func TestAnnotateErrors(t *testing.T) {
 func TestAnnotateObject(t *testing.T) {
 	pods, _, _ := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -477,10 +477,10 @@ func TestAnnotateObject(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdAnnotate(f, buf)
+	cmd := NewCmdAnnotate(tf, buf)
 	cmd.SetOutput(buf)
 	options := &AnnotateOptions{}
 	args := []string{"pods/foo", "a=b", "c-"}
@@ -490,7 +490,7 @@ func TestAnnotateObject(t *testing.T) {
 	if err := options.Validate(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if err := options.RunAnnotate(f, cmd); err != nil {
+	if err := options.RunAnnotate(tf, cmd); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }
@@ -498,7 +498,7 @@ func TestAnnotateObject(t *testing.T) {
 func TestAnnotateObjectFromFile(t *testing.T) {
 	pods, _, _ := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -529,10 +529,10 @@ func TestAnnotateObjectFromFile(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdAnnotate(f, buf)
+	cmd := NewCmdAnnotate(tf, buf)
 	cmd.SetOutput(buf)
 	options := &AnnotateOptions{}
 	options.Filenames = []string{"../../../examples/storage/cassandra/cassandra-controller.yaml"}
@@ -543,13 +543,13 @@ func TestAnnotateObjectFromFile(t *testing.T) {
 	if err := options.Validate(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if err := options.RunAnnotate(f, cmd); err != nil {
+	if err := options.RunAnnotate(tf, cmd); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }
 
 func TestAnnotateLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.UnstructuredClient = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Group: "testgroup", Version: "v1"},
 		NegotiatedSerializer: unstructuredSerializer,
@@ -559,10 +559,10 @@ func TestAnnotateLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdAnnotate(f, buf)
+	cmd := NewCmdAnnotate(tf, buf)
 	options := &AnnotateOptions{local: true}
 	options.Filenames = []string{"../../../examples/storage/cassandra/cassandra-controller.yaml"}
 	args := []string{"a=b"}
@@ -572,7 +572,7 @@ func TestAnnotateLocal(t *testing.T) {
 	if err := options.Validate(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if err := options.RunAnnotate(f, cmd); err != nil {
+	if err := options.RunAnnotate(tf, cmd); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }
@@ -580,7 +580,7 @@ func TestAnnotateLocal(t *testing.T) {
 func TestAnnotateMultipleObjects(t *testing.T) {
 	pods, _, _ := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	tf.UnstructuredClient = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Group: "testgroup", Version: "v1"},
@@ -612,10 +612,10 @@ func TestAnnotateMultipleObjects(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdAnnotate(f, buf)
+	cmd := NewCmdAnnotate(tf, buf)
 	cmd.SetOutput(buf)
 	options := &AnnotateOptions{all: true}
 	args := []string{"pods", "a=b", "c-"}
@@ -625,7 +625,7 @@ func TestAnnotateMultipleObjects(t *testing.T) {
 	if err := options.Validate(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if err := options.RunAnnotate(f, cmd); err != nil {
+	if err := options.RunAnnotate(tf, cmd); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }

pkg/kubectl/cmd/attach_test.go

@@ -139,7 +139,7 @@ func TestPodAndContainerAttach(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -154,13 +154,13 @@ func TestPodAndContainerAttach(t *testing.T) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 
 		cmd := &cobra.Command{}
 		options := test.p
 		cmdutil.AddPodRunningTimeoutFlag(cmd, test.timeout)
 
-		err := options.Complete(f, cmd, test.args)
+		err := options.Complete(tf, cmd, test.args)
 		if test.expectError && err == nil {
 			t.Errorf("%s: unexpected non-error", test.name)
 		}
@@ -219,7 +219,7 @@ func TestAttach(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -242,7 +242,7 @@ func TestAttach(t *testing.T) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: legacyscheme.Codecs, GroupVersion: &schema.GroupVersion{Version: test.version}}}
+		tf.ClientConfigVal = &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: legacyscheme.Codecs, GroupVersion: &schema.GroupVersion{Version: test.version}}}
 		bufOut := bytes.NewBuffer([]byte{})
 		bufErr := bytes.NewBuffer([]byte{})
 		bufIn := bytes.NewBuffer([]byte{})
@@ -262,7 +262,7 @@ func TestAttach(t *testing.T) {
 		}
 		cmd := &cobra.Command{}
 		cmdutil.AddPodRunningTimeoutFlag(cmd, 1000)
-		if err := params.Complete(f, cmd, []string{"foo"}); err != nil {
+		if err := params.Complete(tf, cmd, []string{"foo"}); err != nil {
 			t.Fatal(err)
 		}
 		err := params.Run()
@@ -309,7 +309,7 @@ func TestAttachWarnings(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -331,7 +331,7 @@ func TestAttachWarnings(t *testing.T) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: legacyscheme.Codecs, GroupVersion: &schema.GroupVersion{Version: test.version}}}
+		tf.ClientConfigVal = &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: legacyscheme.Codecs, GroupVersion: &schema.GroupVersion{Version: test.version}}}
 		bufOut := bytes.NewBuffer([]byte{})
 		bufErr := bytes.NewBuffer([]byte{})
 		bufIn := bytes.NewBuffer([]byte{})
@@ -350,7 +350,7 @@ func TestAttachWarnings(t *testing.T) {
 		}
 		cmd := &cobra.Command{}
 		cmdutil.AddPodRunningTimeoutFlag(cmd, 1000)
-		if err := params.Complete(f, cmd, []string{"foo"}); err != nil {
+		if err := params.Complete(tf, cmd, []string{"foo"}); err != nil {
 			t.Fatal(err)
 		}
 		if err := params.Run(); err != nil {

pkg/kubectl/cmd/auth/cani_test.go

@@ -120,7 +120,7 @@ func TestRunAccessCheck(t *testing.T) {
 		test.o.Out = ioutil.Discard
 		test.o.Err = ioutil.Discard
 
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		ns := legacyscheme.Codecs
 
 		tf.Client = &fake.RESTClient{
@@ -155,9 +155,9 @@ func TestRunAccessCheck(t *testing.T) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}}
+		tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}}
 
-		if err := test.o.Complete(f, test.args); err != nil {
+		if err := test.o.Complete(tf, test.args); err != nil {
 			t.Errorf("%s: %v", test.name, err)
 			continue
 		}

pkg/kubectl/cmd/clusterinfo_dump_test.go

@@ -30,7 +30,7 @@ func TestSetupOutputWriterNoOp(t *testing.T) {
 	tests := []string{"", "-"}
 	for _, test := range tests {
 		out := &bytes.Buffer{}
-		f, _ := cmdtesting.NewAPIFactory()
+		f := cmdtesting.NewTestFactory()
 		cmd := NewCmdClusterInfoDump(f, os.Stdout)
 		cmd.Flag("output-directory").Value.Set(test)
 		writer := setupOutputWriter(cmd, out, "/some/file/that/should/be/ignored")
@@ -50,7 +50,7 @@ func TestSetupOutputWriterFile(t *testing.T) {
 	defer os.RemoveAll(dir)
 
 	out := &bytes.Buffer{}
-	f, _ := cmdtesting.NewAPIFactory()
+	f := cmdtesting.NewTestFactory()
 	cmd := NewCmdClusterInfoDump(f, os.Stdout)
 	cmd.Flag("output-directory").Value.Set(dir)
 	writer := setupOutputWriter(cmd, out, file)

pkg/kubectl/cmd/cmd_test.go

@@ -177,14 +177,14 @@ func stringBody(body string) io.ReadCloser {
 }
 
 func Example_printMultiContainersReplicationControllerWithWide() {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
 		NegotiatedSerializer: ns,
 		Client:               nil,
 	}
-	cmd := NewCmdRun(f, os.Stdin, os.Stdout, os.Stderr)
+	cmd := NewCmdRun(tf, os.Stdin, os.Stdout, os.Stderr)
 	ctrl := &api.ReplicationController{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:              "foo",
@@ -227,14 +227,14 @@ func Example_printMultiContainersReplicationControllerWithWide() {
 }
 
 func Example_printReplicationController() {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
 		NegotiatedSerializer: ns,
 		Client:               nil,
 	}
-	cmd := NewCmdRun(f, os.Stdin, os.Stdout, os.Stderr)
+	cmd := NewCmdRun(tf, os.Stdin, os.Stdout, os.Stderr)
 	ctrl := &api.ReplicationController{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:              "foo",
@@ -276,7 +276,7 @@ func Example_printReplicationController() {
 }
 
 func Example_printPodWithWideFormat() {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -284,7 +284,7 @@ func Example_printPodWithWideFormat() {
 		Client:               nil,
 	}
 	nodeName := "kubernetes-node-abcd"
-	cmd := NewCmdRun(f, os.Stdin, os.Stdout, os.Stderr)
+	cmd := NewCmdRun(tf, os.Stdin, os.Stdout, os.Stderr)
 	pod := &api.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:              "test1",
@@ -314,7 +314,7 @@ func Example_printPodWithWideFormat() {
 }
 
 func Example_printPodWithShowLabels() {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -322,7 +322,7 @@ func Example_printPodWithShowLabels() {
 		Client:               nil,
 	}
 	nodeName := "kubernetes-node-abcd"
-	cmd := NewCmdRun(f, os.Stdin, os.Stdout, os.Stderr)
+	cmd := NewCmdRun(tf, os.Stdin, os.Stdout, os.Stderr)
 	pod := &api.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:              "test1",
@@ -447,17 +447,17 @@ func newAllPhasePodList() *api.PodList {
 }
 
 func Example_printPodHideTerminated() {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
 		NegotiatedSerializer: ns,
 		Client:               nil,
 	}
-	cmd := NewCmdRun(f, os.Stdin, os.Stdout, os.Stderr)
+	cmd := NewCmdRun(tf, os.Stdin, os.Stdout, os.Stderr)
 	podList := newAllPhasePodList()
 	// filter pods
-	filterFuncs := f.DefaultResourceFilterFunc()
+	filterFuncs := tf.DefaultResourceFilterFunc()
 	filterOpts := cmdutil.ExtractCmdPrintOptions(cmd, false)
 	_, filteredPodList, errs := cmdutil.FilterResourceList(podList, filterFuncs, filterOpts)
 	if errs != nil {
@@ -481,14 +481,14 @@ func Example_printPodHideTerminated() {
 }
 
 func Example_printPodShowAll() {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
 		NegotiatedSerializer: ns,
 		Client:               nil,
 	}
-	cmd := NewCmdRun(f, os.Stdin, os.Stdout, os.Stderr)
+	cmd := NewCmdRun(tf, os.Stdin, os.Stdout, os.Stderr)
 	podList := newAllPhasePodList()
 	err := cmdutil.PrintObject(cmd, podList, os.Stdout)
 	if err != nil {
@@ -504,14 +504,14 @@ func Example_printPodShowAll() {
 }
 
 func Example_printServiceWithLabels() {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
 		NegotiatedSerializer: ns,
 		Client:               nil,
 	}
-	cmd := resource.NewCmdGet(f, os.Stdout, os.Stderr)
+	cmd := resource.NewCmdGet(tf, os.Stdout, os.Stderr)
 	svc := &api.ServiceList{
 		Items: []api.Service{
 			{

pkg/kubectl/cmd/convert_test.go

@@ -101,7 +101,7 @@ func TestConvertObject(t *testing.T) {
 	for _, tc := range testcases {
 		for _, field := range tc.fields {
 			t.Run(fmt.Sprintf("%s %s", tc.name, field), func(t *testing.T) {
-				f, tf := cmdtesting.NewAPIFactory()
+				tf := cmdtesting.NewTestFactory()
 				tf.UnstructuredClient = &fake.RESTClient{
 					Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
 						t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
@@ -111,7 +111,7 @@ func TestConvertObject(t *testing.T) {
 				tf.Namespace = "test"
 
 				buf := bytes.NewBuffer([]byte{})
-				cmd := NewCmdConvert(f, buf)
+				cmd := NewCmdConvert(tf, buf)
 				cmd.Flags().Set("filename", tc.file)
 				cmd.Flags().Set("output-version", tc.outputVersion)
 				cmd.Flags().Set("local", "true")

pkg/kubectl/cmd/create_clusterrole_test.go

@@ -32,10 +32,10 @@ import (
 func TestCreateClusterRole(t *testing.T) {
 	clusterRoleName := "my-cluster-role"
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.Namespace = "test"
 	tf.Client = &fake.RESTClient{}
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	tests := map[string]struct {
 		verbs               string
@@ -125,7 +125,7 @@ func TestCreateClusterRole(t *testing.T) {
 
 	for name, test := range tests {
 		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdCreateClusterRole(f, buf)
+		cmd := NewCmdCreateClusterRole(tf, buf)
 		cmd.Flags().Set("dry-run", "true")
 		cmd.Flags().Set("output", "yaml")
 		cmd.Flags().Set("verb", test.verbs)
@@ -147,7 +147,7 @@ func TestCreateClusterRole(t *testing.T) {
 }
 
 func TestClusterRoleValidate(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.Namespace = "test"
 
 	tests := map[string]struct {
@@ -426,7 +426,7 @@ func TestClusterRoleValidate(t *testing.T) {
 
 	for name, test := range tests {
 		t.Run(name, func(t *testing.T) {
-			test.clusterRoleOptions.Mapper, _ = f.Object()
+			test.clusterRoleOptions.Mapper, _ = tf.Object()
 			err := test.clusterRoleOptions.Validate()
 			if test.expectErr && err == nil {
 				t.Errorf("%s: expect error happens, but validate passes.", name)

pkg/kubectl/cmd/create_clusterrolebinding_test.go

@@ -67,7 +67,7 @@ func TestCreateClusterRoleBinding(t *testing.T) {
 		},
 	}
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	info, _ := runtime.SerializerInfoForMediaType(ns.SupportedMediaTypes(), runtime.ContentTypeJSON)
@@ -110,7 +110,7 @@ func TestCreateClusterRoleBinding(t *testing.T) {
 
 	expectedOutput := "clusterrolebinding.rbac.authorization.k8s.io/" + expectBinding.Name + "\n"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateClusterRoleBinding(f, buf)
+	cmd := NewCmdCreateClusterRoleBinding(tf, buf)
 	cmd.Flags().Set("clusterrole", "fake-clusterrole")
 	cmd.Flags().Set("user", "fake-user")
 	cmd.Flags().Set("group", "fake-group")

pkg/kubectl/cmd/create_configmap_test.go

@@ -32,7 +32,7 @@ import (
 func TestCreateConfigMap(t *testing.T) {
 	configMap := &v1.ConfigMap{}
 	configMap.Name = "my-configmap"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -51,7 +51,7 @@ func TestCreateConfigMap(t *testing.T) {
 	}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateConfigMap(f, buf)
+	cmd := NewCmdCreateConfigMap(tf, buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Run(cmd, []string{configMap.Name})
 	expectedOutput := "configmap/" + configMap.Name + "\n"

pkg/kubectl/cmd/create_deployment_test.go

@@ -74,7 +74,7 @@ func Test_generatorFromName(t *testing.T) {
 
 func TestCreateDeployment(t *testing.T) {
 	depName := "jonny-dep"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -86,11 +86,11 @@ func TestCreateDeployment(t *testing.T) {
 			}, nil
 		}),
 	}
-	tf.ClientConfig = &restclient.Config{}
+	tf.ClientConfigVal = &restclient.Config{}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdCreateDeployment(f, buf, buf)
+	cmd := NewCmdCreateDeployment(tf, buf, buf)
 	cmd.Flags().Set("dry-run", "true")
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("image", "hollywood/jonny.depp:v2")
@@ -103,7 +103,7 @@ func TestCreateDeployment(t *testing.T) {
 
 func TestCreateDeploymentNoImage(t *testing.T) {
 	depName := "jonny-dep"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -115,13 +115,13 @@ func TestCreateDeploymentNoImage(t *testing.T) {
 			}, nil
 		}),
 	}
-	tf.ClientConfig = &restclient.Config{}
+	tf.ClientConfigVal = &restclient.Config{}
 	tf.Namespace = "test"
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateDeployment(f, buf, buf)
+	cmd := NewCmdCreateDeployment(tf, buf, buf)
 	cmd.Flags().Set("dry-run", "true")
 	cmd.Flags().Set("output", "name")
-	err := createDeployment(f, buf, buf, cmd, []string{depName})
+	err := createDeployment(tf, buf, buf, cmd, []string{depName})
 	assert.Error(t, err, "at least one image must be specified")
 }

pkg/kubectl/cmd/create_job_test.go

@@ -81,7 +81,7 @@ func TestCreateJobFromCronJob(t *testing.T) {
 		submittedJob = ca.GetObject().(*batchv1.Job)
 		return true, expectJob, nil
 	})
-	f, _ := cmdtesting.NewAPIFactory()
+	f := cmdtesting.NewTestFactory()
 	buf := bytes.NewBuffer([]byte{})
 	cmdOptions := &CreateJobOptions{
 		Name:      testJobName,

pkg/kubectl/cmd/create_namespace_test.go

@@ -32,7 +32,7 @@ import (
 func TestCreateNamespace(t *testing.T) {
 	namespaceObject := &v1.Namespace{}
 	namespaceObject.Name = "my-namespace"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -50,7 +50,7 @@ func TestCreateNamespace(t *testing.T) {
 		}),
 	}
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateNamespace(f, buf)
+	cmd := NewCmdCreateNamespace(tf, buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Run(cmd, []string{namespaceObject.Name})
 	expectedOutput := "namespace/" + namespaceObject.Name + "\n"

pkg/kubectl/cmd/create_pdb_test.go

@@ -31,7 +31,7 @@ import (
 
 func TestCreatePdb(t *testing.T) {
 	pdbName := "my-pdb"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -44,16 +44,16 @@ func TestCreatePdb(t *testing.T) {
 			}, nil
 		}),
 	}
-	tf.ClientConfig = &restclient.Config{}
+	tf.ClientConfigVal = &restclient.Config{}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdCreatePodDisruptionBudget(f, buf)
+	cmd := NewCmdCreatePodDisruptionBudget(tf, buf)
 	cmd.Flags().Set("min-available", "1")
 	cmd.Flags().Set("selector", "app=rails")
 	cmd.Flags().Set("dry-run", "true")
 	cmd.Flags().Set("output", "name")
-	CreatePodDisruptionBudget(f, buf, cmd, []string{pdbName})
+	CreatePodDisruptionBudget(tf, buf, cmd, []string{pdbName})
 	expectedOutput := "poddisruptionbudget.policy/" + pdbName + "\n"
 	if buf.String() != expectedOutput {
 		t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String())

pkg/kubectl/cmd/create_priorityclass_test.go

@@ -31,7 +31,7 @@ import (
 
 func TestCreatePriorityClass(t *testing.T) {
 	pcName := "my-pc"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -44,16 +44,16 @@ func TestCreatePriorityClass(t *testing.T) {
 			}, nil
 		}),
 	}
-	tf.ClientConfig = &restclient.Config{}
+	tf.ClientConfigVal = &restclient.Config{}
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdCreatePriorityClass(f, buf)
+	cmd := NewCmdCreatePriorityClass(tf, buf)
 	cmd.Flags().Set("value", "1000")
 	cmd.Flags().Set("global-default", "true")
 	cmd.Flags().Set("description", "my priority")
 	cmd.Flags().Set("dry-run", "true")
 	cmd.Flags().Set("output", "name")
-	CreatePriorityClass(f, buf, cmd, []string{pcName})
+	CreatePriorityClass(tf, buf, cmd, []string{pcName})
 	expectedOutput := "priorityclass.scheduling.k8s.io/" + pcName + "\n"
 	if buf.String() != expectedOutput {
 		t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String())

pkg/kubectl/cmd/create_quota_test.go

@@ -32,7 +32,7 @@ import (
 func TestCreateQuota(t *testing.T) {
 	resourceQuotaObject := &v1.ResourceQuota{}
 	resourceQuotaObject.Name = "my-quota"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -74,7 +74,7 @@ func TestCreateQuota(t *testing.T) {
 	}
 	for name, test := range tests {
 		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdCreateQuota(f, buf)
+		cmd := NewCmdCreateQuota(tf, buf)
 		cmd.Flags().Parse(test.flags)
 		cmd.Flags().Set("output", "name")
 		cmd.Run(cmd, []string{resourceQuotaObject.Name})

pkg/kubectl/cmd/create_role_test.go

@@ -34,10 +34,10 @@ import (
 func TestCreateRole(t *testing.T) {
 	roleName := "my-role"
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.Namespace = "test"
 	tf.Client = &fake.RESTClient{}
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	tests := map[string]struct {
 		verbs         string
@@ -124,7 +124,7 @@ func TestCreateRole(t *testing.T) {
 	for name, test := range tests {
 		t.Run(name, func(t *testing.T) {
 			buf := bytes.NewBuffer([]byte{})
-			cmd := NewCmdCreateRole(f, buf)
+			cmd := NewCmdCreateRole(tf, buf)
 			cmd.Flags().Set("dry-run", "true")
 			cmd.Flags().Set("output", "yaml")
 			cmd.Flags().Set("verb", test.verbs)
@@ -146,7 +146,7 @@ func TestCreateRole(t *testing.T) {
 }
 
 func TestValidate(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.Namespace = "test"
 
 	tests := map[string]struct {
@@ -331,7 +331,7 @@ func TestValidate(t *testing.T) {
 	}
 
 	for name, test := range tests {
-		test.roleOptions.Mapper, _ = f.Object()
+		test.roleOptions.Mapper, _ = tf.Object()
 		err := test.roleOptions.Validate()
 		if test.expectErr && err == nil {
 			t.Errorf("%s: expect error happens but validate passes.", name)
@@ -345,13 +345,13 @@ func TestValidate(t *testing.T) {
 func TestComplete(t *testing.T) {
 	roleName := "my-role"
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.Namespace = "test"
 	tf.Client = &fake.RESTClient{}
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateRole(f, buf)
+	cmd := NewCmdCreateRole(tf, buf)
 	cmd.Flags().Set("resource", "pods,deployments.extensions")
 
 	tests := map[string]struct {
@@ -476,7 +476,7 @@ func TestComplete(t *testing.T) {
 	}
 
 	for name, test := range tests {
-		err := test.roleOptions.Complete(f, cmd, test.params)
+		err := test.roleOptions.Complete(tf, cmd, test.params)
 		if !test.expectErr && err != nil {
 			t.Errorf("%s: unexpected error: %v", name, err)
 		}

pkg/kubectl/cmd/create_rolebinding_test.go

@@ -69,7 +69,7 @@ func TestCreateRoleBinding(t *testing.T) {
 		},
 	}
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	info, _ := runtime.SerializerInfoForMediaType(ns.SupportedMediaTypes(), runtime.ContentTypeJSON)
@@ -111,7 +111,7 @@ func TestCreateRoleBinding(t *testing.T) {
 	}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateRoleBinding(f, buf)
+	cmd := NewCmdCreateRoleBinding(tf, buf)
 	cmd.Flags().Set("role", "fake-role")
 	cmd.Flags().Set("user", "fake-user")
 	cmd.Flags().Set("group", "fake-group")

pkg/kubectl/cmd/create_secret_test.go

@@ -37,7 +37,7 @@ func TestCreateSecretGeneric(t *testing.T) {
 		},
 	}
 	secretObject.Name = "my-secret"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -56,7 +56,7 @@ func TestCreateSecretGeneric(t *testing.T) {
 	}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateSecretGeneric(f, buf)
+	cmd := NewCmdCreateSecretGeneric(tf, buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("from-literal", "password=includes,comma")
 	cmd.Flags().Set("from-literal", "username=test_user")
@@ -70,7 +70,7 @@ func TestCreateSecretGeneric(t *testing.T) {
 func TestCreateSecretDockerRegistry(t *testing.T) {
 	secretObject := &v1.Secret{}
 	secretObject.Name = "my-secret"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -89,7 +89,7 @@ func TestCreateSecretDockerRegistry(t *testing.T) {
 	}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateSecretDockerRegistry(f, buf)
+	cmd := NewCmdCreateSecretDockerRegistry(tf, buf)
 	cmd.Flags().Set("docker-username", "test-user")
 	cmd.Flags().Set("docker-password", "test-pass")
 	cmd.Flags().Set("docker-email", "test-email")

pkg/kubectl/cmd/create_service_test.go

@@ -32,7 +32,7 @@ import (
 func TestCreateService(t *testing.T) {
 	service := &v1.Service{}
 	service.Name = "my-service"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	negSer := legacyscheme.Codecs
 
@@ -51,7 +51,7 @@ func TestCreateService(t *testing.T) {
 	}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateServiceClusterIP(f, buf)
+	cmd := NewCmdCreateServiceClusterIP(tf, buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("tcp", "8080:8000")
 	cmd.Run(cmd, []string{service.Name})
@@ -64,7 +64,7 @@ func TestCreateService(t *testing.T) {
 func TestCreateServiceNodePort(t *testing.T) {
 	service := &v1.Service{}
 	service.Name = "my-node-port-service"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	negSer := legacyscheme.Codecs
 
@@ -83,7 +83,7 @@ func TestCreateServiceNodePort(t *testing.T) {
 	}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateServiceNodePort(f, buf)
+	cmd := NewCmdCreateServiceNodePort(tf, buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("tcp", "30000:8000")
 	cmd.Run(cmd, []string{service.Name})
@@ -96,7 +96,7 @@ func TestCreateServiceNodePort(t *testing.T) {
 func TestCreateServiceExternalName(t *testing.T) {
 	service := &v1.Service{}
 	service.Name = "my-external-name-service"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	negSer := legacyscheme.Codecs
 
@@ -115,7 +115,7 @@ func TestCreateServiceExternalName(t *testing.T) {
 	}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateServiceExternalName(f, buf)
+	cmd := NewCmdCreateServiceExternalName(tf, buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("external-name", "name")
 	cmd.Run(cmd, []string{service.Name})

pkg/kubectl/cmd/create_serviceaccount_test.go

@@ -32,7 +32,7 @@ import (
 func TestCreateServiceAccount(t *testing.T) {
 	serviceAccountObject := &v1.ServiceAccount{}
 	serviceAccountObject.Name = "my-service-account"
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -51,7 +51,7 @@ func TestCreateServiceAccount(t *testing.T) {
 	}
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdCreateServiceAccount(f, buf)
+	cmd := NewCmdCreateServiceAccount(tf, buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Run(cmd, []string{serviceAccountObject.Name})
 	expectedOutput := "serviceaccount/" + serviceAccountObject.Name + "\n"

pkg/kubectl/cmd/create_test.go

@@ -33,7 +33,7 @@ func TestExtraArgsFail(t *testing.T) {
 	buf := bytes.NewBuffer([]byte{})
 	errBuf := bytes.NewBuffer([]byte{})
 
-	f, _ := cmdtesting.NewAPIFactory()
+	f := cmdtesting.NewTestFactory()
 	c := NewCmdCreate(f, buf, errBuf)
 	options := CreateOptions{}
 	if options.ValidateArgs(c, []string{"rc"}) == nil {
@@ -46,7 +46,7 @@ func TestCreateObject(t *testing.T) {
 	_, _, rc := testData()
 	rc.Items[0].Name = "redis-master-controller"
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -66,7 +66,7 @@ func TestCreateObject(t *testing.T) {
 	buf := bytes.NewBuffer([]byte{})
 	errBuf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdCreate(f, buf, errBuf)
+	cmd := NewCmdCreate(tf, buf, errBuf)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
 	cmd.Flags().Set("output", "name")
 	cmd.Run(cmd, []string{})
@@ -81,7 +81,7 @@ func TestCreateMultipleObject(t *testing.T) {
 	initTestErrorHandler(t)
 	_, svc, rc := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -103,7 +103,7 @@ func TestCreateMultipleObject(t *testing.T) {
 	buf := bytes.NewBuffer([]byte{})
 	errBuf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdCreate(f, buf, errBuf)
+	cmd := NewCmdCreate(tf, buf, errBuf)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
 	cmd.Flags().Set("filename", "../../../examples/guestbook/frontend-service.yaml")
 	cmd.Flags().Set("output", "name")
@@ -120,7 +120,7 @@ func TestCreateDirectory(t *testing.T) {
 	_, _, rc := testData()
 	rc.Items[0].Name = "name"
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -140,7 +140,7 @@ func TestCreateDirectory(t *testing.T) {
 	buf := bytes.NewBuffer([]byte{})
 	errBuf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdCreate(f, buf, errBuf)
+	cmd := NewCmdCreate(tf, buf, errBuf)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy")
 	cmd.Flags().Set("output", "name")
 	cmd.Run(cmd, []string{})

pkg/kubectl/cmd/describe_test.go

@@ -32,9 +32,9 @@ import (
 // Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get.
 func TestDescribeUnknownSchemaObject(t *testing.T) {
 	d := &testDescriber{Output: "test output"}
-	f, tf := cmdtesting.NewTestFactory()
+	tf := cmdtesting.NewTestFactory()
 	_, _, codec := cmdtesting.NewExternalScheme()
-	tf.Describer = d
+	tf.DescriberVal = d
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", "foo"))},
@@ -42,7 +42,7 @@ func TestDescribeUnknownSchemaObject(t *testing.T) {
 	tf.Namespace = "non-default"
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})
-	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd := NewCmdDescribe(tf, buf, buferr)
 	cmd.Run(cmd, []string{"type", "foo"})
 
 	if d.Name != "foo" || d.Namespace != "" {
@@ -57,10 +57,10 @@ func TestDescribeUnknownSchemaObject(t *testing.T) {
 // Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get.
 func TestDescribeUnknownNamespacedSchemaObject(t *testing.T) {
 	d := &testDescriber{Output: "test output"}
-	f, tf := cmdtesting.NewTestFactory()
+	tf := cmdtesting.NewTestFactory()
 	_, _, codec := cmdtesting.NewExternalScheme()
 
-	tf.Describer = d
+	tf.DescriberVal = d
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalNamespacedType("", "", "foo", "non-default"))},
@@ -68,7 +68,7 @@ func TestDescribeUnknownNamespacedSchemaObject(t *testing.T) {
 	tf.Namespace = "non-default"
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})
-	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd := NewCmdDescribe(tf, buf, buferr)
 	cmd.Run(cmd, []string{"namespacedtype", "foo"})
 
 	if d.Name != "foo" || d.Namespace != "non-default" {
@@ -82,11 +82,11 @@ func TestDescribeUnknownNamespacedSchemaObject(t *testing.T) {
 
 func TestDescribeObject(t *testing.T) {
 	_, _, rc := testData()
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
-	tf.Describer = d
+	tf.DescriberVal = d
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -102,7 +102,7 @@ func TestDescribeObject(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})
-	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd := NewCmdDescribe(tf, buf, buferr)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
 	cmd.Run(cmd, []string{})
 
@@ -117,11 +117,11 @@ func TestDescribeObject(t *testing.T) {
 
 func TestDescribeListObjects(t *testing.T) {
 	pods, _, _ := testData()
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
-	tf.Describer = d
+	tf.DescriberVal = d
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)},
@@ -130,7 +130,7 @@ func TestDescribeListObjects(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})
-	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd := NewCmdDescribe(tf, buf, buferr)
 	cmd.Run(cmd, []string{"pods"})
 	if buf.String() != fmt.Sprintf("%s\n\n%s", d.Output, d.Output) {
 		t.Errorf("unexpected output: %s", buf.String())
@@ -139,11 +139,11 @@ func TestDescribeListObjects(t *testing.T) {
 
 func TestDescribeObjectShowEvents(t *testing.T) {
 	pods, _, _ := testData()
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
-	tf.Describer = d
+	tf.DescriberVal = d
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)},
@@ -152,7 +152,7 @@ func TestDescribeObjectShowEvents(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})
-	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd := NewCmdDescribe(tf, buf, buferr)
 	cmd.Flags().Set("show-events", "true")
 	cmd.Run(cmd, []string{"pods"})
 	if d.Settings.ShowEvents != true {
@@ -162,11 +162,11 @@ func TestDescribeObjectShowEvents(t *testing.T) {
 
 func TestDescribeObjectSkipEvents(t *testing.T) {
 	pods, _, _ := testData()
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	d := &testDescriber{Output: "test output"}
-	tf.Describer = d
+	tf.DescriberVal = d
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)},
@@ -175,7 +175,7 @@ func TestDescribeObjectSkipEvents(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})
-	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd := NewCmdDescribe(tf, buf, buferr)
 	cmd.Flags().Set("show-events", "false")
 	cmd.Run(cmd, []string{"pods"})
 	if d.Settings.ShowEvents != false {
@@ -184,11 +184,11 @@ func TestDescribeObjectSkipEvents(t *testing.T) {
 }
 
 func TestDescribeHelpMessage(t *testing.T) {
-	f, _ := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 
 	buf := bytes.NewBuffer([]byte{})
 	buferr := bytes.NewBuffer([]byte{})
-	cmd := NewCmdDescribe(f, buf, buferr)
+	cmd := NewCmdDescribe(tf, buf, buferr)
 	cmd.SetArgs([]string{"-h"})
 	cmd.SetOutput(buf)
 	_, err := cmd.ExecuteC()

pkg/kubectl/cmd/drain_test.go

@@ -150,7 +150,7 @@ func TestCordon(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -194,10 +194,10 @@ func TestCordon(t *testing.T) {
 				}
 			}),
 		}
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 
 		buf := bytes.NewBuffer([]byte{})
-		cmd := test.cmd(f, buf)
+		cmd := test.cmd(tf, buf)
 
 		saw_fatal := false
 		func() {
@@ -600,7 +600,7 @@ func TestDrain(t *testing.T) {
 			new_node := &corev1.Node{}
 			deleted := false
 			evicted := false
-			f, tf := cmdtesting.NewAPIFactory()
+			tf := cmdtesting.NewTestFactory()
 			codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 			ns := legacyscheme.Codecs
 
@@ -700,11 +700,11 @@ func TestDrain(t *testing.T) {
 					}
 				}),
 			}
-			tf.ClientConfig = defaultClientConfig()
+			tf.ClientConfigVal = defaultClientConfig()
 
 			buf := bytes.NewBuffer([]byte{})
 			errBuf := bytes.NewBuffer([]byte{})
-			cmd := NewCmdDrain(f, buf, errBuf)
+			cmd := NewCmdDrain(tf, buf, errBuf)
 
 			saw_fatal := false
 			fatal_msg := ""
@@ -824,9 +824,9 @@ func TestDeletePods(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		f, _ := cmdtesting.NewAPIFactory()
-		o := DrainOptions{Factory: f}
-		o.mapper, _ = f.Object()
+		tf := cmdtesting.NewTestFactory()
+		o := DrainOptions{Factory: tf}
+		o.mapper, _ = tf.Object()
 		o.Out = os.Stdout
 		_, pods := createPods(false)
 		pendingPods, err := o.waitForDelete(pods, test.interval, test.timeout, false, test.getPodFn)

pkg/kubectl/cmd/edit_test.go

@@ -206,7 +206,7 @@ func TestEdit(t *testing.T) {
 				t.Fatalf("%s: %v", name, err)
 			}
 
-			f, tf := cmdtesting.NewAPIFactory()
+			tf := cmdtesting.NewTestFactory()
 			tf.UnstructuredClientForMappingFunc = func(mapping *meta.RESTMapping) (resource.RESTClient, error) {
 				versionedAPIPath := ""
 				if mapping.GroupVersionKind.Group == "" {
@@ -224,20 +224,20 @@ func TestEdit(t *testing.T) {
 			if len(testcase.Namespace) > 0 {
 				tf.Namespace = testcase.Namespace
 			}
-			tf.ClientConfig = defaultClientConfig()
-			tf.Command = "edit test cmd invocation"
+			tf.ClientConfigVal = defaultClientConfig()
+			tf.CommandVal = "edit test cmd invocation"
 			buf := bytes.NewBuffer([]byte{})
 			errBuf := bytes.NewBuffer([]byte{})
 
 			var cmd *cobra.Command
 			switch testcase.Mode {
 			case "edit":
-				cmd = NewCmdEdit(f, buf, errBuf)
+				cmd = NewCmdEdit(tf, buf, errBuf)
 			case "create":
-				cmd = NewCmdCreate(f, buf, errBuf)
+				cmd = NewCmdCreate(tf, buf, errBuf)
 				cmd.Flags().Set("edit", "true")
 			case "edit-last-applied":
-				cmd = NewCmdApplyEditLastApplied(f, buf, errBuf)
+				cmd = NewCmdApplyEditLastApplied(tf, buf, errBuf)
 			default:
 				t.Fatalf("%s: unexpected mode %s", name, testcase.Mode)
 			}

pkg/kubectl/cmd/exec_test.go

@@ -130,7 +130,7 @@ func TestPodAndContainer(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		ns := legacyscheme.Codecs
 
 		tf.Client = &fake.RESTClient{
@@ -138,12 +138,12 @@ func TestPodAndContainer(t *testing.T) {
 			Client:               fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return nil, nil }),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 
 		cmd := &cobra.Command{}
 		options := test.p
 		options.Err = bytes.NewBuffer([]byte{})
-		err := options.Complete(f, cmd, test.args, test.argsLenAtDash)
+		err := options.Complete(tf, cmd, test.args, test.argsLenAtDash)
 		if test.expectError && err == nil {
 			t.Errorf("%s: unexpected non-error", test.name)
 		}
@@ -187,7 +187,7 @@ func TestExec(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -206,7 +206,7 @@ func TestExec(t *testing.T) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 		bufOut := bytes.NewBuffer([]byte{})
 		bufErr := bytes.NewBuffer([]byte{})
 		bufIn := bytes.NewBuffer([]byte{})
@@ -226,7 +226,7 @@ func TestExec(t *testing.T) {
 		}
 		cmd := &cobra.Command{}
 		args := []string{"test", "command"}
-		if err := params.Complete(f, cmd, args, -1); err != nil {
+		if err := params.Complete(tf, cmd, args, -1); err != nil {
 			t.Fatal(err)
 		}
 		err := params.Run()

pkg/kubectl/cmd/expose_test.go

@@ -466,7 +466,7 @@ func TestRunExposeService(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -488,7 +488,7 @@ func TestRunExposeService(t *testing.T) {
 		tf.Namespace = test.ns
 		buf := bytes.NewBuffer([]byte{})
 
-		cmd := NewCmdExposeService(f, buf)
+		cmd := NewCmdExposeService(tf, buf)
 		cmd.SetOutput(buf)
 		for flag, value := range test.flags {
 			cmd.Flags().Set(flag, value)

pkg/kubectl/cmd/label_test.go

@@ -321,12 +321,12 @@ func TestLabelErrors(t *testing.T) {
 	}
 
 	for k, testCase := range testCases {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 
 		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdLabel(f, buf)
+		cmd := NewCmdLabel(tf, buf)
 		cmd.SetOutput(buf)
 
 		for k, v := range testCase.flags {
@@ -338,7 +338,7 @@ func TestLabelErrors(t *testing.T) {
 			err = opts.Validate()
 		}
 		if err == nil {
-			err = opts.RunLabel(f, cmd)
+			err = opts.RunLabel(tf, cmd)
 		}
 		if !testCase.errFn(err) {
 			t.Errorf("%s: unexpected error: %v", k, err)
@@ -352,7 +352,7 @@ func TestLabelErrors(t *testing.T) {
 
 func TestLabelForResourceFromFile(t *testing.T) {
 	pods, _, _ := testData()
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -382,10 +382,10 @@ func TestLabelForResourceFromFile(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdLabel(f, buf)
+	cmd := NewCmdLabel(tf, buf)
 	opts := LabelOptions{FilenameOptions: resource.FilenameOptions{
 		Filenames: []string{"../../../examples/storage/cassandra/cassandra-controller.yaml"}}}
 	err := opts.Complete(buf, cmd, []string{"a=b"})
@@ -393,7 +393,7 @@ func TestLabelForResourceFromFile(t *testing.T) {
 		err = opts.Validate()
 	}
 	if err == nil {
-		err = opts.RunLabel(f, cmd)
+		err = opts.RunLabel(tf, cmd)
 	}
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -404,7 +404,7 @@ func TestLabelForResourceFromFile(t *testing.T) {
 }
 
 func TestLabelLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.UnstructuredClient = &fake.RESTClient{
 		NegotiatedSerializer: unstructuredSerializer,
 		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -413,10 +413,10 @@ func TestLabelLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdLabel(f, buf)
+	cmd := NewCmdLabel(tf, buf)
 	opts := LabelOptions{FilenameOptions: resource.FilenameOptions{
 		Filenames: []string{"../../../examples/storage/cassandra/cassandra-controller.yaml"}},
 		local: true}
@@ -425,7 +425,7 @@ func TestLabelLocal(t *testing.T) {
 		err = opts.Validate()
 	}
 	if err == nil {
-		err = opts.RunLabel(f, cmd)
+		err = opts.RunLabel(tf, cmd)
 	}
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -437,7 +437,7 @@ func TestLabelLocal(t *testing.T) {
 
 func TestLabelMultipleObjects(t *testing.T) {
 	pods, _, _ := testData()
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -469,17 +469,17 @@ func TestLabelMultipleObjects(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdLabel(f, buf)
+	cmd := NewCmdLabel(tf, buf)
 	opts := LabelOptions{all: true}
 	err := opts.Complete(buf, cmd, []string{"pods", "a=b"})
 	if err == nil {
 		err = opts.Validate()
 	}
 	if err == nil {
-		err = opts.RunLabel(f, cmd)
+		err = opts.RunLabel(tf, cmd)
 	}
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)

pkg/kubectl/cmd/logs_test.go

@@ -49,7 +49,7 @@ func TestLog(t *testing.T) {
 	}
 	for _, test := range tests {
 		logContent := "test log content"
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -71,10 +71,10 @@ func TestLog(t *testing.T) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 		buf := bytes.NewBuffer([]byte{})
 
-		cmd := NewCmdLogs(f, buf, buf)
+		cmd := NewCmdLogs(tf, buf, buf)
 		cmd.Flags().Set("namespace", "test")
 		cmd.Run(cmd, []string{"foo"})
 
@@ -100,7 +100,7 @@ func testPod() *api.Pod {
 }
 
 func TestValidateLogFlags(t *testing.T) {
-	f, _ := cmdtesting.NewAPIFactory()
+	f := cmdtesting.NewTestFactory()
 
 	tests := []struct {
 		name     string
@@ -151,7 +151,7 @@ func TestValidateLogFlags(t *testing.T) {
 }
 
 func TestLogComplete(t *testing.T) {
-	f, _ := cmdtesting.NewAPIFactory()
+	f := cmdtesting.NewTestFactory()
 
 	tests := []struct {
 		name     string

pkg/kubectl/cmd/patch_test.go

@@ -31,7 +31,7 @@ import (
 func TestPatchObject(t *testing.T) {
 	_, svc, _ := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -56,7 +56,7 @@ func TestPatchObject(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdPatch(f, buf)
+	cmd := NewCmdPatch(tf, buf)
 	cmd.Flags().Set("namespace", "test")
 	cmd.Flags().Set("patch", `{"spec":{"type":"NodePort"}}`)
 	cmd.Flags().Set("output", "name")
@@ -71,7 +71,7 @@ func TestPatchObject(t *testing.T) {
 func TestPatchObjectFromFile(t *testing.T) {
 	_, svc, _ := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -89,7 +89,7 @@ func TestPatchObjectFromFile(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdPatch(f, buf)
+	cmd := NewCmdPatch(tf, buf)
 	cmd.Flags().Set("namespace", "test")
 	cmd.Flags().Set("patch", `{"spec":{"type":"NodePort"}}`)
 	cmd.Flags().Set("output", "name")
@@ -107,7 +107,7 @@ func TestPatchNoop(t *testing.T) {
 	getObject := &svc.Items[0]
 	patchObject := &svc.Items[0]
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -134,7 +134,7 @@ func TestPatchNoop(t *testing.T) {
 		}
 		patchObject.Annotations["foo"] = "bar"
 		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdPatch(f, buf)
+		cmd := NewCmdPatch(tf, buf)
 		cmd.Flags().Set("namespace", "test")
 		cmd.Flags().Set("patch", `{"metadata":{"annotations":{"foo":"bar"}}}`)
 		cmd.Run(cmd, []string{"services", "frontend"})
@@ -153,7 +153,7 @@ func TestPatchObjectFromFileOutput(t *testing.T) {
 	}
 	svcCopy.Labels["post-patch"] = "post-patch-value"
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -173,7 +173,7 @@ func TestPatchObjectFromFileOutput(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdPatch(f, buf)
+	cmd := NewCmdPatch(tf, buf)
 	cmd.Flags().Set("namespace", "test")
 	cmd.Flags().Set("patch", `{"spec":{"type":"NodePort"}}`)
 	cmd.Flags().Set("output", "yaml")

pkg/kubectl/cmd/plugin_test.go

@@ -92,7 +92,7 @@ func TestPluginCmd(t *testing.T) {
 			success: test.expectedSuccess,
 		}
 
-		f, _ := cmdtesting.NewAPIFactory()
+		f := cmdtesting.NewTestFactory()
 		cmd := NewCmdForPlugin(f, test.plugin, runner, inBuf, outBuf, errBuf)
 		if cmd == nil {
 			if !test.expectedNilCmd {

pkg/kubectl/cmd/portforward_test.go

@@ -72,7 +72,7 @@ func testPortForward(t *testing.T, flags map[string]string, args []string) {
 	}
 	for _, test := range tests {
 		var err error
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -93,16 +93,16 @@ func testPortForward(t *testing.T, flags map[string]string, args []string) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 		ff := &fakePortForwarder{}
 		if test.pfErr {
 			ff.pfErr = fmt.Errorf("pf error")
 		}
 
 		opts := &PortForwardOptions{}
-		cmd := NewCmdPortForward(f, os.Stdout, os.Stderr)
+		cmd := NewCmdPortForward(tf, os.Stdout, os.Stderr)
 		cmd.Run = func(cmd *cobra.Command, args []string) {
-			if err = opts.Complete(f, cmd, args); err != nil {
+			if err = opts.Complete(tf, cmd, args); err != nil {
 				return
 			}
 			opts.PortForwarder = ff

pkg/kubectl/cmd/replace_test.go

@@ -32,7 +32,7 @@ import (
 func TestReplaceObject(t *testing.T) {
 	_, _, rc := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	deleted := false
@@ -64,7 +64,7 @@ func TestReplaceObject(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdReplace(f, buf)
+	cmd := NewCmdReplace(tf, buf)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
 	cmd.Flags().Set("output", "name")
 	cmd.Run(cmd, []string{})
@@ -88,7 +88,7 @@ func TestReplaceObject(t *testing.T) {
 func TestReplaceMultipleObject(t *testing.T) {
 	_, svc, rc := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	redisMasterDeleted := false
@@ -134,7 +134,7 @@ func TestReplaceMultipleObject(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdReplace(f, buf)
+	cmd := NewCmdReplace(tf, buf)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
 	cmd.Flags().Set("filename", "../../../examples/guestbook/frontend-service.yaml")
 	cmd.Flags().Set("output", "name")
@@ -158,7 +158,7 @@ func TestReplaceMultipleObject(t *testing.T) {
 func TestReplaceDirectory(t *testing.T) {
 	_, _, rc := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	created := map[string]bool{}
@@ -191,7 +191,7 @@ func TestReplaceDirectory(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdReplace(f, buf)
+	cmd := NewCmdReplace(tf, buf)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy")
 	cmd.Flags().Set("namespace", "test")
 	cmd.Flags().Set("output", "name")
@@ -215,7 +215,7 @@ func TestReplaceDirectory(t *testing.T) {
 func TestForceReplaceObjectNotFound(t *testing.T) {
 	_, _, rc := testData()
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 
 	tf.UnstructuredClient = &fake.RESTClient{
@@ -237,7 +237,7 @@ func TestForceReplaceObjectNotFound(t *testing.T) {
 	tf.Namespace = "test"
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdReplace(f, buf)
+	cmd := NewCmdReplace(tf, buf)
 	cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
 	cmd.Flags().Set("force", "true")
 	cmd.Flags().Set("cascade", "false")

pkg/kubectl/cmd/rollingupdate_test.go

@@ -24,7 +24,7 @@ import (
 )
 
 func TestValidateArgs(t *testing.T) {
-	f, _ := cmdtesting.NewAPIFactory()
+	f := cmdtesting.NewTestFactory()
 
 	tests := []struct {
 		testName  string

pkg/kubectl/cmd/run_test.go

@@ -168,7 +168,7 @@ func TestRunArgsFollowDashRules(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -186,11 +186,11 @@ func TestRunArgsFollowDashRules(t *testing.T) {
 			}),
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = &restclient.Config{}
-		cmd := NewCmdRun(f, os.Stdin, os.Stdout, os.Stderr)
+		tf.ClientConfigVal = &restclient.Config{}
+		cmd := NewCmdRun(tf, os.Stdin, os.Stdout, os.Stderr)
 		cmd.Flags().Set("image", "nginx")
 		cmd.Flags().Set("generator", "run/v1")
-		err := RunRun(f, os.Stdin, os.Stdout, os.Stderr, cmd, test.args, test.argsLenAtDash)
+		err := RunRun(tf, os.Stdin, os.Stdout, os.Stderr, cmd, test.args, test.argsLenAtDash)
 		if test.expectError && err == nil {
 			t.Errorf("unexpected non-error (%s)", test.name)
 		}
@@ -293,11 +293,11 @@ func TestGenerateService(t *testing.T) {
 	}
 	for _, test := range tests {
 		sawPOST := false
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 		tf.Client = &fake.RESTClient{
 			GroupVersion:         schema.GroupVersion{Version: "v1"},
 			NegotiatedSerializer: ns,
@@ -346,7 +346,7 @@ func TestGenerateService(t *testing.T) {
 		}
 
 		buff := &bytes.Buffer{}
-		_, err := generateService(f, cmd, test.args, test.serviceGenerator, test.params, "namespace", buff)
+		_, err := generateService(tf, cmd, test.args, test.serviceGenerator, test.params, "namespace", buff)
 		if test.expectErr {
 			if err == nil {
 				t.Error("unexpected non-error")
@@ -437,23 +437,23 @@ func TestRunValidations(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		f, tf := cmdtesting.NewTestFactory()
+		tf := cmdtesting.NewTestFactory()
 		_, _, codec := cmdtesting.NewExternalScheme()
 		tf.Client = &fake.RESTClient{
 			NegotiatedSerializer: scheme.Codecs,
 			Resp:                 &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", ""))},
 		}
 		tf.Namespace = "test"
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 		inBuf := bytes.NewReader([]byte{})
 		outBuf := bytes.NewBuffer([]byte{})
 		errBuf := bytes.NewBuffer([]byte{})
 
-		cmd := NewCmdRun(f, inBuf, outBuf, errBuf)
+		cmd := NewCmdRun(tf, inBuf, outBuf, errBuf)
 		for flagName, flagValue := range test.flags {
 			cmd.Flags().Set(flagName, flagValue)
 		}
-		err := RunRun(f, inBuf, outBuf, errBuf, cmd, test.args, cmd.ArgsLenAtDash())
+		err := RunRun(tf, inBuf, outBuf, errBuf, cmd, test.args, cmd.ArgsLenAtDash())
 		if err != nil && len(test.expectedErr) > 0 {
 			if !strings.Contains(err.Error(), test.expectedErr) {
 				t.Errorf("unexpected error: %v", err)

pkg/kubectl/cmd/set/BUILD

@@ -61,7 +61,6 @@ go_test(
         "//pkg/api/legacyscheme:go_default_library",
         "//pkg/api/testapi:go_default_library",
         "//pkg/apis/rbac:go_default_library",
-        "//pkg/kubectl/categories:go_default_library",
         "//pkg/kubectl/cmd/testing:go_default_library",
         "//pkg/kubectl/cmd/util:go_default_library",
         "//pkg/kubectl/resource:go_default_library",

pkg/kubectl/cmd/set/set_env_test.go

@@ -40,14 +40,13 @@ import (
 	"k8s.io/client-go/rest/fake"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
-	"k8s.io/kubernetes/pkg/kubectl/categories"
 	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/kubectl/scheme"
 )
 
 func TestSetEnvLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 	tf.Client = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Version: ""},
@@ -58,10 +57,10 @@ func TestSetEnvLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdEnv(f, os.Stdin, buf, buf)
+	cmd := NewCmdEnv(tf, os.Stdin, buf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")
@@ -70,10 +69,10 @@ func TestSetEnvLocal(t *testing.T) {
 		Filenames: []string{"../../../../examples/storage/cassandra/cassandra-controller.yaml"}},
 		Out:   buf,
 		Local: true}
-	opts.Complete(f, cmd)
+	opts.Complete(tf, cmd)
 	err := opts.Validate([]string{"env=prod"})
 	if err == nil {
-		err = opts.RunEnv(f)
+		err = opts.RunEnv(tf)
 	}
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -84,7 +83,7 @@ func TestSetEnvLocal(t *testing.T) {
 }
 
 func TestSetMultiResourcesEnvLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -96,10 +95,10 @@ func TestSetMultiResourcesEnvLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdEnv(f, os.Stdin, buf, buf)
+	cmd := NewCmdEnv(tf, os.Stdin, buf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")
@@ -108,10 +107,10 @@ func TestSetMultiResourcesEnvLocal(t *testing.T) {
 		Filenames: []string{"../../../../test/fixtures/pkg/kubectl/cmd/set/multi-resource-yaml.yaml"}},
 		Out:   buf,
 		Local: true}
-	opts.Complete(f, cmd)
+	opts.Complete(tf, cmd)
 	err := opts.Validate([]string{"env=prod"})
 	if err == nil {
-		err = opts.RunEnv(f)
+		err = opts.RunEnv(tf)
 	}
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -498,11 +497,10 @@ func TestSetEnvRemote(t *testing.T) {
 	for _, input := range inputs {
 		groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
 		testapi.Default = testapi.Groups[input.testAPIGroup]
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
 		ns := legacyscheme.Codecs
 		tf.Namespace = "test"
-		tf.CategoryExpander = categories.LegacyCategoryExpander
 		tf.Client = &fake.RESTClient{
 			GroupVersion:         groupVersion,
 			NegotiatedSerializer: ns,
@@ -529,14 +527,14 @@ func TestSetEnvRemote(t *testing.T) {
 			}),
 			VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
 		}
-		cmd := NewCmdEnv(f, out, out, out)
+		cmd := NewCmdEnv(tf, out, out, out)
 		cmd.SetOutput(out)
 		cmd.Flags().Set("output", "yaml")
 		opts := input.opts
-		opts.Complete(f, cmd)
+		opts.Complete(tf, cmd)
 		err := opts.Validate(input.args)
 		assert.NoError(t, err)
-		err = opts.RunEnv(f)
+		err = opts.RunEnv(tf)
 		assert.NoError(t, err)
 	}
 	// TODO This global state restoration needs fixing, b/c it's wrong. Tests should not modify global state

pkg/kubectl/cmd/set/set_image_test.go

@@ -39,14 +39,13 @@ import (
 	"k8s.io/client-go/rest/fake"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
-	"k8s.io/kubernetes/pkg/kubectl/categories"
 	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/kubectl/scheme"
 )
 
 func TestImageLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -58,10 +57,10 @@ func TestImageLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdImage(f, buf, buf)
+	cmd := NewCmdImage(tf, buf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")
@@ -70,7 +69,7 @@ func TestImageLocal(t *testing.T) {
 		Filenames: []string{"../../../../examples/storage/cassandra/cassandra-controller.yaml"}},
 		Out:   buf,
 		Local: true}
-	err := opts.Complete(f, cmd, []string{"cassandra=thingy"})
+	err := opts.Complete(tf, cmd, []string{"cassandra=thingy"})
 	if err == nil {
 		err = opts.Validate()
 	}
@@ -149,7 +148,7 @@ func TestSetImageValidation(t *testing.T) {
 }
 
 func TestSetMultiResourcesImageLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -161,10 +160,10 @@ func TestSetMultiResourcesImageLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdImage(f, buf, buf)
+	cmd := NewCmdImage(tf, buf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")
@@ -173,7 +172,7 @@ func TestSetMultiResourcesImageLocal(t *testing.T) {
 		Filenames: []string{"../../../../test/fixtures/pkg/kubectl/cmd/set/multi-resource-yaml.yaml"}},
 		Out:   buf,
 		Local: true}
-	err := opts.Complete(f, cmd, []string{"*=thingy"})
+	err := opts.Complete(tf, cmd, []string{"*=thingy"})
 	if err == nil {
 		err = opts.Validate()
 	}
@@ -500,11 +499,10 @@ func TestSetImageRemote(t *testing.T) {
 	for _, input := range inputs {
 		groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
 		testapi.Default = testapi.Groups[input.testAPIGroup]
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
 		ns := legacyscheme.Codecs
 		tf.Namespace = "test"
-		tf.CategoryExpander = categories.LegacyCategoryExpander
 		tf.Client = &fake.RESTClient{
 			GroupVersion:         groupVersion,
 			NegotiatedSerializer: ns,
@@ -532,13 +530,13 @@ func TestSetImageRemote(t *testing.T) {
 			VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
 		}
 		out := new(bytes.Buffer)
-		cmd := NewCmdImage(f, out, out)
+		cmd := NewCmdImage(tf, out, out)
 		cmd.SetOutput(out)
 		cmd.Flags().Set("output", "yaml")
 		opts := ImageOptions{
 			Out:   out,
 			Local: false}
-		err := opts.Complete(f, cmd, input.args)
+		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

@@ -39,14 +39,13 @@ import (
 	"k8s.io/client-go/rest/fake"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
-	"k8s.io/kubernetes/pkg/kubectl/categories"
 	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/kubectl/scheme"
 )
 
 func TestResourcesLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -58,10 +57,10 @@ func TestResourcesLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdResources(f, buf, buf)
+	cmd := NewCmdResources(tf, buf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")
@@ -74,7 +73,7 @@ func TestResourcesLocal(t *testing.T) {
 		Requests:          "cpu=200m,memory=512Mi",
 		ContainerSelector: "*"}
 
-	err := opts.Complete(f, cmd, []string{})
+	err := opts.Complete(tf, cmd, []string{})
 	if err == nil {
 		err = opts.Validate()
 	}
@@ -90,7 +89,7 @@ func TestResourcesLocal(t *testing.T) {
 }
 
 func TestSetMultiResourcesLimitsLocal(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 
 	tf.Client = &fake.RESTClient{
@@ -102,10 +101,10 @@ func TestSetMultiResourcesLimitsLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdResources(f, buf, buf)
+	cmd := NewCmdResources(tf, buf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")
@@ -118,7 +117,7 @@ func TestSetMultiResourcesLimitsLocal(t *testing.T) {
 		Requests:          "cpu=200m,memory=512Mi",
 		ContainerSelector: "*"}
 
-	err := opts.Complete(f, cmd, []string{})
+	err := opts.Complete(tf, cmd, []string{})
 	if err == nil {
 		err = opts.Validate()
 	}
@@ -446,11 +445,10 @@ func TestSetResourcesRemote(t *testing.T) {
 		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
 			groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
 			testapi.Default = testapi.Groups[input.testAPIGroup]
-			f, tf := cmdtesting.NewAPIFactory()
+			tf := cmdtesting.NewTestFactory()
 			codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
 			ns := legacyscheme.Codecs
 			tf.Namespace = "test"
-			tf.CategoryExpander = categories.LegacyCategoryExpander
 			tf.Client = &fake.RESTClient{
 				GroupVersion:         groupVersion,
 				NegotiatedSerializer: ns,
@@ -478,14 +476,14 @@ func TestSetResourcesRemote(t *testing.T) {
 				VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
 			}
 			buf := new(bytes.Buffer)
-			cmd := NewCmdResources(f, buf, buf)
+			cmd := NewCmdResources(tf, buf, buf)
 			cmd.SetOutput(buf)
 			cmd.Flags().Set("output", "yaml")
 			opts := ResourcesOptions{
 				Out:               buf,
 				Limits:            "cpu=200m,memory=512Mi",
 				ContainerSelector: "*"}
-			err := opts.Complete(f, cmd, input.args)
+			err := opts.Complete(tf, cmd, input.args)
 			if err == nil {
 				err = opts.Validate()
 			}

pkg/kubectl/cmd/set/set_selector_test.go

@@ -316,7 +316,7 @@ func TestGetResourcesAndSelector(t *testing.T) {
 }
 
 func TestSelectorTest(t *testing.T) {
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 	tf.Client = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Version: ""},
@@ -327,10 +327,10 @@ func TestSelectorTest(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdSelector(f, buf)
+	cmd := NewCmdSelector(tf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")

pkg/kubectl/cmd/set/set_serviceaccount_test.go

@@ -39,7 +39,6 @@ import (
 	"k8s.io/client-go/rest/fake"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
-	"k8s.io/kubernetes/pkg/kubectl/categories"
 	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/kubectl/scheme"
@@ -68,7 +67,7 @@ func TestSetServiceAccountLocal(t *testing.T) {
 
 	for i, input := range inputs {
 		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
-			f, tf := cmdtesting.NewAPIFactory()
+			tf := cmdtesting.NewTestFactory()
 			tf.Client = &fake.RESTClient{
 				GroupVersion: schema.GroupVersion{Version: "v1"},
 				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -78,7 +77,7 @@ func TestSetServiceAccountLocal(t *testing.T) {
 			}
 			tf.Namespace = "test"
 			out := new(bytes.Buffer)
-			cmd := NewCmdServiceAccount(f, out, out)
+			cmd := NewCmdServiceAccount(tf, out, out)
 			cmd.SetOutput(out)
 			cmd.Flags().Set("output", "yaml")
 			cmd.Flags().Set("local", "true")
@@ -87,7 +86,7 @@ func TestSetServiceAccountLocal(t *testing.T) {
 				Filenames: []string{input.yaml}},
 				out:   out,
 				local: true}
-			err := saConfig.Complete(f, cmd, []string{serviceAccount})
+			err := saConfig.Complete(tf, cmd, []string{serviceAccount})
 			assert.NoError(t, err)
 			err = saConfig.Run()
 			assert.NoError(t, err)
@@ -98,7 +97,7 @@ func TestSetServiceAccountLocal(t *testing.T) {
 
 func TestSetServiceAccountMultiLocal(t *testing.T) {
 	testapi.Default = testapi.Groups[""]
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	ns := legacyscheme.Codecs
 	tf.Client = &fake.RESTClient{
 		GroupVersion:         schema.GroupVersion{Version: ""},
@@ -109,10 +108,10 @@ func TestSetServiceAccountMultiLocal(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
+	tf.ClientConfigVal = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: ""}}}
 
 	buf := bytes.NewBuffer([]byte{})
-	cmd := NewCmdServiceAccount(f, buf, buf)
+	cmd := NewCmdServiceAccount(tf, buf, buf)
 	cmd.SetOutput(buf)
 	cmd.Flags().Set("output", "name")
 	cmd.Flags().Set("local", "true")
@@ -121,7 +120,7 @@ func TestSetServiceAccountMultiLocal(t *testing.T) {
 		out:   buf,
 		local: true}
 
-	err := opts.Complete(f, cmd, []string{serviceAccount})
+	err := opts.Complete(tf, cmd, []string{serviceAccount})
 	if err == nil {
 		err = opts.Run()
 	}
@@ -313,11 +312,10 @@ func TestSetServiceAccountRemote(t *testing.T) {
 	for _, input := range inputs {
 		groupVersion := schema.GroupVersion{Group: input.apiGroup, Version: input.apiVersion}
 		testapi.Default = testapi.Groups[input.testAPIGroup]
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := scheme.Codecs.CodecForVersions(scheme.Codecs.LegacyCodec(groupVersion), scheme.Codecs.UniversalDecoder(groupVersion), groupVersion, groupVersion)
 		ns := legacyscheme.Codecs
 		tf.Namespace = "test"
-		tf.CategoryExpander = categories.LegacyCategoryExpander
 		tf.Client = &fake.RESTClient{
 			GroupVersion:         groupVersion,
 			NegotiatedSerializer: ns,
@@ -345,13 +343,13 @@ func TestSetServiceAccountRemote(t *testing.T) {
 			VersionedAPIPath: path.Join(input.apiPrefix, testapi.Default.GroupVersion().String()),
 		}
 		out := new(bytes.Buffer)
-		cmd := NewCmdServiceAccount(f, out, out)
+		cmd := NewCmdServiceAccount(tf, out, out)
 		cmd.SetOutput(out)
 		cmd.Flags().Set("output", "yaml")
 		saConfig := serviceAccountConfig{
 			out:   out,
 			local: false}
-		err := saConfig.Complete(f, cmd, input.args)
+		err := saConfig.Complete(tf, cmd, input.args)
 		assert.NoError(t, err)
 		err = saConfig.Run()
 		assert.NoError(t, err)
@@ -367,7 +365,7 @@ func TestServiceAccountValidation(t *testing.T) {
 		{args: []string{serviceAccount}, errorString: resourceMissingErrString},
 	}
 	for _, input := range inputs {
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		tf.Client = &fake.RESTClient{
 			GroupVersion: schema.GroupVersion{Version: "v1"},
 			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
@@ -377,11 +375,11 @@ func TestServiceAccountValidation(t *testing.T) {
 		}
 		tf.Namespace = "test"
 		out := bytes.NewBuffer([]byte{})
-		cmd := NewCmdServiceAccount(f, out, out)
+		cmd := NewCmdServiceAccount(tf, out, out)
 		cmd.SetOutput(out)
 
 		saConfig := &serviceAccountConfig{}
-		err := saConfig.Complete(f, cmd, input.args)
+		err := saConfig.Complete(tf, cmd, input.args)
 		assert.EqualError(t, err, input.errorString)
 	}
 }

pkg/kubectl/cmd/set/set_subject_test.go

@@ -28,7 +28,7 @@ import (
 )
 
 func TestValidate(t *testing.T) {
-	_, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	tf.Namespace = "test"
 
 	tests := map[string]struct {

pkg/kubectl/cmd/taint_test.go

@@ -239,7 +239,7 @@ func TestTaint(t *testing.T) {
 		oldNode, expectNewNode := generateNodeAndTaintedNode(test.oldTaints, test.newTaints)
 		new_node := &v1.Node{}
 		tainted := false
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 		ns := legacyscheme.Codecs
 
@@ -298,10 +298,10 @@ func TestTaint(t *testing.T) {
 				}
 			}),
 		}
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 
 		buf := bytes.NewBuffer([]byte{})
-		cmd := NewCmdTaint(f, buf)
+		cmd := NewCmdTaint(tf, buf)
 
 		saw_fatal := false
 		func() {

pkg/kubectl/cmd/testing/BUILD

@@ -22,14 +22,11 @@ go_library(
         "//pkg/kubectl/cmd/util:go_default_library",
         "//pkg/kubectl/cmd/util/openapi:go_default_library",
         "//pkg/kubectl/cmd/util/openapi/testing:go_default_library",
-        "//pkg/kubectl/plugins:go_default_library",
         "//pkg/kubectl/resource:go_default_library",
         "//pkg/kubectl/scheme:go_default_library",
         "//pkg/kubectl/validation:go_default_library",
         "//pkg/printers:go_default_library",
         "//vendor/github.com/spf13/cobra:go_default_library",
-        "//vendor/github.com/spf13/pflag:go_default_library",
-        "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",

pkg/kubectl/cmd/top_node_test.go

@@ -49,7 +49,7 @@ func TestTopNodeAllMetrics(t *testing.T) {
 	expectedMetricsPath := fmt.Sprintf("%s/%s/nodes", baseMetricsAddress, metricsApiVersion)
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -76,10 +76,10 @@ func TestTopNodeAllMetrics(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdTopNode(f, nil, buf)
+	cmd := NewCmdTopNode(tf, nil, buf)
 	cmd.Run(cmd, []string{})
 
 	// Check the presence of node names in the output.
@@ -100,7 +100,7 @@ func TestTopNodeAllMetricsCustomDefaults(t *testing.T) {
 	expectedMetricsPath := fmt.Sprintf("%s/%s/nodes", customBaseMetricsAddress, metricsApiVersion)
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -127,7 +127,7 @@ func TestTopNodeAllMetricsCustomDefaults(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 	buf := bytes.NewBuffer([]byte{})
 
 	opts := &TopNodeOptions{
@@ -137,7 +137,7 @@ func TestTopNodeAllMetricsCustomDefaults(t *testing.T) {
 			Service:   "custom-heapster-service",
 		},
 	}
-	cmd := NewCmdTopNode(f, opts, buf)
+	cmd := NewCmdTopNode(tf, opts, buf)
 	cmd.Run(cmd, []string{})
 
 	// Check the presence of node names in the output.
@@ -161,7 +161,7 @@ func TestTopNodeWithNameMetrics(t *testing.T) {
 	expectedPath := fmt.Sprintf("%s/%s/nodes/%s", baseMetricsAddress, metricsApiVersion, expectedMetrics.Name)
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes/%s", apiPrefix, apiVersion, expectedMetrics.Name)
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -188,10 +188,10 @@ func TestTopNodeWithNameMetrics(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdTopNode(f, nil, buf)
+	cmd := NewCmdTopNode(tf, nil, buf)
 	cmd.Run(cmd, []string{expectedMetrics.Name})
 
 	// Check the presence of node names in the output.
@@ -226,7 +226,7 @@ func TestTopNodeWithLabelSelectorMetrics(t *testing.T) {
 	expectedQuery := fmt.Sprintf("labelSelector=%s", url.QueryEscape(label))
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -253,10 +253,10 @@ func TestTopNodeWithLabelSelectorMetrics(t *testing.T) {
 		}),
 	}
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdTopNode(f, nil, buf)
+	cmd := NewCmdTopNode(tf, nil, buf)
 	cmd.Flags().Set("selector", label)
 	cmd.Run(cmd, []string{})
 
@@ -279,7 +279,7 @@ func TestTopNodeAllMetricsFromMetricsServer(t *testing.T) {
 	expectedMetrics, nodes := testNodeV1beta1MetricsData()
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -304,15 +304,15 @@ func TestTopNodeAllMetricsFromMetricsServer(t *testing.T) {
 		return true, expectedMetrics, nil
 	})
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdTopNode(f, nil, buf)
+	cmd := NewCmdTopNode(tf, nil, buf)
 
 	// TODO in the long run, we want to test most of our commands like this. Wire the options struct with specific mocks
 	// TODO then check the particular Run functionality and harvest results from fake clients
 	cmdOptions := &TopNodeOptions{}
-	if err := cmdOptions.Complete(f, cmd, []string{}, buf); err != nil {
+	if err := cmdOptions.Complete(tf, cmd, []string{}, buf); err != nil {
 		t.Fatal(err)
 	}
 	cmdOptions.MetricsClient = fakemetricsClientset
@@ -343,7 +343,7 @@ func TestTopNodeWithNameMetricsFromMetricsServer(t *testing.T) {
 	}
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes/%s", apiPrefix, apiVersion, expectedMetrics.Name)
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -368,15 +368,15 @@ func TestTopNodeWithNameMetricsFromMetricsServer(t *testing.T) {
 		return true, &expectedMetrics, nil
 	})
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdTopNode(f, nil, buf)
+	cmd := NewCmdTopNode(tf, nil, buf)
 
 	// TODO in the long run, we want to test most of our commands like this. Wire the options struct with specific mocks
 	// TODO then check the particular Run functionality and harvest results from fake clients
 	cmdOptions := &TopNodeOptions{}
-	if err := cmdOptions.Complete(f, cmd, []string{expectedMetrics.Name}, buf); err != nil {
+	if err := cmdOptions.Complete(tf, cmd, []string{expectedMetrics.Name}, buf); err != nil {
 		t.Fatal(err)
 	}
 	cmdOptions.MetricsClient = fakemetricsClientset
@@ -417,7 +417,7 @@ func TestTopNodeWithLabelSelectorMetricsFromMetricsServer(t *testing.T) {
 	label := "key=value"
 	expectedNodePath := fmt.Sprintf("/%s/%s/nodes", apiPrefix, apiVersion)
 
-	f, tf := cmdtesting.NewAPIFactory()
+	tf := cmdtesting.NewTestFactory()
 	codec := legacyscheme.Codecs.LegacyCodec(scheme.Versions...)
 	ns := legacyscheme.Codecs
 
@@ -443,16 +443,16 @@ func TestTopNodeWithLabelSelectorMetricsFromMetricsServer(t *testing.T) {
 		return true, expectedMetrics, nil
 	})
 	tf.Namespace = "test"
-	tf.ClientConfig = defaultClientConfig()
+	tf.ClientConfigVal = defaultClientConfig()
 	buf := bytes.NewBuffer([]byte{})
 
-	cmd := NewCmdTopNode(f, nil, buf)
+	cmd := NewCmdTopNode(tf, nil, buf)
 	cmd.Flags().Set("selector", label)
 
 	// TODO in the long run, we want to test most of our commands like this. Wire the options struct with specific mocks
 	// TODO then check the particular Run functionality and harvest results from fake clients
 	cmdOptions := &TopNodeOptions{}
-	if err := cmdOptions.Complete(f, cmd, []string{}, buf); err != nil {
+	if err := cmdOptions.Complete(tf, cmd, []string{}, buf); err != nil {
 		t.Fatal(err)
 	}
 	cmdOptions.MetricsClient = fakemetricsClientset

pkg/kubectl/cmd/top_pod_test.go

@@ -162,7 +162,7 @@ func TestTopPod(t *testing.T) {
 			}
 		}
 
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		ns := legacyscheme.Codecs
 
 		tf.Client = &fake.RESTClient{
@@ -187,10 +187,10 @@ func TestTopPod(t *testing.T) {
 			}),
 		}
 		tf.Namespace = testNS
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 		buf := bytes.NewBuffer([]byte{})
 
-		cmd := NewCmdTopPod(f, nil, buf)
+		cmd := NewCmdTopPod(tf, nil, buf)
 		for name, value := range testCase.flags {
 			cmd.Flags().Set(name, value)
 		}
@@ -304,7 +304,7 @@ func TestTopPodWithMetricsServer(t *testing.T) {
 				})
 			}
 
-			f, tf := cmdtesting.NewAPIFactory()
+			tf := cmdtesting.NewTestFactory()
 			ns := legacyscheme.Codecs
 
 			tf.Client = &fake.RESTClient{
@@ -323,10 +323,10 @@ func TestTopPodWithMetricsServer(t *testing.T) {
 				}),
 			}
 			tf.Namespace = testNS
-			tf.ClientConfig = defaultClientConfig()
+			tf.ClientConfigVal = defaultClientConfig()
 			buf := bytes.NewBuffer([]byte{})
 
-			cmd := NewCmdTopPod(f, nil, buf)
+			cmd := NewCmdTopPod(tf, nil, buf)
 			var cmdOptions *TopPodOptions
 			if testCase.options != nil {
 				cmdOptions = testCase.options
@@ -336,7 +336,7 @@ func TestTopPodWithMetricsServer(t *testing.T) {
 
 			// TODO in the long run, we want to test most of our commands like this. Wire the options struct with specific mocks
 			// TODO then check the particular Run functionality and harvest results from fake clients.  We probably end up skipping the factory altogether.
-			if err := cmdOptions.Complete(f, cmd, testCase.args, buf); err != nil {
+			if err := cmdOptions.Complete(tf, cmd, testCase.args, buf); err != nil {
 				t.Fatal(err)
 			}
 			cmdOptions.MetricsClient = fakemetricsClientset
@@ -499,7 +499,7 @@ func TestTopPodCustomDefaults(t *testing.T) {
 			}
 		}
 
-		f, tf := cmdtesting.NewAPIFactory()
+		tf := cmdtesting.NewTestFactory()
 		ns := legacyscheme.Codecs
 
 		tf.Client = &fake.RESTClient{
@@ -524,7 +524,7 @@ func TestTopPodCustomDefaults(t *testing.T) {
 			}),
 		}
 		tf.Namespace = testNS
-		tf.ClientConfig = defaultClientConfig()
+		tf.ClientConfigVal = defaultClientConfig()
 		buf := bytes.NewBuffer([]byte{})
 
 		opts := &TopPodOptions{
@@ -535,7 +535,7 @@ func TestTopPodCustomDefaults(t *testing.T) {
 			},
 			DiscoveryClient: &fakeDiscovery{},
 		}
-		cmd := NewCmdTopPod(f, opts, buf)
+		cmd := NewCmdTopPod(tf, opts, buf)
 		for name, value := range testCase.flags {
 			cmd.Flags().Set(name, value)
 		}

pkg/kubectl/cmd/top_test.go

@@ -43,7 +43,7 @@ const (
 func TestTopSubcommandsExist(t *testing.T) {
 	initTestErrorHandler(t)
 
-	f, _ := cmdtesting.NewAPIFactory()
+	f := cmdtesting.NewTestFactory()
 	buf := bytes.NewBuffer([]byte{})
 
 	cmd := NewCmdTop(f, buf, buf)