Merge pull request #12641 from jszczepkowski/etcd-test-get

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) {
-	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()
+func TestEtcdGetController(t *testing.T) {
 	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(&copy)
 }
 
 func TestEtcdUpdateController(t *testing.T) {

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

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

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)

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

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

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

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

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

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