update tests to be specific about the versions they are testing instead of floating

pkg/api/testapi/testapi.go

@@ -74,23 +74,16 @@ import (
 )
 
 var (
-	Groups        = make(map[string]TestGroup)
-	Default       TestGroup
-	Authorization TestGroup
-	Autoscaling   TestGroup
-	Batch         TestGroup
-	Extensions    TestGroup
-	Events        TestGroup
-	Apps          TestGroup
-	Policy        TestGroup
-	Rbac          TestGroup
-	Certificates  TestGroup
-	Scheduling    TestGroup
-	Settings      TestGroup
-	Storage       TestGroup
-	ImagePolicy   TestGroup
-	Admission     TestGroup
-	Networking    TestGroup
+	Groups      = make(map[string]TestGroup)
+	Default     TestGroup
+	Autoscaling TestGroup
+	Batch       TestGroup
+	Extensions  TestGroup
+	Apps        TestGroup
+	Policy      TestGroup
+	Rbac        TestGroup
+	Storage     TestGroup
+	Admission   TestGroup
 
 	serializer        runtime.SerializerInfo
 	storageSerializer runtime.SerializerInfo
@@ -98,9 +91,6 @@ var (
 
 type TestGroup struct {
 	externalGroupVersion schema.GroupVersion
-	internalGroupVersion schema.GroupVersion
-	internalTypes        map[string]reflect.Type
-	externalTypes        map[string]reflect.Type
 }
 
 func init() {
@@ -139,12 +129,8 @@ func init() {
 				panic(fmt.Sprintf("Error parsing groupversion %v: %v", gvString, err))
 			}
 
-			internalGroupVersion := schema.GroupVersion{Group: groupVersion.Group, Version: runtime.APIVersionInternal}
 			Groups[groupVersion.Group] = TestGroup{
 				externalGroupVersion: groupVersion,
-				internalGroupVersion: internalGroupVersion,
-				internalTypes:        legacyscheme.Scheme.KnownTypes(internalGroupVersion),
-				externalTypes:        legacyscheme.Scheme.KnownTypes(groupVersion),
 			}
 		}
 	}
@@ -153,18 +139,12 @@ func init() {
 		externalGroupVersion := schema.GroupVersion{Group: api.GroupName, Version: legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersions[0].Version}
 		Groups[api.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: api.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(api.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[extensions.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: extensions.GroupName, Version: legacyscheme.Registry.GroupOrDie(extensions.GroupName).GroupVersions[0].Version}
 		Groups[extensions.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: extensions.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(extensions.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[autoscaling.GroupName]; !ok {
@@ -178,9 +158,6 @@ func init() {
 		externalGroupVersion := schema.GroupVersion{Group: autoscaling.GroupName, Version: legacyscheme.Registry.GroupOrDie(autoscaling.GroupName).GroupVersions[0].Version}
 		Groups[autoscaling.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: extensions.SchemeGroupVersion,
-			internalTypes:        internalTypes,
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[autoscaling.GroupName+"IntraGroup"]; !ok {
@@ -194,135 +171,90 @@ func init() {
 		externalGroupVersion := schema.GroupVersion{Group: autoscaling.GroupName, Version: legacyscheme.Registry.GroupOrDie(autoscaling.GroupName).GroupVersions[0].Version}
 		Groups[autoscaling.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: autoscaling.SchemeGroupVersion,
-			internalTypes:        internalTypes,
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[batch.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: batch.GroupName, Version: legacyscheme.Registry.GroupOrDie(batch.GroupName).GroupVersions[0].Version}
 		Groups[batch.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: batch.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(batch.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[apps.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: apps.GroupName, Version: legacyscheme.Registry.GroupOrDie(apps.GroupName).GroupVersions[0].Version}
 		Groups[apps.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: apps.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(apps.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[policy.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: policy.GroupName, Version: legacyscheme.Registry.GroupOrDie(policy.GroupName).GroupVersions[0].Version}
 		Groups[policy.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: policy.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(policy.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[rbac.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: rbac.GroupName, Version: legacyscheme.Registry.GroupOrDie(rbac.GroupName).GroupVersions[0].Version}
 		Groups[rbac.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: rbac.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(rbac.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[scheduling.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: scheduling.GroupName, Version: legacyscheme.Registry.GroupOrDie(scheduling.GroupName).GroupVersions[0].Version}
 		Groups[scheduling.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: scheduling.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(scheduling.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[settings.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: settings.GroupName, Version: legacyscheme.Registry.GroupOrDie(settings.GroupName).GroupVersions[0].Version}
 		Groups[settings.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: settings.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(settings.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[storage.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: storage.GroupName, Version: legacyscheme.Registry.GroupOrDie(storage.GroupName).GroupVersions[0].Version}
 		Groups[storage.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: storage.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(storage.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[certificates.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: certificates.GroupName, Version: legacyscheme.Registry.GroupOrDie(certificates.GroupName).GroupVersions[0].Version}
 		Groups[certificates.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: certificates.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(certificates.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[imagepolicy.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: imagepolicy.GroupName, Version: legacyscheme.Registry.GroupOrDie(imagepolicy.GroupName).GroupVersions[0].Version}
 		Groups[imagepolicy.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: imagepolicy.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(imagepolicy.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[authorization.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: authorization.GroupName, Version: legacyscheme.Registry.GroupOrDie(authorization.GroupName).GroupVersions[0].Version}
 		Groups[authorization.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: authorization.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(authorization.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[admissionregistration.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: admissionregistration.GroupName, Version: legacyscheme.Registry.GroupOrDie(admissionregistration.GroupName).GroupVersions[0].Version}
 		Groups[admissionregistration.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: admissionregistration.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(admissionregistration.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[admission.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: admission.GroupName, Version: legacyscheme.Registry.GroupOrDie(admission.GroupName).GroupVersions[0].Version}
 		Groups[admission.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: admission.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(admission.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[networking.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: networking.GroupName, Version: legacyscheme.Registry.GroupOrDie(networking.GroupName).GroupVersions[0].Version}
 		Groups[networking.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: networking.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(networking.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 	if _, ok := Groups[events.GroupName]; !ok {
 		externalGroupVersion := schema.GroupVersion{Group: events.GroupName, Version: legacyscheme.Registry.GroupOrDie(events.GroupName).GroupVersions[0].Version}
 		Groups[events.GroupName] = TestGroup{
 			externalGroupVersion: externalGroupVersion,
-			internalGroupVersion: events.SchemeGroupVersion,
-			internalTypes:        legacyscheme.Scheme.KnownTypes(events.SchemeGroupVersion),
-			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
 
@@ -331,21 +263,10 @@ func init() {
 	Batch = Groups[batch.GroupName]
 	Apps = Groups[apps.GroupName]
 	Policy = Groups[policy.GroupName]
-	Certificates = Groups[certificates.GroupName]
 	Extensions = Groups[extensions.GroupName]
-	Events = Groups[events.GroupName]
 	Rbac = Groups[rbac.GroupName]
-	Scheduling = Groups[scheduling.GroupName]
-	Settings = Groups[settings.GroupName]
 	Storage = Groups[storage.GroupName]
-	ImagePolicy = Groups[imagepolicy.GroupName]
-	Authorization = Groups[authorization.GroupName]
 	Admission = Groups[admission.GroupName]
-	Networking = Groups[networking.GroupName]
-}
-
-func (g TestGroup) ContentConfig() (string, *schema.GroupVersion, runtime.Codec) {
-	return "application/json", g.GroupVersion(), g.Codec()
 }
 
 func (g TestGroup) GroupVersion() *schema.GroupVersion {
@@ -353,22 +274,6 @@ func (g TestGroup) GroupVersion() *schema.GroupVersion {
 	return &copyOfGroupVersion
 }
 
-// InternalGroupVersion returns the group,version used to identify the internal
-// types for this API
-func (g TestGroup) InternalGroupVersion() schema.GroupVersion {
-	return g.internalGroupVersion
-}
-
-// InternalTypes returns a map of internal API types' kind names to their Go types.
-func (g TestGroup) InternalTypes() map[string]reflect.Type {
-	return g.internalTypes
-}
-
-// ExternalTypes returns a map of external API types' kind names to their Go types.
-func (g TestGroup) ExternalTypes() map[string]reflect.Type {
-	return g.externalTypes
-}
-
 // Codec returns the codec for the API version to test against, as set by the
 // KUBE_TEST_API_TYPE env var.
 func (g TestGroup) Codec() runtime.Codec {
@@ -378,11 +283,6 @@ func (g TestGroup) Codec() runtime.Codec {
 	return legacyscheme.Codecs.CodecForVersions(serializer.Serializer, legacyscheme.Codecs.UniversalDeserializer(), schema.GroupVersions{g.externalGroupVersion}, nil)
 }
 
-// NegotiatedSerializer returns the negotiated serializer for the server.
-func (g TestGroup) NegotiatedSerializer() runtime.NegotiatedSerializer {
-	return legacyscheme.Codecs
-}
-
 func StorageMediaType() string {
 	return os.Getenv("KUBE_TEST_API_STORAGE_TYPE")
 }

pkg/api/testing/conversion_test.go

@@ -24,6 +24,7 @@ import (
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/diff"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
@@ -46,11 +47,11 @@ func BenchmarkPodConversion(b *testing.B) {
 	scheme := legacyscheme.Scheme
 	for i := 0; i < b.N; i++ {
 		pod := &items[i%width]
-		versionedObj, err := scheme.UnsafeConvertToVersion(pod, legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersions[0])
+		versionedObj, err := scheme.UnsafeConvertToVersion(pod, schema.GroupVersion{Group: "", Version: "v1"})
 		if err != nil {
 			b.Fatalf("Conversion error: %v", err)
 		}
-		if _, err = scheme.UnsafeConvertToVersion(versionedObj, testapi.Default.InternalGroupVersion()); err != nil {
+		if _, err = scheme.UnsafeConvertToVersion(versionedObj, schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal}); err != nil {
 			b.Fatalf("Conversion error: %v", err)
 		}
 	}
@@ -70,11 +71,11 @@ func BenchmarkNodeConversion(b *testing.B) {
 	var result *api.Node
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		versionedObj, err := scheme.UnsafeConvertToVersion(&node, legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersions[0])
+		versionedObj, err := scheme.UnsafeConvertToVersion(&node, schema.GroupVersion{Group: "", Version: "v1"})
 		if err != nil {
 			b.Fatalf("Conversion error: %v", err)
 		}
-		obj, err := scheme.UnsafeConvertToVersion(versionedObj, testapi.Default.InternalGroupVersion())
+		obj, err := scheme.UnsafeConvertToVersion(versionedObj, schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal})
 		if err != nil {
 			b.Fatalf("Conversion error: %v", err)
 		}
@@ -100,11 +101,11 @@ func BenchmarkReplicationControllerConversion(b *testing.B) {
 	var result *api.ReplicationController
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		versionedObj, err := scheme.UnsafeConvertToVersion(&replicationController, legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersions[0])
+		versionedObj, err := scheme.UnsafeConvertToVersion(&replicationController, schema.GroupVersion{Group: "", Version: "v1"})
 		if err != nil {
 			b.Fatalf("Conversion error: %v", err)
 		}
-		obj, err := scheme.UnsafeConvertToVersion(versionedObj, testapi.Default.InternalGroupVersion())
+		obj, err := scheme.UnsafeConvertToVersion(versionedObj, schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal})
 		if err != nil {
 			b.Fatalf("Conversion error: %v", err)
 		}

pkg/api/testing/copy_test.go

@@ -26,16 +26,15 @@ import (
 
 	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
 	"k8s.io/apimachinery/pkg/api/testing/roundtrip"
+	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/diff"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
-	"k8s.io/kubernetes/pkg/api/testapi"
-	api "k8s.io/kubernetes/pkg/apis/core"
 )
 
 func TestDeepCopyApiObjects(t *testing.T) {
 	for i := 0; i < *roundtrip.FuzzIters; i++ {
-		for _, version := range []schema.GroupVersion{testapi.Default.InternalGroupVersion(), legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersions[0]} {
+		for _, version := range []schema.GroupVersion{{Group: "", Version: runtime.APIVersionInternal}, {Group: "", Version: "v1"}} {
 			f := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(rand.Int63()), legacyscheme.Codecs)
 			for kind := range legacyscheme.Scheme.KnownTypes(version) {
 				doDeepCopyTest(t, version.WithKind(kind), f)
@@ -79,7 +78,7 @@ func doDeepCopyTest(t *testing.T, kind schema.GroupVersionKind, f *fuzz.Fuzzer)
 
 func TestDeepCopySingleType(t *testing.T) {
 	for i := 0; i < *roundtrip.FuzzIters; i++ {
-		for _, version := range []schema.GroupVersion{testapi.Default.InternalGroupVersion(), legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersions[0]} {
+		for _, version := range []schema.GroupVersion{{Group: "", Version: runtime.APIVersionInternal}, {Group: "", Version: "v1"}} {
 			f := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(rand.Int63()), legacyscheme.Codecs)
 			doDeepCopyTest(t, version.WithKind("Pod"), f)
 		}

pkg/api/testing/serialization_test.go

@@ -89,7 +89,7 @@ func TestSetControllerConversion(t *testing.T) {
 	extGroup := testapi.Extensions
 	defaultGroup := testapi.Default
 
-	fuzzInternalObject(t, extGroup.InternalGroupVersion(), rs, rand.Int63())
+	fuzzInternalObject(t, schema.GroupVersion{Group: "extensions", Version: runtime.APIVersionInternal}, rs, rand.Int63())
 
 	// explicitly set the selector to something that is convertible to old-style selectors
 	// (since normally we'll fuzz the selectors with things that aren't convertible)

pkg/api/testing/unstructured_test.go

@@ -30,6 +30,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	metaunstruct "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/diff"
 	"k8s.io/apimachinery/pkg/util/json"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
@@ -37,11 +38,11 @@ import (
 	api "k8s.io/kubernetes/pkg/apis/core"
 )
 
-func doRoundTrip(t *testing.T, group testapi.TestGroup, kind string) {
+func doRoundTrip(t *testing.T, internalVersion schema.GroupVersion, externalVersion schema.GroupVersion, kind string) {
 	// We do fuzzing on the internal version of the object, and only then
 	// convert to the external version. This is because custom fuzzing
 	// function are only supported for internal objects.
-	internalObj, err := legacyscheme.Scheme.New(group.InternalGroupVersion().WithKind(kind))
+	internalObj, err := legacyscheme.Scheme.New(internalVersion.WithKind(kind))
 	if err != nil {
 		t.Fatalf("Couldn't create internal object %v: %v", kind, err)
 	}
@@ -62,7 +63,7 @@ func doRoundTrip(t *testing.T, group testapi.TestGroup, kind string) {
 			},
 		).Fuzz(internalObj)
 
-	item, err := legacyscheme.Scheme.New(group.GroupVersion().WithKind(kind))
+	item, err := legacyscheme.Scheme.New(externalVersion.WithKind(kind))
 	if err != nil {
 		t.Fatalf("Couldn't create external object %v: %v", kind, err)
 	}
@@ -118,13 +119,13 @@ func doRoundTrip(t *testing.T, group testapi.TestGroup, kind string) {
 
 func TestRoundTrip(t *testing.T) {
 	for groupKey, group := range testapi.Groups {
-		for kind := range group.ExternalTypes() {
+		for kind := range legacyscheme.Scheme.KnownTypes(*group.GroupVersion()) {
 			if nonRoundTrippableTypes.Has(kind) {
 				continue
 			}
 			t.Logf("Testing: %v in %v", kind, groupKey)
 			for i := 0; i < 50; i++ {
-				doRoundTrip(t, group, kind)
+				doRoundTrip(t, schema.GroupVersion{Group: groupKey, Version: runtime.APIVersionInternal}, *group.GroupVersion(), kind)
 				if t.Failed() {
 					break
 				}
@@ -135,7 +136,7 @@ func TestRoundTrip(t *testing.T) {
 
 func TestRoundTripWithEmptyCreationTimestamp(t *testing.T) {
 	for groupKey, group := range testapi.Groups {
-		for kind := range group.ExternalTypes() {
+		for kind := range legacyscheme.Scheme.KnownTypes(*group.GroupVersion()) {
 			if nonRoundTrippableTypes.Has(kind) {
 				continue
 			}