vendor files

vendor/k8s.io/apimachinery/pkg/runtime/embedded_test.go

@@ -0,0 +1,256 @@
+/*
+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 runtime_test
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+	runtimetesting "k8s.io/apimachinery/pkg/runtime/testing"
+	"k8s.io/apimachinery/pkg/util/diff"
+)
+
+func TestDecodeEmptyRawExtensionAsObject(t *testing.T) {
+	internalGV := schema.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
+	externalGV := schema.GroupVersion{Group: "test.group", Version: "v1test"}
+	externalGVK := externalGV.WithKind("ObjectTest")
+
+	s := runtime.NewScheme()
+	s.AddKnownTypes(internalGV, &runtimetesting.ObjectTest{})
+	s.AddKnownTypeWithName(externalGVK, &runtimetesting.ObjectTestExternal{})
+
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	obj, gvk, err := codec.Decode([]byte(`{"kind":"`+externalGVK.Kind+`","apiVersion":"`+externalGV.String()+`","items":[{}]}`), nil, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	test := obj.(*runtimetesting.ObjectTest)
+	if unk, ok := test.Items[0].(*runtime.Unknown); !ok || unk.Kind != "" || unk.APIVersion != "" || string(unk.Raw) != "{}" || unk.ContentType != runtime.ContentTypeJSON {
+		t.Fatalf("unexpected object: %#v", test.Items[0])
+	}
+	if *gvk != externalGVK {
+		t.Fatalf("unexpected kind: %#v", gvk)
+	}
+
+	obj, gvk, err = codec.Decode([]byte(`{"kind":"`+externalGVK.Kind+`","apiVersion":"`+externalGV.String()+`","items":[{"kind":"Other","apiVersion":"v1"}]}`), nil, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	test = obj.(*runtimetesting.ObjectTest)
+	if unk, ok := test.Items[0].(*runtime.Unknown); !ok || unk.Kind != "" || unk.APIVersion != "" || string(unk.Raw) != `{"kind":"Other","apiVersion":"v1"}` || unk.ContentType != runtime.ContentTypeJSON {
+		t.Fatalf("unexpected object: %#v", test.Items[0])
+	}
+	if *gvk != externalGVK {
+		t.Fatalf("unexpected kind: %#v", gvk)
+	}
+}
+
+func TestArrayOfRuntimeObject(t *testing.T) {
+	internalGV := schema.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
+	externalGV := schema.GroupVersion{Group: "test.group", Version: "v1test"}
+
+	s := runtime.NewScheme()
+	s.AddKnownTypes(internalGV, &runtimetesting.EmbeddedTest{})
+	s.AddKnownTypeWithName(externalGV.WithKind("EmbeddedTest"), &runtimetesting.EmbeddedTestExternal{})
+	s.AddKnownTypes(internalGV, &runtimetesting.ObjectTest{})
+	s.AddKnownTypeWithName(externalGV.WithKind("ObjectTest"), &runtimetesting.ObjectTestExternal{})
+
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	innerItems := []runtime.Object{
+		&runtimetesting.EmbeddedTest{ID: "baz"},
+	}
+	items := []runtime.Object{
+		&runtimetesting.EmbeddedTest{ID: "foo"},
+		&runtimetesting.EmbeddedTest{ID: "bar"},
+		// TODO: until YAML is removed, this JSON must be in ascending key order to ensure consistent roundtrip serialization
+		&runtime.Unknown{
+			Raw:         []byte(`{"apiVersion":"unknown.group/unknown","foo":"bar","kind":"OtherTest"}`),
+			ContentType: runtime.ContentTypeJSON,
+		},
+		&runtimetesting.ObjectTest{
+			Items: runtime.NewEncodableList(codec, innerItems),
+		},
+	}
+	internal := &runtimetesting.ObjectTest{
+		Items: runtime.NewEncodableList(codec, items),
+	}
+	wire, err := runtime.Encode(codec, internal)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	t.Logf("Wire format is:\n%s\n", string(wire))
+
+	obj := &runtimetesting.ObjectTestExternal{}
+	if err := json.Unmarshal(wire, obj); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	t.Logf("exact wire is: %s", string(obj.Items[0].Raw))
+
+	items[3] = &runtimetesting.ObjectTest{Items: innerItems}
+	internal.Items = items
+
+	decoded, err := runtime.Decode(codec, wire)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	list, err := meta.ExtractList(decoded)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if errs := runtime.DecodeList(list, codec); len(errs) > 0 {
+		t.Fatalf("unexpected error: %v", errs)
+	}
+
+	list2, err := meta.ExtractList(list[3])
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if errs := runtime.DecodeList(list2, codec); len(errs) > 0 {
+		t.Fatalf("unexpected error: %v", errs)
+	}
+	if err := meta.SetList(list[3], list2); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// we want DecodeList to set type meta if possible, even on runtime.Unknown objects
+	internal.Items[2].(*runtime.Unknown).TypeMeta = runtime.TypeMeta{Kind: "OtherTest", APIVersion: "unknown.group/unknown"}
+	if e, a := internal.Items, list; !reflect.DeepEqual(e, a) {
+		t.Errorf("mismatched decoded: %s", diff.ObjectGoPrintSideBySide(e, a))
+	}
+}
+
+func TestNestedObject(t *testing.T) {
+	internalGV := schema.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
+	externalGV := schema.GroupVersion{Group: "test.group", Version: "v1test"}
+	embeddedTestExternalGVK := externalGV.WithKind("EmbeddedTest")
+
+	s := runtime.NewScheme()
+	s.AddKnownTypes(internalGV, &runtimetesting.EmbeddedTest{})
+	s.AddKnownTypeWithName(embeddedTestExternalGVK, &runtimetesting.EmbeddedTestExternal{})
+
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	inner := &runtimetesting.EmbeddedTest{
+		ID: "inner",
+	}
+	outer := &runtimetesting.EmbeddedTest{
+		ID:     "outer",
+		Object: runtime.NewEncodable(codec, inner),
+	}
+
+	wire, err := runtime.Encode(codec, outer)
+	if err != nil {
+		t.Fatalf("Unexpected encode error '%v'", err)
+	}
+
+	t.Logf("Wire format is:\n%v\n", string(wire))
+
+	decoded, err := runtime.Decode(codec, wire)
+	if err != nil {
+		t.Fatalf("Unexpected decode error %v", err)
+	}
+
+	// for later tests
+	outer.Object = inner
+
+	if e, a := outer, decoded; reflect.DeepEqual(e, a) {
+		t.Errorf("Expected unequal %#v %#v", e, a)
+	}
+
+	obj, err := runtime.Decode(codec, decoded.(*runtimetesting.EmbeddedTest).Object.(*runtime.Unknown).Raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	decoded.(*runtimetesting.EmbeddedTest).Object = obj
+	if e, a := outer, decoded; !reflect.DeepEqual(e, a) {
+		t.Errorf("Expected equal %#v %#v", e, a)
+	}
+
+	// test JSON decoding of the external object, which should preserve
+	// raw bytes
+	var externalViaJSON runtimetesting.EmbeddedTestExternal
+	err = json.Unmarshal(wire, &externalViaJSON)
+	if err != nil {
+		t.Fatalf("Unexpected decode error %v", err)
+	}
+	if externalViaJSON.Kind == "" || externalViaJSON.APIVersion == "" || externalViaJSON.ID != "outer" {
+		t.Errorf("Expected objects to have type info set, got %#v", externalViaJSON)
+	}
+	if len(externalViaJSON.EmptyObject.Raw) > 0 {
+		t.Errorf("Expected deserialization of empty nested objects into empty bytes, got %#v", externalViaJSON)
+	}
+
+	// test JSON decoding, too, since Decode uses yaml unmarshalling.
+	// Generic Unmarshalling of JSON cannot load the nested objects because there is
+	// no default schema set.  Consumers wishing to get direct JSON decoding must use
+	// the external representation
+	var decodedViaJSON runtimetesting.EmbeddedTest
+	err = json.Unmarshal(wire, &decodedViaJSON)
+	if err == nil {
+		t.Fatal("Expeceted decode error")
+	}
+	if _, ok := err.(*json.UnmarshalTypeError); !ok {
+		t.Fatalf("Unexpected decode error: %v", err)
+	}
+	if a := decodedViaJSON; a.Object != nil || a.EmptyObject != nil {
+		t.Errorf("Expected embedded objects to be nil: %#v", a)
+	}
+}
+
+// TestDeepCopyOfRuntimeObject checks to make sure that runtime.Objects's can be passed through DeepCopy with fidelity
+func TestDeepCopyOfRuntimeObject(t *testing.T) {
+	internalGV := schema.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
+	externalGV := schema.GroupVersion{Group: "test.group", Version: "v1test"}
+	embeddedTestExternalGVK := externalGV.WithKind("EmbeddedTest")
+
+	s := runtime.NewScheme()
+	s.AddKnownTypes(internalGV, &runtimetesting.EmbeddedTest{})
+	s.AddKnownTypeWithName(embeddedTestExternalGVK, &runtimetesting.EmbeddedTestExternal{})
+
+	original := &runtimetesting.EmbeddedTest{
+		ID: "outer",
+		Object: &runtimetesting.EmbeddedTest{
+			ID: "inner",
+		},
+	}
+
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	originalData, err := runtime.Encode(codec, original)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	t.Logf("originalRole = %v\n", string(originalData))
+
+	copyOfOriginal := original.DeepCopy()
+	copiedData, err := runtime.Encode(codec, copyOfOriginal)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	t.Logf("copyOfRole   = %v\n", string(copiedData))
+
+	if !reflect.DeepEqual(original, copyOfOriginal) {
+		t.Errorf("expected \n%v\n, got \n%v", string(originalData), string(copiedData))
+	}
+}