openapi: refactor into more generic structure

pkg/kubectl/cmd/BUILD

@@ -217,7 +217,6 @@ go_test(
         "//pkg/printers/internalversion:go_default_library",
         "//pkg/util/i18n:go_default_library",
         "//pkg/util/strings:go_default_library",
-        "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/github.com/spf13/cobra:go_default_library",
         "//vendor/github.com/stretchr/testify/assert:go_default_library",
         "//vendor/gopkg.in/yaml.v2:go_default_library",

pkg/kubectl/cmd/get.go

@@ -566,13 +566,13 @@ func outputOptsForMappingFromOpenAPI(f cmdutil.Factory, openAPIcacheDir string,
 		return nil, false
 	}
 	// Found openapi metadata for this resource
-	kind, found := api.LookupResource(mapping.GroupVersionKind)
-	if !found {
-		// Kind not found, return empty columns
+	schema := api.LookupResource(mapping.GroupVersionKind)
+	if schema == nil {
+		// Schema not found, return empty columns
 		return nil, false
 	}
 
-	columns, found := openapi.GetPrintColumns(kind.Extensions)
+	columns, found := openapi.GetPrintColumns(schema.GetExtensions())
 	if !found {
 		// Extension not found, return empty columns
 		return nil, false

pkg/kubectl/cmd/get_test.go

@@ -26,8 +26,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/go-openapi/spec"
-
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -218,20 +216,27 @@ func TestGetObjectsWithOpenAPIOutputFormatPresent(t *testing.T) {
 	}
 }
 
-func testOpenAPISchemaData() (*openapi.Resources, error) {
-	return &openapi.Resources{
-		GroupVersionKindToName: map[schema.GroupVersionKind]string{
+type FakeResources struct {
+	resources map[schema.GroupVersionKind]openapi.Schema
+}
+
+func (f FakeResources) LookupResource(s schema.GroupVersionKind) openapi.Schema {
+	return f.resources[s]
+}
+
+var _ openapi.Resources = &FakeResources{}
+
+func testOpenAPISchemaData() (openapi.Resources, error) {
+	return &FakeResources{
+		resources: map[schema.GroupVersionKind]openapi.Schema{
 			{
 				Version: "v1",
 				Kind:    "Pod",
-			}: "io.k8s.kubernetes.pkg.api.v1.Pod",
-		},
-		NameToDefinition: map[string]openapi.Kind{
-			"io.k8s.kubernetes.pkg.api.v1.Pod": {
-				Name:       "io.k8s.kubernetes.pkg.api.v1.Pod",
-				IsResource: false,
-				Extensions: spec.Extensions{
-					"x-kubernetes-print-columns": "custom-columns=NAME:.metadata.name,RSRC:.metadata.resourceVersion",
+			}: &openapi.Primitive{
+				BaseSchema: openapi.BaseSchema{
+					Extensions: map[string]interface{}{
+						"x-kubernetes-print-columns": "custom-columns=NAME:.metadata.name,RSRC:.metadata.resourceVersion",
+					},
 				},
 			},
 		},

pkg/kubectl/cmd/testing/fake.go

@@ -243,7 +243,7 @@ type TestFactory struct {
 
 	ClientForMappingFunc             func(mapping *meta.RESTMapping) (resource.RESTClient, error)
 	UnstructuredClientForMappingFunc func(mapping *meta.RESTMapping) (resource.RESTClient, error)
-	OpenAPISchemaFunc                func() (*openapi.Resources, error)
+	OpenAPISchemaFunc                func() (openapi.Resources, error)
 }
 
 type FakeFactory struct {
@@ -418,8 +418,8 @@ func (f *FakeFactory) SwaggerSchema(schema.GroupVersionKind) (*swagger.ApiDeclar
 	return nil, nil
 }
 
-func (f *FakeFactory) OpenAPISchema(cacheDir string) (*openapi.Resources, error) {
-	return &openapi.Resources{}, nil
+func (f *FakeFactory) OpenAPISchema(cacheDir string) (openapi.Resources, error) {
+	return nil, nil
 }
 
 func (f *FakeFactory) DefaultNamespace() (string, bool, error) {
@@ -756,11 +756,11 @@ func (f *fakeAPIFactory) SwaggerSchema(schema.GroupVersionKind) (*swagger.ApiDec
 	return nil, nil
 }
 
-func (f *fakeAPIFactory) OpenAPISchema(cacheDir string) (*openapi.Resources, error) {
+func (f *fakeAPIFactory) OpenAPISchema(cacheDir string) (openapi.Resources, error) {
 	if f.tf.OpenAPISchemaFunc != nil {
 		return f.tf.OpenAPISchemaFunc()
 	}
-	return &openapi.Resources{}, nil
+	return nil, nil
 }
 
 func NewAPIFactory() (cmdutil.Factory, *TestFactory, runtime.Codec, runtime.NegotiatedSerializer) {

pkg/kubectl/cmd/util/factory.go

@@ -224,7 +224,7 @@ type ObjectMappingFactory interface {
 	// SwaggerSchema returns the schema declaration for the provided group version kind.
 	SwaggerSchema(schema.GroupVersionKind) (*swagger.ApiDeclaration, error)
 	// OpenAPISchema returns the schema openapi schema definiton
-	OpenAPISchema(cacheDir string) (*openapi.Resources, error)
+	OpenAPISchema(cacheDir string) (openapi.Resources, error)
 }
 
 // BuilderFactory holds the second level of factory methods.  These functions depend upon ObjectMappingFactory and ClientAccessFactory methods.

pkg/kubectl/cmd/util/factory_object_mapping.go

@@ -445,7 +445,7 @@ func (f *ring1Factory) SwaggerSchema(gvk schema.GroupVersionKind) (*swagger.ApiD
 // schema will be cached separately for different client / server combinations.
 // Note, the cache will not be invalidated if the server changes its open API schema without
 // changing the server version.
-func (f *ring1Factory) OpenAPISchema(cacheDir string) (*openapi.Resources, error) {
+func (f *ring1Factory) OpenAPISchema(cacheDir string) (openapi.Resources, error) {
 	discovery, err := f.clientAccessFactory.DiscoveryClient()
 	if err != nil {
 		return nil, err

pkg/kubectl/cmd/util/openapi/BUILD

@@ -12,6 +12,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "doc.go",
+        "document.go",
         "extensions.go",
         "openapi.go",
         "openapi_cache.go",
@@ -22,10 +23,10 @@ go_library(
         "//pkg/version:go_default_library",
         "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/golang/protobuf/proto:go_default_library",
         "//vendor/github.com/googleapis/gnostic/OpenAPIv2:go_default_library",
         "//vendor/gopkg.in/yaml.v2:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//vendor/k8s.io/client-go/discovery:go_default_library",
     ],
 )
@@ -43,7 +44,6 @@ go_test(
     tags = ["automanaged"],
     deps = [
         "//pkg/kubectl/cmd/util/openapi:go_default_library",
-        "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/github.com/googleapis/gnostic/OpenAPIv2:go_default_library",
         "//vendor/github.com/googleapis/gnostic/compiler:go_default_library",
         "//vendor/github.com/onsi/ginkgo:go_default_library",

pkg/kubectl/cmd/util/openapi/document.go

+/*
+Copyright 2017 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 openapi
+
+import (
+	"fmt"
+	"strings"
+
+	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
+	yaml "gopkg.in/yaml.v2"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+func newSchemaError(path *Path, format string, a ...interface{}) error {
+	err := fmt.Sprintf(format, a...)
+	if path.Len() == 0 {
+		return fmt.Errorf("SchemaError: %v", err)
+	}
+	return fmt.Errorf("SchemaError(%v): %v", path, err)
+}
+
+// groupVersionKindExtensionKey is the key used to lookup the
+// GroupVersionKind value for an object definition from the
+// definition's "extensions" map.
+const groupVersionKindExtensionKey = "x-kubernetes-group-version-kind"
+
+func vendorExtensionToMap(e []*openapi_v2.NamedAny) map[string]interface{} {
+	values := map[string]interface{}{}
+
+	for _, na := range e {
+		if na.GetName() == "" || na.GetValue() == nil {
+			continue
+		}
+		if na.GetValue().GetYaml() == "" {
+			continue
+		}
+		var value interface{}
+		err := yaml.Unmarshal([]byte(na.GetValue().GetYaml()), &value)
+		if err != nil {
+			continue
+		}
+
+		values[na.GetName()] = value
+	}
+
+	return values
+}
+
+// Get and parse GroupVersionKind from the extension. Returns empty if it doesn't have one.
+func parseGroupVersionKind(s *openapi_v2.Schema) schema.GroupVersionKind {
+	extensionMap := vendorExtensionToMap(s.GetVendorExtension())
+
+	// Get the extensions
+	gvkExtension, ok := extensionMap[groupVersionKindExtensionKey]
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+
+	// gvk extension must be a list of 1 element.
+	gvkList, ok := gvkExtension.([]interface{})
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	if len(gvkList) != 1 {
+		return schema.GroupVersionKind{}
+
+	}
+	gvk := gvkList[0]
+
+	// gvk extension list must be a map with group, version, and
+	// kind fields
+	gvkMap, ok := gvk.(map[interface{}]interface{})
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	group, ok := gvkMap["group"].(string)
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	version, ok := gvkMap["version"].(string)
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+	kind, ok := gvkMap["kind"].(string)
+	if !ok {
+		return schema.GroupVersionKind{}
+	}
+
+	return schema.GroupVersionKind{
+		Group:   group,
+		Version: version,
+		Kind:    kind,
+	}
+}
+
+// Definitions is an implementation of `Resources`. It looks for
+// resources in an openapi Schema.
+type Definitions struct {
+	models    map[string]Schema
+	resources map[schema.GroupVersionKind]string
+}
+
+var _ Resources = &Definitions{}
+
+// NewOpenAPIData creates a new `Resources` out of the openapi document.
+func NewOpenAPIData(doc *openapi_v2.Document) (Resources, error) {
+	definitions := Definitions{
+		models:    map[string]Schema{},
+		resources: map[schema.GroupVersionKind]string{},
+	}
+
+	// Save the list of all models first. This will allow us to
+	// validate that we don't have any dangling reference.
+	for _, namedSchema := range doc.GetDefinitions().GetAdditionalProperties() {
+		definitions.models[namedSchema.GetName()] = nil
+	}
+
+	// Now, parse each model. We can validate that references exists.
+	for _, namedSchema := range doc.GetDefinitions().GetAdditionalProperties() {
+		schema, err := definitions.ParseSchema(namedSchema.GetValue(), &Path{key: namedSchema.GetName()})
+		if err != nil {
+			return nil, err
+		}
+		definitions.models[namedSchema.GetName()] = schema
+		gvk := parseGroupVersionKind(namedSchema.GetValue())
+		if len(gvk.Kind) > 0 {
+			definitions.resources[gvk] = namedSchema.GetName()
+		}
+	}
+
+	return &definitions, nil
+}
+
+// We believe the schema is a reference, verify that and returns a new
+// Schema
+func (d *Definitions) parseReference(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetProperties().GetAdditionalProperties()) > 0 {
+		return nil, newSchemaError(path, "unallowed embedded type definition")
+	}
+	if len(s.GetType().GetValue()) > 0 {
+		return nil, newSchemaError(path, "definition reference can't have a type")
+	}
+
+	if !strings.HasPrefix(s.GetXRef(), "#/definitions/") {
+		return nil, newSchemaError(path, "unallowed reference to non-definition %q", s.GetXRef())
+	}
+	reference := strings.TrimPrefix(s.GetXRef(), "#/definitions/")
+	if _, ok := d.models[reference]; !ok {
+		return nil, newSchemaError(path, "unknown model in reference: %q", reference)
+	}
+	return &Reference{
+		Reference:   reference,
+		definitions: d,
+	}, nil
+}
+
+func (d *Definitions) parseBaseSchema(s *openapi_v2.Schema, path *Path) BaseSchema {
+	return BaseSchema{
+		Description: s.GetDescription(),
+		Extensions:  vendorExtensionToMap(s.GetVendorExtension()),
+		Path:        *path,
+	}
+}
+
+// We believe the schema is a map, verify and return a new schema
+func (d *Definitions) parseMap(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) != 0 && s.GetType().GetValue()[0] != object {
+		return nil, newSchemaError(path, "invalid object type")
+	}
+	if s.GetAdditionalProperties().GetSchema() == nil {
+		return nil, newSchemaError(path, "invalid object doesn't have additional properties")
+	}
+	sub, err := d.ParseSchema(s.GetAdditionalProperties().GetSchema(), path)
+	if err != nil {
+		return nil, err
+	}
+	return &Map{
+		BaseSchema: d.parseBaseSchema(s, path),
+		SubType:    sub,
+	}, nil
+}
+
+func (d *Definitions) parsePrimitive(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	var t string
+	if len(s.GetType().GetValue()) > 1 {
+		return nil, newSchemaError(path, "primitive can't have more than 1 type")
+	}
+	if len(s.GetType().GetValue()) == 1 {
+		t = s.GetType().GetValue()[0]
+	}
+	switch t {
+	case String:
+	case Number:
+	case Integer:
+	case Boolean:
+	case "": // Some models are completely empty, and can be safely ignored.
+		// Do nothing
+	default:
+		return nil, newSchemaError(path, "Unknown primitive type: %q", t)
+	}
+	return &Primitive{
+		BaseSchema: d.parseBaseSchema(s, path),
+		Type:       t,
+		Format:     s.GetFormat(),
+	}, nil
+}
+
+func (d *Definitions) parseArray(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) != 1 {
+		return nil, newSchemaError(path, "array should have exactly one type")
+	}
+	if s.GetType().GetValue()[0] != array {
+		return nil, newSchemaError(path, `array should have type "array"`)
+	}
+	if len(s.GetItems().GetSchema()) != 1 {
+		return nil, newSchemaError(path, "array should have exactly one sub-item")
+	}
+	sub, err := d.ParseSchema(s.GetItems().GetSchema()[0], path)
+	if err != nil {
+		return nil, err
+	}
+	return &Array{
+		BaseSchema: d.parseBaseSchema(s, path),
+		SubType:    sub,
+	}, nil
+}
+
+func (d *Definitions) parseKind(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) != 0 && s.GetType().GetValue()[0] != object {
+		return nil, newSchemaError(path, "invalid object type")
+	}
+	if s.GetProperties() == nil {
+		return nil, newSchemaError(path, "object doesn't have properties")
+	}
+
+	fields := map[string]Schema{}
+
+	for _, namedSchema := range s.GetProperties().GetAdditionalProperties() {
+		var err error
+		fields[namedSchema.GetName()], err = d.ParseSchema(namedSchema.GetValue(), &Path{parent: path, key: namedSchema.GetName()})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &Kind{
+		BaseSchema:     d.parseBaseSchema(s, path),
+		RequiredFields: s.GetRequired(),
+		Fields:         fields,
+	}, nil
+}
+
+// ParseSchema creates a walkable Schema from an openapi schema. While
+// this function is public, it doesn't leak through the interface.
+func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	if len(s.GetType().GetValue()) == 1 {
+		t := s.GetType().GetValue()[0]
+		switch t {
+		case object:
+			return d.parseMap(s, path)
+		case array:
+			return d.parseArray(s, path)
+		}
+
+	}
+	if s.GetXRef() != "" {
+		return d.parseReference(s, path)
+	}
+	if s.GetProperties() != nil {
+		return d.parseKind(s, path)
+	}
+	return d.parsePrimitive(s, path)
+}
+
+// LookupResource is public through the interface of Resources. It
+// returns a visitable schema from the given group-version-kind.
+func (d *Definitions) LookupResource(gvk schema.GroupVersionKind) Schema {
+	modelName, found := d.resources[gvk]
+	if !found {
+		return nil
+	}
+	model, found := d.models[modelName]
+	if !found {
+		return nil
+	}
+	return model
+}
+
+// SchemaReference doesn't match a specific type. It's mostly a
+// pass-through type.
+type Reference struct {
+	Reference string
+
+	definitions *Definitions
+}
+
+var _ Schema = &Reference{}
+
+func (r *Reference) GetSubSchema() Schema {
+	return r.definitions.models[r.Reference]
+}
+
+func (r *Reference) Accept(s SchemaVisitor) {
+	r.GetSubSchema().Accept(s)
+}
+
+func (r *Reference) GetDescription() string {
+	return r.GetSubSchema().GetDescription()
+}
+
+func (r *Reference) GetExtensions() map[string]interface{} {
+	return r.GetSubSchema().GetExtensions()
+}
+
+func (*Reference) GetPath() *Path {
+	// Reference never has a path, because it can be referenced from
+	// multiple locations.
+	return &Path{}
+}
+
+func (r *Reference) GetName() string {
+	return r.Reference
+}

pkg/kubectl/cmd/util/openapi/openapi_cache.go

@@ -18,7 +18,6 @@ package openapi
 
 import (
 	"bytes"
-	"encoding/gob"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -26,15 +25,13 @@ import (
 	"path/filepath"
 
 	"github.com/golang/glog"
+	"github.com/golang/protobuf/proto"
+	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
 
 	"k8s.io/client-go/discovery"
 	"k8s.io/kubernetes/pkg/version"
 )
 
-func init() {
-	registerBinaryEncodingTypes()
-}
-
 const openapiFileName = "openapi_cache"
 
 type CachingOpenAPIClient struct {
@@ -61,12 +58,12 @@ func NewCachingOpenAPIClient(client discovery.OpenAPISchemaInterface, version, c
 // It will first attempt to read the spec from a local cache
 // If it cannot read a local cache, it will read the file
 // using the client and then write the cache.
-func (c *CachingOpenAPIClient) OpenAPIData() (*Resources, error) {
+func (c *CachingOpenAPIClient) OpenAPIData() (Resources, error) {
 	// Try to use the cached version
 	if c.useCache() {
 		doc, err := c.readOpenAPICache()
 		if err == nil {
-			return doc, nil
+			return NewOpenAPIData(doc)
 		}
 	}
 
@@ -85,7 +82,7 @@ func (c *CachingOpenAPIClient) OpenAPIData() (*Resources, error) {
 
 	// Try to cache the openapi spec
 	if c.useCache() {
-		err = c.writeToCache(oa)
+		err = c.writeToCache(s)
 		if err != nil {
 			// Just log an message, no need to fail the command since we got the data we need
 			glog.V(2).Infof("Unable to cache openapi spec %v", err)
@@ -102,7 +99,7 @@ func (c *CachingOpenAPIClient) useCache() bool {
 }
 
 // readOpenAPICache tries to read the openapi spec from the local file cache
-func (c *CachingOpenAPIClient) readOpenAPICache() (*Resources, error) {
+func (c *CachingOpenAPIClient) readOpenAPICache() (*openapi_v2.Document, error) {
 	// Get the filename to read
 	filename := c.openAPICacheFilename()
 
@@ -112,38 +109,18 @@ func (c *CachingOpenAPIClient) readOpenAPICache() (*Resources, error) {
 		return nil, err
 	}
 
-	// Decode the openapi spec
-	s, err := c.decodeSpec(data)
-
-	return s, err
-}
-
-// decodeSpec binary decodes the openapi spec
-func (c *CachingOpenAPIClient) decodeSpec(data []byte) (*Resources, error) {
-	b := bytes.NewBuffer(data)
-	d := gob.NewDecoder(b)
-	parsed := &Resources{}
-	err := d.Decode(parsed)
-	return parsed, err
-}
-
-// encodeSpec binary encodes the openapi spec
-func (c *CachingOpenAPIClient) encodeSpec(parsed *Resources) ([]byte, error) {
-	b := &bytes.Buffer{}
-	e := gob.NewEncoder(b)
-	err := e.Encode(parsed)
-	return b.Bytes(), err
-
+	doc := &openapi_v2.Document{}
+	return doc, proto.Unmarshal(data, doc)
 }
 
 // writeToCache tries to write the openapi spec to the local file cache.
 // writes the data to a new tempfile, and then links the cache file and the tempfile
-func (c *CachingOpenAPIClient) writeToCache(parsed *Resources) error {
+func (c *CachingOpenAPIClient) writeToCache(doc *openapi_v2.Document) error {
 	// Get the constant filename used to read the cache.
 	cacheFile := c.openAPICacheFilename()
 
 	// Binary encode the spec.  This is 10x as fast as using json encoding.  (60ms vs 600ms)
-	b, err := c.encodeSpec(parsed)
+	b, err := proto.Marshal(doc)
 	if err != nil {
 		return fmt.Errorf("Could not binary encode openapi spec: %v", err)
 	}
@@ -184,9 +161,3 @@ func linkFiles(old, new string) error {
 	}
 	return nil
 }
-
-// registerBinaryEncodingTypes registers the types so they can be binary encoded by gob
-func registerBinaryEncodingTypes() {
-	gob.Register(map[interface{}]interface{}{})
-	gob.Register([]interface{}{})
-}

pkg/kubectl/cmd/util/openapi/openapi_cache_test.go

@@ -38,7 +38,7 @@ var _ = Describe("When reading openAPIData", func() {
 	var err error
 	var client *fakeOpenAPIClient
 	var instance *openapi.CachingOpenAPIClient
-	var expectedData *openapi.Resources
+	var expectedData openapi.Resources
 
 	BeforeEach(func() {
 		tmpDir, err = ioutil.TempDir("", "openapi_cache_test")
@@ -61,7 +61,7 @@ var _ = Describe("When reading openAPIData", func() {
 		By("getting the live openapi spec from the server")
 		result, err := instance.OpenAPIData()
 		Expect(err).To(BeNil())
-		expectEqual(result, expectedData)
+		Expect(result).To(Equal(expectedData))
 		Expect(client.calls).To(Equal(1))
 
 		By("writing the live openapi spec to a local cache file")
@@ -83,13 +83,13 @@ var _ = Describe("When reading openAPIData", func() {
 		// First call should use the client
 		result, err := instance.OpenAPIData()
 		Expect(err).To(BeNil())
-		expectEqual(result, expectedData)
+		Expect(result).To(Equal(expectedData))
 		Expect(client.calls).To(Equal(1))
 
 		// Second call shouldn't use the client
 		result, err = instance.OpenAPIData()
 		Expect(err).To(BeNil())
-		expectEqual(result, expectedData)
+		Expect(result).To(Equal(expectedData))
 		Expect(client.calls).To(Equal(1))
 
 		names, err := getFilenames(tmpDir)
@@ -153,7 +153,7 @@ var _ = Describe("Reading openAPIData", func() {
 			By("getting the live openapi schema")
 			result, err := instance.OpenAPIData()
 			Expect(err).To(BeNil())
-			expectEqual(result, expectedData)
+			Expect(result).To(Equal(expectedData))
 			Expect(client.calls).To(Equal(1))
 
 			files, err := ioutil.ReadDir(tmpDir)
@@ -181,7 +181,7 @@ var _ = Describe("Reading openAPIData", func() {
 			By("getting the live openapi schema")
 			result, err := instance.OpenAPIData()
 			Expect(err).To(BeNil())
-			expectEqual(result, expectedData)
+			Expect(result).To(Equal(expectedData))
 			Expect(client.calls).To(Equal(1))
 
 			files, err := ioutil.ReadDir(tmpDir)
@@ -204,19 +204,6 @@ func getFilenames(path string) ([]string, error) {
 	return result, nil
 }
 
-func expectEqual(a *openapi.Resources, b *openapi.Resources) {
-	Expect(a.NameToDefinition).To(HaveLen(len(b.NameToDefinition)))
-	for k, v := range a.NameToDefinition {
-		Expect(v).To(Equal(b.NameToDefinition[k]),
-			fmt.Sprintf("Names for GVK do not match %v", k))
-	}
-	Expect(a.GroupVersionKindToName).To(HaveLen(len(b.GroupVersionKindToName)))
-	for k, v := range a.GroupVersionKindToName {
-		Expect(v).To(Equal(b.GroupVersionKindToName[k]),
-			fmt.Sprintf("Values for name do not match %v", k))
-	}
-}
-
 type fakeOpenAPIClient struct {
 	calls int
 	err   error
@@ -276,5 +263,6 @@ func (d *apiData) OpenAPISchema() (*openapi_v2.Document, error) {
 		}
 		d.data, d.err = openapi_v2.NewDocument(info, compiler.NewContext("$root", nil))
 	})
+
 	return d.data, d.err
 }

pkg/kubectl/cmd/util/openapi/openapi_getter.go

@@ -26,7 +26,7 @@ import (
 type synchronizedOpenAPIGetter struct {
 	// Cached results
 	sync.Once
-	openAPISchema *Resources
+	openAPISchema Resources
 	err           error
 
 	serverVersion string
@@ -39,7 +39,7 @@ var _ Getter = &synchronizedOpenAPIGetter{}
 // Getter is an interface for fetching openapi specs and parsing them into an Resources struct
 type Getter interface {
 	// OpenAPIData returns the parsed OpenAPIData
-	Get() (*Resources, error)
+	Get() (Resources, error)
 }
 
 // NewOpenAPIGetter returns an object to return OpenAPIDatas which either read from a
@@ -53,7 +53,7 @@ func NewOpenAPIGetter(cacheDir, serverVersion string, openAPIClient discovery.Op
 }
 
 // Resources implements Getter
-func (g *synchronizedOpenAPIGetter) Get() (*Resources, error) {
+func (g *synchronizedOpenAPIGetter) Get() (Resources, error) {
 	g.Do(func() {
 		client := NewCachingOpenAPIClient(g.openAPIClient, g.serverVersion, g.cacheDir)
 		result, err := client.OpenAPIData()

pkg/kubectl/cmd/util/openapi/openapi_getter_test.go

@@ -27,7 +27,7 @@ import (
 
 var _ = Describe("Getting the Resources", func() {
 	var client *fakeOpenAPIClient
-	var expectedData *openapi.Resources
+	var expectedData openapi.Resources
 	var instance openapi.Getter
 
 	BeforeEach(func() {
@@ -47,12 +47,12 @@ var _ = Describe("Getting the Resources", func() {
 
 			result, err := instance.Get()
 			Expect(err).To(BeNil())
-			expectEqual(result, expectedData)
+			Expect(result).To(Equal(expectedData))
 			Expect(client.calls).To(Equal(1))
 
 			result, err = instance.Get()
 			Expect(err).To(BeNil())
-			expectEqual(result, expectedData)
+			Expect(result).To(Equal(expectedData))
 			// No additional client calls expected
 			Expect(client.calls).To(Equal(1))
 		})