Merge pull request #17469 from timothysc/etcd-remove-fakeclient-part4

Auto commit by PR queue bot

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) *Tester {
-
-func New(t *testing.T, storage rest.Storage, storageError injectErrorFunc) *Tester {
 	return &Tester{
-		T:            t,
+		T:       t,
-		storage:      storage,
+		storage: storage,
-		storageError: storageError,
 	}
 }
 
-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) {
+func (t *Tester) TestList(valid runtime.Object, assignFn AssignFunc) {
-	t.testListError()
+	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), emitFn, labelsPass, labelsFail, actions)
-	t.testWatchLabels(copyOrDie(valid), initWatchFn, emitFn, labelsPass, labelsFail, actions)
+	t.testWatchFields(copyOrDie(valid), emitFn, fieldsPass, fieldsFail, actions)
-	t.testWatchFields(copyOrDie(valid), initWatchFn, 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)
-		_, err := t.storage.(rest.GracefulDeleter).Delete(t.TestContext(), objectMeta.Name, nil)
+	if err == nil || !errors.IsNotFound(err) {
-		if err == nil || !errors.IsNotFound(err) {
+		t.Errorf("unexpected error: %v", 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)
+	foo3 := copyOrDie(obj)
-	t.setObjectMeta(foo1, "foo1")
+	t.setObjectMeta(foo3, "foo3")
-	foo2 := copyOrDie(obj)
+	foo4 := copyOrDie(obj)
-	foo2Meta := t.getObjectMetaOrFail(foo2)
+	foo4Meta := t.getObjectMetaOrFail(foo4)
-	foo2Meta.Name = "foo2"
+	foo4Meta.Name = "foo4"
-	foo2Meta.Namespace = api.NamespaceValue(ctx)
+	foo4Meta.Namespace = api.NamespaceValue(ctx)
-	foo2Meta.Labels = testLabels
+	foo4Meta.Labels = testLabels
 
-	existing := assignFn([]runtime.Object{foo1, foo2})
+	objs := ([]runtime.Object{foo3, foo4})
-	filtered := []runtime.Object{existing[1]}
+
+	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)
+		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)
 	}
 }
 
 // =============================================================================
 // Watching tests.
 
-func (t *Tester) testWatch(initWatchFn InitWatchFunc, injectErrFn InjectErrFunc) {
+func (t *Tester) testWatchFields(obj runtime.Object, emitFn EmitFunc, fieldsPass, fieldsFail []fields.Set, actions []string) {
-	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) {
 	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)
 			}

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewController())
 }
 
 func TestList(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewController())
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validController,
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(newValidDaemonSet())
 }
 
 func TestGet(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(newValidDaemonSet())
 }
 
 func TestList(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(newValidDaemonSet())
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validDaemonSet,
 		// matching labels

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) {
+func newStorage(t *testing.T) (*DeploymentStorage, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Deployment.Etcd)
 	test.TestDelete(validNewDeployment())
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Deployment.Etcd)
 	test.TestGet(validNewDeployment())
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Deployment.Etcd)
 	test.TestList(validNewDeployment())
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
+	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
+	deployment := obj.(*extensions.Scale)
-	testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &deployment)
 	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
+	deployment := obj.(*extensions.Deployment)
-	testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &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)
 	}

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewEndpoints())
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewEndpoints())
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewEndpoints())
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewEndpoints(),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	fakeClient.HideExpires = true
+	return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), server
-	return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), fakeClient
 }
 
 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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewEvent(test.TestNamespace()))
 }

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"
+	etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
-	"k8s.io/kubernetes/pkg/util"
 )
 
-func newStorage(t *testing.T) (*ScaleREST, *tools.FakeEtcdClient) {
+func newStorage(t *testing.T) (*ScaleREST, *etcdtesting.EtcdTestServer, storage.Interface) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	return NewStorage(etcdStorage, generic.UndecoratedStorage).Scale, fakeClient
+	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) {
+	scale := obj.(*extensions.Scale)
-		t.Errorf("unexpected scale: %s", util.ObjectDiff(e, a))
+	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
+	updated := obj.(*extensions.Scale)
-	testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &controller)
+	if updated.Spec.Replicas != replicas {
-	if controller.Spec.Replicas != replicas {
+		t.Errorf("wrong replicas count expected: %d got: %d", replicas, updated.Spec.Replicas)
-		t.Errorf("wrong replicas count expected: %d got: %d", replicas, controller.Spec.Replicas)
 	}
 }

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

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewHorizontalPodAutoscaler("foo"))
 }
 
 func TestGet(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewHorizontalPodAutoscaler("foo"))
 }
 
 func TestList(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewHorizontalPodAutoscaler("foo"))
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewHorizontalPodAutoscaler("foo"),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validIngress())
 }
 
 func TestGet(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validIngress())
 }
 
 func TestList(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validIngress())
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validIngress(),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewJob())
 }
 
 func TestGet(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewJob())
 }
 
 func TestList(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewJob())
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewJob(),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).GeneratesName()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewLimitRange())
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewLimitRange())
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewLimitRange())
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewLimitRange(),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope().ReturnDeletedObject()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject()
 	test.TestDelete(validNewNamespace())
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestGet(validNewNamespace())
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestList(validNewNamespace())
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	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 {

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestDelete(validNewNode())
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestGet(validNewNode())
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestList(validNewNode())
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestWatch(
 		validNewNode(),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope().ReturnDeletedObject()
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestGet(validNewPersistentVolume("foo"))
 }
 
 func TestList(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ClusterScope()
 	test.TestList(validNewPersistentVolume("foo"))
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
+	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)
+	storage, statusStorage, server := newStorage(t)
-	fakeClient.TestIndex = true
+	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",
+			Name: "foo",
-			ResourceVersion: "1",
 		},
 		Status: api.PersistentVolumeStatus{
 			Phase: api.VolumeBound,
 		},
 	}
 
-	expected := *pvStart
+	_, _, err = statusStorage.Update(ctx, pvIn)
-	expected.ResourceVersion = "2"
-	expected.Labels = pvIn.Labels
-	expected.Status = pvIn.Status
-
-	_, _, 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) {
+	pvOut := obj.(*api.PersistentVolume)
-		t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, pvOut))
+	// 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))
 	}
 }

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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",
+			Name:      "foo",
-			Namespace:       api.NamespaceDefault,
+			Namespace: api.NamespaceDefault,
-			ResourceVersion: "1",
 		},
 		Spec: api.PersistentVolumeClaimSpec{
 			AccessModes: []api.PersistentVolumeAccessMode{api.ReadWriteOnce},
@@ -163,20 +167,17 @@ func TestUpdateStatus(t *testing.T) {
 		},
 	}
 
-	expected := *pvcStart
+	_, _, err = statusStorage.Update(ctx, pvc)
-	expected.ResourceVersion = "2"
-	expected.Labels = pvc.Labels
-	expected.Status = pvc.Status
-
-	_, _, 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) {
+	pvcOut := obj.(*api.PersistentVolumeClaim)
-		t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, pvcOut))
+	// 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))
 	}
 }

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) {
+func newStorage(t *testing.T) (*REST, *BindingREST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, _, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
+	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)
+	storage, _, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewPod())
 }
 
 func TestList(t *testing.T) {
-	storage, _, _, fakeClient := newStorage(t)
+	storage, _, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewPod())
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, _, fakeClient := newStorage(t)
+	storage, _, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, _, server := newStorage(t)
-	fakeClient.TestIndex = true
+	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
+	pod := obj.(*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)
-	}
 	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{}
+	podOut := obj.(*api.Pod)
-	testapi.Default.Codec().DecodeInto([]byte(response.Node.Value), podOut)
+	// validChangedPod only changes the Labels, so were checking the update was valid
-	if !api.Semantic.DeepEqual(podOut, podIn) {
+	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",
+			Name: "foo",
-			ResourceVersion: "1",
 			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
+	podOut := obj.(*api.Pod)
-	testapi.Default.Codec().DecodeInto([]byte(response.Node.Value), &podOut)
+	// Check to verify the Spec and Label updates match from change above.  Those are the fields changed.
-	if !api.Semantic.DeepEqual(podOut, podIn) {
+	if !api.Semantic.DeepEqual(podOut.Spec, podIn.Spec) || !api.Semantic.DeepEqual(podOut.Labels, podIn.Labels) {
-		t.Errorf("expected: %#v, got: %#v", podOut, podIn)
+		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",
+			Name: "foo",
-			ResourceVersion: "1",
 			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) {
+	podOut := obj.(*api.Pod)
-		t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, podOut))
+	// 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))
 	}
 }

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
 	test.TestDelete(validNewPodTemplate("foo"))
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewPodTemplate("foo"))
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewPodTemplate("foo"))
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewPodTemplate("foo"),
 		// matching labels

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) {
+func NewEtcdStorage(t *testing.T, group string) (storage.Interface, *etcdtesting.EtcdTestServer) {
-	fakeClient := tools.NewFakeEtcdClient(t)
+	server := etcdtesting.NewEtcdTestClientServer(t)
-	fakeClient.TestIndex = true
+	storage := etcdstorage.NewEtcdStorage(server.Client, testapi.Groups[group].Codec(), etcdtest.PathPrefix())
-	etcdStorage := etcdstorage.NewEtcdStorage(fakeClient, testapi.Groups[group].Codec(), etcdtest.PathPrefix())
+	return storage, server
-	return etcdStorage, fakeClient
 }
 
 type Tester struct {
-	tester     *resttest.Tester
+	tester  *resttest.Tester
-	fakeClient *tools.FakeEtcdClient
+	storage *etcdgeneric.Etcd
-	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),
+		tester:  resttest.New(t, storage),
-		fakeClient: fakeClient,
+		storage: 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)
+	return t.storage.Storage.Set(ctx, key, obj, nil, 0)
-
-	codec, err := getCodec(obj)
-	if err != nil {
-		return err
-	}
-	_, err = t.fakeClient.Set(key, runtime.EncodeOrDie(codec, obj), 0)
-	return err
 }
 
 func (t *Tester) setObjectsForList(objects []runtime.Object) []runtime.Object {
-	result := make([]runtime.Object, len(objects))
+	key := t.storage.KeyRootFunc(t.tester.TestContext())
-	key := etcdtest.AddPrefix(t.storage.KeyRootFunc(t.tester.TestContext()))
+	if err := storagetesting.CreateObjList(key, t.storage.Storage, objects); err != nil {
-
+		t.tester.Errorf("unexpected error: %v", err)
-	if len(objects) > 0 {
+		return nil
-		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),
-		}
 	}
-	return result
+	return objects
-}
-
-func (t *Tester) setResourceVersion(resourceVersion uint64) {
-	t.fakeClient.ChangeIndex = resourceVersion
-}
-
-func (t *Tester) injectWatchError(err error) {
-	t.fakeClient.WatchInjectError <- err
 }
 
 func (t *Tester) emitObject(obj runtime.Object, action string) error {
-	codec, err := getCodec(obj)
+	ctx := t.tester.TestContext()
-	if err != nil {
+	var err error
-		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
-}
 
-func isNotFoundEtcdError(err error) bool {
+	switch action {
-	etcdError, ok := err.(*etcd.EtcdError)
+	case etcdstorage.EtcdCreate:
-	if !ok {
+		err = t.setObject(ctx, obj)
-		return false
+	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
 }

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) {
+func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
 	test.TestDelete(validNewResourceQuota())
 }
 
 func TestGet(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewResourceQuota())
 }
 
 func TestList(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewResourceQuota())
 }
 
 func TestWatch(t *testing.T) {
-	storage, _, fakeClient := newStorage(t)
+	storage, _, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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",
+			Name:      "foo",
-			Namespace:       api.NamespaceDefault,
+			Namespace: api.NamespaceDefault,
-			ResourceVersion: "1",
 		},
 		Status: api.ResourceQuotaStatus{
 			Used: api.ResourceList{
@@ -181,17 +176,14 @@ func TestUpdateStatus(t *testing.T) {
 		},
 	}
 
-	expected := *resourcequotaStart
+	_, _, err = status.Update(ctx, resourcequotaIn)
-	expected.ResourceVersion = "2"
-	expected.Labels = resourcequotaIn.Labels
-	expected.Status = resourcequotaIn.Status
-
-	_, _, err := status.Update(ctx, resourcequotaIn)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
-	rqOut, err := storage.Get(ctx, "foo")
+	obj, err := storage.Get(ctx, "foo")
-	if !api.Semantic.DeepEqual(&expected, rqOut) {
+	rqOut := obj.(*api.ResourceQuota)
-		t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, rqOut))
+	// 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))
 	}
 }

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewSecret("foo"))
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewSecret("foo"))
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewSecret("foo"))
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewSecret("foo"),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*Etcd, *etcdtesting.EtcdTestServer, allocator.Interface) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	storage, server, _ := newStorage(t)
-	fakeClient.ExpectNotFoundGet(key())
+	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)
+	storage, server, backing := newStorage(t)
-	if _, err := fakeClient.Set(key(), runtime.EncodeOrDie(testapi.Default.Codec(), validNewRangeAllocation()), 0); err != nil {
+	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)
 	}

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
 	test.TestDelete(validService())
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
 	test.TestGet(validService())
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
 	test.TestList(validService())
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validService(),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*etcdtesting.EtcdTestServer, ipallocator.Interface, allocator.Interface, storage.Interface) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	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)
+	server, storage, _, _ := newStorage(t)
-	fakeClient.ExpectNotFoundGet(key())
+	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)
+	server, storage, backing, si := newStorage(t)
-	if _, err := fakeClient.Set(key(), runtime.EncodeOrDie(testapi.Default.Codec(), validNewRangeAllocation()), 0); err != nil {
+	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)
 }

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "")
-	return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
 	test.TestDelete(validNewServiceAccount("foo"))
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewServiceAccount("foo"))
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewServiceAccount("foo"))
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewServiceAccount("foo"),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
-	return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewThirdPartyResource("foo"))
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewThirdPartyResource("foo"))
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewThirdPartyResource("foo"))
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewThirdPartyResource("foo"),
 		// matching labels

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) {
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
-	etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
+	etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
-	return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), fakeClient
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	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)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestDelete(validNewThirdPartyResourceData("foo"))
 }
 
 func TestGet(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestGet(validNewThirdPartyResourceData("foo"))
 }
 
 func TestList(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestList(validNewThirdPartyResourceData("foo"))
 }
 
 func TestWatch(t *testing.T) {
-	storage, fakeClient := newStorage(t)
+	storage, server := newStorage(t)
-	test := registrytest.New(t, fakeClient, storage.Etcd)
+	defer server.Terminate(t)
+	test := registrytest.New(t, storage.Etcd)
 	test.TestWatch(
 		validNewThirdPartyResourceData("foo"),
 		// matching labels

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 {
+func CreateObj(helper storage.Interface, name string, obj, out runtime.Object, ttl uint64) error {
-	err := helper.Set(context.TODO(), name, obj, out, ttl)
+	return helper.Set(context.TODO(), name, obj, out, ttl)
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-	return err
 }
 
-// CreateList will properly create a list using the storage interface
+//CreateObjList will create a list from the array of objects
-func CreateList(t *testing.T, prefix string, helper storage.Interface, list runtime.Object) error {
+func CreateObjList(prefix string, helper storage.Interface, items []runtime.Object) error {
-	items, err := runtime.ExtractList(list)
-	if err != nil {
-		return err
-	}
 	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)
 }