registry: cut-off kube dependencies from registrytest

pkg/registry/apps/controllerrevision/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/apps"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -34,7 +35,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	var (
 		valid       = stripObjectMeta(newControllerRevision("validname", metav1.NamespaceDefault, newObject(), 0))
 		badRevision = stripObjectMeta(newControllerRevision("validname", "validns", newObject(), -1))
@@ -58,7 +59,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 
 	addLabel := func(obj runtime.Object) runtime.Object {
 		rev := obj.(*apps.ControllerRevision)
@@ -93,7 +94,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
 }
 
@@ -101,7 +102,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
 }
 
@@ -109,7 +110,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
 }
 
@@ -117,7 +118,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0),
 		[]labels.Set{

pkg/registry/apps/statefulset/storage/storage_test.go

@@ -29,6 +29,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/apps"
 	"k8s.io/kubernetes/pkg/apis/autoscaling"
 	api "k8s.io/kubernetes/pkg/apis/core"
@@ -93,7 +94,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.StatefulSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.StatefulSet.Store)
+	test := registrytest.New(t, storage.StatefulSet.Store, legacyscheme.Scheme)
 	ps := validNewStatefulSet()
 	ps.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -146,7 +147,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.StatefulSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.StatefulSet.Store)
+	test := registrytest.New(t, storage.StatefulSet.Store, legacyscheme.Scheme)
 	test.TestGet(validNewStatefulSet())
 }
 
@@ -154,7 +155,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.StatefulSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.StatefulSet.Store)
+	test := registrytest.New(t, storage.StatefulSet.Store, legacyscheme.Scheme)
 	test.TestList(validNewStatefulSet())
 }
 
@@ -162,7 +163,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.StatefulSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.StatefulSet.Store)
+	test := registrytest.New(t, storage.StatefulSet.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewStatefulSet())
 }
 
@@ -170,7 +171,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.StatefulSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.StatefulSet.Store)
+	test := registrytest.New(t, storage.StatefulSet.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewStatefulSet(),
 		// matching labels

pkg/registry/autoscaling/horizontalpodautoscaler/storage/storage_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/autoscaling"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	// Ensure that autoscaling/v1 package is initialized.
@@ -74,7 +75,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	autoscaler := validNewHorizontalPodAutoscaler("foo")
 	autoscaler.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -89,7 +90,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewHorizontalPodAutoscaler("foo"),
@@ -106,7 +107,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewHorizontalPodAutoscaler("foo"))
 }
 
@@ -114,7 +115,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewHorizontalPodAutoscaler("foo"))
 }
 
@@ -122,7 +123,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewHorizontalPodAutoscaler("foo"))
 }
 
@@ -130,7 +131,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewHorizontalPodAutoscaler("foo"),
 		// matching labels

pkg/registry/batch/cronjob/storage/storage_test.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/apis/batch"
 	api "k8s.io/kubernetes/pkg/apis/core"
@@ -73,7 +74,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	validCronJob := validNewCronJob()
 	validCronJob.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -95,7 +96,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	schedule := "1 1 1 1 ?"
 	test.TestUpdate(
 		// valid
@@ -124,7 +125,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewCronJob())
 }
 
@@ -137,7 +138,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewCronJob())
 }
 
@@ -150,7 +151,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewCronJob())
 }
 
@@ -163,7 +164,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewCronJob(),
 		// matching labels

pkg/registry/batch/job/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/batch"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -82,7 +83,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Job.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Job.Store)
+	test := registrytest.New(t, storage.Job.Store, legacyscheme.Scheme)
 	validJob := validNewJob()
 	validJob.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -103,7 +104,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Job.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Job.Store)
+	test := registrytest.New(t, storage.Job.Store, legacyscheme.Scheme)
 	two := int32(2)
 	test.TestUpdate(
 		// valid
@@ -132,7 +133,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Job.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Job.Store)
+	test := registrytest.New(t, storage.Job.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewJob())
 }
 
@@ -140,7 +141,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Job.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Job.Store)
+	test := registrytest.New(t, storage.Job.Store, legacyscheme.Scheme)
 	test.TestGet(validNewJob())
 }
 
@@ -148,7 +149,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Job.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Job.Store)
+	test := registrytest.New(t, storage.Job.Store, legacyscheme.Scheme)
 	test.TestList(validNewJob())
 }
 
@@ -156,7 +157,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Job.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Job.Store)
+	test := registrytest.New(t, storage.Job.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewJob(),
 		// matching labels

pkg/registry/core/configmap/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -60,7 +61,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 
 	validConfigMap := validNewConfigMap()
 	validConfigMap.ObjectMeta = metav1.ObjectMeta{
@@ -88,7 +89,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewConfigMap(),
@@ -111,7 +112,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewConfigMap())
 }
 
@@ -119,7 +120,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewConfigMap())
 }
 
@@ -127,7 +128,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewConfigMap())
 }
 
@@ -135,7 +136,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewConfigMap(),
 		// matching labels

pkg/registry/core/endpoint/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -67,7 +68,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	endpoints := validNewEndpoints()
 	endpoints.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -84,7 +85,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).AllowCreateOnUpdate()
 	test.TestUpdate(
 		// valid
 		validNewEndpoints(),
@@ -104,7 +105,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewEndpoints())
 }
 
@@ -112,7 +113,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewEndpoints())
 }
 
@@ -120,7 +121,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewEndpoints())
 }
 
@@ -128,7 +129,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewEndpoints(),
 		// matching labels

pkg/registry/core/event/storage/storage_test.go

@@ -23,6 +23,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -58,7 +59,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	event := validNewEvent(test.TestNamespace())
 	event.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -73,7 +74,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).AllowCreateOnUpdate()
 	test.TestUpdate(
 		// valid
 		validNewEvent(test.TestNamespace()),
@@ -96,7 +97,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewEvent(test.TestNamespace()))
 }
 

pkg/registry/core/limitrange/storage/storage_test.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -69,7 +70,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).GeneratesName()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).GeneratesName()
 	validLimitRange := validNewLimitRange()
 	validLimitRange.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -86,7 +87,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).AllowCreateOnUpdate()
 	test.TestUpdate(
 		// valid
 		validNewLimitRange(),
@@ -115,7 +116,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewLimitRange())
 }
 
@@ -123,7 +124,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewLimitRange())
 }
 
@@ -131,7 +132,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewLimitRange())
 }
 
@@ -139,7 +140,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewLimitRange(),
 		// matching labels

pkg/registry/core/namespace/storage/storage_test.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -49,7 +50,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.store).ClusterScope()
+	test := registrytest.New(t, storage.store, legacyscheme.Scheme).ClusterScope()
 	namespace := validNewNamespace()
 	namespace.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
 	test.TestCreate(
@@ -93,7 +94,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.store).ClusterScope().ReturnDeletedObject()
+	test := registrytest.New(t, storage.store, legacyscheme.Scheme).ClusterScope().ReturnDeletedObject()
 	test.TestDelete(validNewNamespace())
 }
 
@@ -101,7 +102,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.store).ClusterScope()
+	test := registrytest.New(t, storage.store, legacyscheme.Scheme).ClusterScope()
 	test.TestGet(validNewNamespace())
 }
 
@@ -109,7 +110,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.store).ClusterScope()
+	test := registrytest.New(t, storage.store, legacyscheme.Scheme).ClusterScope()
 	test.TestList(validNewNamespace())
 }
 
@@ -117,7 +118,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.store).ClusterScope()
+	test := registrytest.New(t, storage.store, legacyscheme.Scheme).ClusterScope()
 	test.TestWatch(
 		validNewNamespace(),
 		// matching labels

pkg/registry/core/node/storage/storage_test.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	kubeletclient "k8s.io/kubernetes/pkg/kubelet/client"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -70,7 +71,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	node := validNewNode()
 	node.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
 	test.TestCreate(
@@ -87,7 +88,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestUpdate(
 		// valid
 		validNewNode(),
@@ -104,7 +105,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestDelete(validNewNode())
 }
 
@@ -112,7 +113,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestGet(validNewNode())
 }
 
@@ -120,7 +121,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestList(validNewNode())
 }
 
@@ -128,7 +129,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestWatch(
 		validNewNode(),
 		// matching labels

pkg/registry/core/persistentvolume/storage/storage_test.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -85,7 +86,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	pv := validNewPersistentVolume("foo")
 	pv.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
 	test.TestCreate(
@@ -102,7 +103,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestUpdate(
 		// valid
 		validNewPersistentVolume("foo"),
@@ -121,7 +122,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope().ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope().ReturnDeletedObject()
 	test.TestDelete(validNewPersistentVolume("foo"))
 }
 
@@ -129,7 +130,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestGet(validNewPersistentVolume("foo"))
 }
 
@@ -137,7 +138,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestList(validNewPersistentVolume("foo"))
 }
 
@@ -145,7 +146,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestWatch(
 		validNewPersistentVolume("foo"),
 		// matching labels

pkg/registry/core/persistentvolumeclaim/storage/storage_test.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -71,7 +72,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	pv := validNewPersistentVolumeClaim("foo", metav1.NamespaceDefault)
 	pv.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -88,7 +89,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewPersistentVolumeClaim("foo", metav1.NamespaceDefault),
@@ -105,7 +106,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ReturnDeletedObject()
 	test.TestDelete(validNewPersistentVolumeClaim("foo", metav1.NamespaceDefault))
 }
 
@@ -113,7 +114,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewPersistentVolumeClaim("foo", metav1.NamespaceDefault))
 }
 
@@ -121,7 +122,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewPersistentVolumeClaim("foo", metav1.NamespaceDefault))
 }
 
@@ -129,7 +130,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewPersistentVolumeClaim("foo", metav1.NamespaceDefault),
 		// matching labels

pkg/registry/core/pod/storage/storage_test.go

@@ -40,6 +40,7 @@ import (
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	utilfeaturetesting "k8s.io/apiserver/pkg/util/feature/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 	"k8s.io/kubernetes/pkg/securitycontext"
@@ -98,7 +99,7 @@ func TestCreate(t *testing.T) {
 	storage, _, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	pod := validNewPod()
 	pod.ObjectMeta = metav1.ObjectMeta{}
 	// Make an invalid pod with an an incorrect label.
@@ -125,7 +126,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewPod(),
@@ -142,7 +143,7 @@ func TestDelete(t *testing.T) {
 	storage, _, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ReturnDeletedObject()
 	test.TestDelete(validNewPod())
 
 	scheduledPod := validNewPod()
@@ -366,7 +367,7 @@ func TestGet(t *testing.T) {
 	storage, _, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewPod())
 }
 
@@ -374,7 +375,7 @@ func TestList(t *testing.T) {
 	storage, _, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewPod())
 }
 
@@ -382,7 +383,7 @@ func TestWatch(t *testing.T) {
 	storage, _, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewPod(),
 		// matching labels

pkg/registry/core/podtemplate/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -72,7 +73,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	pod := validNewPodTemplate("foo")
 	pod.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -89,7 +90,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		//valid
 		validNewPodTemplate("foo"),
@@ -106,7 +107,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ReturnDeletedObject()
 	test.TestDelete(validNewPodTemplate("foo"))
 }
 
@@ -114,7 +115,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewPodTemplate("foo"))
 }
 
@@ -122,7 +123,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewPodTemplate("foo"))
 }
 
@@ -130,7 +131,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewPodTemplate("foo"),
 		// matching labels

pkg/registry/core/replicationcontroller/storage/storage_test.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/autoscaling"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -98,7 +99,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Controller.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Controller.Store)
+	test := registrytest.New(t, storage.Controller.Store, legacyscheme.Scheme)
 	controller := validNewController()
 	controller.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -119,7 +120,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Controller.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Controller.Store)
+	test := registrytest.New(t, storage.Controller.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewController(),
@@ -147,7 +148,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Controller.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Controller.Store)
+	test := registrytest.New(t, storage.Controller.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewController())
 }
 
@@ -206,7 +207,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Controller.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Controller.Store)
+	test := registrytest.New(t, storage.Controller.Store, legacyscheme.Scheme)
 	test.TestGet(validNewController())
 }
 
@@ -214,7 +215,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Controller.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Controller.Store)
+	test := registrytest.New(t, storage.Controller.Store, legacyscheme.Scheme)
 	test.TestList(validNewController())
 }
 
@@ -222,7 +223,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Controller.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Controller.Store)
+	test := registrytest.New(t, storage.Controller.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validController,
 		// matching labels

pkg/registry/core/resourcequota/storage/storage_test.go

@@ -29,6 +29,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -68,7 +69,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	resourcequota := validNewResourceQuota()
 	resourcequota.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -109,7 +110,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ReturnDeletedObject()
 	test.TestDelete(validNewResourceQuota())
 }
 
@@ -117,7 +118,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewResourceQuota())
 }
 
@@ -125,7 +126,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewResourceQuota())
 }
 
@@ -133,7 +134,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewResourceQuota(),
 		// matching labels

pkg/registry/core/secret/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -56,7 +57,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	secret := validNewSecret("foo")
 	secret.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo-"}
 	test.TestCreate(
@@ -79,7 +80,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewSecret("foo"),
@@ -96,7 +97,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewSecret("foo"))
 }
 
@@ -104,7 +105,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewSecret("foo"))
 }
 
@@ -112,7 +113,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewSecret("foo"))
 }
 
@@ -120,7 +121,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewSecret("foo"),
 		// matching labels

pkg/registry/core/service/storage/storage_test.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -66,7 +67,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	validService := validService()
 	validService.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -97,7 +98,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).AllowCreateOnUpdate()
 	test.TestUpdate(
 		// valid
 		validService(),
@@ -124,7 +125,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).AllowCreateOnUpdate()
 	test.TestDelete(validService())
 }
 
@@ -132,7 +133,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).AllowCreateOnUpdate()
 	test.TestGet(validService())
 }
 
@@ -140,7 +141,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).AllowCreateOnUpdate()
 	test.TestList(validService())
 }
 
@@ -148,7 +149,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validService(),
 		// matching labels

pkg/registry/core/serviceaccount/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -54,7 +55,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	serviceAccount := validNewServiceAccount("foo")
 	serviceAccount.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo-"}
 	test.TestCreate(
@@ -72,7 +73,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewServiceAccount("foo"),
@@ -89,7 +90,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ReturnDeletedObject()
 	test.TestDelete(validNewServiceAccount("foo"))
 }
 
@@ -97,7 +98,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewServiceAccount("foo"))
 }
 
@@ -105,7 +106,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewServiceAccount("foo"))
 }
 
@@ -113,7 +114,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewServiceAccount("foo"),
 		// matching labels

pkg/registry/extensions/daemonset/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -80,7 +81,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	ds := newValidDaemonSet()
 	ds.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -107,7 +108,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		newValidDaemonSet(),
@@ -136,7 +137,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(newValidDaemonSet())
 }
 
@@ -144,7 +145,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(newValidDaemonSet())
 }
 
@@ -152,7 +153,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(newValidDaemonSet())
 }
 
@@ -160,7 +161,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validDaemonSet,
 		// matching labels

pkg/registry/extensions/deployment/storage/storage_test.go

@@ -34,6 +34,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/rest"
 	storeerr "k8s.io/apiserver/pkg/storage/errors"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/autoscaling"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/extensions"
@@ -98,7 +99,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Deployment.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Deployment.Store)
+	test := registrytest.New(t, storage.Deployment.Store, legacyscheme.Scheme)
 	deployment := validNewDeployment()
 	deployment.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -118,7 +119,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Deployment.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Deployment.Store)
+	test := registrytest.New(t, storage.Deployment.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewDeployment(),
@@ -151,7 +152,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Deployment.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Deployment.Store)
+	test := registrytest.New(t, storage.Deployment.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewDeployment())
 }
 
@@ -159,7 +160,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Deployment.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Deployment.Store)
+	test := registrytest.New(t, storage.Deployment.Store, legacyscheme.Scheme)
 	test.TestGet(validNewDeployment())
 }
 
@@ -167,7 +168,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Deployment.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Deployment.Store)
+	test := registrytest.New(t, storage.Deployment.Store, legacyscheme.Scheme)
 	test.TestList(validNewDeployment())
 }
 
@@ -175,7 +176,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Deployment.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Deployment.Store)
+	test := registrytest.New(t, storage.Deployment.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewDeployment(),
 		// matching labels

pkg/registry/extensions/ingress/storage/storage_test.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -122,7 +123,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	ingress := validIngress()
 	noDefaultBackendAndRules := validIngress()
 	noDefaultBackendAndRules.Spec.Backend = &extensions.IngressBackend{}
@@ -142,7 +143,7 @@ func TestUpdate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validIngress(),
@@ -178,7 +179,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validIngress())
 }
 
@@ -186,7 +187,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validIngress())
 }
 
@@ -194,7 +195,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validIngress())
 }
 
@@ -202,7 +203,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validIngress(),
 		// matching labels

pkg/registry/extensions/podsecuritypolicy/storage/storage_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	// Ensure that extensions/v1beta1 package is initialized.
 	_ "k8s.io/api/extensions/v1beta1"
@@ -68,7 +69,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	psp := validNewPodSecurityPolicy()
 	psp.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo-"}
 	test.TestCreate(
@@ -85,7 +86,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestUpdate(
 		// valid
 		validNewPodSecurityPolicy(),
@@ -102,7 +103,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope().ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope().ReturnDeletedObject()
 	test.TestDelete(validNewPodSecurityPolicy())
 }
 
@@ -110,7 +111,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestGet(validNewPodSecurityPolicy())
 }
 
@@ -118,7 +119,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestList(validNewPodSecurityPolicy())
 }
 
@@ -126,7 +127,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestWatch(
 		validNewPodSecurityPolicy(),
 		// matching labels

pkg/registry/extensions/replicaset/storage/storage_test.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/autoscaling"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/extensions"
@@ -95,7 +96,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.ReplicaSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.ReplicaSet.Store)
+	test := registrytest.New(t, storage.ReplicaSet.Store, legacyscheme.Scheme)
 	rs := validNewReplicaSet()
 	rs.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -116,7 +117,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.ReplicaSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.ReplicaSet.Store)
+	test := registrytest.New(t, storage.ReplicaSet.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewReplicaSet(),
@@ -144,7 +145,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.ReplicaSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.ReplicaSet.Store)
+	test := registrytest.New(t, storage.ReplicaSet.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewReplicaSet())
 }
 
@@ -203,7 +204,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.ReplicaSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.ReplicaSet.Store)
+	test := registrytest.New(t, storage.ReplicaSet.Store, legacyscheme.Scheme)
 	test.TestGet(validNewReplicaSet())
 }
 
@@ -211,7 +212,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.ReplicaSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.ReplicaSet.Store)
+	test := registrytest.New(t, storage.ReplicaSet.Store, legacyscheme.Scheme)
 	test.TestList(validNewReplicaSet())
 }
 
@@ -219,7 +220,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.ReplicaSet.Store.DestroyFunc()
-	test := registrytest.New(t, storage.ReplicaSet.Store)
+	test := registrytest.New(t, storage.ReplicaSet.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewReplicaSet(),
 		// matching labels

pkg/registry/networking/networkpolicy/storage/storage_test.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/networking"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -71,7 +72,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	np := validNetworkPolicy()
 	np.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo-"}
 	test.TestCreate(
@@ -89,7 +90,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNetworkPolicy(),
@@ -132,7 +133,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNetworkPolicy())
 }
 
@@ -140,7 +141,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNetworkPolicy())
 }
 
@@ -148,7 +149,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNetworkPolicy())
 }
 
@@ -156,7 +157,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNetworkPolicy(),
 		// matching labels

pkg/registry/policy/poddisruptionbudget/storage/storage_test.go

@@ -27,6 +27,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/generic"
 	"k8s.io/apiserver/pkg/registry/rest"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/policy"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -69,7 +70,7 @@ func TestCreate(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	pdb := validNewPodDisruptionBudget()
 	pdb.ObjectMeta = metav1.ObjectMeta{}
 	test.TestCreate(
@@ -130,7 +131,7 @@ func TestGet(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewPodDisruptionBudget())
 }
 
@@ -138,7 +139,7 @@ func TestList(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewPodDisruptionBudget())
 }
 
@@ -146,7 +147,7 @@ func TestDelete(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewPodDisruptionBudget())
 }
 
@@ -154,7 +155,7 @@ func TestWatch(t *testing.T) {
 	storage, _, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewPodDisruptionBudget(),
 		// matching labels

pkg/registry/registrytest/etcd.go

@@ -33,9 +33,7 @@ import (
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
 	"k8s.io/apiserver/pkg/storage/storagebackend"
 	storagetesting "k8s.io/apiserver/pkg/storage/testing"
-	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
-	api "k8s.io/kubernetes/pkg/apis/core"
 )
 
 func NewEtcdStorage(t *testing.T, group string) (*storagebackend.Config, *etcdtesting.EtcdTestServer) {
@@ -50,9 +48,9 @@ type Tester struct {
 }
 type UpdateFunc func(runtime.Object) runtime.Object
 
-func New(t *testing.T, storage *genericregistry.Store) *Tester {
+func New(t *testing.T, storage *genericregistry.Store, scheme *runtime.Scheme) *Tester {
 	return &Tester{
-		tester:  resttest.New(t, storage, legacyscheme.Scheme),
+		tester:  resttest.New(t, storage, scheme),
 		storage: storage,
 	}
 }
@@ -151,29 +149,6 @@ func (t *Tester) TestWatch(valid runtime.Object, labelsPass, labelsFail []labels
 	)
 }
 
-// =============================================================================
-// get codec based on runtime.Object
-func getCodec(obj runtime.Object) (runtime.Codec, error) {
-	fqKinds, _, err := legacyscheme.Scheme.ObjectKinds(obj)
-	if err != nil {
-		return nil, fmt.Errorf("unexpected encoding error: %v", err)
-	}
-	fqKind := fqKinds[0]
-	// TODO: caesarxuchao: we should detect which group an object belongs to
-	// by using the version returned by Schem.ObjectVersionAndKind() once we
-	// split the schemes for internal objects.
-	// TODO: caesarxuchao: we should add a map from kind to group in Scheme.
-	var codec runtime.Codec
-	if legacyscheme.Scheme.Recognizes(legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersion.WithKind(fqKind.Kind)) {
-		codec = testapi.Default.Codec()
-	} else if legacyscheme.Scheme.Recognizes(testapi.Extensions.GroupVersion().WithKind(fqKind.Kind)) {
-		codec = testapi.Extensions.Codec()
-	} else {
-		return nil, fmt.Errorf("unexpected kind: %v", fqKind)
-	}
-	return codec, nil
-}
-
 // Helper functions
 
 func (t *Tester) getObject(ctx genericapirequest.Context, obj runtime.Object) (runtime.Object, error) {

pkg/registry/scheduling/priorityclass/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/scheduling"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
 )
@@ -55,7 +56,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestCreate(
 		validNewPriorityClass(),
 		// invalid cases
@@ -74,7 +75,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestUpdate(
 		// valid
 		validNewPriorityClass(),
@@ -100,7 +101,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestDelete(validNewPriorityClass())
 }
 
@@ -108,7 +109,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestGet(validNewPriorityClass())
 }
 
@@ -116,7 +117,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestList(validNewPriorityClass())
 }
 
@@ -124,7 +125,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestWatch(
 		validNewPriorityClass(),
 		// matching labels

pkg/registry/settings/podpreset/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/settings"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -102,7 +103,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	invalidPodPreset := validNewPodPreset(test.TestNamespace())
 	invalidPodPreset.Spec.VolumeMounts[0].Name = "/cache/VolumeMounts"
 	test.TestCreate(
@@ -116,7 +117,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestUpdate(
 		// valid
 		validNewPodPreset(test.TestNamespace()),
@@ -133,7 +134,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestDelete(validNewPodPreset(test.TestNamespace()))
 }
 
@@ -141,7 +142,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestGet(validNewPodPreset(test.TestNamespace()))
 }
 
@@ -149,7 +150,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestList(validNewPodPreset(test.TestNamespace()))
 }
 
@@ -157,7 +158,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store)
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme)
 	test.TestWatch(
 		validNewPodPreset(test.TestNamespace()),
 		// matching labels

pkg/registry/storage/storageclass/storage/storage_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apiserver/pkg/registry/generic"
 	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	storageapi "k8s.io/kubernetes/pkg/apis/storage"
 	"k8s.io/kubernetes/pkg/registry/registrytest"
@@ -64,7 +65,7 @@ func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	storageClass := validNewStorageClass("foo")
 	storageClass.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
 	deleteReclaimPolicy := api.PersistentVolumeReclaimDelete
@@ -83,7 +84,7 @@ func TestUpdate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestUpdate(
 		// valid
 		validNewStorageClass("foo"),
@@ -107,7 +108,7 @@ func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope().ReturnDeletedObject()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope().ReturnDeletedObject()
 	test.TestDelete(validNewStorageClass("foo"))
 }
 
@@ -115,7 +116,7 @@ func TestGet(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestGet(validNewStorageClass("foo"))
 }
 
@@ -123,7 +124,7 @@ func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestList(validNewStorageClass("foo"))
 }
 
@@ -131,7 +132,7 @@ func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
 	defer storage.Store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.Store, legacyscheme.Scheme).ClusterScope()
 	test.TestWatch(
 		validNewStorageClass("foo"),
 		// matching labels