Conversion from typed to unstructured should set GVK

staging/src/k8s.io/apimachinery/pkg/runtime/scheme.go

@@ -431,6 +431,7 @@ func (s *Scheme) Convert(in, out interface{}, context interface{}) error {
 				return err
 			}
 			unstructuredOut.SetUnstructuredContent(content)
+			unstructuredOut.GetObjectKind().SetGroupVersionKind(gvk)
 			return nil
 		}
 

staging/src/k8s.io/apimachinery/pkg/runtime/scheme_test.go

@@ -55,14 +55,26 @@ func TestScheme(t *testing.T) {
 	// Register functions to verify that scope.Meta() gets set correctly.
 	err := scheme.AddConversionFuncs(
 		func(in *runtimetesting.InternalSimple, out *runtimetesting.ExternalSimple, scope conversion.Scope) error {
-			scope.Convert(&in.TypeMeta, &out.TypeMeta, 0)
+			err := scope.Convert(&in.TypeMeta, &out.TypeMeta, 0)
-			scope.Convert(&in.TestString, &out.TestString, 0)
+			if err != nil {
+				return err
+			}
+			err = scope.Convert(&in.TestString, &out.TestString, 0)
+			if err != nil {
+				return err
+			}
 			internalToExternalCalls++
 			return nil
 		},
 		func(in *runtimetesting.ExternalSimple, out *runtimetesting.InternalSimple, scope conversion.Scope) error {
-			scope.Convert(&in.TypeMeta, &out.TypeMeta, 0)
+			err := scope.Convert(&in.TypeMeta, &out.TypeMeta, 0)
-			scope.Convert(&in.TestString, &out.TestString, 0)
+			if err != nil {
+				return err
+			}
+			err = scope.Convert(&in.TestString, &out.TestString, 0)
+			if err != nil {
+				return err
+			}
 			externalToInternalCalls++
 			return nil
 		},
@@ -71,140 +83,160 @@ func TestScheme(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	codecs := serializer.NewCodecFactory(scheme)
+	t.Run("Encode, Decode, DecodeInto, and DecodeToVersion", func(t *testing.T) {
-	codec := codecs.LegacyCodec(externalGV)
+		simple := &runtimetesting.InternalSimple{
-	info, _ := runtime.SerializerInfoForMediaType(codecs.SupportedMediaTypes(), runtime.ContentTypeJSON)
+			TestString: "foo",
-	jsonserializer := info.Serializer
+		}
 
-	simple := &runtimetesting.InternalSimple{
+		codecs := serializer.NewCodecFactory(scheme)
-		TestString: "foo",
+		codec := codecs.LegacyCodec(externalGV)
-	}
+		info, _ := runtime.SerializerInfoForMediaType(codecs.SupportedMediaTypes(), runtime.ContentTypeJSON)
+		jsonserializer := info.Serializer
 
-	// Test Encode, Decode, DecodeInto, and DecodeToVersion
+		obj := runtime.Object(simple)
-	obj := runtime.Object(simple)
+		data, err := runtime.Encode(codec, obj)
-	data, err := runtime.Encode(codec, obj)
+		if err != nil {
-	if err != nil {
+			t.Fatal(err)
-		t.Fatal(err)
+		}
-	}
 
-	obj2, err := runtime.Decode(codec, data)
+		obj2, err := runtime.Decode(codec, data)
-	if err != nil {
+		if err != nil {
-		t.Fatal(err)
+			t.Fatal(err)
-	}
+		}
-	if _, ok := obj2.(*runtimetesting.InternalSimple); !ok {
+		if _, ok := obj2.(*runtimetesting.InternalSimple); !ok {
-		t.Fatalf("Got wrong type")
+			t.Fatalf("Got wrong type")
-	}
+		}
-	if e, a := simple, obj2; !reflect.DeepEqual(e, a) {
+		if e, a := simple, obj2; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected:\n %#v,\n Got:\n %#v", e, a)
+			t.Errorf("Expected:\n %#v,\n Got:\n %#v", e, a)
-	}
+		}
 
-	obj3 := &runtimetesting.InternalSimple{}
+		obj3 := &runtimetesting.InternalSimple{}
-	if err := runtime.DecodeInto(codec, data, obj3); err != nil {
+		if err := runtime.DecodeInto(codec, data, obj3); err != nil {
-		t.Fatal(err)
+			t.Fatal(err)
-	}
+		}
-	// clearing TypeMeta is a function of the scheme, which we do not test here (ConvertToVersion
+		// clearing TypeMeta is a function of the scheme, which we do not test here (ConvertToVersion
-	// does not automatically clear TypeMeta anymore).
+		// does not automatically clear TypeMeta anymore).
-	simple.TypeMeta = runtime.TypeMeta{Kind: "Simple", APIVersion: externalGV.String()}
+		simple.TypeMeta = runtime.TypeMeta{Kind: "Simple", APIVersion: externalGV.String()}
-	if e, a := simple, obj3; !reflect.DeepEqual(e, a) {
+		if e, a := simple, obj3; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected:\n %#v,\n Got:\n %#v", e, a)
+			t.Errorf("Expected:\n %#v,\n Got:\n %#v", e, a)
-	}
+		}
 
-	obj4, err := runtime.Decode(jsonserializer, data)
+		obj4, err := runtime.Decode(jsonserializer, data)
-	if err != nil {
+		if err != nil {
-		t.Fatal(err)
+			t.Fatal(err)
-	}
+		}
-	if _, ok := obj4.(*runtimetesting.ExternalSimple); !ok {
+		if _, ok := obj4.(*runtimetesting.ExternalSimple); !ok {
-		t.Fatalf("Got wrong type")
+			t.Fatalf("Got wrong type")
-	}
+		}
+	})
+	t.Run("Convert", func(t *testing.T) {
+		simple := &runtimetesting.InternalSimple{
+			TestString: "foo",
+		}
 
-	// Test Convert
+		external := &runtimetesting.ExternalSimple{}
-	external := &runtimetesting.ExternalSimple{}
+		err = scheme.Convert(simple, external, nil)
-	err = scheme.Convert(simple, external, nil)
+		if err != nil {
-	if err != nil {
+			t.Fatalf("Unexpected error: %v", err)
-		t.Fatalf("Unexpected error: %v", err)
+		}
-	}
+		if e, a := simple.TestString, external.TestString; e != a {
-	if e, a := simple.TestString, external.TestString; e != a {
+			t.Errorf("Expected %q, got %q", e, a)
-		t.Errorf("Expected %v, got %v", e, a)
+		}
-	}
+	})
+	t.Run("Convert internal to unstructured", func(t *testing.T) {
+		simple := &runtimetesting.InternalSimple{
+			TestString: "foo",
+		}
 
-	// Test convert internal to unstructured
+		unstructuredObj := &runtimetesting.Unstructured{}
-	unstructuredObj := &runtimetesting.Unstructured{}
+		err = scheme.Convert(simple, unstructuredObj, nil)
-	err = scheme.Convert(simple, unstructuredObj, nil)
+		if err == nil || !strings.Contains(err.Error(), "to Unstructured without providing a preferred version to convert to") {
-	if err == nil || !strings.Contains(err.Error(), "to Unstructured without providing a preferred version to convert to") {
+			t.Fatalf("Unexpected non-error: %v", err)
-		t.Fatalf("Unexpected non-error: %v", err)
+		}
-	}
+		err = scheme.Convert(simple, unstructuredObj, schema.GroupVersion{Group: "test.group", Version: "testExternal"})
-	err = scheme.Convert(simple, unstructuredObj, schema.GroupVersion{Group: "test.group", Version: "testExternal"})
+		if err != nil {
-	if err != nil {
+			t.Fatalf("Unexpected error: %v", err)
-		t.Fatalf("Unexpected error: %v", err)
+		}
-	}
+		if e, a := simple.TestString, unstructuredObj.Object["testString"].(string); e != a {
-	if e, a := simple.TestString, unstructuredObj.Object["testString"].(string); e != a {
+			t.Errorf("Expected %q, got %q", e, a)
-		t.Errorf("Expected %v, got %v", e, a)
+		}
-	}
+		if e := unstructuredObj.GetObjectKind().GroupVersionKind(); !reflect.DeepEqual(e, schema.GroupVersionKind{Group: "test.group", Version: "testExternal", Kind: "Simple"}) {
-	if e := unstructuredObj.GetObjectKind().GroupVersionKind(); !reflect.DeepEqual(e, schema.GroupVersionKind{Group: "test.group", Version: "testExternal", Kind: "Simple"}) {
+			t.Errorf("Unexpected object kind: %#v", e)
-		t.Errorf("Unexpected object kind: %#v", e)
+		}
-	}
+		if gvks, unversioned, err := scheme.ObjectKinds(unstructuredObj); err != nil || !reflect.DeepEqual(gvks[0], schema.GroupVersionKind{Group: "test.group", Version: "testExternal", Kind: "Simple"}) || unversioned {
-	if gvks, unversioned, err := scheme.ObjectKinds(unstructuredObj); err != nil || !reflect.DeepEqual(gvks[0], schema.GroupVersionKind{Group: "test.group", Version: "testExternal", Kind: "Simple"}) || unversioned {
+			t.Errorf("Scheme did not recognize unversioned: %v, %#v %t", err, gvks, unversioned)
-		t.Errorf("Scheme did not recognize unversioned: %v, %#v %t", err, gvks, unversioned)
+		}
-	}
+	})
+	t.Run("Convert external to unstructured", func(t *testing.T) {
+		unstructuredObj := &runtimetesting.Unstructured{}
+		external := &runtimetesting.ExternalSimple{
+			TestString: "foo",
+		}
 
-	// Test convert external to unstructured
+		err = scheme.Convert(external, unstructuredObj, nil)
-	unstructuredObj = &runtimetesting.Unstructured{}
+		if err != nil {
-	err = scheme.Convert(external, unstructuredObj, nil)
+			t.Fatalf("Unexpected error: %v", err)
-	if err != nil {
+		}
-		t.Fatalf("Unexpected error: %v", err)
+		if e, a := external.TestString, unstructuredObj.Object["testString"].(string); e != a {
-	}
+			t.Errorf("Expected %q, got %q", e, a)
-	if e, a := simple.TestString, unstructuredObj.Object["testString"].(string); e != a {
+		}
-		t.Errorf("Expected %v, got %v", e, a)
+		if e := unstructuredObj.GetObjectKind().GroupVersionKind(); !reflect.DeepEqual(e, schema.GroupVersionKind{Group: "test.group", Version: "testExternal", Kind: "Simple"}) {
-	}
+			t.Errorf("Unexpected object kind: %#v", e)
-	if e := unstructuredObj.GetObjectKind().GroupVersionKind(); !reflect.DeepEqual(e, schema.GroupVersionKind{Group: "test.group", Version: "testExternal", Kind: "Simple"}) {
+		}
-		t.Errorf("Unexpected object kind: %#v", e)
+	})
-	}
+	t.Run("Convert unstructured to unstructured", func(t *testing.T) {
-
+		uIn := &runtimetesting.Unstructured{Object: map[string]interface{}{
-	// Test convert unstructured to unstructured
+			"test": []interface{}{"other", "test"},
-	uIn := &runtimetesting.Unstructured{Object: map[string]interface{}{
+		}}
-		"test": []interface{}{"other", "test"},
+		uOut := &runtimetesting.Unstructured{}
-	}}
+		err = scheme.Convert(uIn, uOut, nil)
-	uOut := &runtimetesting.Unstructured{}
+		if err != nil {
-	err = scheme.Convert(uIn, uOut, nil)
+			t.Fatalf("Unexpected error: %v", err)
-	if err != nil {
+		}
-		t.Fatalf("Unexpected error: %v", err)
+		if !reflect.DeepEqual(uIn.Object, uOut.Object) {
-	}
+			t.Errorf("Unexpected object contents: %#v", uOut.Object)
-	if !reflect.DeepEqual(uIn.Object, uOut.Object) {
+		}
-		t.Errorf("Unexpected object contents: %#v", uOut.Object)
+	})
-	}
+	t.Run("Convert unstructured to structured", func(t *testing.T) {
-
+		unstructuredObj := &runtimetesting.Unstructured{
-	// Test convert unstructured to structured
+			Object: map[string]interface{}{
-	externalOut := &runtimetesting.ExternalSimple{}
+				"testString": "bla",
-	err = scheme.Convert(unstructuredObj, externalOut, nil)
+			},
-	if err != nil {
+		}
-		t.Fatalf("Unexpected error: %v", err)
+		unstructuredObj.SetGroupVersionKind(externalGV.WithKind("Simple"))
-	}
+		externalOut := &runtimetesting.ExternalSimple{}
-	if !reflect.DeepEqual(external, externalOut) {
+		err = scheme.Convert(unstructuredObj, externalOut, nil)
-		t.Errorf("Unexpected object contents: %#v", externalOut)
+		if err != nil {
-	}
+			t.Fatalf("Unexpected error: %v", err)
-
+		}
-	// Encode and Convert should each have caused an increment.
+		if externalOut.TestString != "bla" {
-	if e, a := 3, internalToExternalCalls; e != a {
+			t.Errorf("Unexpected object contents: %#v", externalOut)
-		t.Errorf("Expected %v, got %v", e, a)
+		}
-	}
+	})
-	// DecodeInto and Decode should each have caused an increment because of a conversion
+	t.Run("Encode and Convert should each have caused an increment", func(t *testing.T) {
-	if e, a := 2, externalToInternalCalls; e != a {
+		if e, a := 3, internalToExternalCalls; e != a {
-		t.Errorf("Expected %v, got %v", e, a)
+			t.Errorf("Expected %v, got %v", e, a)
-	}
+		}
-
+	})
-	// Verify that unstructured types must have V and K set
+	t.Run("DecodeInto and Decode should each have caused an increment because of a conversion", func(t *testing.T) {
-	emptyObj := &runtimetesting.Unstructured{Object: make(map[string]interface{})}
+		if e, a := 2, externalToInternalCalls; e != a {
-	if _, _, err := scheme.ObjectKinds(emptyObj); !runtime.IsMissingKind(err) {
+			t.Errorf("Expected %v, got %v", e, a)
-		t.Errorf("unexpected error: %v", err)
+		}
-	}
+	})
-	emptyObj.SetGroupVersionKind(schema.GroupVersionKind{Kind: "Test"})
+	t.Run("Verify that unstructured types must have V and K set", func(t *testing.T) {
-	if _, _, err := scheme.ObjectKinds(emptyObj); !runtime.IsMissingVersion(err) {
+		emptyObj := &runtimetesting.Unstructured{Object: make(map[string]interface{})}
-		t.Errorf("unexpected error: %v", err)
+		if _, _, err := scheme.ObjectKinds(emptyObj); !runtime.IsMissingKind(err) {
-	}
+			t.Errorf("unexpected error: %v", err)
-	emptyObj.SetGroupVersionKind(schema.GroupVersionKind{Kind: "Test", Version: "v1"})
+		}
-	if _, _, err := scheme.ObjectKinds(emptyObj); err != nil {
+		emptyObj.SetGroupVersionKind(schema.GroupVersionKind{Kind: "Test"})
-		t.Errorf("unexpected error: %v", err)
+		if _, _, err := scheme.ObjectKinds(emptyObj); !runtime.IsMissingVersion(err) {
-	}
+			t.Errorf("unexpected error: %v", err)
+		}
+		emptyObj.SetGroupVersionKind(schema.GroupVersionKind{Kind: "Test", Version: "v1"})
+		if _, _, err := scheme.ObjectKinds(emptyObj); err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+	})
 }
 
 func TestBadJSONRejection(t *testing.T) {

staging/src/k8s.io/apimachinery/pkg/runtime/testing/types.go

@@ -315,6 +315,9 @@ func (u *Unstructured) GroupVersionKind() schema.GroupVersionKind {
 }
 
 func (u *Unstructured) SetGroupVersionKind(gvk schema.GroupVersionKind) {
+	if u.Object == nil {
+		u.Object = make(map[string]interface{})
+	}
 	u.Object["apiVersion"] = gvk.GroupVersion().String()
 	u.Object["kind"] = gvk.Kind
 }