Replace openapi Fake with kube-openapi version

There are two version of this fake class, let's just use that one
version.

vendor/k8s.io/kube-openapi/pkg/handler/handler.go

@@ -58,7 +58,6 @@ type OpenAPIService struct {
 	// rwMutex protects All members of this service.
 	rwMutex sync.RWMutex
 
-	orgSpec      *spec.Swagger
 	lastModified time.Time
 
 	specBytes []byte
@@ -161,7 +160,6 @@ func (o *OpenAPIService) getSwaggerPbGzBytes() ([]byte, string, time.Time) {
 }
 
 func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
-	orgSpec := openapiSpec
 	specBytes, err := json.MarshalIndent(openapiSpec, " ", " ")
 	if err != nil {
 		return err
@@ -181,7 +179,6 @@ func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
 	o.rwMutex.Lock()
 	defer o.rwMutex.Unlock()
 
-	o.orgSpec = orgSpec
 	o.specBytes = specBytes
 	o.specPb = specPb
 	o.specPbGz = specPbGz

vendor/k8s.io/kube-openapi/pkg/util/proto/BUILD

@@ -26,6 +26,7 @@ filegroup(
     name = "all-srcs",
     srcs = [
         ":package-srcs",
+        "//vendor/k8s.io/kube-openapi/pkg/util/proto/testing:all-srcs",
         "//vendor/k8s.io/kube-openapi/pkg/util/proto/validation:all-srcs",
     ],
     tags = ["automanaged"],

vendor/k8s.io/kube-openapi/pkg/util/proto/document.go

@@ -21,8 +21,8 @@ import (
 	"sort"
 	"strings"
 
-	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
-	yaml "gopkg.in/yaml.v2"
+	"github.com/googleapis/gnostic/OpenAPIv2"
+	"gopkg.in/yaml.v2"
 )
 
 func newSchemaError(path *Path, format string, a ...interface{}) error {
@@ -126,12 +126,17 @@ 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")
 	}
+	var sub Schema
 	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
+		sub = &Arbitrary{
+			BaseSchema: d.parseBaseSchema(s, path),
+		}
+	} else {
+		var err error
+		sub, err = d.ParseSchema(s.GetAdditionalProperties().GetSchema(), path)
+		if err != nil {
+			return nil, err
+		}
 	}
 	return &Map{
 		BaseSchema: d.parseBaseSchema(s, path),
@@ -148,12 +153,10 @@ func (d *Definitions) parsePrimitive(s *openapi_v2.Schema, path *Path) (Schema,
 		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
+	case String: // do nothing
+	case Number: // do nothing
+	case Integer: // do nothing
+	case Boolean: // do nothing
 	default:
 		return nil, newSchemaError(path, "Unknown primitive type: %q", t)
 	}
@@ -219,27 +222,38 @@ func (d *Definitions) parseArbitrary(s *openapi_v2.Schema, path *Path) (Schema,
 // 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) {
-	objectTypes := s.GetType().GetValue()
-	if len(objectTypes) == 1 {
-		t := objectTypes[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)
+	objectTypes := s.GetType().GetValue()
+	switch len(objectTypes) {
+	case 0:
+		// in the OpenAPI schema served by older k8s versions, object definitions created from structs did not include
+		// the type:object property (they only included the "properties" property), so we need to handle this case
+		if s.GetProperties() != nil {
+			return d.parseKind(s, path)
+		} else {
+			// Definition has no type and no properties. Treat it as an arbitrary value
+			// TODO: what if it has additionalProperties or patternProperties?
+			return d.parseArbitrary(s, path)
+		}
+	case 1:
+		t := objectTypes[0]
+		switch t {
+		case object:
+			if s.GetProperties() != nil {
+				return d.parseKind(s, path)
+			} else {
+				return d.parseMap(s, path)
+			}
+		case array:
+			return d.parseArray(s, path)
+		}
+		return d.parsePrimitive(s, path)
+	default:
+		// the OpenAPI generator never generates (nor it ever did in the past) OpenAPI type definitions with multiple types
+		return nil, newSchemaError(path, "definitions with multiple types aren't supported")
 	}
-	if len(objectTypes) == 0 || (len(objectTypes) == 1 && objectTypes[0] == "") {
-		return d.parseArbitrary(s, path)
-	}
-	return d.parsePrimitive(s, path)
 }
 
 // LookupModel is public through the interface of Models. It

vendor/k8s.io/kube-openapi/pkg/util/proto/openapi.go

@@ -59,7 +59,7 @@ type SchemaVisitor interface {
 }
 
 // SchemaVisitorArbitrary is an additional visitor interface which handles
-// arbitrary types. For backwards compatability, it's a separate interface
+// arbitrary types. For backwards compatibility, it's a separate interface
 // which is checked for at runtime.
 type SchemaVisitorArbitrary interface {
 	SchemaVisitor

vendor/k8s.io/kube-openapi/pkg/util/proto/testing/BUILD

@@ -0,0 +1,27 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["openapi.go"],
+    importpath = "k8s.io/kube-openapi/pkg/util/proto/testing",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/googleapis/gnostic/OpenAPIv2:go_default_library",
+        "//vendor/github.com/googleapis/gnostic/compiler:go_default_library",
+        "//vendor/gopkg.in/yaml.v2:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kube-openapi/pkg/util/proto/testing/openapi.go

@@ -0,0 +1,68 @@
+/*
+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 testing
+
+import (
+	"io/ioutil"
+	"os"
+	"sync"
+
+	yaml "gopkg.in/yaml.v2"
+
+	"github.com/googleapis/gnostic/OpenAPIv2"
+	"github.com/googleapis/gnostic/compiler"
+)
+
+// Fake opens and returns a openapi swagger from a file Path. It will
+// parse only once and then return the same copy everytime.
+type Fake struct {
+	Path string
+
+	once     sync.Once
+	document *openapi_v2.Document
+	err      error
+}
+
+// OpenAPISchema returns the openapi document and a potential error.
+func (f *Fake) OpenAPISchema() (*openapi_v2.Document, error) {
+	f.once.Do(func() {
+		_, err := os.Stat(f.Path)
+		if err != nil {
+			f.err = err
+			return
+		}
+		spec, err := ioutil.ReadFile(f.Path)
+		if err != nil {
+			f.err = err
+			return
+		}
+		var info yaml.MapSlice
+		err = yaml.Unmarshal(spec, &info)
+		if err != nil {
+			f.err = err
+			return
+		}
+		f.document, f.err = openapi_v2.NewDocument(info, compiler.NewContext("$root", nil))
+	})
+	return f.document, f.err
+}
+
+type Empty struct{}
+
+func (Empty) OpenAPISchema() (*openapi_v2.Document, error) {
+	return nil, nil
+}