vendor: remove dep and use vndr

Signed-off-by: Antonio Murdaca <runcom@redhat.com>

vendor/k8s.io/client-go/discovery/discovery_client.go

@@ -123,7 +123,7 @@ func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err
 	v := &metav1.APIVersions{}
 	err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
 	apiGroup := metav1.APIGroup{}
-	if err == nil {
+	if err == nil && len(v.Versions) != 0 {
 		apiGroup = apiVersionsToAPIGroup(v)
 	}
 	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
@@ -141,8 +141,10 @@ func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err
 		apiGroupList = &metav1.APIGroupList{}
 	}
 
-	// append the group retrieved from /api to the list
-	apiGroupList.Groups = append(apiGroupList.Groups, apiGroup)
+	// append the group retrieved from /api to the list if not empty
+	if len(v.Versions) != 0 {
+		apiGroupList.Groups = append(apiGroupList.Groups, apiGroup)
+	}
 	return apiGroupList, nil
 }
 

vendor/k8s.io/client-go/discovery/discovery_client_test.go

@@ -1,740 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package discovery_test
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"reflect"
-	"testing"
-
-	"github.com/emicklei/go-restful/swagger"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/sets"
-	"k8s.io/apimachinery/pkg/version"
-	. "k8s.io/client-go/discovery"
-	"k8s.io/client-go/pkg/api/v1"
-	restclient "k8s.io/client-go/rest"
-)
-
-func TestGetServerVersion(t *testing.T) {
-	expect := version.Info{
-		Major:     "foo",
-		Minor:     "bar",
-		GitCommit: "baz",
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		output, err := json.Marshal(expect)
-		if err != nil {
-			t.Errorf("unexpected encoding error: %v", err)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(output)
-	}))
-	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-
-	got, err := client.ServerVersion()
-	if err != nil {
-		t.Fatalf("unexpected encoding error: %v", err)
-	}
-	if e, a := expect, *got; !reflect.DeepEqual(e, a) {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-}
-
-func TestGetServerGroupsWithV1Server(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		var obj interface{}
-		switch req.URL.Path {
-		case "/api":
-			obj = &metav1.APIVersions{
-				Versions: []string{
-					"v1",
-				},
-			}
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-		output, err := json.Marshal(obj)
-		if err != nil {
-			t.Fatalf("unexpected encoding error: %v", err)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(output)
-	}))
-	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	// ServerGroups should not return an error even if server returns error at /api and /apis
-	apiGroupList, err := client.ServerGroups()
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	groupVersions := metav1.ExtractGroupVersions(apiGroupList)
-	if !reflect.DeepEqual(groupVersions, []string{"v1"}) {
-		t.Errorf("expected: %q, got: %q", []string{"v1"}, groupVersions)
-	}
-}
-
-func TestGetServerGroupsWithBrokenServer(t *testing.T) {
-	for _, statusCode := range []int{http.StatusNotFound, http.StatusForbidden} {
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-			w.WriteHeader(statusCode)
-		}))
-		defer server.Close()
-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-		// ServerGroups should not return an error even if server returns Not Found or Forbidden error at all end points
-		apiGroupList, err := client.ServerGroups()
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		groupVersions := metav1.ExtractGroupVersions(apiGroupList)
-		if len(groupVersions) != 0 {
-			t.Errorf("expected empty list, got: %q", groupVersions)
-		}
-	}
-}
-
-func TestGetServerResourcesWithV1Server(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		var obj interface{}
-		switch req.URL.Path {
-		case "/api":
-			obj = &metav1.APIVersions{
-				Versions: []string{
-					"v1",
-				},
-			}
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-		output, err := json.Marshal(obj)
-		if err != nil {
-			t.Errorf("unexpected encoding error: %v", err)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(output)
-	}))
-	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	// ServerResources should not return an error even if server returns error at /api/v1.
-	serverResources, err := client.ServerResources()
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-	gvs := groupVersions(serverResources)
-	if !sets.NewString(gvs...).Has("v1") {
-		t.Errorf("missing v1 in resource list: %v", serverResources)
-	}
-}
-
-func TestGetServerResources(t *testing.T) {
-	stable := metav1.APIResourceList{
-		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
-			{Name: "pods", Namespaced: true, Kind: "Pod"},
-			{Name: "services", Namespaced: true, Kind: "Service"},
-			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
-		},
-	}
-	beta := metav1.APIResourceList{
-		GroupVersion: "extensions/v1beta1",
-		APIResources: []metav1.APIResource{
-			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
-			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
-			{Name: "jobs", Namespaced: true, Kind: "Job"},
-		},
-	}
-	tests := []struct {
-		resourcesList *metav1.APIResourceList
-		path          string
-		request       string
-		expectErr     bool
-	}{
-		{
-			resourcesList: &stable,
-			path:          "/api/v1",
-			request:       "v1",
-			expectErr:     false,
-		},
-		{
-			resourcesList: &beta,
-			path:          "/apis/extensions/v1beta1",
-			request:       "extensions/v1beta1",
-			expectErr:     false,
-		},
-		{
-			resourcesList: &stable,
-			path:          "/api/v1",
-			request:       "foobar",
-			expectErr:     true,
-		},
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		var list interface{}
-		switch req.URL.Path {
-		case "/api/v1":
-			list = &stable
-		case "/apis/extensions/v1beta1":
-			list = &beta
-		case "/api":
-			list = &metav1.APIVersions{
-				Versions: []string{
-					"v1",
-				},
-			}
-		case "/apis":
-			list = &metav1.APIGroupList{
-				Groups: []metav1.APIGroup{
-					{
-						Versions: []metav1.GroupVersionForDiscovery{
-							{GroupVersion: "extensions/v1beta1"},
-						},
-					},
-				},
-			}
-		default:
-			t.Logf("unexpected request: %s", req.URL.Path)
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-		output, err := json.Marshal(list)
-		if err != nil {
-			t.Errorf("unexpected encoding error: %v", err)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(output)
-	}))
-	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	for _, test := range tests {
-		got, err := client.ServerResourcesForGroupVersion(test.request)
-		if test.expectErr {
-			if err == nil {
-				t.Error("unexpected non-error")
-			}
-			continue
-		}
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-			continue
-		}
-		if !reflect.DeepEqual(got, test.resourcesList) {
-			t.Errorf("expected:\n%v\ngot:\n%v\n", test.resourcesList, got)
-		}
-	}
-
-	serverResources, err := client.ServerResources()
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-	serverGroupVersions := sets.NewString(groupVersions(serverResources)...)
-	for _, api := range []string{"v1", "extensions/v1beta1"} {
-		if !serverGroupVersions.Has(api) {
-			t.Errorf("missing expected api %q in %v", api, serverResources)
-		}
-	}
-}
-
-func swaggerSchemaFakeServer() (*httptest.Server, error) {
-	request := 1
-	var sErr error
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		var resp interface{}
-		if request == 1 {
-			resp = metav1.APIVersions{Versions: []string{"v1", "v2", "v3"}}
-			request++
-		} else {
-			resp = swagger.ApiDeclaration{}
-		}
-		output, err := json.Marshal(resp)
-		if err != nil {
-			sErr = err
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(output)
-	}))
-	return server, sErr
-}
-
-func TestGetSwaggerSchema(t *testing.T) {
-	expect := swagger.ApiDeclaration{}
-
-	server, err := swaggerSchemaFakeServer()
-	if err != nil {
-		t.Errorf("unexpected encoding error: %v", err)
-	}
-	defer server.Close()
-
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	got, err := client.SwaggerSchema(v1.SchemeGroupVersion)
-	if err != nil {
-		t.Fatalf("unexpected encoding error: %v", err)
-	}
-	if e, a := expect, *got; !reflect.DeepEqual(e, a) {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-}
-
-func TestGetSwaggerSchemaFail(t *testing.T) {
-	expErr := "API version: api.group/v4 is not supported by the server. Use one of: [v1 v2 v3]"
-
-	server, err := swaggerSchemaFakeServer()
-	if err != nil {
-		t.Errorf("unexpected encoding error: %v", err)
-	}
-	defer server.Close()
-
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	got, err := client.SwaggerSchema(schema.GroupVersion{Group: "api.group", Version: "v4"})
-	if got != nil {
-		t.Fatalf("unexpected response: %v", got)
-	}
-	if err.Error() != expErr {
-		t.Errorf("expected an error, got %v", err)
-	}
-}
-
-func TestServerPreferredResources(t *testing.T) {
-	stable := metav1.APIResourceList{
-		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
-			{Name: "pods", Namespaced: true, Kind: "Pod"},
-			{Name: "services", Namespaced: true, Kind: "Service"},
-			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
-		},
-	}
-	tests := []struct {
-		resourcesList []*metav1.APIResourceList
-		response      func(w http.ResponseWriter, req *http.Request)
-		expectErr     func(err error) bool
-	}{
-		{
-			resourcesList: []*metav1.APIResourceList{&stable},
-			expectErr:     IsGroupDiscoveryFailedError,
-			response: func(w http.ResponseWriter, req *http.Request) {
-				var list interface{}
-				switch req.URL.Path {
-				case "/apis/extensions/v1beta1":
-					w.WriteHeader(http.StatusInternalServerError)
-					return
-				case "/api/v1":
-					list = &stable
-				case "/api":
-					list = &metav1.APIVersions{
-						Versions: []string{
-							"v1",
-						},
-					}
-				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
-							{
-								Versions: []metav1.GroupVersionForDiscovery{
-									{GroupVersion: "extensions/v1beta1"},
-								},
-							},
-						},
-					}
-				default:
-					t.Logf("unexpected request: %s", req.URL.Path)
-					w.WriteHeader(http.StatusNotFound)
-					return
-				}
-				output, err := json.Marshal(list)
-				if err != nil {
-					t.Errorf("unexpected encoding error: %v", err)
-					return
-				}
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(http.StatusOK)
-				w.Write(output)
-			},
-		},
-		{
-			resourcesList: nil,
-			expectErr:     IsGroupDiscoveryFailedError,
-			response: func(w http.ResponseWriter, req *http.Request) {
-				var list interface{}
-				switch req.URL.Path {
-				case "/apis/extensions/v1beta1":
-					w.WriteHeader(http.StatusInternalServerError)
-					return
-				case "/api/v1":
-					w.WriteHeader(http.StatusInternalServerError)
-				case "/api":
-					list = &metav1.APIVersions{
-						Versions: []string{
-							"v1",
-						},
-					}
-				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
-							{
-								Versions: []metav1.GroupVersionForDiscovery{
-									{GroupVersion: "extensions/v1beta1"},
-								},
-							},
-						},
-					}
-				default:
-					t.Logf("unexpected request: %s", req.URL.Path)
-					w.WriteHeader(http.StatusNotFound)
-					return
-				}
-				output, err := json.Marshal(list)
-				if err != nil {
-					t.Errorf("unexpected encoding error: %v", err)
-					return
-				}
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(http.StatusOK)
-				w.Write(output)
-			},
-		},
-	}
-	for _, test := range tests {
-		server := httptest.NewServer(http.HandlerFunc(test.response))
-		defer server.Close()
-
-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-		resources, err := client.ServerPreferredResources()
-		if test.expectErr != nil {
-			if err == nil {
-				t.Error("unexpected non-error")
-			}
-
-			continue
-		}
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-			continue
-		}
-		got, err := GroupVersionResources(resources)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-			continue
-		}
-		expected, _ := GroupVersionResources(test.resourcesList)
-		if !reflect.DeepEqual(got, expected) {
-			t.Errorf("expected:\n%v\ngot:\n%v\n", test.resourcesList, got)
-		}
-		server.Close()
-	}
-}
-
-func TestServerPreferredResourcesRetries(t *testing.T) {
-	stable := metav1.APIResourceList{
-		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
-			{Name: "pods", Namespaced: true, Kind: "Pod"},
-		},
-	}
-	beta := metav1.APIResourceList{
-		GroupVersion: "extensions/v1",
-		APIResources: []metav1.APIResource{
-			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
-		},
-	}
-
-	response := func(numErrors int) http.HandlerFunc {
-		var i = 0
-		return func(w http.ResponseWriter, req *http.Request) {
-			var list interface{}
-			switch req.URL.Path {
-			case "/apis/extensions/v1beta1":
-				if i < numErrors {
-					i++
-					w.WriteHeader(http.StatusInternalServerError)
-					return
-				}
-				list = &beta
-			case "/api/v1":
-				list = &stable
-			case "/api":
-				list = &metav1.APIVersions{
-					Versions: []string{
-						"v1",
-					},
-				}
-			case "/apis":
-				list = &metav1.APIGroupList{
-					Groups: []metav1.APIGroup{
-						{
-							Name: "extensions",
-							Versions: []metav1.GroupVersionForDiscovery{
-								{GroupVersion: "extensions/v1beta1"},
-							},
-							PreferredVersion: metav1.GroupVersionForDiscovery{
-								GroupVersion: "extensions/v1beta1",
-								Version:      "v1beta1",
-							},
-						},
-					},
-				}
-			default:
-				t.Logf("unexpected request: %s", req.URL.Path)
-				w.WriteHeader(http.StatusNotFound)
-				return
-			}
-			output, err := json.Marshal(list)
-			if err != nil {
-				t.Errorf("unexpected encoding error: %v", err)
-				return
-			}
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			w.Write(output)
-		}
-	}
-	tests := []struct {
-		responseErrors  int
-		expectResources int
-		expectedError   func(err error) bool
-	}{
-		{
-			responseErrors:  1,
-			expectResources: 2,
-			expectedError: func(err error) bool {
-				return err == nil
-			},
-		},
-		{
-			responseErrors:  2,
-			expectResources: 1,
-			expectedError:   IsGroupDiscoveryFailedError,
-		},
-	}
-
-	for i, tc := range tests {
-		server := httptest.NewServer(http.HandlerFunc(response(tc.responseErrors)))
-		defer server.Close()
-
-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-		resources, err := client.ServerPreferredResources()
-		if !tc.expectedError(err) {
-			t.Errorf("case %d: unexpected error: %v", i, err)
-		}
-		got, err := GroupVersionResources(resources)
-		if err != nil {
-			t.Errorf("case %d: unexpected error: %v", i, err)
-		}
-		if len(got) != tc.expectResources {
-			t.Errorf("case %d: expect %d resources, got %#v", i, tc.expectResources, got)
-		}
-		server.Close()
-	}
-}
-
-func TestServerPreferredNamespacedResources(t *testing.T) {
-	stable := metav1.APIResourceList{
-		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
-			{Name: "pods", Namespaced: true, Kind: "Pod"},
-			{Name: "services", Namespaced: true, Kind: "Service"},
-			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
-		},
-	}
-	batchv1 := metav1.APIResourceList{
-		GroupVersion: "batch/v1",
-		APIResources: []metav1.APIResource{
-			{Name: "jobs", Namespaced: true, Kind: "Job"},
-		},
-	}
-	batchv2alpha1 := metav1.APIResourceList{
-		GroupVersion: "batch/v2alpha1",
-		APIResources: []metav1.APIResource{
-			{Name: "jobs", Namespaced: true, Kind: "Job"},
-			{Name: "cronjobs", Namespaced: true, Kind: "CronJob"},
-		},
-	}
-	batchv3alpha1 := metav1.APIResourceList{
-		GroupVersion: "batch/v3alpha1",
-		APIResources: []metav1.APIResource{
-			{Name: "jobs", Namespaced: true, Kind: "Job"},
-			{Name: "cronjobs", Namespaced: true, Kind: "CronJob"},
-		},
-	}
-	tests := []struct {
-		response func(w http.ResponseWriter, req *http.Request)
-		expected map[schema.GroupVersionResource]struct{}
-	}{
-		{
-			response: func(w http.ResponseWriter, req *http.Request) {
-				var list interface{}
-				switch req.URL.Path {
-				case "/api/v1":
-					list = &stable
-				case "/api":
-					list = &metav1.APIVersions{
-						Versions: []string{
-							"v1",
-						},
-					}
-				default:
-					t.Logf("unexpected request: %s", req.URL.Path)
-					w.WriteHeader(http.StatusNotFound)
-					return
-				}
-				output, err := json.Marshal(list)
-				if err != nil {
-					t.Errorf("unexpected encoding error: %v", err)
-					return
-				}
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(http.StatusOK)
-				w.Write(output)
-			},
-			expected: map[schema.GroupVersionResource]struct{}{
-				schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}:     {},
-				schema.GroupVersionResource{Group: "", Version: "v1", Resource: "services"}: {},
-			},
-		},
-		{
-			response: func(w http.ResponseWriter, req *http.Request) {
-				var list interface{}
-				switch req.URL.Path {
-				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
-							{
-								Name: "batch",
-								Versions: []metav1.GroupVersionForDiscovery{
-									{GroupVersion: "batch/v1", Version: "v1"},
-									{GroupVersion: "batch/v2alpha1", Version: "v2alpha1"},
-									{GroupVersion: "batch/v3alpha1", Version: "v3alpha1"},
-								},
-								PreferredVersion: metav1.GroupVersionForDiscovery{GroupVersion: "batch/v1", Version: "v1"},
-							},
-						},
-					}
-				case "/apis/batch/v1":
-					list = &batchv1
-				case "/apis/batch/v2alpha1":
-					list = &batchv2alpha1
-				case "/apis/batch/v3alpha1":
-					list = &batchv3alpha1
-				default:
-					t.Logf("unexpected request: %s", req.URL.Path)
-					w.WriteHeader(http.StatusNotFound)
-					return
-				}
-				output, err := json.Marshal(list)
-				if err != nil {
-					t.Errorf("unexpected encoding error: %v", err)
-					return
-				}
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(http.StatusOK)
-				w.Write(output)
-			},
-			expected: map[schema.GroupVersionResource]struct{}{
-				schema.GroupVersionResource{Group: "batch", Version: "v1", Resource: "jobs"}:           {},
-				schema.GroupVersionResource{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"}: {},
-			},
-		},
-		{
-			response: func(w http.ResponseWriter, req *http.Request) {
-				var list interface{}
-				switch req.URL.Path {
-				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
-							{
-								Name: "batch",
-								Versions: []metav1.GroupVersionForDiscovery{
-									{GroupVersion: "batch/v1", Version: "v1"},
-									{GroupVersion: "batch/v2alpha1", Version: "v2alpha1"},
-									{GroupVersion: "batch/v3alpha1", Version: "v3alpha1"},
-								},
-								PreferredVersion: metav1.GroupVersionForDiscovery{GroupVersion: "batch/v2alpha", Version: "v2alpha1"},
-							},
-						},
-					}
-				case "/apis/batch/v1":
-					list = &batchv1
-				case "/apis/batch/v2alpha1":
-					list = &batchv2alpha1
-				case "/apis/batch/v3alpha1":
-					list = &batchv3alpha1
-				default:
-					t.Logf("unexpected request: %s", req.URL.Path)
-					w.WriteHeader(http.StatusNotFound)
-					return
-				}
-				output, err := json.Marshal(list)
-				if err != nil {
-					t.Errorf("unexpected encoding error: %v", err)
-					return
-				}
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(http.StatusOK)
-				w.Write(output)
-			},
-			expected: map[schema.GroupVersionResource]struct{}{
-				schema.GroupVersionResource{Group: "batch", Version: "v2alpha1", Resource: "jobs"}:     {},
-				schema.GroupVersionResource{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"}: {},
-			},
-		},
-	}
-	for i, test := range tests {
-		server := httptest.NewServer(http.HandlerFunc(test.response))
-		defer server.Close()
-
-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-		resources, err := client.ServerPreferredNamespacedResources()
-		if err != nil {
-			t.Errorf("[%d] unexpected error: %v", i, err)
-			continue
-		}
-		got, err := GroupVersionResources(resources)
-		if err != nil {
-			t.Errorf("[%d] unexpected error: %v", i, err)
-			continue
-		}
-
-		if !reflect.DeepEqual(got, test.expected) {
-			t.Errorf("[%d] expected:\n%v\ngot:\n%v\n", i, test.expected, got)
-		}
-		server.Close()
-	}
-}
-
-func groupVersions(resources []*metav1.APIResourceList) []string {
-	result := []string{}
-	for _, resourceList := range resources {
-		result = append(result, resourceList.GroupVersion)
-	}
-	return result
-}

vendor/k8s.io/client-go/discovery/fake/discovery.go

@@ -1,97 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package fake
-
-import (
-	"fmt"
-
-	"github.com/emicklei/go-restful/swagger"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/version"
-	"k8s.io/client-go/pkg/api/v1"
-	kubeversion "k8s.io/client-go/pkg/version"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/testing"
-)
-
-type FakeDiscovery struct {
-	*testing.Fake
-}
-
-func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	action := testing.ActionImpl{
-		Verb:     "get",
-		Resource: schema.GroupVersionResource{Resource: "resource"},
-	}
-	c.Invokes(action, nil)
-	for _, resourceList := range c.Resources {
-		if resourceList.GroupVersion == groupVersion {
-			return resourceList, nil
-		}
-	}
-	return nil, fmt.Errorf("GroupVersion %q not found", groupVersion)
-}
-
-func (c *FakeDiscovery) ServerResources() ([]*metav1.APIResourceList, error) {
-	action := testing.ActionImpl{
-		Verb:     "get",
-		Resource: schema.GroupVersionResource{Resource: "resource"},
-	}
-	c.Invokes(action, nil)
-	return c.Resources, nil
-}
-
-func (c *FakeDiscovery) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	return nil, nil
-}
-
-func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return nil, nil
-}
-
-func (c *FakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
-	return nil, nil
-}
-
-func (c *FakeDiscovery) ServerVersion() (*version.Info, error) {
-	action := testing.ActionImpl{}
-	action.Verb = "get"
-	action.Resource = schema.GroupVersionResource{Resource: "version"}
-
-	c.Invokes(action, nil)
-	versionInfo := kubeversion.Get()
-	return &versionInfo, nil
-}
-
-func (c *FakeDiscovery) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
-	action := testing.ActionImpl{}
-	action.Verb = "get"
-	if version == v1.SchemeGroupVersion {
-		action.Resource = schema.GroupVersionResource{Resource: "/swaggerapi/api/" + version.Version}
-	} else {
-		action.Resource = schema.GroupVersionResource{Resource: "/swaggerapi/apis/" + version.Group + "/" + version.Version}
-	}
-
-	c.Invokes(action, nil)
-	return &swagger.ApiDeclaration{}, nil
-}
-
-func (c *FakeDiscovery) RESTClient() restclient.Interface {
-	return nil
-}

vendor/k8s.io/client-go/discovery/helper.go

@@ -23,8 +23,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/sets"
 	apimachineryversion "k8s.io/apimachinery/pkg/version"
-	// Import solely to initialize client auth plugins.
-	_ "k8s.io/client-go/plugin/pkg/client/auth"
 )
 
 // MatchesServerVersion queries the server to compares the build version
@@ -49,6 +47,9 @@ func MatchesServerVersion(clientVersion apimachineryversion.Info, client Discove
 //   preference.
 // - If version is provided and the server does not support it,
 //   return an error.
+// TODO negotiation should be reserved for cases where we need a version for a given group.  In those cases, it should return an ordered list of
+// server preferences.  From that list, a separate function can match from an ordered list of client versions.
+// This is not what the function has ever done before, but it makes more logical sense.
 func NegotiateVersion(client DiscoveryInterface, requiredGV *schema.GroupVersion, clientRegisteredGVs []schema.GroupVersion) (*schema.GroupVersion, error) {
 	clientVersions := sets.String{}
 	for _, gv := range clientRegisteredGVs {
@@ -104,8 +105,8 @@ func NegotiateVersion(client DiscoveryInterface, requiredGV *schema.GroupVersion
 		return &clientRegisteredGVs[0], nil
 	}
 
-	return nil, fmt.Errorf("failed to negotiate an api version; server supports: %v, client supports: %v",
-		serverVersions, clientVersions)
+	// fall back to an empty GroupVersion.  Most client commands no longer respect a GroupVersion anyway
+	return &schema.GroupVersion{}, nil
 }
 
 // GroupVersionResources converts APIResourceLists to the GroupVersionResources.

vendor/k8s.io/client-go/discovery/helper_blackbox_test.go

@@ -1,231 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package discovery_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"strings"
-	"testing"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	uapi "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/sets"
-	"k8s.io/client-go/discovery"
-	"k8s.io/client-go/pkg/api"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/rest/fake"
-
-	_ "k8s.io/client-go/pkg/api/install"
-)
-
-func objBody(object interface{}) io.ReadCloser {
-	output, err := json.MarshalIndent(object, "", "")
-	if err != nil {
-		panic(err)
-	}
-	return ioutil.NopCloser(bytes.NewReader([]byte(output)))
-}
-
-func TestNegotiateVersion(t *testing.T) {
-	tests := []struct {
-		name            string
-		requiredVersion *schema.GroupVersion
-		expectedVersion *schema.GroupVersion
-		serverVersions  []string
-		clientVersions  []schema.GroupVersion
-		expectErr       func(err error) bool
-		sendErr         error
-		statusCode      int
-	}{
-		{
-			name:            "server supports client default",
-			serverVersions:  []string{"version1", api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
-			statusCode:      http.StatusOK,
-		},
-		{
-			name:            "server falls back to client supported",
-			serverVersions:  []string{"version1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
-			statusCode:      http.StatusOK,
-		},
-		{
-			name:            "explicit version supported",
-			requiredVersion: &schema.GroupVersion{Version: "v1"},
-			serverVersions:  []string{"/version1", api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "v1"},
-			statusCode:      http.StatusOK,
-		},
-		{
-			name:            "explicit version not supported on server",
-			requiredVersion: &schema.GroupVersion{Version: "v1"},
-			serverVersions:  []string{"version1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectErr:       func(err error) bool { return strings.Contains(err.Error(), `server does not support API version "v1"`) },
-			statusCode:      http.StatusOK,
-		},
-		{
-			name:            "explicit version not supported on client",
-			requiredVersion: &schema.GroupVersion{Version: "v1"},
-			serverVersions:  []string{"v1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}},
-			expectErr:       func(err error) bool { return strings.Contains(err.Error(), `client does not support API version "v1"`) },
-			statusCode:      http.StatusOK,
-		},
-		{
-			name:           "connection refused error",
-			serverVersions: []string{"version1"},
-			clientVersions: []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			sendErr:        errors.New("connection refused"),
-			expectErr:      func(err error) bool { return strings.Contains(err.Error(), "connection refused") },
-			statusCode:     http.StatusOK,
-		},
-		{
-			name:            "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, use default GroupVersion",
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
-			statusCode:      http.StatusForbidden,
-		},
-		{
-			name:            "discovery fails due to 404 Not Found errors and thus serverVersions is empty, use requested GroupVersion",
-			requiredVersion: &schema.GroupVersion{Version: "version1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
-			statusCode:      http.StatusNotFound,
-		},
-		{
-			name:       "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, no fallback GroupVersion",
-			expectErr:  func(err error) bool { return strings.Contains(err.Error(), "failed to negotiate an api version;") },
-			statusCode: http.StatusForbidden,
-		},
-	}
-
-	for _, test := range tests {
-		fakeClient := &fake.RESTClient{
-			APIRegistry:          api.Registry,
-			NegotiatedSerializer: api.Codecs,
-			Resp: &http.Response{
-				StatusCode: test.statusCode,
-				Body:       objBody(&uapi.APIVersions{Versions: test.serverVersions}),
-			},
-			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-				if test.sendErr != nil {
-					return nil, test.sendErr
-				}
-				header := http.Header{}
-				header.Set("Content-Type", runtime.ContentTypeJSON)
-				return &http.Response{StatusCode: test.statusCode, Header: header, Body: objBody(&uapi.APIVersions{Versions: test.serverVersions})}, nil
-			}),
-		}
-		c := discovery.NewDiscoveryClientForConfigOrDie(&restclient.Config{})
-		c.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-		response, err := discovery.NegotiateVersion(c, test.requiredVersion, test.clientVersions)
-		if err == nil && test.expectErr != nil {
-			t.Errorf("expected error, got nil for [%s].", test.name)
-		}
-		if err != nil {
-			if test.expectErr == nil || !test.expectErr(err) {
-				t.Errorf("unexpected error for [%s]: %v.", test.name, err)
-			}
-			continue
-		}
-		if *response != *test.expectedVersion {
-			t.Errorf("%s: expected version %s, got %s.", test.name, test.expectedVersion, response)
-		}
-	}
-}
-
-func TestFilteredBy(t *testing.T) {
-	all := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return true
-	})
-	none := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return false
-	})
-	onlyV2 := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return strings.HasSuffix(gv, "/v2") || gv == "v2"
-	})
-	onlyBar := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return r.Kind == "Bar"
-	})
-
-	foo := []*metav1.APIResourceList{
-		{
-			GroupVersion: "foo/v1",
-			APIResources: []metav1.APIResource{
-				{Name: "bar", Kind: "Bar"},
-				{Name: "test", Kind: "Test"},
-			},
-		},
-		{
-			GroupVersion: "foo/v2",
-			APIResources: []metav1.APIResource{
-				{Name: "bar", Kind: "Bar"},
-				{Name: "test", Kind: "Test"},
-			},
-		},
-		{
-			GroupVersion: "foo/v3",
-			APIResources: []metav1.APIResource{},
-		},
-	}
-
-	tests := []struct {
-		input             []*metav1.APIResourceList
-		pred              discovery.ResourcePredicate
-		expectedResources []string
-	}{
-		{nil, all, []string{}},
-		{[]*metav1.APIResourceList{
-			{GroupVersion: "foo/v1"},
-		}, all, []string{}},
-		{foo, all, []string{"foo/v1.bar", "foo/v1.test", "foo/v2.bar", "foo/v2.test"}},
-		{foo, onlyV2, []string{"foo/v2.bar", "foo/v2.test"}},
-		{foo, onlyBar, []string{"foo/v1.bar", "foo/v2.bar"}},
-		{foo, none, []string{}},
-	}
-	for i, test := range tests {
-		filtered := discovery.FilteredBy(test.pred, test.input)
-
-		if expected, got := sets.NewString(test.expectedResources...), sets.NewString(stringify(filtered)...); !expected.Equal(got) {
-			t.Errorf("[%d] unexpected group versions: expected=%v, got=%v", i, test.expectedResources, stringify(filtered))
-		}
-	}
-}
-
-func stringify(rls []*metav1.APIResourceList) []string {
-	result := []string{}
-	for _, rl := range rls {
-		for _, r := range rl.APIResources {
-			result = append(result, rl.GroupVersion+"."+r.Name)
-		}
-		if len(rl.APIResources) == 0 {
-			result = append(result, rl.GroupVersion)
-		}
-	}
-	return result
-}

vendor/k8s.io/client-go/discovery/restmapper.go

@@ -43,8 +43,9 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 	unionMapper := meta.MultiRESTMapper{}
 
 	var groupPriority []string
-	var resourcePriority []schema.GroupVersionResource
-	var kindPriority []schema.GroupVersionKind
+	// /v1 is special.  It should always come first
+	resourcePriority := []schema.GroupVersionResource{{Group: "", Version: "v1", Resource: meta.AnyResource}}
+	kindPriority := []schema.GroupVersionKind{{Group: "", Version: "v1", Kind: meta.AnyKind}}
 
 	for _, group := range groupResources {
 		groupPriority = append(groupPriority, group.Group.Name)

vendor/k8s.io/client-go/discovery/restmapper_test.go

@@ -1,330 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package discovery_test
-
-import (
-	"reflect"
-	"testing"
-
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/version"
-	. "k8s.io/client-go/discovery"
-	"k8s.io/client-go/pkg/api"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/rest/fake"
-
-	"github.com/emicklei/go-restful/swagger"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestRESTMapper(t *testing.T) {
-	resources := []*APIGroupResources{
-		{
-			Group: metav1.APIGroup{
-				Versions: []metav1.GroupVersionForDiscovery{
-					{Version: "v1"},
-					{Version: "v2"},
-				},
-				PreferredVersion: metav1.GroupVersionForDiscovery{Version: "v1"},
-			},
-			VersionedResources: map[string][]metav1.APIResource{
-				"v1": {
-					{Name: "pods", Namespaced: true, Kind: "Pod"},
-				},
-				"v2": {
-					{Name: "pods", Namespaced: true, Kind: "Pod"},
-				},
-			},
-		},
-		{
-			Group: metav1.APIGroup{
-				Name: "extensions",
-				Versions: []metav1.GroupVersionForDiscovery{
-					{Version: "v1beta"},
-				},
-				PreferredVersion: metav1.GroupVersionForDiscovery{Version: "v1beta"},
-			},
-			VersionedResources: map[string][]metav1.APIResource{
-				"v1beta": {
-					{Name: "jobs", Namespaced: true, Kind: "Job"},
-				},
-			},
-		},
-	}
-
-	restMapper := NewRESTMapper(resources, nil)
-
-	kindTCs := []struct {
-		input schema.GroupVersionResource
-		want  schema.GroupVersionKind
-	}{
-		{
-			input: schema.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-			want: schema.GroupVersionKind{
-				Version: "v1",
-				Kind:    "Pod",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
-				Version:  "v2",
-				Resource: "pods",
-			},
-			want: schema.GroupVersionKind{
-				Version: "v2",
-				Kind:    "Pod",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
-				Resource: "pods",
-			},
-			want: schema.GroupVersionKind{
-				Version: "v1",
-				Kind:    "Pod",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
-				Resource: "jobs",
-			},
-			want: schema.GroupVersionKind{
-				Group:   "extensions",
-				Version: "v1beta",
-				Kind:    "Job",
-			},
-		},
-	}
-
-	for _, tc := range kindTCs {
-		got, err := restMapper.KindFor(tc.input)
-		if err != nil {
-			t.Errorf("KindFor(%#v) unexpected error: %v", tc.input, err)
-			continue
-		}
-
-		if !reflect.DeepEqual(got, tc.want) {
-			t.Errorf("KindFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
-		}
-	}
-
-	resourceTCs := []struct {
-		input schema.GroupVersionResource
-		want  schema.GroupVersionResource
-	}{
-		{
-			input: schema.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-			want: schema.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
-				Version:  "v2",
-				Resource: "pods",
-			},
-			want: schema.GroupVersionResource{
-				Version:  "v2",
-				Resource: "pods",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
-				Resource: "pods",
-			},
-			want: schema.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
-				Resource: "jobs",
-			},
-			want: schema.GroupVersionResource{
-				Group:    "extensions",
-				Version:  "v1beta",
-				Resource: "jobs",
-			},
-		},
-	}
-
-	for _, tc := range resourceTCs {
-		got, err := restMapper.ResourceFor(tc.input)
-		if err != nil {
-			t.Errorf("ResourceFor(%#v) unexpected error: %v", tc.input, err)
-			continue
-		}
-
-		if !reflect.DeepEqual(got, tc.want) {
-			t.Errorf("ResourceFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
-		}
-	}
-}
-
-func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
-	assert := assert.New(t)
-
-	cdc := fakeCachedDiscoveryInterface{fresh: false}
-	m := NewDeferredDiscoveryRESTMapper(&cdc, api.Registry.InterfacesFor)
-	assert.False(cdc.fresh, "should NOT be fresh after instantiation")
-	assert.Zero(cdc.invalidateCalls, "should not have called Invalidate()")
-
-	gvk, err := m.KindFor(schema.GroupVersionResource{
-		Group:    "a",
-		Version:  "v1",
-		Resource: "foo",
-	})
-	assert.NoError(err)
-	assert.True(cdc.fresh, "should be fresh after a cache-miss")
-	assert.Equal(cdc.invalidateCalls, 1, "should have called Invalidate() once")
-	assert.Equal(gvk.Kind, "Foo")
-
-	gvk, err = m.KindFor(schema.GroupVersionResource{
-		Group:    "a",
-		Version:  "v1",
-		Resource: "foo",
-	})
-	assert.NoError(err)
-	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again")
-
-	gvk, err = m.KindFor(schema.GroupVersionResource{
-		Group:    "a",
-		Version:  "v1",
-		Resource: "bar",
-	})
-	assert.Error(err)
-	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again after another cache-miss, but with fresh==true")
-
-	cdc.fresh = false
-	gvk, err = m.KindFor(schema.GroupVersionResource{
-		Group:    "a",
-		Version:  "v1",
-		Resource: "bar",
-	})
-	assert.Error(err)
-	assert.Equal(cdc.invalidateCalls, 2, "should HAVE called Invalidate() again after another cache-miss, but with fresh==false")
-}
-
-type fakeCachedDiscoveryInterface struct {
-	invalidateCalls int
-	fresh           bool
-	enabledA        bool
-}
-
-var _ CachedDiscoveryInterface = &fakeCachedDiscoveryInterface{}
-
-func (c *fakeCachedDiscoveryInterface) Fresh() bool {
-	return c.fresh
-}
-
-func (c *fakeCachedDiscoveryInterface) Invalidate() {
-	c.invalidateCalls = c.invalidateCalls + 1
-	c.fresh = true
-	c.enabledA = true
-}
-
-func (c *fakeCachedDiscoveryInterface) RESTClient() restclient.Interface {
-	return &fake.RESTClient{}
-}
-
-func (c *fakeCachedDiscoveryInterface) ServerGroups() (*metav1.APIGroupList, error) {
-	if c.enabledA {
-		return &metav1.APIGroupList{
-			Groups: []metav1.APIGroup{
-				{
-					Name: "a",
-					Versions: []metav1.GroupVersionForDiscovery{
-						{
-							GroupVersion: "a/v1",
-							Version:      "v1",
-						},
-					},
-					PreferredVersion: metav1.GroupVersionForDiscovery{
-						GroupVersion: "a/v1",
-						Version:      "v1",
-					},
-				},
-			},
-		}, nil
-	}
-	return &metav1.APIGroupList{}, nil
-}
-
-func (c *fakeCachedDiscoveryInterface) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	if c.enabledA && groupVersion == "a/v1" {
-		return &metav1.APIResourceList{
-			GroupVersion: "a/v1",
-			APIResources: []metav1.APIResource{
-				{
-					Name:       "foo",
-					Kind:       "Foo",
-					Namespaced: false,
-				},
-			},
-		}, nil
-	}
-
-	return nil, errors.NewNotFound(schema.GroupResource{}, "")
-}
-
-func (c *fakeCachedDiscoveryInterface) ServerResources() ([]*metav1.APIResourceList, error) {
-	if c.enabledA {
-		av1, _ := c.ServerResourcesForGroupVersion("a/v1")
-		return []*metav1.APIResourceList{av1}, nil
-	}
-	return []*metav1.APIResourceList{}, nil
-}
-
-func (c *fakeCachedDiscoveryInterface) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	if c.enabledA {
-		return []*metav1.APIResourceList{
-			{
-				GroupVersion: "a/v1",
-				APIResources: []metav1.APIResource{
-					{
-						Name:  "foo",
-						Kind:  "Foo",
-						Verbs: []string{},
-					},
-				},
-			},
-		}, nil
-	}
-	return nil, nil
-}
-
-func (c *fakeCachedDiscoveryInterface) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return nil, nil
-}
-
-func (c *fakeCachedDiscoveryInterface) ServerVersion() (*version.Info, error) {
-	return &version.Info{}, nil
-}
-
-func (c *fakeCachedDiscoveryInterface) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
-	return &swagger.ApiDeclaration{}, nil
-}