github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

registry: cut-off kube dependencies from registrytest

pull/6/head
Dr. Stefan Schimanski 2017-11-13 17:55:39 +01:00
parent 6e950cc629
commit 3410f536f4
31 changed files with 205 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
pkg/registry/apps/controllerrevision/storage/storage_test.go
View File

@ -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{

11
pkg/registry/apps/statefulset/storage/storage_test.go
View File

@ -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

13
pkg/registry/autoscaling/horizontalpodautoscaler/storage/storage_test.go
View File

@ -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

13
pkg/registry/batch/cronjob/storage/storage_test.go
View File

@ -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

13
pkg/registry/batch/job/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/configmap/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/endpoint/storage/storage_test.go
View File

@ -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

7
pkg/registry/core/event/storage/storage_test.go
View File

@ -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()))
}

13
pkg/registry/core/limitrange/storage/storage_test.go
View File

@ -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

11
pkg/registry/core/namespace/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/node/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/persistentvolume/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/persistentvolumeclaim/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/pod/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/podtemplate/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/replicationcontroller/storage/storage_test.go
View File

@ -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

11
pkg/registry/core/resourcequota/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/secret/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/service/storage/storage_test.go
View File

@ -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

13
pkg/registry/core/serviceaccount/storage/storage_test.go
View File

@ -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

13
pkg/registry/extensions/daemonset/storage/storage_test.go
View File

@ -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

13
pkg/registry/extensions/deployment/storage/storage_test.go
View File

@ -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

13
pkg/registry/extensions/ingress/storage/storage_test.go
View File

@ -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

13
pkg/registry/extensions/podsecuritypolicy/storage/storage_test.go
View File

@ -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

13
pkg/registry/extensions/replicaset/storage/storage_test.go
View File

@ -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

13
pkg/registry/networking/networkpolicy/storage/storage_test.go
View File

@ -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

11
pkg/registry/policy/poddisruptionbudget/storage/storage_test.go
View File

@ -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

29
pkg/registry/registrytest/etcd.go
View File

@ -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) {

13
pkg/registry/scheduling/priorityclass/storage/storage_test.go
View File

@ -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

13
pkg/registry/settings/podpreset/storage/storage_test.go
View File

@ -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

13
pkg/registry/storage/storageclass/storage/storage_test.go
View File

@ -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