108 lines
3.2 KiB
Go
108 lines
3.2 KiB
Go
/*
|
|
Copyright 2018 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 internal_test
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/runtime/schema"
|
|
"k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal"
|
|
"k8s.io/kube-openapi/pkg/util/proto"
|
|
"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
|
|
)
|
|
|
|
// TestVersionConverter tests the version converter
|
|
func TestVersionConverter(t *testing.T) {
|
|
d, err := fakeSchema.OpenAPISchema()
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse OpenAPI schema: %v", err)
|
|
}
|
|
m, err := proto.NewOpenAPIData(d)
|
|
if err != nil {
|
|
t.Fatalf("Failed to build OpenAPI models: %v", err)
|
|
}
|
|
tc, err := internal.NewTypeConverter(m, false)
|
|
if err != nil {
|
|
t.Fatalf("Failed to build TypeConverter: %v", err)
|
|
}
|
|
oc := fakeObjectConvertor{
|
|
gvkForVersion("v1beta1"): objForGroupVersion("apps/v1beta1"),
|
|
gvkForVersion("v1"): objForGroupVersion("apps/v1"),
|
|
}
|
|
vc := internal.NewVersionConverter(tc, oc, schema.GroupVersion{Group: "apps", Version: runtime.APIVersionInternal})
|
|
|
|
input, err := tc.ObjectToTyped(objForGroupVersion("apps/v1beta1"))
|
|
if err != nil {
|
|
t.Fatalf("error creating converting input object to a typed value: %v", err)
|
|
}
|
|
expected := objForGroupVersion("apps/v1")
|
|
output, err := vc.Convert(input, fieldpath.APIVersion("apps/v1"))
|
|
if err != nil {
|
|
t.Fatalf("expected err to be nil but got %v", err)
|
|
}
|
|
actual, err := tc.TypedToObject(output)
|
|
if err != nil {
|
|
t.Fatalf("error converting output typed value to an object %v", err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Fatalf("expected to get %v but got %v", expected, actual)
|
|
}
|
|
}
|
|
|
|
func gvkForVersion(v string) schema.GroupVersionKind {
|
|
return schema.GroupVersionKind{
|
|
Group: "apps",
|
|
Version: v,
|
|
Kind: "Deployment",
|
|
}
|
|
}
|
|
|
|
func objForGroupVersion(gv string) runtime.Object {
|
|
return &unstructured.Unstructured{
|
|
Object: map[string]interface{}{
|
|
"apiVersion": gv,
|
|
"kind": "Deployment",
|
|
},
|
|
}
|
|
}
|
|
|
|
type fakeObjectConvertor map[schema.GroupVersionKind]runtime.Object
|
|
|
|
var _ runtime.ObjectConvertor = fakeObjectConvertor{}
|
|
|
|
func (c fakeObjectConvertor) ConvertToVersion(_ runtime.Object, gv runtime.GroupVersioner) (runtime.Object, error) {
|
|
allKinds := make([]schema.GroupVersionKind, 0)
|
|
for kind := range c {
|
|
allKinds = append(allKinds, kind)
|
|
}
|
|
gvk, _ := gv.KindForGroupVersionKinds(allKinds)
|
|
return c[gvk], nil
|
|
}
|
|
|
|
func (fakeObjectConvertor) Convert(_, _, _ interface{}) error {
|
|
return fmt.Errorf("function not implemented")
|
|
}
|
|
|
|
func (fakeObjectConvertor) ConvertFieldLabel(_ schema.GroupVersionKind, _, _ string) (string, string, error) {
|
|
return "", "", fmt.Errorf("function not implemented")
|
|
}
|