add mock openapi server for testing

Author: Alexander Zielenski

pkg/util/proto/openapi_test.go

@@ -266,25 +266,20 @@ var _ = Describe("Path", func() {
 })
 
 var _ = Describe("Reading apps/v1/Deployment from v3.0.0 openAPIData", func() {
-	var models proto.Models
-	s, schemaErr := fakeSchemaV300.OpenAPIV3Schema("apps/v1")
-	models, modelsErr := proto.NewOpenAPIV3Data(s)
+	var deployment *proto.Kind
+	BeforeSuite(func() {
+		var models proto.Models
+		s, schemaErr := fakeSchemaV300.OpenAPIV3Schema("apps/v1")
+		models, modelsErr := proto.NewOpenAPIV3Data(s)
 
-	It("should load the schema", func() {
 		Expect(schemaErr).To(BeNil())
 		Expect(modelsErr).To(BeNil())
-	})
 
-	model := "io.k8s.api.apps.v1.Deployment"
-	schema := models.LookupModel(model)
-	deployment := schema.(*proto.Kind)
-
-	It("should lookup the Schema by its model name", func() {
+		model := "io.k8s.api.apps.v1.Deployment"
+		schema := models.LookupModel(model)
 		Expect(schema).ToNot(BeNil())
-	})
 
-	It("should be a Kind", func() {
-		deployment := schema.(*proto.Kind)
+		deployment = schema.(*proto.Kind)
 		Expect(deployment).ToNot(BeNil())
 	})
 
@@ -319,13 +314,12 @@ var _ = Describe("Reading apps/v1/Deployment from v3.0.0 openAPIData", func() {
 
 	Describe("status", func() {
 		var status *proto.Kind
-		key := deployment.Fields["status"].(proto.Reference)
-		status = key.SubSchema().(*proto.Kind)
-
-		It("status key of type Reference", func() {
+		BeforeSuite(func() {
 			Expect(deployment.Fields).To(HaveKey("status"))
+			key := deployment.Fields["status"].(proto.Reference)
 			Expect(key).ToNot(BeNil())
 			Expect(key.Reference()).To(Equal("io.k8s.api.apps.v1.DeploymentStatus"))
+			status = key.SubSchema().(*proto.Kind)
 			Expect(status).ToNot(BeNil())
 		})
 
@@ -351,13 +345,13 @@ var _ = Describe("Reading apps/v1/Deployment from v3.0.0 openAPIData", func() {
 	})
 
 	Describe("spec subschema", func() {
-		key, _ := deployment.Fields["spec"].(proto.Reference)
-		spec := key.SubSchema().(*proto.Kind)
-
-		It("should have a spec key of type Reference", func() {
+		var spec *proto.Kind
+		BeforeSuite(func() {
 			Expect(deployment.Fields).To(HaveKey("spec"))
+			key, _ := deployment.Fields["spec"].(proto.Reference)
 			Expect(key).ToNot(BeNil())
 			Expect(key.Reference()).To(Equal("io.k8s.api.apps.v1.DeploymentSpec"))
+			spec = key.SubSchema().(*proto.Kind)
 			Expect(spec).ToNot(BeNil())
 		})
 

pkg/util/proto/testing/openapi.go

@@ -17,24 +17,25 @@ limitations under the License.
 package testing
 
 import (
+	"io/fs"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"sync"
 
 	openapi_v2 "github.com/google/gnostic/openapiv2"
 	openapi_v3 "github.com/google/gnostic/openapiv3"
+	"k8s.io/kube-openapi/pkg/handler3"
 )
 
 // 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
-	documentV3 *openapi_v3.Document
-	err        error
+	once     sync.Once
+	document *openapi_v2.Document
+	err      error
 }
 
 // OpenAPISchema returns the openapi document and a potential error.
@@ -55,21 +56,33 @@ func (f *Fake) OpenAPISchema() (*openapi_v2.Document, error) {
 	return f.document, f.err
 }
 
-func (f *Fake) OpenAPIV3Schema(groupVersion string) (*openapi_v3.Document, error) {
-	f.once.Do(func() {
-		_, err := os.Stat(f.Path)
-		if err != nil {
-			f.err = err
-			return
+func (f *Fake) OpenAPIV3Discovery() (*handler3.OpenAPIV3Discovery, error) {
+	// Read directory to determine groups
+	res := &handler3.OpenAPIV3Discovery{}
+	filepath.WalkDir(f.Path, func(path string, d fs.DirEntry, err error) error {
+		if filepath.Ext(path) != "json" {
+			return nil
 		}
-		spec, err := ioutil.ReadFile(filepath.Join(f.Path, groupVersion+".json"))
-		if err != nil {
-			f.err = err
-			return
+
+		res.Paths[path] = handler3.OpenAPIV3DiscoveryGroupVersion{
+			URL: "/openapi/v3/" + path,
 		}
-		f.documentV3, f.err = openapi_v3.ParseDocument(spec)
+		return nil
 	})
-	return f.documentV3, f.err
+
+	return res, nil
+}
+
+func (f *Fake) OpenAPIV3Schema(groupVersion string) (*openapi_v3.Document, error) {
+	_, err := os.Stat(f.Path)
+	if err != nil {
+		return nil, err
+	}
+	spec, err := ioutil.ReadFile(filepath.Join(f.Path, groupVersion+".json"))
+	if err != nil {
+		return nil, err
+	}
+	return openapi_v3.ParseDocument(spec)
 }
 
 type Empty struct{}

pkg/util/proto/testing/openapiv3.go

@@ -0,0 +1,138 @@
+/*
+Copyright 2021 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 (
+	"encoding/json"
+	"io/fs"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+
+	openapi_v3 "github.com/google/gnostic/openapiv3"
+	"k8s.io/kube-openapi/pkg/handler3"
+	"k8s.io/kube-openapi/pkg/spec3"
+)
+
+// Creates a mock OpenAPIV3 server as it would be on a standing kubernetes
+// API server.
+//
+// specsPath - Give a path to some test data organized so that each GroupVersion
+// 	has its own OpenAPI V3 JSON file.
+// 		i.e. apps/v1beta1 is stored in <specsPath>/apps/v1beta1.json
+func NewFakeOpenAPIV3Server(specsPath string) (*httptest.Server, map[string]*openapi_v3.Document, error) {
+	mux := &testMux{}
+	server := httptest.NewServer(mux)
+
+	openAPIVersionedService, err := handler3.NewOpenAPIService(nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	err = openAPIVersionedService.RegisterOpenAPIV3VersionedService("/openapi/v3", mux)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	grouped := make(map[string][]byte)
+	var testV3Specs = make(map[string]*openapi_v3.Document)
+
+	addSpec := func(path string) {
+		file, err := os.Open(path)
+		if err != nil {
+			panic(err)
+		}
+
+		defer file.Close()
+		vals, err := ioutil.ReadAll(file)
+		if err != nil {
+			panic(err)
+		}
+
+		rel, err := filepath.Rel(specsPath, path)
+		if err == nil {
+			grouped[rel[:(len(rel)-len(filepath.Ext(rel)))]] = vals
+		}
+	}
+
+	filepath.WalkDir(specsPath, func(path string, d fs.DirEntry, err error) error {
+		if filepath.Ext(path) != ".json" || d.IsDir() {
+			return nil
+		}
+
+		addSpec(path)
+		return nil
+	})
+
+	for gv, jsonSpec := range grouped {
+		spec := &spec3.OpenAPI{}
+		err = json.Unmarshal(jsonSpec, spec)
+		if err != nil {
+			return nil, nil, err
+		}
+		gnosticSpec, err := openapi_v3.ParseDocument(jsonSpec)
+		if err != nil {
+			return nil, nil, err
+		}
+		testV3Specs[gv] = gnosticSpec
+		openAPIVersionedService.UpdateGroupVersion(gv, spec)
+	}
+
+	return server, testV3Specs, nil
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Tiny Test HTTP Mux
+////////////////////////////////////////////////////////////////////////////////
+
+type testMux struct {
+	prefixMap map[string]http.Handler
+	pathMap   map[string]http.Handler
+}
+
+func (t *testMux) Handle(path string, handler http.Handler) {
+	if t.pathMap == nil {
+		t.pathMap = make(map[string]http.Handler)
+	}
+	t.pathMap[path] = handler
+}
+
+func (t *testMux) HandlePrefix(path string, handler http.Handler) {
+	if t.prefixMap == nil {
+		t.prefixMap = make(map[string]http.Handler)
+	}
+	t.prefixMap[path] = handler
+}
+
+func (t *testMux) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	if handler, ok := t.pathMap[req.URL.Path]; ok {
+		handler.ServeHTTP(w, req)
+		return
+	}
+
+	for k, v := range t.prefixMap {
+		if strings.HasPrefix(req.URL.Path, k) {
+			v.ServeHTTP(w, req)
+			return
+		}
+	}
+
+	w.WriteHeader(http.StatusNotFound)
+}