From f09a08d15aec934557b3da50d6f26313d9f4a0b2 Mon Sep 17 00:00:00 2001 From: Jerzy Szczepkowski Date: Tue, 11 Aug 2015 09:20:21 +0200 Subject: [PATCH] Refactoring of get etcd tests. Refactoring of get etcd tests: introudced new generic resttest, TestGet; Converted all etcd tests to use it. --- pkg/api/rest/resttest/resttest.go | 219 ++++++++++++------ pkg/registry/controller/etcd/etcd_test.go | 86 +------ pkg/registry/endpoint/etcd/etcd_test.go | 28 +-- .../horizontalpodautoscaler/etcd/etcd_test.go | 31 +-- pkg/registry/minion/etcd/etcd_test.go | 35 +-- pkg/registry/namespace/etcd/etcd_test.go | 28 +-- .../persistentvolume/etcd/etcd_test.go | 28 +-- .../persistentvolumeclaim/etcd/etcd_test.go | 32 +-- pkg/registry/pod/etcd/etcd_test.go | 104 +-------- pkg/registry/resourcequota/etcd/etcd_test.go | 101 +------- pkg/tools/fake_etcd_client.go | 2 +- 11 files changed, 179 insertions(+), 515 deletions(-) diff --git a/pkg/api/rest/resttest/resttest.go b/pkg/api/rest/resttest/resttest.go index 547ee55596..106237ddc9 100644 --- a/pkg/api/rest/resttest/resttest.go +++ b/pkg/api/rest/resttest/resttest.go @@ -75,6 +75,14 @@ func (t *Tester) TestContext() api.Context { return api.WithNamespace(api.NewContext(), t.TestNamespace()) } +func (t *Tester) getObjectMetaOrFail(obj runtime.Object) *api.ObjectMeta { + meta, err := api.ObjectMetaFor(obj) + if err != nil { + t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, obj) + } + return meta +} + func copyOrDie(obj runtime.Object) runtime.Object { out, err := api.Scheme.Copy(obj) if err != nil { @@ -98,11 +106,7 @@ func (t *Tester) TestCreate(valid runtime.Object, invalid ...runtime.Object) { } func (t *Tester) TestCreateResetsUserData(valid runtime.Object) { - objectMeta, err := api.ObjectMetaFor(valid) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, valid) - } - + objectMeta := t.getObjectMetaOrFail(valid) now := util.Now() objectMeta.UID = "bad-uid" objectMeta.CreationTimestamp = now @@ -120,11 +124,7 @@ func (t *Tester) TestCreateResetsUserData(valid runtime.Object) { } func (t *Tester) TestCreateHasMetadata(valid runtime.Object) { - objectMeta, err := api.ObjectMetaFor(valid) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, valid) - } - + objectMeta := t.getObjectMetaOrFail(valid) objectMeta.Name = "" objectMeta.GenerateName = "test-" objectMeta.Namespace = t.TestNamespace() @@ -142,15 +142,11 @@ func (t *Tester) TestCreateHasMetadata(valid runtime.Object) { } func (t *Tester) TestCreateGeneratesName(valid runtime.Object) { - objectMeta, err := api.ObjectMetaFor(valid) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, valid) - } - + objectMeta := t.getObjectMetaOrFail(valid) objectMeta.Name = "" objectMeta.GenerateName = "test-" - _, err = t.storage.(rest.Creater).Create(t.TestContext(), valid) + _, err := t.storage.(rest.Creater).Create(t.TestContext(), valid) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -160,11 +156,7 @@ func (t *Tester) TestCreateGeneratesName(valid runtime.Object) { } func (t *Tester) TestCreateGeneratesNameReturnsServerTimeout(valid runtime.Object) { - objectMeta, err := api.ObjectMetaFor(valid) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, valid) - } - + objectMeta := t.getObjectMetaOrFail(valid) objectMeta.Name = "" objectMeta.GenerateName = "test-" t.withStorageError(errors.NewAlreadyExists("kind", "thing"), func() { @@ -186,14 +178,10 @@ func (t *Tester) TestCreateInvokesValidation(invalid ...runtime.Object) { } func (t *Tester) TestCreateRejectsMismatchedNamespace(valid runtime.Object) { - objectMeta, err := api.ObjectMetaFor(valid) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, valid) - } - + objectMeta := t.getObjectMetaOrFail(valid) objectMeta.Namespace = "not-default" - _, err = t.storage.(rest.Creater).Create(t.TestContext(), valid) + _, err := t.storage.(rest.Creater).Create(t.TestContext(), valid) if err == nil { t.Errorf("Expected an error, but we didn't get one") } else if !strings.Contains(err.Error(), "does not match the namespace sent on the request") { @@ -202,10 +190,7 @@ func (t *Tester) TestCreateRejectsMismatchedNamespace(valid runtime.Object) { } func (t *Tester) TestCreateDiscardsObjectNamespace(valid runtime.Object) { - objectMeta, err := api.ObjectMetaFor(valid) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, valid) - } + objectMeta := t.getObjectMetaOrFail(valid) // Ignore non-empty namespace in object meta objectMeta.Namespace = "not-default" @@ -215,10 +200,7 @@ func (t *Tester) TestCreateDiscardsObjectNamespace(valid runtime.Object) { if err != nil { t.Fatalf("Unexpected error: %v", err) } - createdObjectMeta, err := api.ObjectMetaFor(created) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, created) - } + createdObjectMeta := t.getObjectMetaOrFail(created) if createdObjectMeta.Namespace != api.NamespaceNone { t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.Namespace) } @@ -233,20 +215,14 @@ func (t *Tester) TestCreateIgnoresContextNamespace(valid runtime.Object) { if err != nil { t.Fatalf("Unexpected error: %v", err) } - createdObjectMeta, err := api.ObjectMetaFor(created) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, created) - } + createdObjectMeta := t.getObjectMetaOrFail(created) if createdObjectMeta.Namespace != api.NamespaceNone { t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.Namespace) } } func (t *Tester) TestCreateIgnoresMismatchedNamespace(valid runtime.Object) { - objectMeta, err := api.ObjectMetaFor(valid) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, valid) - } + objectMeta := t.getObjectMetaOrFail(valid) // Ignore non-empty namespace in object meta objectMeta.Namespace = "not-default" @@ -257,10 +233,7 @@ func (t *Tester) TestCreateIgnoresMismatchedNamespace(valid runtime.Object) { if err != nil { t.Fatalf("Unexpected error: %v", err) } - createdObjectMeta, err := api.ObjectMetaFor(created) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, created) - } + createdObjectMeta := t.getObjectMetaOrFail(created) if createdObjectMeta.Namespace != api.NamespaceNone { t.Errorf("Expected empty namespace on created object, got '%v'", createdObjectMeta.Namespace) } @@ -291,12 +264,9 @@ func (t *Tester) TestUpdateFailsOnVersion(older runtime.Object) { func (t *Tester) TestDeleteInvokesValidation(invalid ...runtime.Object) { for i, obj := range invalid { - objectMeta, err := api.ObjectMetaFor(obj) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, obj) - } + objectMeta := t.getObjectMetaOrFail(obj) ctx := t.TestContext() - _, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, nil) + _, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, nil) if !errors.IsInvalid(err) { t.Errorf("%d: Expected to get an invalid resource error, got %v", i, err) } @@ -313,10 +283,7 @@ func (t *Tester) TestDelete(createFn func() runtime.Object, wasGracefulFn func() func (t *Tester) TestDeleteNonExist(createFn func() runtime.Object) { existing := createFn() - objectMeta, err := api.ObjectMetaFor(existing) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, existing) - } + objectMeta := t.getObjectMetaOrFail(existing) context := t.TestContext() t.withStorageError(&etcd.EtcdError{ErrorCode: tools.EtcdErrorCodeNotFound}, func() { @@ -334,12 +301,9 @@ func (t *Tester) TestDeleteGraceful(createFn func() runtime.Object, expectedGrac func (t *Tester) TestDeleteNoGraceful(createFn func() runtime.Object, wasGracefulFn func() bool) { existing := createFn() - objectMeta, err := api.ObjectMetaFor(existing) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, existing) - } + objectMeta := t.getObjectMetaOrFail(existing) ctx := api.WithNamespace(t.TestContext(), objectMeta.Namespace) - _, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, api.NewDeleteOptions(10)) + _, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, api.NewDeleteOptions(10)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -352,13 +316,9 @@ func (t *Tester) TestDeleteNoGraceful(createFn func() runtime.Object, wasGracefu } func (t *Tester) TestDeleteGracefulHasDefault(existing runtime.Object, expectedGrace int64, wasGracefulFn func() bool) { - objectMeta, err := api.ObjectMetaFor(existing) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, existing) - } - + objectMeta := t.getObjectMetaOrFail(existing) ctx := api.WithNamespace(t.TestContext(), objectMeta.Namespace) - _, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, &api.DeleteOptions{}) + _, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, &api.DeleteOptions{}) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -371,13 +331,9 @@ func (t *Tester) TestDeleteGracefulHasDefault(existing runtime.Object, expectedG } func (t *Tester) TestDeleteGracefulUsesZeroOnNil(existing runtime.Object, expectedGrace int64) { - objectMeta, err := api.ObjectMetaFor(existing) - if err != nil { - t.Fatalf("object does not have ObjectMeta: %v\n%#v", err, existing) - } - + objectMeta := t.getObjectMetaOrFail(existing) ctx := api.WithNamespace(t.TestContext(), objectMeta.Namespace) - _, err = t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, nil) + _, err := t.storage.(rest.GracefulDeleter).Delete(ctx, objectMeta.Name, nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -385,3 +341,120 @@ func (t *Tester) TestDeleteGracefulUsesZeroOnNil(existing runtime.Object, expect t.Errorf("unexpected error, object should exist: %v", err) } } + +func (t *Tester) TestGetFound(obj runtime.Object) { + ctx := t.TestContext() + objMeta := t.getObjectMetaOrFail(obj) + objMeta.Name = "foo1" + objMeta.Namespace = api.NamespaceValue(ctx) + + existing, err := t.storage.(rest.Creater).Create(ctx, obj) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + existingMeta := t.getObjectMetaOrFail(existing) + + got, err := t.storage.(rest.Getter).Get(ctx, "foo1") + if err != nil { + t.Errorf("unexpected error: %v", err) + } + gotMeta := t.getObjectMetaOrFail(got) + gotMeta.ResourceVersion = existingMeta.ResourceVersion + if e, a := existing, got; !api.Semantic.DeepEqual(e, a) { + t.Errorf("unexpected obj: %#v, expected %#v", e, a) + } +} + +func (t *Tester) TestGetNotFound(obj runtime.Object) { + ctx := t.TestContext() + objMeta := t.getObjectMetaOrFail(obj) + objMeta.Name = "foo2" + objMeta.Namespace = api.NamespaceValue(ctx) + _, err := t.storage.(rest.Creater).Create(ctx, obj) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + _, err = t.storage.(rest.Getter).Get(ctx, "foo3") + if !errors.IsNotFound(err) { + t.Errorf("unexpected error returned: %#v", err) + } +} + +func (t *Tester) TestGetMimatchedNamespace(obj runtime.Object) { + ctx1 := api.WithNamespace(api.NewContext(), "bar1") + ctx2 := api.WithNamespace(api.NewContext(), "bar2") + objMeta := t.getObjectMetaOrFail(obj) + objMeta.Name = "foo4" + objMeta.Namespace = api.NamespaceValue(ctx1) + _, err := t.storage.(rest.Creater).Create(ctx1, obj) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + _, err = t.storage.(rest.Getter).Get(ctx2, "foo4") + if t.clusterScope { + if err != nil { + t.Errorf("unexpected error: %v", err) + } + } else { + if !errors.IsNotFound(err) { + t.Errorf("unexpected error returned: %#v", err) + } + } +} + +// TestGetDifferentNamespace ensures same-name objects in different namespaces do not clash +func (t *Tester) TestGetDifferentNamespace(obj runtime.Object) { + if t.clusterScope { + t.Fatalf("the test does not work in in cluster-scope") + } + + objMeta := t.getObjectMetaOrFail(obj) + objMeta.Name = "foo5" + + ctx1 := api.WithNamespace(api.NewContext(), "bar3") + objMeta.Namespace = api.NamespaceValue(ctx1) + _, err := t.storage.(rest.Creater).Create(ctx1, obj) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + + ctx2 := api.WithNamespace(api.NewContext(), "bar4") + objMeta.Namespace = api.NamespaceValue(ctx2) + _, err = t.storage.(rest.Creater).Create(ctx2, obj) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + + got1, err := t.storage.(rest.Getter).Get(ctx1, objMeta.Name) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + got1Meta := t.getObjectMetaOrFail(got1) + if got1Meta.Name != objMeta.Name { + t.Errorf("unexpected name of object: %#v, expected: %s", got1, objMeta.Name) + } + if got1Meta.Namespace != api.NamespaceValue(ctx1) { + t.Errorf("unexpected namespace of object: %#v, expected: %s", got1, api.NamespaceValue(ctx1)) + } + + got2, err := t.storage.(rest.Getter).Get(ctx2, objMeta.Name) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + got2Meta := t.getObjectMetaOrFail(got2) + if got2Meta.Name != objMeta.Name { + t.Errorf("unexpected name of object: %#v, expected: %s", got2, objMeta.Name) + } + if got2Meta.Namespace != api.NamespaceValue(ctx2) { + t.Errorf("unexpected namespace of object: %#v, expected: %s", got2, api.NamespaceValue(ctx2)) + } +} + +func (t *Tester) TestGet(obj runtime.Object) { + t.TestGetFound(obj) + t.TestGetNotFound(obj) + t.TestGetMimatchedNamespace(obj) + if !t.clusterScope { + t.TestGetDifferentNamespace(obj) + } +} diff --git a/pkg/registry/controller/etcd/etcd_test.go b/pkg/registry/controller/etcd/etcd_test.go index 03f595c8d1..c826400d35 100644 --- a/pkg/registry/controller/etcd/etcd_test.go +++ b/pkg/registry/controller/etcd/etcd_test.go @@ -205,25 +205,6 @@ func TestCreateControllerWithConflictingNamespace(t *testing.T) { } } -func TestEtcdGetController(t *testing.T) { - ctx := api.NewDefaultContext() - storage, fakeClient := newStorage(t) - key, _ := makeControllerKey(ctx, validController.Name) - key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, &validController), 0) - ctrl, err := storage.Get(ctx, validController.Name) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - controller, ok := ctrl.(*api.ReplicationController) - if !ok { - t.Errorf("Expected a controller, got %#v", ctrl) - } - if controller.Name != validController.Name { - t.Errorf("Unexpected controller: %#v", controller) - } -} - func TestEtcdControllerValidatesUpdate(t *testing.T) { ctx := api.NewDefaultContext() storage, _ := newStorage(t) @@ -331,70 +312,11 @@ func TestGenerationNumber(t *testing.T) { } } -// TestEtcdGetControllerDifferentNamespace ensures same-name controllers in different namespaces do not clash -func TestEtcdGetControllerDifferentNamespace(t *testing.T) { +func TestEtcdGetController(t *testing.T) { storage, fakeClient := newStorage(t) - - otherNs := "other" - ctx1 := api.NewDefaultContext() - ctx2 := api.WithNamespace(api.NewContext(), otherNs) - - key1, _ := makeControllerKey(ctx1, validController.Name) - key2, _ := makeControllerKey(ctx2, validController.Name) - - key1 = etcdtest.AddPrefix(key1) - key2 = etcdtest.AddPrefix(key2) - - fakeClient.Set(key1, runtime.EncodeOrDie(latest.Codec, &validController), 0) - otherNsController := validController - otherNsController.Namespace = otherNs - fakeClient.Set(key2, runtime.EncodeOrDie(latest.Codec, &otherNsController), 0) - - obj, err := storage.Get(ctx1, validController.Name) - ctrl1, _ := obj.(*api.ReplicationController) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - if ctrl1.Name != "foo" { - t.Errorf("Unexpected controller: %#v", ctrl1) - } - if ctrl1.Namespace != "default" { - t.Errorf("Unexpected controller: %#v", ctrl1) - } - - obj, err = storage.Get(ctx2, validController.Name) - ctrl2, _ := obj.(*api.ReplicationController) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - if ctrl2.Name != "foo" { - t.Errorf("Unexpected controller: %#v", ctrl2) - } - if ctrl2.Namespace != "other" { - t.Errorf("Unexpected controller: %#v", ctrl2) - } - -} - -func TestEtcdGetControllerNotFound(t *testing.T) { - ctx := api.NewDefaultContext() - storage, fakeClient := newStorage(t) - key, _ := makeControllerKey(ctx, validController.Name) - key = etcdtest.AddPrefix(key) - - fakeClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: nil, - }, - E: tools.EtcdErrorNotFound, - } - ctrl, err := storage.Get(ctx, validController.Name) - if ctrl != nil { - t.Errorf("Unexpected non-nil controller: %#v", ctrl) - } - if !errors.IsNotFound(err) { - t.Errorf("Unexpected error returned: %#v", err) - } + test := resttest.New(t, storage, fakeClient.SetError) + copy := validController + test.TestGet(©) } func TestEtcdUpdateController(t *testing.T) { diff --git a/pkg/registry/endpoint/etcd/etcd_test.go b/pkg/registry/endpoint/etcd/etcd_test.go index 08b834f401..63a7b2ec6c 100644 --- a/pkg/registry/endpoint/etcd/etcd_test.go +++ b/pkg/registry/endpoint/etcd/etcd_test.go @@ -154,34 +154,10 @@ func TestEtcdListEndpoints(t *testing.T) { } func TestEtcdGetEndpoints(t *testing.T) { - ctx := api.NewDefaultContext() storage, fakeClient := newStorage(t) + test := resttest.New(t, storage, fakeClient.SetError) endpoints := validNewEndpoints() - name := endpoints.Name - key, _ := storage.KeyFunc(ctx, name) - key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, endpoints), 0) - - response, err := fakeClient.Get(key, false, false) - if err != nil { - t.Fatalf("Unexpected error %v", err) - } - var endpointsOut api.Endpoints - err = latest.Codec.DecodeInto([]byte(response.Node.Value), &endpointsOut) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - - obj, err := storage.Get(ctx, name) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - got := obj.(*api.Endpoints) - - endpoints.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion - if e, a := endpoints, got; !api.Semantic.DeepEqual(*e, *a) { - t.Errorf("Unexpected endpoints: %#v, expected %#v", e, a) - } + test.TestGet(endpoints) } func TestListEmptyEndpointsList(t *testing.T) { diff --git a/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go b/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go index 7f611393c1..ba26671d56 100644 --- a/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go +++ b/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go @@ -136,32 +136,11 @@ func TestDelete(t *testing.T) { test.TestDeleteNoGraceful(createFn, gracefulSetFn) } -func TestEtcdGet(t *testing.T) { - ctx := api.NewDefaultContext() - registry, fakeClient, _ := newStorage(t) - autoscaler := validNewHorizontalPodAutoscaler("foo3") - name := autoscaler.Name - key, _ := registry.KeyFunc(ctx, name) - key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(testapi.Codec(), autoscaler), 0) - response, err := fakeClient.Get(key, false, false) - if err != nil { - t.Fatalf("Unexpected error %v", err) - } - var autoscalerOut expapi.HorizontalPodAutoscaler - err = testapi.Codec().DecodeInto([]byte(response.Node.Value), &autoscalerOut) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - obj, err := registry.Get(ctx, name) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - got := obj.(*expapi.HorizontalPodAutoscaler) - autoscaler.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion - if e, a := autoscaler, got; !api.Semantic.DeepEqual(*e, *a) { - t.Errorf("Unexpected autoscaler: %#v, expected %#v", e, a) - } +func TestGet(t *testing.T) { + storage, fakeEtcdClient, _ := newStorage(t) + test := resttest.New(t, storage, fakeEtcdClient.SetError) + autoscaler := validNewHorizontalPodAutoscaler("foo") + test.TestGet(autoscaler) } func TestEmptyList(t *testing.T) { diff --git a/pkg/registry/minion/etcd/etcd_test.go b/pkg/registry/minion/etcd/etcd_test.go index 088b7b2af7..d5180ee9a0 100644 --- a/pkg/registry/minion/etcd/etcd_test.go +++ b/pkg/registry/minion/etcd/etcd_test.go @@ -22,7 +22,6 @@ import ( "time" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/latest" "k8s.io/kubernetes/pkg/api/resource" "k8s.io/kubernetes/pkg/api/rest/resttest" @@ -211,23 +210,10 @@ func TestEtcdListNodesMatch(t *testing.T) { } func TestEtcdGetNode(t *testing.T) { - ctx := api.NewContext() storage, fakeClient := newStorage(t) + test := resttest.New(t, storage, fakeClient.SetError).ClusterScope() node := validNewNode() - key, _ := storage.KeyFunc(ctx, node.Name) - key = etcdtest.AddPrefix(key) - - fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, node), 0) - nodeObj, err := storage.Get(ctx, node.Name) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - got := nodeObj.(*api.Node) - - node.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion - if e, a := node, got; !api.Semantic.DeepEqual(*e, *a) { - t.Errorf("Unexpected node: %#v, expected %#v", e, a) - } + test.TestGet(node) } func TestEtcdUpdateEndpoints(t *testing.T) { @@ -260,23 +246,6 @@ func TestEtcdUpdateEndpoints(t *testing.T) { } } -func TestEtcdGetNodeNotFound(t *testing.T) { - ctx := api.NewContext() - storage, fakeClient := newStorage(t) - key := etcdtest.AddPrefix("minions/foo") - fakeClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: nil, - }, - E: tools.EtcdErrorNotFound, - } - _, err := storage.Get(ctx, "foo") - - if !errors.IsNotFound(err) { - t.Errorf("Unexpected error returned: %#v", err) - } -} - func TestEtcdDeleteNode(t *testing.T) { ctx := api.NewContext() storage, fakeClient := newStorage(t) diff --git a/pkg/registry/namespace/etcd/etcd_test.go b/pkg/registry/namespace/etcd/etcd_test.go index 09542df6d6..7af0c234a5 100644 --- a/pkg/registry/namespace/etcd/etcd_test.go +++ b/pkg/registry/namespace/etcd/etcd_test.go @@ -284,32 +284,10 @@ func TestNamespaceDecode(t *testing.T) { } func TestGet(t *testing.T) { - expect := validNewNamespace() - expect.Status.Phase = api.NamespaceActive storage, fakeEtcdClient, _ := newStorage(t) - ctx := api.NewContext() - key, err := storage.Etcd.KeyFunc(ctx, "foo") - key = etcdtest.AddPrefix(key) - if err != nil { - t.Fatalf("unexpected key error: %v", err) - } - fakeEtcdClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: &etcd.Node{ - Value: runtime.EncodeOrDie(latest.Codec, expect), - }, - }, - } - obj, err := storage.Get(api.NewContext(), "foo") - namespace := obj.(*api.Namespace) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - expect.Status.Phase = api.NamespaceActive - if e, a := expect, namespace; !api.Semantic.DeepEqual(e, a) { - t.Errorf("Unexpected namespace: %s", util.ObjectDiff(e, a)) - } + test := resttest.New(t, storage, fakeEtcdClient.SetError).ClusterScope() + namespace := validNewNamespace() + test.TestGet(namespace) } func TestDeleteNamespace(t *testing.T) { diff --git a/pkg/registry/persistentvolume/etcd/etcd_test.go b/pkg/registry/persistentvolume/etcd/etcd_test.go index 38c3fefc46..b8dc5f0626 100644 --- a/pkg/registry/persistentvolume/etcd/etcd_test.go +++ b/pkg/registry/persistentvolume/etcd/etcd_test.go @@ -149,34 +149,10 @@ func TestEtcdListPersistentVolumes(t *testing.T) { } func TestEtcdGetPersistentVolumes(t *testing.T) { - ctx := api.NewContext() storage, _, fakeClient, _ := newStorage(t) + test := resttest.New(t, storage, fakeClient.SetError).ClusterScope() persistentVolume := validNewPersistentVolume("foo") - name := persistentVolume.Name - key, _ := storage.KeyFunc(ctx, name) - key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, persistentVolume), 0) - - response, err := fakeClient.Get(key, false, false) - if err != nil { - t.Fatalf("Unexpected error %v", err) - } - var persistentVolumeOut api.PersistentVolume - err = latest.Codec.DecodeInto([]byte(response.Node.Value), &persistentVolumeOut) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - - obj, err := storage.Get(ctx, name) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - got := obj.(*api.PersistentVolume) - - persistentVolume.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion - if e, a := persistentVolume, got; !api.Semantic.DeepEqual(*e, *a) { - t.Errorf("Unexpected persistentVolume: %#v, expected %#v", e, a) - } + test.TestGet(persistentVolume) } func TestListEmptyPersistentVolumesList(t *testing.T) { diff --git a/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go b/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go index a515e960c9..aa7488ad95 100644 --- a/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go +++ b/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go @@ -147,34 +147,10 @@ func TestEtcdListPersistentVolumeClaims(t *testing.T) { } func TestEtcdGetPersistentVolumeClaims(t *testing.T) { - ctx := api.NewDefaultContext() - registry, _, fakeClient, _ := newStorage(t) - persistentVolume := validNewPersistentVolumeClaim("foo", api.NamespaceDefault) - name := persistentVolume.Name - key, _ := registry.KeyFunc(ctx, name) - key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, persistentVolume), 0) - - response, err := fakeClient.Get(key, false, false) - if err != nil { - t.Fatalf("Unexpected error %v", err) - } - var persistentVolumeOut api.PersistentVolumeClaim - err = latest.Codec.DecodeInto([]byte(response.Node.Value), &persistentVolumeOut) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - - obj, err := registry.Get(ctx, name) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - got := obj.(*api.PersistentVolumeClaim) - - persistentVolume.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion - if e, a := persistentVolume, got; !api.Semantic.DeepEqual(*e, *a) { - t.Errorf("Unexpected persistentVolume: %#v, expected %#v", e, a) - } + storage, _, fakeClient, _ := newStorage(t) + test := resttest.New(t, storage, fakeClient.SetError) + claim := validNewPersistentVolumeClaim("foo", api.NamespaceDefault) + test.TestGet(claim) } func TestListEmptyPersistentVolumeClaimsList(t *testing.T) { diff --git a/pkg/registry/pod/etcd/etcd_test.go b/pkg/registry/pod/etcd/etcd_test.go index dad7e53843..e05f3065e9 100644 --- a/pkg/registry/pod/etcd/etcd_test.go +++ b/pkg/registry/pod/etcd/etcd_test.go @@ -388,33 +388,6 @@ func TestPodDecode(t *testing.T) { } } -func TestGet(t *testing.T) { - expect := validNewPod() - expect.Status.Phase = api.PodRunning - expect.Spec.NodeName = "machine" - - fakeEtcdClient, etcdStorage := newEtcdStorage(t) - key := etcdtest.AddPrefix("/pods/test/foo") - fakeEtcdClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: &etcd.Node{ - Value: runtime.EncodeOrDie(latest.Codec, expect), - }, - }, - } - storage := NewStorage(etcdStorage, nil).Pod - - obj, err := storage.Get(api.WithNamespace(api.NewContext(), "test"), "foo") - pod := obj.(*api.Pod) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if e, a := expect, pod; !api.Semantic.DeepEqual(e, a) { - t.Errorf("Unexpected pod: %s", util.ObjectDiff(e, a)) - } -} - // TODO: remove, this is covered by RESTTest.TestCreate func TestPodStorageValidatesCreate(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) @@ -661,79 +634,12 @@ func TestDeletePod(t *testing.T) { } } -// TestEtcdGetDifferentNamespace ensures same-name pods in different namespaces do not clash -func TestEtcdGetDifferentNamespace(t *testing.T) { - registry, _, _, fakeClient, _ := newStorage(t) - - ctx1 := api.NewDefaultContext() - ctx2 := api.WithNamespace(api.NewContext(), "other") - - key1, _ := registry.KeyFunc(ctx1, "foo") - key2, _ := registry.KeyFunc(ctx2, "foo") - - key1 = etcdtest.AddPrefix(key1) - key2 = etcdtest.AddPrefix(key2) - - fakeClient.Set(key1, runtime.EncodeOrDie(latest.Codec, &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: "default", Name: "foo"}}), 0) - fakeClient.Set(key2, runtime.EncodeOrDie(latest.Codec, &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: "other", Name: "foo"}}), 0) - - obj, err := registry.Get(ctx1, "foo") - if err != nil { - t.Errorf("unexpected error: %v", err) - } - pod1 := obj.(*api.Pod) - if pod1.Name != "foo" { - t.Errorf("Unexpected pod: %#v", pod1) - } - if pod1.Namespace != "default" { - t.Errorf("Unexpected pod: %#v", pod1) - } - - obj, err = registry.Get(ctx2, "foo") - if err != nil { - t.Errorf("unexpected error: %v", err) - } - pod2 := obj.(*api.Pod) - if pod2.Name != "foo" { - t.Errorf("Unexpected pod: %#v", pod2) - } - if pod2.Namespace != "other" { - t.Errorf("Unexpected pod: %#v", pod2) - } - -} - func TestEtcdGet(t *testing.T) { - registry, _, _, fakeClient, _ := newStorage(t) - ctx := api.NewDefaultContext() - key, _ := registry.KeyFunc(ctx, "foo") - key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}), 0) - obj, err := registry.Get(ctx, "foo") - if err != nil { - t.Errorf("unexpected error: %v", err) - } - pod := obj.(*api.Pod) - if pod.Name != "foo" { - t.Errorf("Unexpected pod: %#v", pod) - } -} - -func TestEtcdGetNotFound(t *testing.T) { - registry, _, _, fakeClient, _ := newStorage(t) - ctx := api.NewDefaultContext() - key, _ := registry.KeyFunc(ctx, "foo") - key = etcdtest.AddPrefix(key) - fakeClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: nil, - }, - E: tools.EtcdErrorNotFound, - } - _, err := registry.Get(ctx, "foo") - if !errors.IsNotFound(err) { - t.Errorf("Unexpected error returned: %#v", err) - } + fakeEtcdClient, etcdStorage := newEtcdStorage(t) + storage := NewStorage(etcdStorage, nil).Pod + test := resttest.New(t, storage, fakeEtcdClient.SetError) + pod := validNewPod() + test.TestGet(pod) } func TestEtcdCreate(t *testing.T) { diff --git a/pkg/registry/resourcequota/etcd/etcd_test.go b/pkg/registry/resourcequota/etcd/etcd_test.go index 912bc683db..05198ebdf9 100644 --- a/pkg/registry/resourcequota/etcd/etcd_test.go +++ b/pkg/registry/resourcequota/etcd/etcd_test.go @@ -314,30 +314,6 @@ func TestResourceQuotaDecode(t *testing.T) { } } -func TestGet(t *testing.T) { - expect := validNewResourceQuota() - fakeEtcdClient, etcdStorage := newEtcdStorage(t) - storage, _ := NewStorage(etcdStorage) - key := "/resourcequotas/test/foo" - key = etcdtest.AddPrefix(key) - fakeEtcdClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: &etcd.Node{ - Value: runtime.EncodeOrDie(latest.Codec, expect), - }, - }, - } - obj, err := storage.Get(api.WithNamespace(api.NewContext(), "test"), "foo") - resourcequota := obj.(*api.ResourceQuota) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if e, a := expect, resourcequota; !api.Semantic.DeepEqual(e, a) { - t.Errorf("Unexpected resourcequota: %s", util.ObjectDiff(e, a)) - } -} - func TestDeleteResourceQuota(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) fakeEtcdClient.ChangeIndex = 1 @@ -366,79 +342,12 @@ func TestDeleteResourceQuota(t *testing.T) { } } -// TestEtcdGetDifferentNamespace ensures same-name resourcequotas in different namespaces do not clash -func TestEtcdGetDifferentNamespace(t *testing.T) { - registry, _, fakeClient, _ := newStorage(t) - - ctx1 := api.NewDefaultContext() - ctx2 := api.WithNamespace(api.NewContext(), "other") - - key1, _ := registry.KeyFunc(ctx1, "foo") - key2, _ := registry.KeyFunc(ctx2, "foo") - - key1 = etcdtest.AddPrefix(key1) - key2 = etcdtest.AddPrefix(key2) - - fakeClient.Set(key1, runtime.EncodeOrDie(latest.Codec, &api.ResourceQuota{ObjectMeta: api.ObjectMeta{Namespace: "default", Name: "foo"}}), 0) - fakeClient.Set(key2, runtime.EncodeOrDie(latest.Codec, &api.ResourceQuota{ObjectMeta: api.ObjectMeta{Namespace: "other", Name: "foo"}}), 0) - - obj, err := registry.Get(ctx1, "foo") - if err != nil { - t.Errorf("unexpected error: %v", err) - } - resourcequota1 := obj.(*api.ResourceQuota) - if resourcequota1.Name != "foo" { - t.Errorf("Unexpected resourcequota: %#v", resourcequota1) - } - if resourcequota1.Namespace != "default" { - t.Errorf("Unexpected resourcequota: %#v", resourcequota1) - } - - obj, err = registry.Get(ctx2, "foo") - if err != nil { - t.Errorf("unexpected error: %v", err) - } - resourcequota2 := obj.(*api.ResourceQuota) - if resourcequota2.Name != "foo" { - t.Errorf("Unexpected resourcequota: %#v", resourcequota2) - } - if resourcequota2.Namespace != "other" { - t.Errorf("Unexpected resourcequota: %#v", resourcequota2) - } - -} - func TestEtcdGet(t *testing.T) { - registry, _, fakeClient, _ := newStorage(t) - ctx := api.NewDefaultContext() - key, _ := registry.KeyFunc(ctx, "foo") - key = etcdtest.AddPrefix(key) - fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, &api.ResourceQuota{ObjectMeta: api.ObjectMeta{Name: "foo"}}), 0) - obj, err := registry.Get(ctx, "foo") - if err != nil { - t.Errorf("unexpected error: %v", err) - } - resourcequota := obj.(*api.ResourceQuota) - if resourcequota.Name != "foo" { - t.Errorf("Unexpected resourcequota: %#v", resourcequota) - } -} - -func TestEtcdGetNotFound(t *testing.T) { - registry, _, fakeClient, _ := newStorage(t) - ctx := api.NewDefaultContext() - key, _ := registry.KeyFunc(ctx, "foo") - key = etcdtest.AddPrefix(key) - fakeClient.Data[key] = tools.EtcdResponseWithError{ - R: &etcd.Response{ - Node: nil, - }, - E: tools.EtcdErrorNotFound, - } - _, err := registry.Get(ctx, "foo") - if !errors.IsNotFound(err) { - t.Errorf("Unexpected error returned: %#v", err) - } + fakeEtcdClient, etcdStorage := newEtcdStorage(t) + storage, _ := NewStorage(etcdStorage) + test := resttest.New(t, storage, fakeEtcdClient.SetError) + resourcequota := validNewResourceQuota() + test.TestGet(resourcequota) } func TestEtcdCreateFailsWithoutNamespace(t *testing.T) { diff --git a/pkg/tools/fake_etcd_client.go b/pkg/tools/fake_etcd_client.go index bf4b7fdd1f..22b8a59e76 100644 --- a/pkg/tools/fake_etcd_client.go +++ b/pkg/tools/fake_etcd_client.go @@ -136,7 +136,7 @@ func (f *FakeEtcdClient) Get(key string, sort, recursive bool) (*etcd.Response, result := f.Data[key] if result.R == nil { if _, ok := f.expectNotFoundGetSet[key]; !ok { - f.t.Fatalf("data for %s was not defined prior to invoking Get", key) + f.t.Logf("data for %s was not defined prior to invoking Get", key) } return &etcd.Response{}, f.NewError(EtcdErrorCodeNotFound) }