From 02851dd1b78cc7659f639b827a215531e356f197 Mon Sep 17 00:00:00 2001 From: "Timothy St. Clair" Date: Tue, 3 Nov 2015 13:43:27 -0600 Subject: [PATCH] Removal of fakeClient and shift to storage.Interface for all registry tests. --- pkg/api/rest/resttest/resttest.go | 142 +++---------- pkg/registry/controller/etcd/etcd_test.go | 41 ++-- pkg/registry/daemonset/etcd/etcd_test.go | 38 ++-- pkg/registry/deployment/etcd/etcd_test.go | 67 +++--- pkg/registry/endpoint/etcd/etcd_test.go | 38 ++-- pkg/registry/event/etcd/etcd_test.go | 24 ++- .../experimental/controller/etcd/etcd_test.go | 41 ++-- pkg/registry/generic/etcd/etcd_test.go | 2 +- .../horizontalpodautoscaler/etcd/etcd_test.go | 38 ++-- pkg/registry/ingress/etcd/etcd_test.go | 38 ++-- pkg/registry/job/etcd/etcd_test.go | 38 ++-- pkg/registry/limitrange/etcd/etcd_test.go | 38 ++-- pkg/registry/namespace/etcd/etcd_test.go | 48 +++-- pkg/registry/node/etcd/etcd_test.go | 38 ++-- .../persistentvolume/etcd/etcd_test.go | 68 +++--- .../persistentvolumeclaim/etcd/etcd_test.go | 65 +++--- pkg/registry/pod/etcd/etcd_test.go | 200 ++++++++---------- pkg/registry/podtemplate/etcd/etcd_test.go | 38 ++-- pkg/registry/registrytest/etcd.go | 141 ++++-------- pkg/registry/resourcequota/etcd/etcd_test.go | 80 ++++--- pkg/registry/secret/etcd/etcd_test.go | 38 ++-- .../service/allocator/etcd/etcd_test.go | 28 +-- pkg/registry/service/etcd/etcd_test.go | 38 ++-- .../service/ipallocator/etcd/etcd_test.go | 31 ++- pkg/registry/serviceaccount/etcd/etcd_test.go | 38 ++-- .../thirdpartyresource/etcd/etcd_test.go | 38 ++-- .../thirdpartyresourcedata/etcd/etcd_test.go | 38 ++-- pkg/storage/testing/utils.go | 32 +-- 28 files changed, 709 insertions(+), 795 deletions(-) diff --git a/pkg/api/rest/resttest/resttest.go b/pkg/api/rest/resttest/resttest.go index d688444561..d565eb0abd 100644 --- a/pkg/api/rest/resttest/resttest.go +++ b/pkg/api/rest/resttest/resttest.go @@ -32,36 +32,25 @@ import ( "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" "k8s.io/kubernetes/pkg/util" ) type Tester struct { *testing.T storage rest.Storage - storageError injectErrorFunc clusterScope bool createOnUpdate bool generatesName bool returnDeletedObject bool } -type injectErrorFunc func(err error) - -func New(t *testing.T, storage rest.Storage, storageError injectErrorFunc) *Tester { +func New(t *testing.T, storage rest.Storage) *Tester { return &Tester{ - T: t, - storage: storage, - storageError: storageError, + T: t, + storage: storage, } } -func (t *Tester) withStorageError(err error, fn func()) { - t.storageError(err) - defer t.storageError(nil) - fn() -} - func (t *Tester) ClusterScope() *Tester { t.clusterScope = true return t @@ -142,7 +131,6 @@ func (t *Tester) TestCreate(valid runtime.Object, setFn SetFunc, getFn GetFunc, t.testCreateHasMetadata(copyOrDie(valid)) if !t.generatesName { t.testCreateGeneratesName(copyOrDie(valid)) - t.testCreateGeneratesNameReturnsServerTimeout(copyOrDie(valid)) } t.testCreateEquals(copyOrDie(valid), getFn) t.testCreateAlreadyExisting(copyOrDie(valid), setFn) @@ -158,9 +146,9 @@ func (t *Tester) TestCreate(valid runtime.Object, setFn SetFunc, getFn GetFunc, } // Test updating an object. -func (t *Tester) TestUpdate(valid runtime.Object, setFn SetFunc, setRVFn SetRVFunc, getFn GetFunc, updateFn UpdateFunc, invalidUpdateFn ...UpdateFunc) { +func (t *Tester) TestUpdate(valid runtime.Object, setFn SetFunc, getFn GetFunc, updateFn UpdateFunc, invalidUpdateFn ...UpdateFunc) { t.testUpdateEquals(copyOrDie(valid), setFn, getFn, updateFn) - t.testUpdateFailsOnVersionTooOld(copyOrDie(valid), setFn, setRVFn) + t.testUpdateFailsOnVersionTooOld(copyOrDie(valid), setFn) t.testUpdateOnNotFound(copyOrDie(valid)) if !t.clusterScope { t.testUpdateRejectsMismatchedNamespace(copyOrDie(valid), setFn) @@ -194,20 +182,18 @@ func (t *Tester) TestGet(valid runtime.Object) { } // Test listing objects. -func (t *Tester) TestList(valid runtime.Object, assignFn AssignFunc, setRVFn SetRVFunc) { - t.testListError() +func (t *Tester) TestList(valid runtime.Object, assignFn AssignFunc) { + t.testListNotFound(assignFn) t.testListFound(copyOrDie(valid), assignFn) - t.testListNotFound(assignFn, setRVFn) t.testListMatchLabels(copyOrDie(valid), assignFn) } // Test watching objects. func (t *Tester) TestWatch( - valid runtime.Object, initWatchFn InitWatchFunc, injectErrFn InjectErrFunc, emitFn EmitFunc, + valid runtime.Object, emitFn EmitFunc, labelsPass, labelsFail []labels.Set, fieldsPass, fieldsFail []fields.Set, actions []string) { - t.testWatch(initWatchFn, injectErrFn) - t.testWatchLabels(copyOrDie(valid), initWatchFn, emitFn, labelsPass, labelsFail, actions) - t.testWatchFields(copyOrDie(valid), initWatchFn, emitFn, fieldsPass, fieldsFail, actions) + t.testWatchLabels(copyOrDie(valid), emitFn, labelsPass, labelsFail, actions) + t.testWatchFields(copyOrDie(valid), emitFn, fieldsPass, fieldsFail, actions) } // ============================================================================= @@ -285,18 +271,6 @@ func (t *Tester) testCreateGeneratesName(valid runtime.Object) { } } -func (t *Tester) testCreateGeneratesNameReturnsServerTimeout(valid runtime.Object) { - objectMeta := t.getObjectMetaOrFail(valid) - objectMeta.Name = "" - objectMeta.GenerateName = "test-" - t.withStorageError(errors.NewAlreadyExists("kind", "thing"), func() { - _, err := t.storage.(rest.Creater).Create(t.TestContext(), valid) - if err == nil || !errors.IsServerTimeout(err) { - t.Fatalf("Unexpected error: %v", err) - } - }) -} - func (t *Tester) testCreateHasMetadata(valid runtime.Object) { objectMeta := t.getObjectMetaOrFail(valid) objectMeta.Name = "" @@ -452,20 +426,19 @@ func (t *Tester) testUpdateEquals(obj runtime.Object, setFn SetFunc, getFn GetFu } } -func (t *Tester) testUpdateFailsOnVersionTooOld(obj runtime.Object, setFn SetFunc, setRVFn SetRVFunc) { +func (t *Tester) testUpdateFailsOnVersionTooOld(obj runtime.Object, setFn SetFunc) { ctx := t.TestContext() foo := copyOrDie(obj) t.setObjectMeta(foo, "foo3") - setRVFn(10) if err := setFn(ctx, foo); err != nil { t.Errorf("unexpected error: %v", err) } older := copyOrDie(foo) olderMeta := t.getObjectMetaOrFail(older) - olderMeta.ResourceVersion = "8" + olderMeta.ResourceVersion = "1" _, _, err := t.storage.(rest.Updater).Update(t.TestContext(), older) if err == nil { @@ -572,12 +545,11 @@ func (t *Tester) testDeleteNoGraceful(obj runtime.Object, setFn SetFunc, getFn G func (t *Tester) testDeleteNonExist(obj runtime.Object) { objectMeta := t.getObjectMetaOrFail(obj) - t.withStorageError(tools.EtcdErrorNotFound, func() { - _, err := t.storage.(rest.GracefulDeleter).Delete(t.TestContext(), objectMeta.Name, nil) - if err == nil || !errors.IsNotFound(err) { - t.Errorf("unexpected error: %v", err) - } - }) + _, err := t.storage.(rest.GracefulDeleter).Delete(t.TestContext(), objectMeta.Name, nil) + if err == nil || !errors.IsNotFound(err) { + t.Errorf("unexpected error: %v", err) + } + } // ============================================================================= @@ -848,18 +820,6 @@ func listToItems(listObj runtime.Object) ([]runtime.Object, error) { return result, nil } -func (t *Tester) testListError() { - ctx := t.TestContext() - - storageError := fmt.Errorf("test error") - t.withStorageError(storageError, func() { - _, err := t.storage.(rest.Lister).List(ctx, nil) - if err != storageError { - t.Errorf("unexpected error: %v", err) - } - }) -} - func (t *Tester) testListFound(obj runtime.Object, assignFn AssignFunc) { ctx := t.TestContext() @@ -890,16 +850,18 @@ func (t *Tester) testListMatchLabels(obj runtime.Object, assignFn AssignFunc) { ctx := t.TestContext() testLabels := map[string]string{"key": "value"} - foo1 := copyOrDie(obj) - t.setObjectMeta(foo1, "foo1") - foo2 := copyOrDie(obj) - foo2Meta := t.getObjectMetaOrFail(foo2) - foo2Meta.Name = "foo2" - foo2Meta.Namespace = api.NamespaceValue(ctx) - foo2Meta.Labels = testLabels + foo3 := copyOrDie(obj) + t.setObjectMeta(foo3, "foo3") + foo4 := copyOrDie(obj) + foo4Meta := t.getObjectMetaOrFail(foo4) + foo4Meta.Name = "foo4" + foo4Meta.Namespace = api.NamespaceValue(ctx) + foo4Meta.Labels = testLabels - existing := assignFn([]runtime.Object{foo1, foo2}) - filtered := []runtime.Object{existing[1]} + objs := ([]runtime.Object{foo3, foo4}) + + assignFn(objs) + filtered := []runtime.Object{objs[1]} selector := labels.SelectorFromSet(labels.Set(testLabels)) options := &api.ListOptions{LabelSelector: selector} @@ -919,10 +881,8 @@ func (t *Tester) testListMatchLabels(obj runtime.Object, assignFn AssignFunc) { } } -func (t *Tester) testListNotFound(assignFn AssignFunc, setRVFn SetRVFunc) { +func (t *Tester) testListNotFound(assignFn AssignFunc) { ctx := t.TestContext() - - setRVFn(uint64(123)) _ = assignFn([]runtime.Object{}) listObj, err := t.storage.(rest.Lister).List(ctx, nil) @@ -934,45 +894,14 @@ func (t *Tester) testListNotFound(assignFn AssignFunc, setRVFn SetRVFunc) { t.Errorf("unexpected error: %v", err) } if len(items) != 0 { - t.Errorf("unexpected items: %v", items) - } - - meta, err := api.ListMetaFor(listObj) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - if meta.ResourceVersion != "123" { - t.Errorf("unexpected resource version: %d", meta.ResourceVersion) + t.Errorf("unexpected items: %#v", items) } } // ============================================================================= // Watching tests. -func (t *Tester) testWatch(initWatchFn InitWatchFunc, injectErrFn InjectErrFunc) { - ctx := t.TestContext() - watcher, err := t.storage.(rest.Watcher).Watch(ctx, &api.ListOptions{ResourceVersion: "1"}) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - initWatchFn() - - select { - case _, ok := <-watcher.ResultChan(): - if !ok { - t.Errorf("watch channel should be open") - } - default: - } - - injectErrFn(nil) - if _, ok := <-watcher.ResultChan(); ok { - t.Errorf("watch channel should be closed") - } - watcher.Stop() -} - -func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc, emitFn EmitFunc, fieldsPass, fieldsFail []fields.Set, actions []string) { +func (t *Tester) testWatchFields(obj runtime.Object, emitFn EmitFunc, fieldsPass, fieldsFail []fields.Set, actions []string) { ctx := t.TestContext() for _, field := range fieldsPass { @@ -980,9 +909,9 @@ func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc, options := &api.ListOptions{FieldSelector: field.AsSelector(), ResourceVersion: "1"} watcher, err := t.storage.(rest.Watcher).Watch(ctx, options) if err != nil { - t.Errorf("unexpected error: %v", err) + t.Errorf("unexpected error: %v, %v", err, action) } - initWatchFn() + if err := emitFn(obj, action); err != nil { t.Errorf("unexpected error: %v", err) } @@ -1006,7 +935,6 @@ func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc, if err != nil { t.Errorf("unexpected error: %v", err) } - initWatchFn() if err := emitFn(obj, action); err != nil { t.Errorf("unexpected error: %v", err) } @@ -1022,7 +950,7 @@ func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc, } } -func (t *Tester) testWatchLabels(obj runtime.Object, initWatchFn InitWatchFunc, emitFn EmitFunc, labelsPass, labelsFail []labels.Set, actions []string) { +func (t *Tester) testWatchLabels(obj runtime.Object, emitFn EmitFunc, labelsPass, labelsFail []labels.Set, actions []string) { ctx := t.TestContext() for _, label := range labelsPass { @@ -1032,7 +960,6 @@ func (t *Tester) testWatchLabels(obj runtime.Object, initWatchFn InitWatchFunc, if err != nil { t.Errorf("unexpected error: %v", err) } - initWatchFn() if err := emitFn(obj, action); err != nil { t.Errorf("unexpected error: %v", err) } @@ -1056,7 +983,6 @@ func (t *Tester) testWatchLabels(obj runtime.Object, initWatchFn InitWatchFunc, if err != nil { t.Errorf("unexpected error: %v", err) } - initWatchFn() if err := emitFn(obj, action); err != nil { t.Errorf("unexpected error: %v", err) } diff --git a/pkg/registry/controller/etcd/etcd_test.go b/pkg/registry/controller/etcd/etcd_test.go index a9471565a5..287292f50e 100644 --- a/pkg/registry/controller/etcd/etcd_test.go +++ b/pkg/registry/controller/etcd/etcd_test.go @@ -25,13 +25,13 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") controllerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return controllerStorage, statusStorage, fakeClient + return controllerStorage, statusStorage, server } // createController is a helper function that returns a controller with the updated resource version. @@ -76,8 +76,9 @@ func validNewController() *api.ReplicationController { var validController = validNewController() func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) controller := validNewController() controller.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -95,8 +96,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewController(), @@ -126,13 +128,15 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewController()) } func TestGenerationNumber(t *testing.T) { - storage, _, _ := newStorage(t) + storage, _, server := newStorage(t) + defer server.Terminate(t) modifiedSno := *validNewController() modifiedSno.Generation = 100 modifiedSno.Status.ObservedGeneration = 10 @@ -181,20 +185,23 @@ func TestGenerationNumber(t *testing.T) { } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewController()) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewController()) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validController, // matching labels diff --git a/pkg/registry/daemonset/etcd/etcd_test.go b/pkg/registry/daemonset/etcd/etcd_test.go index c1bdf5fb3e..963672dc9a 100755 --- a/pkg/registry/daemonset/etcd/etcd_test.go +++ b/pkg/registry/daemonset/etcd/etcd_test.go @@ -26,13 +26,13 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") daemonSetStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return daemonSetStorage, statusStorage, fakeClient + return daemonSetStorage, statusStorage, server } func newValidDaemonSet() *extensions.DaemonSet { @@ -66,8 +66,9 @@ func newValidDaemonSet() *extensions.DaemonSet { var validDaemonSet = newValidDaemonSet() func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) ds := newValidDaemonSet() ds.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -84,8 +85,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid newValidDaemonSet(), @@ -120,26 +122,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(newValidDaemonSet()) } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(newValidDaemonSet()) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(newValidDaemonSet()) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validDaemonSet, // matching labels diff --git a/pkg/registry/deployment/etcd/etcd_test.go b/pkg/registry/deployment/etcd/etcd_test.go index 7cc5569d69..10e00877ff 100755 --- a/pkg/registry/deployment/etcd/etcd_test.go +++ b/pkg/registry/deployment/etcd/etcd_test.go @@ -20,7 +20,6 @@ import ( "testing" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" @@ -28,14 +27,14 @@ import ( "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "k8s.io/kubernetes/pkg/util" ) -func newStorage(t *testing.T) (*DeploymentStorage, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions") +func newStorage(t *testing.T) (*DeploymentStorage, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") deploymentStorage := NewStorage(etcdStorage, generic.UndecoratedStorage) - return &deploymentStorage, fakeClient + return &deploymentStorage, server } var namespace = "foo-namespace" @@ -92,8 +91,9 @@ func validNewScale() *extensions.Scale { var validScale = *validNewScale() func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Deployment.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Deployment.Etcd) deployment := validNewDeployment() deployment.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -110,8 +110,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Deployment.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Deployment.Etcd) test.TestUpdate( // valid validNewDeployment(), @@ -146,26 +147,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Deployment.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Deployment.Etcd) test.TestDelete(validNewDeployment()) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Deployment.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Deployment.Etcd) test.TestGet(validNewDeployment()) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Deployment.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Deployment.Etcd) test.TestList(validNewDeployment()) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Deployment.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Deployment.Etcd) test.TestWatch( validNewDeployment(), // matching labels @@ -188,11 +193,12 @@ func TestWatch(t *testing.T) { } func TestScaleGet(t *testing.T) { - storage, fakeClient := newStorage(t) + storage, server := newStorage(t) + defer server.Terminate(t) ctx := api.WithNamespace(api.NewContext(), namespace) key := etcdtest.AddPrefix("/deployments/" + namespace + "/" + name) - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Extensions.Codec(), &validDeployment), 0); err != nil { + if err := storage.Deployment.Storage.Set(ctx, key, &validDeployment, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } @@ -202,17 +208,17 @@ func TestScaleGet(t *testing.T) { if err != nil { t.Fatalf("unexpected error: %v", err) } - if e, a := expect, scale; !api.Semantic.DeepEqual(e, a) { + if e, a := expect, scale; !api.Semantic.DeepDerivative(e, a) { t.Errorf("unexpected scale: %s", util.ObjectDiff(e, a)) } } func TestScaleUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - + storage, server := newStorage(t) + defer server.Terminate(t) ctx := api.WithNamespace(api.NewContext(), namespace) key := etcdtest.AddPrefix("/deployments/" + namespace + "/" + name) - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Extensions.Codec(), &validDeployment), 0); err != nil { + if err := storage.Deployment.Storage.Set(ctx, key, &validDeployment, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } replicas := 12 @@ -226,24 +232,24 @@ func TestScaleUpdate(t *testing.T) { if _, _, err := storage.Scale.Update(ctx, &update); err != nil { t.Fatalf("unexpected error: %v", err) } - response, err := fakeClient.Get(key, false, false) + obj, err := storage.Scale.Get(ctx, name) if err != nil { t.Fatalf("unexpected error: %v", err) } - var deployment extensions.Deployment - testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &deployment) + deployment := obj.(*extensions.Scale) if deployment.Spec.Replicas != replicas { t.Errorf("wrong replicas count expected: %d got: %d", replicas, deployment.Spec.Replicas) } } func TestStatusUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) + storage, server := newStorage(t) + defer server.Terminate(t) ctx := api.WithNamespace(api.NewContext(), namespace) key := etcdtest.AddPrefix("/deployments/" + namespace + "/" + name) - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Extensions.Codec(), &validDeployment), 0); err != nil { + if err := storage.Deployment.Storage.Set(ctx, key, &validDeployment, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } update := extensions.Deployment{ @@ -259,13 +265,12 @@ func TestStatusUpdate(t *testing.T) { if _, _, err := storage.Status.Update(ctx, &update); err != nil { t.Fatalf("unexpected error: %v", err) } - response, err := fakeClient.Get(key, false, false) + obj, err := storage.Deployment.Get(ctx, name) if err != nil { t.Fatalf("unexpected error: %v", err) } - var deployment extensions.Deployment - testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &deployment) + deployment := obj.(*extensions.Deployment) if deployment.Spec.Replicas != 7 { t.Errorf("we expected .spec.replicas to not be updated but it was updated to %v", deployment.Spec.Replicas) } diff --git a/pkg/registry/endpoint/etcd/etcd_test.go b/pkg/registry/endpoint/etcd/etcd_test.go index 3705d9b4ec..43633c395a 100644 --- a/pkg/registry/endpoint/etcd/etcd_test.go +++ b/pkg/registry/endpoint/etcd/etcd_test.go @@ -25,12 +25,12 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewREST(etcdStorage, generic.UndecoratedStorage), server } func validNewEndpoints() *api.Endpoints { @@ -57,8 +57,9 @@ func validChangedEndpoints() *api.Endpoints { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) endpoints := validNewEndpoints() endpoints.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -72,8 +73,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate() test.TestUpdate( // valid validNewEndpoints(), @@ -90,26 +92,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewEndpoints()) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewEndpoints()) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewEndpoints()) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewEndpoints(), // matching labels diff --git a/pkg/registry/event/etcd/etcd_test.go b/pkg/registry/event/etcd/etcd_test.go index ffba2b96bc..88d3a62f4e 100644 --- a/pkg/registry/event/etcd/etcd_test.go +++ b/pkg/registry/event/etcd/etcd_test.go @@ -23,15 +23,14 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) var testTTL uint64 = 60 -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - fakeClient.HideExpires = true - return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), server } func validNewEvent(namespace string) *api.Event { @@ -49,8 +48,9 @@ func validNewEvent(namespace string) *api.Event { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) event := validNewEvent(test.TestNamespace()) event.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -62,8 +62,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate() test.TestUpdate( // valid validNewEvent(test.TestNamespace()), @@ -83,7 +84,8 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewEvent(test.TestNamespace())) } diff --git a/pkg/registry/experimental/controller/etcd/etcd_test.go b/pkg/registry/experimental/controller/etcd/etcd_test.go index a08b3f8eb2..97cec58070 100644 --- a/pkg/registry/experimental/controller/etcd/etcd_test.go +++ b/pkg/registry/experimental/controller/etcd/etcd_test.go @@ -20,19 +20,17 @@ import ( "testing" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" - "k8s.io/kubernetes/pkg/runtime" + "k8s.io/kubernetes/pkg/storage" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" - "k8s.io/kubernetes/pkg/util" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*ScaleREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - return NewStorage(etcdStorage, generic.UndecoratedStorage).Scale, fakeClient +func newStorage(t *testing.T) (*ScaleREST, *etcdtesting.EtcdTestServer, storage.Interface) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewStorage(etcdStorage, generic.UndecoratedStorage).Scale, server, etcdStorage } var validPodTemplate = api.PodTemplate{ @@ -63,7 +61,7 @@ var validControllerSpec = api.ReplicationControllerSpec{ } var validController = api.ReplicationController{ - ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test", ResourceVersion: "1"}, + ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test"}, Spec: validControllerSpec, } @@ -79,31 +77,31 @@ var validScale = extensions.Scale{ } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) + storage, server, si := newStorage(t) + defer server.Terminate(t) ctx := api.WithNamespace(api.NewContext(), "test") key := etcdtest.AddPrefix("/controllers/test/foo") - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &validController), 0); err != nil { + if err := si.Set(ctx, key, &validController, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } - - expect := &validScale obj, err := storage.Get(ctx, "foo") - scale := obj.(*extensions.Scale) if err != nil { t.Fatalf("unexpected error: %v", err) } - if e, a := expect, scale; !api.Semantic.DeepEqual(e, a) { - t.Errorf("unexpected scale: %s", util.ObjectDiff(e, a)) + scale := obj.(*extensions.Scale) + if scale.Spec.Replicas != validReplicas { + t.Errorf("wrong replicas count expected: %d got: %d", validReplicas, scale.Spec.Replicas) } } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) + storage, server, si := newStorage(t) + defer server.Terminate(t) ctx := api.WithNamespace(api.NewContext(), "test") key := etcdtest.AddPrefix("/controllers/test/foo") - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &validController), 0); err != nil { + if err := si.Set(ctx, key, &validController, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } replicas := 12 @@ -117,14 +115,13 @@ func TestUpdate(t *testing.T) { if _, _, err := storage.Update(ctx, &update); err != nil { t.Fatalf("unexpected error: %v", err) } - response, err := fakeClient.Get(key, false, false) + obj, err := storage.Get(ctx, "foo") if err != nil { t.Fatalf("unexpected error: %v", err) } - var controller api.ReplicationController - testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &controller) - if controller.Spec.Replicas != replicas { - t.Errorf("wrong replicas count expected: %d got: %d", replicas, controller.Spec.Replicas) + updated := obj.(*extensions.Scale) + if updated.Spec.Replicas != replicas { + t.Errorf("wrong replicas count expected: %d got: %d", replicas, updated.Spec.Replicas) } } diff --git a/pkg/registry/generic/etcd/etcd_test.go b/pkg/registry/generic/etcd/etcd_test.go index 5cef69d31f..9d7395dbee 100644 --- a/pkg/registry/generic/etcd/etcd_test.go +++ b/pkg/registry/generic/etcd/etcd_test.go @@ -182,7 +182,7 @@ func TestEtcdList(t *testing.T) { server, registry := NewTestGenericEtcdRegistry(t) if item.in != nil { - if err := storagetesting.CreateList(t, "/pods", registry.Storage, item.in); err != nil { + if err := storagetesting.CreateList("/pods", registry.Storage, item.in); err != nil { t.Errorf("Unexpected error %v", err) } } diff --git a/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go b/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go index b1f2fb758a..75d11d18ca 100644 --- a/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go +++ b/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go @@ -28,13 +28,13 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") horizontalPodAutoscalerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return horizontalPodAutoscalerStorage, statusStorage, fakeClient + return horizontalPodAutoscalerStorage, statusStorage, server } func validNewHorizontalPodAutoscaler(name string) *extensions.HorizontalPodAutoscaler { @@ -56,8 +56,9 @@ func validNewHorizontalPodAutoscaler(name string) *extensions.HorizontalPodAutos } func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) autoscaler := validNewHorizontalPodAutoscaler("foo") autoscaler.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -69,8 +70,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewHorizontalPodAutoscaler("foo"), @@ -84,26 +86,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewHorizontalPodAutoscaler("foo")) } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewHorizontalPodAutoscaler("foo")) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewHorizontalPodAutoscaler("foo")) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewHorizontalPodAutoscaler("foo"), // matching labels diff --git a/pkg/registry/ingress/etcd/etcd_test.go b/pkg/registry/ingress/etcd/etcd_test.go index bc6ffbc233..44cf1de4e9 100755 --- a/pkg/registry/ingress/etcd/etcd_test.go +++ b/pkg/registry/ingress/etcd/etcd_test.go @@ -26,14 +26,14 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "k8s.io/kubernetes/pkg/util/intstr" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") ingressStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return ingressStorage, statusStorage, fakeClient + return ingressStorage, statusStorage, server } var ( @@ -108,8 +108,9 @@ func validIngress() *extensions.Ingress { } func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) ingress := validIngress() noDefaultBackendAndRules := validIngress() noDefaultBackendAndRules.Spec.Backend = &extensions.IngressBackend{} @@ -126,8 +127,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validIngress(), @@ -162,26 +164,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validIngress()) } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validIngress()) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validIngress()) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validIngress(), // matching labels diff --git a/pkg/registry/job/etcd/etcd_test.go b/pkg/registry/job/etcd/etcd_test.go index 7c256252dc..1d1639e754 100644 --- a/pkg/registry/job/etcd/etcd_test.go +++ b/pkg/registry/job/etcd/etcd_test.go @@ -28,13 +28,13 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") jobStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return jobStorage, statusStorage, fakeClient + return jobStorage, statusStorage, server } func validNewJob() *extensions.Job { @@ -72,8 +72,9 @@ func validNewJob() *extensions.Job { } func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) validJob := validNewJob() validJob.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -91,8 +92,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) two := 2 test.TestUpdate( // valid @@ -118,26 +120,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewJob()) } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewJob()) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewJob()) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewJob(), // matching labels diff --git a/pkg/registry/limitrange/etcd/etcd_test.go b/pkg/registry/limitrange/etcd/etcd_test.go index 7211b1d8d5..4567e9fd73 100644 --- a/pkg/registry/limitrange/etcd/etcd_test.go +++ b/pkg/registry/limitrange/etcd/etcd_test.go @@ -26,12 +26,12 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewREST(etcdStorage, generic.UndecoratedStorage), server } func validNewLimitRange() *api.LimitRange { @@ -59,8 +59,9 @@ func validNewLimitRange() *api.LimitRange { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).GeneratesName() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).GeneratesName() validLimitRange := validNewLimitRange() validLimitRange.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -74,8 +75,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate() test.TestUpdate( // valid validNewLimitRange(), @@ -101,26 +103,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewLimitRange()) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewLimitRange()) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewLimitRange()) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewLimitRange(), // matching labels diff --git a/pkg/registry/namespace/etcd/etcd_test.go b/pkg/registry/namespace/etcd/etcd_test.go index 47629d767f..f591056ba3 100644 --- a/pkg/registry/namespace/etcd/etcd_test.go +++ b/pkg/registry/namespace/etcd/etcd_test.go @@ -20,21 +20,19 @@ import ( "testing" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" - "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") namespaceStorage, _, _ := NewREST(etcdStorage, generic.UndecoratedStorage) - return namespaceStorage, fakeClient + return namespaceStorage, server } func validNewNamespace() *api.Namespace { @@ -46,8 +44,9 @@ func validNewNamespace() *api.Namespace { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() namespace := validNewNamespace() namespace.ObjectMeta = api.ObjectMeta{GenerateName: "foo"} test.TestCreate( @@ -61,7 +60,8 @@ func TestCreate(t *testing.T) { } func TestCreateSetsFields(t *testing.T) { - storage, _ := newStorage(t) + storage, server := newStorage(t) + defer server.Terminate(t) namespace := validNewNamespace() ctx := api.NewContext() _, err := storage.Create(ctx, namespace) @@ -86,26 +86,30 @@ func TestCreateSetsFields(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope().ReturnDeletedObject() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject() test.TestDelete(validNewNamespace()) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestGet(validNewNamespace()) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestList(validNewNamespace()) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestWatch( validNewNamespace(), // matching labels @@ -127,7 +131,8 @@ func TestWatch(t *testing.T) { } func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) { - storage, fakeClient := newStorage(t) + storage, server := newStorage(t) + defer server.Terminate(t) key := etcdtest.AddPrefix("namespaces/foo") ctx := api.NewContext() now := unversioned.Now() @@ -141,7 +146,7 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) { }, Status: api.NamespaceStatus{Phase: api.NamespaceActive}, } - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), namespace), 0); err != nil { + if err := storage.Storage.Set(ctx, key, namespace, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } if _, err := storage.Delete(ctx, "foo", nil); err == nil { @@ -150,7 +155,8 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) { } func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) { - storage, fakeClient := newStorage(t) + storage, server := newStorage(t) + defer server.Terminate(t) key := etcdtest.AddPrefix("namespaces/foo") ctx := api.NewContext() now := unversioned.Now() @@ -164,7 +170,7 @@ func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) { }, Status: api.NamespaceStatus{Phase: api.NamespaceActive}, } - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), namespace), 0); err != nil { + if err := storage.Storage.Set(ctx, key, namespace, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } if _, err := storage.Delete(ctx, "foo", nil); err != nil { diff --git a/pkg/registry/node/etcd/etcd_test.go b/pkg/registry/node/etcd/etcd_test.go index e0358a2056..c52c6d4d21 100644 --- a/pkg/registry/node/etcd/etcd_test.go +++ b/pkg/registry/node/etcd/etcd_test.go @@ -27,7 +27,7 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) type fakeConnectionInfoGetter struct { @@ -37,10 +37,10 @@ func (fakeConnectionInfoGetter) GetConnectionInfo(host string) (string, uint, ht return "http", 12345, nil, nil } -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") storage, _ := NewREST(etcdStorage, generic.UndecoratedStorage, fakeConnectionInfoGetter{}, nil) - return storage, fakeClient + return storage, server } func validNewNode() *api.Node { @@ -64,8 +64,9 @@ func validNewNode() *api.Node { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() node := validNewNode() node.ObjectMeta = api.ObjectMeta{GenerateName: "foo"} test.TestCreate( @@ -79,8 +80,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestUpdate( // valid validNewNode(), @@ -94,26 +96,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestDelete(validNewNode()) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestGet(validNewNode()) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestList(validNewNode()) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestWatch( validNewNode(), // matching labels diff --git a/pkg/registry/persistentvolume/etcd/etcd_test.go b/pkg/registry/persistentvolume/etcd/etcd_test.go index 11c5f550e0..3a498ca830 100644 --- a/pkg/registry/persistentvolume/etcd/etcd_test.go +++ b/pkg/registry/persistentvolume/etcd/etcd_test.go @@ -21,21 +21,20 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/resource" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "k8s.io/kubernetes/pkg/util" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") persistentVolumeStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return persistentVolumeStorage, statusStorage, fakeClient + return persistentVolumeStorage, statusStorage, server } func validNewPersistentVolume(name string) *api.PersistentVolume { @@ -64,13 +63,13 @@ func validNewPersistentVolume(name string) *api.PersistentVolume { func validChangedPersistentVolume() *api.PersistentVolume { pv := validNewPersistentVolume("foo") - pv.ResourceVersion = "1" return pv } func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() pv := validNewPersistentVolume("foo") pv.ObjectMeta = api.ObjectMeta{GenerateName: "foo"} test.TestCreate( @@ -84,8 +83,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestUpdate( // valid validNewPersistentVolume("foo"), @@ -101,26 +101,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope().ReturnDeletedObject() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject() test.TestDelete(validNewPersistentVolume("foo")) } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestGet(validNewPersistentVolume("foo")) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestList(validNewPersistentVolume("foo")) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ClusterScope() test.TestWatch( validNewPersistentVolume("foo"), // matching labels @@ -142,39 +146,37 @@ func TestWatch(t *testing.T) { } func TestUpdateStatus(t *testing.T) { - storage, statusStorage, fakeClient := newStorage(t) - fakeClient.TestIndex = true - + storage, statusStorage, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewContext() key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) pvStart := validNewPersistentVolume("foo") - fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), pvStart), 0) + err := storage.Storage.Set(ctx, key, pvStart, nil, 0) + if err != nil { + t.Errorf("unexpected error: %v", err) + } pvIn := &api.PersistentVolume{ ObjectMeta: api.ObjectMeta{ - Name: "foo", - ResourceVersion: "1", + Name: "foo", }, Status: api.PersistentVolumeStatus{ Phase: api.VolumeBound, }, } - expected := *pvStart - expected.ResourceVersion = "2" - expected.Labels = pvIn.Labels - expected.Status = pvIn.Status - - _, _, err := statusStorage.Update(ctx, pvIn) + _, _, err = statusStorage.Update(ctx, pvIn) if err != nil { t.Fatalf("Unexpected error: %v", err) } - pvOut, err := storage.Get(ctx, "foo") + obj, err := storage.Get(ctx, "foo") if err != nil { t.Errorf("unexpected error: %v", err) } - if !api.Semantic.DeepEqual(&expected, pvOut) { - t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, pvOut)) + pvOut := obj.(*api.PersistentVolume) + // only compare the relevant change b/c metadata will differ + if !api.Semantic.DeepEqual(pvIn.Status, pvOut.Status) { + t.Errorf("unexpected object: %s", util.ObjectDiff(pvIn.Status, pvOut.Status)) } } diff --git a/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go b/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go index d37072ca43..7ae360baec 100644 --- a/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go +++ b/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go @@ -21,21 +21,20 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/resource" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "k8s.io/kubernetes/pkg/util" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") persistentVolumeClaimStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return persistentVolumeClaimStorage, statusStorage, fakeClient + return persistentVolumeClaimStorage, statusStorage, server } func validNewPersistentVolumeClaim(name, ns string) *api.PersistentVolumeClaim { @@ -60,8 +59,9 @@ func validNewPersistentVolumeClaim(name, ns string) *api.PersistentVolumeClaim { } func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) pv := validNewPersistentVolumeClaim("foo", api.NamespaceDefault) pv.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -75,8 +75,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewPersistentVolumeClaim("foo", api.NamespaceDefault), @@ -94,26 +95,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ReturnDeletedObject() test.TestDelete(validNewPersistentVolumeClaim("foo", api.NamespaceDefault)) } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewPersistentVolumeClaim("foo", api.NamespaceDefault)) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewPersistentVolumeClaim("foo", api.NamespaceDefault)) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewPersistentVolumeClaim("foo", api.NamespaceDefault), // matching labels @@ -135,20 +140,19 @@ func TestWatch(t *testing.T) { } func TestUpdateStatus(t *testing.T) { - storage, statusStorage, fakeClient := newStorage(t) + storage, statusStorage, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) pvcStart := validNewPersistentVolumeClaim("foo", api.NamespaceDefault) - fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), pvcStart), 0) + err := storage.Storage.Set(ctx, key, pvcStart, nil, 0) pvc := &api.PersistentVolumeClaim{ ObjectMeta: api.ObjectMeta{ - Name: "foo", - Namespace: api.NamespaceDefault, - ResourceVersion: "1", + Name: "foo", + Namespace: api.NamespaceDefault, }, Spec: api.PersistentVolumeClaimSpec{ AccessModes: []api.PersistentVolumeAccessMode{api.ReadWriteOnce}, @@ -163,20 +167,17 @@ func TestUpdateStatus(t *testing.T) { }, } - expected := *pvcStart - expected.ResourceVersion = "2" - expected.Labels = pvc.Labels - expected.Status = pvc.Status - - _, _, err := statusStorage.Update(ctx, pvc) + _, _, err = statusStorage.Update(ctx, pvc) if err != nil { t.Fatalf("Unexpected error: %v", err) } - pvcOut, err := storage.Get(ctx, "foo") + obj, err := storage.Get(ctx, "foo") if err != nil { t.Errorf("unexpected error: %v", err) } - if !api.Semantic.DeepEqual(&expected, pvcOut) { - t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, pvcOut)) + pvcOut := obj.(*api.PersistentVolumeClaim) + // only compare relevant changes b/c of difference in metadata + if !api.Semantic.DeepEqual(pvc.Status, pvcOut.Status) { + t.Errorf("unexpected object: %s", util.ObjectDiff(pvc.Status, pvcOut.Status)) } } diff --git a/pkg/registry/pod/etcd/etcd_test.go b/pkg/registry/pod/etcd/etcd_test.go index cc1efb9b03..5849c755e7 100644 --- a/pkg/registry/pod/etcd/etcd_test.go +++ b/pkg/registry/pod/etcd/etcd_test.go @@ -17,7 +17,6 @@ limitations under the License. package etcd import ( - "fmt" "strings" "testing" @@ -25,7 +24,6 @@ import ( "k8s.io/kubernetes/pkg/api/errors" etcderrors "k8s.io/kubernetes/pkg/api/errors/etcd" "k8s.io/kubernetes/pkg/api/rest" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/registry/generic" @@ -33,14 +31,14 @@ import ( "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/securitycontext" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "k8s.io/kubernetes/pkg/util" ) -func newStorage(t *testing.T) (*REST, *BindingREST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*REST, *BindingREST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") storage := NewStorage(etcdStorage, generic.UndecoratedStorage, nil, nil) - return storage.Pod, storage.Binding, storage.Status, fakeClient + return storage.Pod, storage.Binding, storage.Status, server } func validNewPod() *api.Pod { @@ -72,7 +70,6 @@ func validNewPod() *api.Pod { func validChangedPod() *api.Pod { pod := validNewPod() - pod.ResourceVersion = "1" pod.Labels = map[string]string{ "foo": "bar", } @@ -80,8 +77,9 @@ func validChangedPod() *api.Pod { } func TestCreate(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) pod := validNewPod() pod.ObjectMeta = api.ObjectMeta{} // Make an invalid pod with an an incorrect label. @@ -105,8 +103,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewPod(), @@ -120,8 +119,9 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject() + storage, _, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ReturnDeletedObject() test.TestDelete(validNewPod()) scheduledPod := validNewPod() @@ -129,22 +129,12 @@ func TestDelete(t *testing.T) { test.TestDeleteGraceful(scheduledPod, 30) } -func TestCreateRegistryError(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - fakeClient.Err = fmt.Errorf("test error") - - pod := validNewPod() - _, err := storage.Create(api.NewDefaultContext(), pod) - if err != fakeClient.Err { - t.Fatalf("unexpected error: %v", err) - } -} - func TestCreateSetsFields(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) pod := validNewPod() _, err := storage.Create(api.NewDefaultContext(), pod) - if err != fakeClient.Err { + if err != nil { t.Fatalf("unexpected error: %v", err) } ctx := api.NewDefaultContext() @@ -255,10 +245,10 @@ func TestResourceLocation(t *testing.T) { ctx := api.NewDefaultContext() for _, tc := range testCases { - storage, _, _, fakeClient := newStorage(t) + storage, _, _, server := newStorage(t) key, _ := storage.KeyFunc(ctx, tc.pod.Name) key = etcdtest.AddPrefix(key) - if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &tc.pod), 0); err != nil { + if err := storage.Storage.Create(ctx, key, &tc.pod, nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } @@ -277,24 +267,28 @@ func TestResourceLocation(t *testing.T) { if location.Host != tc.location { t.Errorf("Expected %v, but got %v", tc.location, location.Host) } + server.Terminate(t) } } func TestGet(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewPod()) } func TestList(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewPod()) } func TestWatch(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewPod(), // matching labels @@ -315,12 +309,11 @@ func TestWatch(t *testing.T) { } func TestEtcdCreate(t *testing.T) { - storage, bindingStorage, _, fakeClient := newStorage(t) + storage, bindingStorage, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) - fakeClient.ExpectNotFoundGet(key) _, err := storage.Create(ctx, validNewPod()) if err != nil { t.Fatalf("unexpected error: %v", err) @@ -335,31 +328,21 @@ func TestEtcdCreate(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - resp, err := fakeClient.Get(key, false, false) + _, err = storage.Get(ctx, "foo") if err != nil { t.Fatalf("Unexpected error %v", err) } - var pod api.Pod - err = testapi.Default.Codec().DecodeInto([]byte(resp.Node.Value), &pod) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - - if pod.Name != "foo" { - t.Errorf("Unexpected pod: %#v %s", pod, resp.Node.Value) - } } // Ensure that when scheduler creates a binding for a pod that has already been deleted // by the API server, API server returns not-found error. func TestEtcdCreateBindingNoPod(t *testing.T) { - storage, bindingStorage, _, fakeClient := newStorage(t) + storage, bindingStorage, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) - fakeClient.ExpectNotFoundGet(key) // Assume that a pod has undergone the following: // - Create (apiserver) // - Schedule (scheduler) @@ -385,8 +368,8 @@ func TestEtcdCreateBindingNoPod(t *testing.T) { } func TestEtcdCreateFailsWithoutNamespace(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) - fakeClient.TestIndex = true + storage, _, _, server := newStorage(t) + defer server.Terminate(t) pod := validNewPod() pod.Namespace = "" _, err := storage.Create(api.NewContext(), pod) @@ -397,12 +380,11 @@ func TestEtcdCreateFailsWithoutNamespace(t *testing.T) { } func TestEtcdCreateWithContainersNotFound(t *testing.T) { - storage, bindingStorage, _, fakeClient := newStorage(t) + storage, bindingStorage, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) - fakeClient.ExpectNotFoundGet(key) _, err := storage.Create(ctx, validNewPod()) if err != nil { t.Fatalf("unexpected error: %v", err) @@ -421,30 +403,21 @@ func TestEtcdCreateWithContainersNotFound(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - resp, err := fakeClient.Get(key, false, false) + obj, err := storage.Get(ctx, "foo") if err != nil { t.Fatalf("Unexpected error %v", err) } - var pod api.Pod - err = testapi.Default.Codec().DecodeInto([]byte(resp.Node.Value), &pod) - if err != nil { - t.Errorf("unexpected error: %v", err) - } + pod := obj.(*api.Pod) - if pod.Name != "foo" { - t.Errorf("Unexpected pod: %#v %s", pod, resp.Node.Value) - } if !(pod.Annotations != nil && pod.Annotations["label1"] == "value1") { t.Fatalf("Pod annotations don't match the expected: %v", pod.Annotations) } } func TestEtcdCreateWithConflict(t *testing.T) { - storage, bindingStorage, _, fakeClient := newStorage(t) + storage, bindingStorage, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true - key, _ := storage.KeyFunc(ctx, "foo") - fakeClient.ExpectNotFoundGet(key) _, err := storage.Create(ctx, validNewPod()) if err != nil { @@ -472,12 +445,11 @@ func TestEtcdCreateWithConflict(t *testing.T) { } func TestEtcdCreateWithExistingContainers(t *testing.T) { - storage, bindingStorage, _, fakeClient := newStorage(t) + storage, bindingStorage, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) - fakeClient.ExpectNotFoundGet(key) _, err := storage.Create(ctx, validNewPod()) if err != nil { t.Fatalf("unexpected error: %v", err) @@ -492,19 +464,10 @@ func TestEtcdCreateWithExistingContainers(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - resp, err := fakeClient.Get(key, false, false) + _, err = storage.Get(ctx, "foo") if err != nil { t.Fatalf("Unexpected error %v", err) } - var pod api.Pod - err = testapi.Default.Codec().DecodeInto([]byte(resp.Node.Value), &pod) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - - if pod.Name != "foo" { - t.Errorf("Unexpected pod: %#v %s", pod, resp.Node.Value) - } } func TestEtcdCreateBinding(t *testing.T) { @@ -544,10 +507,9 @@ func TestEtcdCreateBinding(t *testing.T) { }, } for k, test := range testCases { - storage, bindingStorage, _, fakeClient := newStorage(t) + storage, bindingStorage, _, server := newStorage(t) key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) - fakeClient.ExpectNotFoundGet(key) if _, err := storage.Create(ctx, validNewPod()); err != nil { t.Fatalf("%s: unexpected error: %v", k, err) @@ -563,42 +525,45 @@ func TestEtcdCreateBinding(t *testing.T) { t.Errorf("%s: expected: %v, got: %v", k, pod.(*api.Pod).Spec.NodeName, test.binding.Target.Name) } } + server.Terminate(t) } } func TestEtcdUpdateNotScheduled(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), validNewPod()), 1) + if _, err := storage.Create(ctx, validNewPod()); err != nil { + t.Fatalf("unexpected error: %v", err) + } podIn := validChangedPod() _, _, err := storage.Update(ctx, podIn) if err != nil { t.Errorf("Unexpected error: %v", err) } - response, err := fakeClient.Get(key, false, false) + obj, err := storage.Get(ctx, validNewPod().ObjectMeta.Name) if err != nil { - t.Fatalf("Unexpected error: %v", err) + t.Errorf("unexpected error: %v", err) } - podOut := &api.Pod{} - testapi.Default.Codec().DecodeInto([]byte(response.Node.Value), podOut) - if !api.Semantic.DeepEqual(podOut, podIn) { + podOut := obj.(*api.Pod) + // validChangedPod only changes the Labels, so were checking the update was valid + if !api.Semantic.DeepEqual(podIn.Labels, podOut.Labels) { t.Errorf("objects differ: %v", util.ObjectDiff(podOut, podIn)) } } func TestEtcdUpdateScheduled(t *testing.T) { - storage, _, _, fakeClient := newStorage(t) + storage, _, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &api.Pod{ + err := storage.Storage.Create(ctx, key, &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: api.NamespaceDefault, @@ -614,13 +579,15 @@ func TestEtcdUpdateScheduled(t *testing.T) { }, SecurityContext: &api.PodSecurityContext{}, }, - }), 1) + }, nil, 1) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } grace := int64(30) podIn := api.Pod{ ObjectMeta: api.ObjectMeta{ - Name: "foo", - ResourceVersion: "1", + Name: "foo", Labels: map[string]string{ "foo": "bar", }, @@ -641,26 +608,27 @@ func TestEtcdUpdateScheduled(t *testing.T) { SecurityContext: &api.PodSecurityContext{}, }, } - _, _, err := storage.Update(ctx, &podIn) + _, _, err = storage.Update(ctx, &podIn) if err != nil { t.Errorf("Unexpected error: %v", err) } - response, err := fakeClient.Get(key, false, false) + + obj, err := storage.Get(ctx, "foo") if err != nil { - t.Fatalf("Unexpected error: %v", err) + t.Errorf("Unexpected error: %v", err) } - var podOut api.Pod - testapi.Default.Codec().DecodeInto([]byte(response.Node.Value), &podOut) - if !api.Semantic.DeepEqual(podOut, podIn) { - t.Errorf("expected: %#v, got: %#v", podOut, podIn) + podOut := obj.(*api.Pod) + // Check to verify the Spec and Label updates match from change above. Those are the fields changed. + if !api.Semantic.DeepEqual(podOut.Spec, podIn.Spec) || !api.Semantic.DeepEqual(podOut.Labels, podIn.Labels) { + t.Errorf("objects differ: %v", util.ObjectDiff(podOut, podIn)) } } func TestEtcdUpdateStatus(t *testing.T) { - storage, _, statusStorage, fakeClient := newStorage(t) + storage, _, statusStorage, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() - fakeClient.TestIndex = true key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) @@ -680,12 +648,14 @@ func TestEtcdUpdateStatus(t *testing.T) { SecurityContext: &api.PodSecurityContext{}, }, } - fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &podStart), 0) + err := storage.Storage.Create(ctx, key, &podStart, nil, 0) + if err != nil { + t.Errorf("unexpected error: %v", err) + } podIn := api.Pod{ ObjectMeta: api.ObjectMeta{ - Name: "foo", - ResourceVersion: "1", + Name: "foo", Labels: map[string]string{ "foo": "bar", }, @@ -719,15 +689,19 @@ func TestEtcdUpdateStatus(t *testing.T) { expected.Labels = podIn.Labels expected.Status = podIn.Status - _, _, err := statusStorage.Update(ctx, &podIn) + _, _, err = statusStorage.Update(ctx, &podIn) if err != nil { t.Fatalf("Unexpected error: %v", err) } - podOut, err := storage.Get(ctx, "foo") + obj, err := storage.Get(ctx, "foo") if err != nil { t.Errorf("unexpected error: %v", err) } - if !api.Semantic.DeepEqual(&expected, podOut) { - t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, podOut)) + podOut := obj.(*api.Pod) + // Check to verify the Spec, Label, and Status updates match from change above. Those are the fields changed. + if !api.Semantic.DeepEqual(podOut.Spec, podIn.Spec) || + !api.Semantic.DeepEqual(podOut.Labels, podIn.Labels) || + !api.Semantic.DeepEqual(podOut.Status, podIn.Status) { + t.Errorf("objects differ: %v", util.ObjectDiff(podOut, podIn)) } } diff --git a/pkg/registry/podtemplate/etcd/etcd_test.go b/pkg/registry/podtemplate/etcd/etcd_test.go index c0725fbbb0..17ee998b19 100644 --- a/pkg/registry/podtemplate/etcd/etcd_test.go +++ b/pkg/registry/podtemplate/etcd/etcd_test.go @@ -25,12 +25,12 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewREST(etcdStorage, generic.UndecoratedStorage), server } func validNewPodTemplate(name string) *api.PodTemplate { @@ -61,8 +61,9 @@ func validNewPodTemplate(name string) *api.PodTemplate { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) pod := validNewPodTemplate("foo") pod.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -76,8 +77,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( //valid validNewPodTemplate("foo"), @@ -91,26 +93,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ReturnDeletedObject() test.TestDelete(validNewPodTemplate("foo")) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewPodTemplate("foo")) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewPodTemplate("foo")) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewPodTemplate("foo"), // matching labels diff --git a/pkg/registry/registrytest/etcd.go b/pkg/registry/registrytest/etcd.go index 9a30d33dcd..b2f74dfeeb 100644 --- a/pkg/registry/registrytest/etcd.go +++ b/pkg/registry/registrytest/etcd.go @@ -20,9 +20,8 @@ import ( "fmt" "testing" - "github.com/coreos/go-etcd/etcd" - "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/rest/resttest" "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/fields" @@ -32,28 +31,26 @@ import ( "k8s.io/kubernetes/pkg/storage" etcdstorage "k8s.io/kubernetes/pkg/storage/etcd" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" + storagetesting "k8s.io/kubernetes/pkg/storage/testing" ) -func NewEtcdStorage(t *testing.T, group string) (storage.Interface, *tools.FakeEtcdClient) { - fakeClient := tools.NewFakeEtcdClient(t) - fakeClient.TestIndex = true - etcdStorage := etcdstorage.NewEtcdStorage(fakeClient, testapi.Groups[group].Codec(), etcdtest.PathPrefix()) - return etcdStorage, fakeClient +func NewEtcdStorage(t *testing.T, group string) (storage.Interface, *etcdtesting.EtcdTestServer) { + server := etcdtesting.NewEtcdTestClientServer(t) + storage := etcdstorage.NewEtcdStorage(server.Client, testapi.Groups[group].Codec(), etcdtest.PathPrefix()) + return storage, server } type Tester struct { - tester *resttest.Tester - fakeClient *tools.FakeEtcdClient - storage *etcdgeneric.Etcd + tester *resttest.Tester + storage *etcdgeneric.Etcd } type UpdateFunc func(runtime.Object) runtime.Object -func New(t *testing.T, fakeClient *tools.FakeEtcdClient, storage *etcdgeneric.Etcd) *Tester { +func New(t *testing.T, storage *etcdgeneric.Etcd) *Tester { return &Tester{ - tester: resttest.New(t, storage, fakeClient.SetError), - fakeClient: fakeClient, - storage: storage, + tester: resttest.New(t, storage), + storage: storage, } } @@ -98,7 +95,6 @@ func (t *Tester) TestUpdate(valid runtime.Object, validUpdateFunc UpdateFunc, in t.tester.TestUpdate( valid, t.setObject, - t.setResourceVersion, t.getObject, resttest.UpdateFunc(validUpdateFunc), invalidFuncs..., @@ -110,7 +106,7 @@ func (t *Tester) TestDelete(valid runtime.Object) { valid, t.setObject, t.getObject, - isNotFoundEtcdError, + errors.IsNotFound, ) } @@ -131,21 +127,19 @@ func (t *Tester) TestList(valid runtime.Object) { t.tester.TestList( valid, t.setObjectsForList, - t.setResourceVersion, ) } func (t *Tester) TestWatch(valid runtime.Object, labelsPass, labelsFail []labels.Set, fieldsPass, fieldsFail []fields.Set) { t.tester.TestWatch( valid, - t.fakeClient.WaitForWatchCompletion, - t.injectWatchError, t.emitObject, labelsPass, labelsFail, fieldsPass, fieldsFail, - []string{etcdstorage.EtcdCreate, etcdstorage.EtcdSet, etcdstorage.EtcdCAS, etcdstorage.EtcdDelete}, + // TODO: This should be filtered, the registry should not be aware of this level of detail + []string{etcdstorage.EtcdCreate, etcdstorage.EtcdDelete}, ) } @@ -178,24 +172,11 @@ func (t *Tester) getObject(ctx api.Context, obj runtime.Object) (runtime.Object, if err != nil { return nil, err } - key, err := t.storage.KeyFunc(ctx, meta.Name) - if err != nil { - return nil, err - } - key = etcdtest.AddPrefix(key) - resp, err := t.fakeClient.Get(key, false, false) - if err != nil { - return nil, err - } - result := t.storage.NewFunc() - codec, err := getCodec(obj) + result, err := t.storage.Get(ctx, meta.Name) if err != nil { return nil, err } - if err := codec.DecodeInto([]byte(resp.Node.Value), result); err != nil { - return nil, err - } return result, nil } @@ -208,82 +189,34 @@ func (t *Tester) setObject(ctx api.Context, obj runtime.Object) error { if err != nil { return err } - key = etcdtest.AddPrefix(key) - - codec, err := getCodec(obj) - if err != nil { - return err - } - _, err = t.fakeClient.Set(key, runtime.EncodeOrDie(codec, obj), 0) - return err + return t.storage.Storage.Set(ctx, key, obj, nil, 0) } func (t *Tester) setObjectsForList(objects []runtime.Object) []runtime.Object { - result := make([]runtime.Object, len(objects)) - key := etcdtest.AddPrefix(t.storage.KeyRootFunc(t.tester.TestContext())) - - if len(objects) > 0 { - nodes := make([]*etcd.Node, len(objects)) - for i, obj := range objects { - codec, _ := getCodec(obj) - encoded := runtime.EncodeOrDie(codec, obj) - decoded, _ := codec.Decode([]byte(encoded)) - nodes[i] = &etcd.Node{Value: encoded} - result[i] = decoded - } - t.fakeClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: &etcd.Node{ - Nodes: nodes, - }, - }, - E: nil, - } - } else { - t.fakeClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{}, - E: t.fakeClient.NewError(tools.EtcdErrorCodeNotFound), - } + key := t.storage.KeyRootFunc(t.tester.TestContext()) + if err := storagetesting.CreateObjList(key, t.storage.Storage, objects); err != nil { + t.tester.Errorf("unexpected error: %v", err) + return nil } - return result -} - -func (t *Tester) setResourceVersion(resourceVersion uint64) { - t.fakeClient.ChangeIndex = resourceVersion -} - -func (t *Tester) injectWatchError(err error) { - t.fakeClient.WatchInjectError <- err + return objects } func (t *Tester) emitObject(obj runtime.Object, action string) error { - codec, err := getCodec(obj) - if err != nil { - return err - } - encoded, err := codec.Encode(obj) - if err != nil { - return err - } - node := &etcd.Node{ - Value: string(encoded), - } - var prevNode *etcd.Node = nil - if action == etcdstorage.EtcdDelete { - prevNode = node - } - t.fakeClient.WatchResponse <- &etcd.Response{ - Action: action, - Node: node, - PrevNode: prevNode, - } - return nil -} + ctx := t.tester.TestContext() + var err error -func isNotFoundEtcdError(err error) bool { - etcdError, ok := err.(*etcd.EtcdError) - if !ok { - return false + switch action { + case etcdstorage.EtcdCreate: + err = t.setObject(ctx, obj) + case etcdstorage.EtcdDelete: + meta, err := api.ObjectMetaFor(obj) + if err != nil { + return err + } + _, err = t.storage.Delete(ctx, meta.Name, nil) + default: + err = fmt.Errorf("unexpected action: %v", action) } - return etcdError.ErrorCode == tools.EtcdErrorCodeNotFound + + return err } diff --git a/pkg/registry/resourcequota/etcd/etcd_test.go b/pkg/registry/resourcequota/etcd/etcd_test.go index 1bba6c5b60..d93924acf5 100644 --- a/pkg/registry/resourcequota/etcd/etcd_test.go +++ b/pkg/registry/resourcequota/etcd/etcd_test.go @@ -17,26 +17,23 @@ limitations under the License. package etcd import ( - "fmt" "testing" "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/resource" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" - "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "k8s.io/kubernetes/pkg/util" ) -func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") resourceQuotaStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) - return resourceQuotaStorage, statusStorage, fakeClient + return resourceQuotaStorage, statusStorage, server } func validNewResourceQuota() *api.ResourceQuota { @@ -59,8 +56,9 @@ func validNewResourceQuota() *api.ResourceQuota { } func TestCreate(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) resourcequota := validNewResourceQuota() resourcequota.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -73,23 +71,13 @@ func TestCreate(t *testing.T) { ) } -func TestCreateRegistryError(t *testing.T) { - storage, _, fakeClient := newStorage(t) - fakeClient.Err = fmt.Errorf("test error") - - resourcequota := validNewResourceQuota() - _, err := storage.Create(api.NewDefaultContext(), resourcequota) - if err != fakeClient.Err { - t.Fatalf("unexpected error: %v", err) - } -} - func TestCreateSetsFields(t *testing.T) { - storage, _, fakeClient := newStorage(t) + storage, _, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() resourcequota := validNewResourceQuota() _, err := storage.Create(api.NewDefaultContext(), resourcequota) - if err != fakeClient.Err { + if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -107,26 +95,30 @@ func TestCreateSetsFields(t *testing.T) { } func TestDelete(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject() + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ReturnDeletedObject() test.TestDelete(validNewResourceQuota()) } func TestGet(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewResourceQuota()) } func TestList(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewResourceQuota()) } func TestWatch(t *testing.T) { - storage, _, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, _, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewResourceQuota(), // matching labels @@ -147,19 +139,22 @@ func TestWatch(t *testing.T) { } func TestUpdateStatus(t *testing.T) { - storage, status, fakeClient := newStorage(t) + storage, status, server := newStorage(t) + defer server.Terminate(t) ctx := api.NewDefaultContext() key, _ := storage.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) resourcequotaStart := validNewResourceQuota() - fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), resourcequotaStart), 0) + err := storage.Storage.Set(ctx, key, resourcequotaStart, nil, 0) + if err != nil { + t.Fatalf("Unexpected error: %v", err) + } resourcequotaIn := &api.ResourceQuota{ ObjectMeta: api.ObjectMeta{ - Name: "foo", - Namespace: api.NamespaceDefault, - ResourceVersion: "1", + Name: "foo", + Namespace: api.NamespaceDefault, }, Status: api.ResourceQuotaStatus{ Used: api.ResourceList{ @@ -181,17 +176,14 @@ func TestUpdateStatus(t *testing.T) { }, } - expected := *resourcequotaStart - expected.ResourceVersion = "2" - expected.Labels = resourcequotaIn.Labels - expected.Status = resourcequotaIn.Status - - _, _, err := status.Update(ctx, resourcequotaIn) + _, _, err = status.Update(ctx, resourcequotaIn) if err != nil { t.Fatalf("Unexpected error: %v", err) } - rqOut, err := storage.Get(ctx, "foo") - if !api.Semantic.DeepEqual(&expected, rqOut) { - t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, rqOut)) + obj, err := storage.Get(ctx, "foo") + rqOut := obj.(*api.ResourceQuota) + // only compare the meaningful update b/c we can't compare due to metadata + if !api.Semantic.DeepEqual(resourcequotaIn.Status, rqOut.Status) { + t.Errorf("unexpected object: %s", util.ObjectDiff(resourcequotaIn, rqOut)) } } diff --git a/pkg/registry/secret/etcd/etcd_test.go b/pkg/registry/secret/etcd/etcd_test.go index b0e9892610..35fd503e8d 100644 --- a/pkg/registry/secret/etcd/etcd_test.go +++ b/pkg/registry/secret/etcd/etcd_test.go @@ -25,12 +25,12 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewREST(etcdStorage, generic.UndecoratedStorage), server } func validNewSecret(name string) *api.Secret { @@ -46,8 +46,9 @@ func validNewSecret(name string) *api.Secret { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) secret := validNewSecret("foo") secret.ObjectMeta = api.ObjectMeta{GenerateName: "foo-"} test.TestCreate( @@ -67,8 +68,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewSecret("foo"), @@ -82,26 +84,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewSecret("foo")) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewSecret("foo")) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewSecret("foo")) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewSecret("foo"), // matching labels diff --git a/pkg/registry/service/allocator/etcd/etcd_test.go b/pkg/registry/service/allocator/etcd/etcd_test.go index bc64c8991f..b19e4a1041 100644 --- a/pkg/registry/service/allocator/etcd/etcd_test.go +++ b/pkg/registry/service/allocator/etcd/etcd_test.go @@ -21,21 +21,19 @@ import ( "testing" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/registry/service/allocator" - "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "golang.org/x/net/context" ) -func newStorage(t *testing.T) (*Etcd, *tools.FakeEtcdClient, allocator.Interface) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*Etcd, *etcdtesting.EtcdTestServer, allocator.Interface) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") mem := allocator.NewAllocationMap(100, "rangeSpecValue") etcd := NewEtcd(mem, "/ranges/serviceips", "serviceipallocation", etcdStorage) - return etcd, fakeClient, mem + return etcd, server, mem } func validNewRangeAllocation() *api.RangeAllocation { @@ -50,16 +48,17 @@ func key() string { } func TestEmpty(t *testing.T) { - storage, fakeClient, _ := newStorage(t) - fakeClient.ExpectNotFoundGet(key()) + storage, server, _ := newStorage(t) + defer server.Terminate(t) if _, err := storage.Allocate(1); !strings.Contains(err.Error(), "cannot allocate resources of type serviceipallocation at this time") { t.Fatal(err) } } func TestStore(t *testing.T) { - storage, fakeClient, backing := newStorage(t) - if _, err := fakeClient.Set(key(), runtime.EncodeOrDie(testapi.Default.Codec(), validNewRangeAllocation()), 0); err != nil { + storage, server, backing := newStorage(t) + defer server.Terminate(t) + if err := storage.storage.Set(context.TODO(), key(), validNewRangeAllocation(), nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } @@ -77,21 +76,12 @@ func TestStore(t *testing.T) { t.Fatal("Expected allocation to fail") } - obj := fakeClient.Data[key()] - if obj.R == nil || obj.R.Node == nil { - t.Fatalf("%s is empty: %#v", key(), obj) - } - t.Logf("data: %#v", obj.R.Node) - other := allocator.NewAllocationMap(100, "rangeSpecValue") allocation := &api.RangeAllocation{} if err := storage.storage.Get(context.TODO(), key(), allocation, false); err != nil { t.Fatal(err) } - if allocation.ResourceVersion != "2" { - t.Fatalf("%#v", allocation) - } if allocation.Range != "rangeSpecValue" { t.Errorf("unexpected stored Range: %s", allocation.Range) } diff --git a/pkg/registry/service/etcd/etcd_test.go b/pkg/registry/service/etcd/etcd_test.go index f045389da2..0117ffdcdf 100644 --- a/pkg/registry/service/etcd/etcd_test.go +++ b/pkg/registry/service/etcd/etcd_test.go @@ -25,13 +25,13 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" "k8s.io/kubernetes/pkg/util/intstr" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewREST(etcdStorage, generic.UndecoratedStorage), server } func validService() *api.Service { @@ -55,8 +55,9 @@ func validService() *api.Service { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) validService := validService() validService.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -84,8 +85,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate() test.TestUpdate( // valid validService(), @@ -108,26 +110,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate() test.TestDelete(validService()) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate() test.TestGet(validService()) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate() test.TestList(validService()) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validService(), // matching labels diff --git a/pkg/registry/service/ipallocator/etcd/etcd_test.go b/pkg/registry/service/ipallocator/etcd/etcd_test.go index 874c38def2..f70c728716 100644 --- a/pkg/registry/service/ipallocator/etcd/etcd_test.go +++ b/pkg/registry/service/ipallocator/etcd/etcd_test.go @@ -22,18 +22,19 @@ import ( "testing" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/registry/service/allocator" allocatoretcd "k8s.io/kubernetes/pkg/registry/service/allocator/etcd" "k8s.io/kubernetes/pkg/registry/service/ipallocator" - "k8s.io/kubernetes/pkg/runtime" + "k8s.io/kubernetes/pkg/storage" "k8s.io/kubernetes/pkg/storage/etcd/etcdtest" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" + + "golang.org/x/net/context" ) -func newStorage(t *testing.T) (*tools.FakeEtcdClient, ipallocator.Interface, allocator.Interface) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") +func newStorage(t *testing.T) (*etcdtesting.EtcdTestServer, ipallocator.Interface, allocator.Interface, storage.Interface) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") _, cidr, err := net.ParseCIDR("192.168.1.0/24") if err != nil { t.Fatal(err) @@ -47,7 +48,7 @@ func newStorage(t *testing.T) (*tools.FakeEtcdClient, ipallocator.Interface, all return etcd }) - return fakeClient, storage, backing + return server, storage, backing, etcdStorage } func validNewRangeAllocation() *api.RangeAllocation { @@ -63,23 +64,25 @@ func key() string { } func TestEmpty(t *testing.T) { - fakeClient, storage, _ := newStorage(t) - fakeClient.ExpectNotFoundGet(key()) + server, storage, _, _ := newStorage(t) + defer server.Terminate(t) if err := storage.Allocate(net.ParseIP("192.168.1.2")); !strings.Contains(err.Error(), "cannot allocate resources of type serviceipallocation at this time") { t.Fatal(err) } } func TestErrors(t *testing.T) { - _, storage, _ := newStorage(t) + server, storage, _, _ := newStorage(t) + defer server.Terminate(t) if err := storage.Allocate(net.ParseIP("192.168.0.0")); err != ipallocator.ErrNotInRange { t.Fatal(err) } } func TestStore(t *testing.T) { - fakeClient, storage, backing := newStorage(t) - if _, err := fakeClient.Set(key(), runtime.EncodeOrDie(testapi.Default.Codec(), validNewRangeAllocation()), 0); err != nil { + server, storage, backing, si := newStorage(t) + defer server.Terminate(t) + if err := si.Set(context.TODO(), key(), validNewRangeAllocation(), nil, 0); err != nil { t.Fatalf("unexpected error: %v", err) } @@ -96,10 +99,4 @@ func TestStore(t *testing.T) { if err := storage.Allocate(net.ParseIP("192.168.1.2")); err != ipallocator.ErrAllocated { t.Fatal(err) } - - obj := fakeClient.Data[key()] - if obj.R == nil || obj.R.Node == nil { - t.Fatalf("%s is empty: %#v", key(), obj) - } - t.Logf("data: %#v", obj.R.Node) } diff --git a/pkg/registry/serviceaccount/etcd/etcd_test.go b/pkg/registry/serviceaccount/etcd/etcd_test.go index 44429df918..bb7d198d21 100644 --- a/pkg/registry/serviceaccount/etcd/etcd_test.go +++ b/pkg/registry/serviceaccount/etcd/etcd_test.go @@ -25,12 +25,12 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "") + return NewREST(etcdStorage, generic.UndecoratedStorage), server } func validNewServiceAccount(name string) *api.ServiceAccount { @@ -44,8 +44,9 @@ func validNewServiceAccount(name string) *api.ServiceAccount { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) serviceAccount := validNewServiceAccount("foo") serviceAccount.ObjectMeta = api.ObjectMeta{GenerateName: "foo-"} test.TestCreate( @@ -60,8 +61,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewServiceAccount("foo"), @@ -75,26 +77,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject() + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd).ReturnDeletedObject() test.TestDelete(validNewServiceAccount("foo")) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewServiceAccount("foo")) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewServiceAccount("foo")) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewServiceAccount("foo"), // matching labels diff --git a/pkg/registry/thirdpartyresource/etcd/etcd_test.go b/pkg/registry/thirdpartyresource/etcd/etcd_test.go index 5be03837b0..9dfbfbb039 100644 --- a/pkg/registry/thirdpartyresource/etcd/etcd_test.go +++ b/pkg/registry/thirdpartyresource/etcd/etcd_test.go @@ -28,12 +28,12 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions") - return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") + return NewREST(etcdStorage, generic.UndecoratedStorage), server } func validNewThirdPartyResource(name string) *extensions.ThirdPartyResource { @@ -51,8 +51,9 @@ func validNewThirdPartyResource(name string) *extensions.ThirdPartyResource { } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) rsrc := validNewThirdPartyResource("foo") rsrc.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -64,8 +65,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewThirdPartyResource("foo"), @@ -79,26 +81,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewThirdPartyResource("foo")) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewThirdPartyResource("foo")) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewThirdPartyResource("foo")) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewThirdPartyResource("foo"), // matching labels diff --git a/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go b/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go index baa179acf3..a1625af4da 100644 --- a/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go +++ b/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go @@ -28,12 +28,12 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/tools" + etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing" ) -func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { - etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions") - return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), fakeClient +func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { + etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") + return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), server } func validNewThirdPartyResourceData(name string) *extensions.ThirdPartyResourceData { @@ -47,8 +47,9 @@ func validNewThirdPartyResourceData(name string) *extensions.ThirdPartyResourceD } func TestCreate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) rsrc := validNewThirdPartyResourceData("foo") rsrc.ObjectMeta = api.ObjectMeta{} test.TestCreate( @@ -60,8 +61,9 @@ func TestCreate(t *testing.T) { } func TestUpdate(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestUpdate( // valid validNewThirdPartyResourceData("foo"), @@ -75,26 +77,30 @@ func TestUpdate(t *testing.T) { } func TestDelete(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestDelete(validNewThirdPartyResourceData("foo")) } func TestGet(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestGet(validNewThirdPartyResourceData("foo")) } func TestList(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestList(validNewThirdPartyResourceData("foo")) } func TestWatch(t *testing.T) { - storage, fakeClient := newStorage(t) - test := registrytest.New(t, fakeClient, storage.Etcd) + storage, server := newStorage(t) + defer server.Terminate(t) + test := registrytest.New(t, storage.Etcd) test.TestWatch( validNewThirdPartyResourceData("foo"), // matching labels diff --git a/pkg/storage/testing/utils.go b/pkg/storage/testing/utils.go index e025e2f233..bd2d78b901 100644 --- a/pkg/storage/testing/utils.go +++ b/pkg/storage/testing/utils.go @@ -18,7 +18,6 @@ package testing import ( "path" - "testing" "golang.org/x/net/context" "k8s.io/kubernetes/pkg/api/meta" @@ -27,31 +26,36 @@ import ( ) // CreateObj will create a single object using the storage interface -func CreateObj(t *testing.T, helper storage.Interface, name string, obj, out runtime.Object, ttl uint64) error { - err := helper.Set(context.TODO(), name, obj, out, ttl) - if err != nil { - t.Errorf("Unexpected error %v", err) - } - return err +func CreateObj(helper storage.Interface, name string, obj, out runtime.Object, ttl uint64) error { + return helper.Set(context.TODO(), name, obj, out, ttl) } -// CreateList will properly create a list using the storage interface -func CreateList(t *testing.T, prefix string, helper storage.Interface, list runtime.Object) error { - items, err := runtime.ExtractList(list) - if err != nil { - return err - } +//CreateObjList will create a list from the array of objects +func CreateObjList(prefix string, helper storage.Interface, items []runtime.Object) error { for i := range items { obj := items[i] meta, err := meta.Accessor(obj) if err != nil { return err } - err = CreateObj(t, helper, path.Join(prefix, meta.Name()), obj, obj, 0) + err = CreateObj(helper, path.Join(prefix, meta.Name()), obj, obj, 0) if err != nil { return err } items[i] = obj } + return nil +} + +// CreateList will properly create a list using the storage interface +func CreateList(prefix string, helper storage.Interface, list runtime.Object) error { + items, err := runtime.ExtractList(list) + if err != nil { + return err + } + err = CreateObjList(prefix, helper, items) + if err != nil { + return err + } return runtime.SetList(list, items) }