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

Removal of fakeClient and shift to storage.Interface for 

all registry tests.
pull/6/head
Timothy St. Clair 2015-11-03 13:43:27 -06:00
parent 3b014c71dd
commit 02851dd1b7
28 changed files with 709 additions and 795 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
pkg/api/rest/resttest/resttest.go
View File

@ -32,36 +32,25 @@ import (
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
)
type Tester struct {
*testing.T
storage rest.Storage
storageError injectErrorFunc
clusterScope bool
createOnUpdate bool
generatesName bool
returnDeletedObject bool
}
type injectErrorFunc func(err error)
func New(t *testing.T, storage rest.Storage, storageError injectErrorFunc) *Tester {
func New(t *testing.T, storage rest.Storage) *Tester {
return &Tester{
T: t,
storage: storage,
storageError: storageError,
}
}
func (t *Tester) withStorageError(err error, fn func()) {
t.storageError(err)
defer t.storageError(nil)
fn()
}
func (t *Tester) ClusterScope() *Tester {
t.clusterScope = true
return t
@ -142,7 +131,6 @@ func (t *Tester) TestCreate(valid runtime.Object, setFn SetFunc, getFn GetFunc,
t.testCreateHasMetadata(copyOrDie(valid))
if !t.generatesName {
t.testCreateGeneratesName(copyOrDie(valid))
t.testCreateGeneratesNameReturnsServerTimeout(copyOrDie(valid))
}
t.testCreateEquals(copyOrDie(valid), getFn)
t.testCreateAlreadyExisting(copyOrDie(valid), setFn)
@ -158,9 +146,9 @@ func (t *Tester) TestCreate(valid runtime.Object, setFn SetFunc, getFn GetFunc,
}
// Test updating an object.
func (t *Tester) TestUpdate(valid runtime.Object, setFn SetFunc, setRVFn SetRVFunc, getFn GetFunc, updateFn UpdateFunc, invalidUpdateFn ...UpdateFunc) {
func (t *Tester) TestUpdate(valid runtime.Object, setFn SetFunc, getFn GetFunc, updateFn UpdateFunc, invalidUpdateFn ...UpdateFunc) {
t.testUpdateEquals(copyOrDie(valid), setFn, getFn, updateFn)
t.testUpdateFailsOnVersionTooOld(copyOrDie(valid), setFn, setRVFn)
t.testUpdateFailsOnVersionTooOld(copyOrDie(valid), setFn)
t.testUpdateOnNotFound(copyOrDie(valid))
if !t.clusterScope {
t.testUpdateRejectsMismatchedNamespace(copyOrDie(valid), setFn)
@ -194,20 +182,18 @@ func (t *Tester) TestGet(valid runtime.Object) {
}
// Test listing objects.
func (t *Tester) TestList(valid runtime.Object, assignFn AssignFunc, setRVFn SetRVFunc) {
t.testListError()
func (t *Tester) TestList(valid runtime.Object, assignFn AssignFunc) {
t.testListNotFound(assignFn)
t.testListFound(copyOrDie(valid), assignFn)
t.testListNotFound(assignFn, setRVFn)
t.testListMatchLabels(copyOrDie(valid), assignFn)
}
// Test watching objects.
func (t *Tester) TestWatch(
valid runtime.Object, initWatchFn InitWatchFunc, injectErrFn InjectErrFunc, emitFn EmitFunc,
valid runtime.Object, emitFn EmitFunc,
labelsPass, labelsFail []labels.Set, fieldsPass, fieldsFail []fields.Set, actions []string) {
t.testWatch(initWatchFn, injectErrFn)
t.testWatchLabels(copyOrDie(valid), initWatchFn, emitFn, labelsPass, labelsFail, actions)
t.testWatchFields(copyOrDie(valid), initWatchFn, emitFn, fieldsPass, fieldsFail, actions)
t.testWatchLabels(copyOrDie(valid), emitFn, labelsPass, labelsFail, actions)
t.testWatchFields(copyOrDie(valid), emitFn, fieldsPass, fieldsFail, actions)
}
// =============================================================================
@ -285,18 +271,6 @@ func (t *Tester) testCreateGeneratesName(valid runtime.Object) {
}
}
func (t *Tester) testCreateGeneratesNameReturnsServerTimeout(valid runtime.Object) {
objectMeta := t.getObjectMetaOrFail(valid)
objectMeta.Name = ""
objectMeta.GenerateName = "test-"
t.withStorageError(errors.NewAlreadyExists("kind", "thing"), func() {
_, err := t.storage.(rest.Creater).Create(t.TestContext(), valid)
if err == nil || !errors.IsServerTimeout(err) {
t.Fatalf("Unexpected error: %v", err)
}
})
}
func (t *Tester) testCreateHasMetadata(valid runtime.Object) {
objectMeta := t.getObjectMetaOrFail(valid)
objectMeta.Name = ""
@ -452,20 +426,19 @@ func (t *Tester) testUpdateEquals(obj runtime.Object, setFn SetFunc, getFn GetFu
}
}
func (t *Tester) testUpdateFailsOnVersionTooOld(obj runtime.Object, setFn SetFunc, setRVFn SetRVFunc) {
func (t *Tester) testUpdateFailsOnVersionTooOld(obj runtime.Object, setFn SetFunc) {
ctx := t.TestContext()
foo := copyOrDie(obj)
t.setObjectMeta(foo, "foo3")
setRVFn(10)
if err := setFn(ctx, foo); err != nil {
t.Errorf("unexpected error: %v", err)
}
older := copyOrDie(foo)
olderMeta := t.getObjectMetaOrFail(older)
olderMeta.ResourceVersion = "8"
olderMeta.ResourceVersion = "1"
_, _, err := t.storage.(rest.Updater).Update(t.TestContext(), older)
if err == nil {
@ -572,12 +545,11 @@ func (t *Tester) testDeleteNoGraceful(obj runtime.Object, setFn SetFunc, getFn G
func (t *Tester) testDeleteNonExist(obj runtime.Object) {
objectMeta := t.getObjectMetaOrFail(obj)
t.withStorageError(tools.EtcdErrorNotFound, func() {
_, err := t.storage.(rest.GracefulDeleter).Delete(t.TestContext(), objectMeta.Name, nil)
if err == nil || !errors.IsNotFound(err) {
t.Errorf("unexpected error: %v", err)
}
})
}
// =============================================================================
@ -848,18 +820,6 @@ func listToItems(listObj runtime.Object) ([]runtime.Object, error) {
return result, nil
}
func (t *Tester) testListError() {
ctx := t.TestContext()
storageError := fmt.Errorf("test error")
t.withStorageError(storageError, func() {
_, err := t.storage.(rest.Lister).List(ctx, nil)
if err != storageError {
t.Errorf("unexpected error: %v", err)
}
})
}
func (t *Tester) testListFound(obj runtime.Object, assignFn AssignFunc) {
ctx := t.TestContext()
@ -890,16 +850,18 @@ func (t *Tester) testListMatchLabels(obj runtime.Object, assignFn AssignFunc) {
ctx := t.TestContext()
testLabels := map[string]string{"key": "value"}
foo1 := copyOrDie(obj)
t.setObjectMeta(foo1, "foo1")
foo2 := copyOrDie(obj)
foo2Meta := t.getObjectMetaOrFail(foo2)
foo2Meta.Name = "foo2"
foo2Meta.Namespace = api.NamespaceValue(ctx)
foo2Meta.Labels = testLabels
foo3 := copyOrDie(obj)
t.setObjectMeta(foo3, "foo3")
foo4 := copyOrDie(obj)
foo4Meta := t.getObjectMetaOrFail(foo4)
foo4Meta.Name = "foo4"
foo4Meta.Namespace = api.NamespaceValue(ctx)
foo4Meta.Labels = testLabels
existing := assignFn([]runtime.Object{foo1, foo2})
filtered := []runtime.Object{existing[1]}
objs := ([]runtime.Object{foo3, foo4})
assignFn(objs)
filtered := []runtime.Object{objs[1]}
selector := labels.SelectorFromSet(labels.Set(testLabels))
options := &api.ListOptions{LabelSelector: selector}
@ -919,10 +881,8 @@ func (t *Tester) testListMatchLabels(obj runtime.Object, assignFn AssignFunc) {
}
}
func (t *Tester) testListNotFound(assignFn AssignFunc, setRVFn SetRVFunc) {
func (t *Tester) testListNotFound(assignFn AssignFunc) {
ctx := t.TestContext()
setRVFn(uint64(123))
_ = assignFn([]runtime.Object{})
listObj, err := t.storage.(rest.Lister).List(ctx, nil)
@ -934,45 +894,14 @@ func (t *Tester) testListNotFound(assignFn AssignFunc, setRVFn SetRVFunc) {
t.Errorf("unexpected error: %v", err)
}
if len(items) != 0 {
t.Errorf("unexpected items: %v", items)
}
meta, err := api.ListMetaFor(listObj)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if meta.ResourceVersion != "123" {
t.Errorf("unexpected resource version: %d", meta.ResourceVersion)
t.Errorf("unexpected items: %#v", items)
}
}
// =============================================================================
// Watching tests.
func (t *Tester) testWatch(initWatchFn InitWatchFunc, injectErrFn InjectErrFunc) {
ctx := t.TestContext()
watcher, err := t.storage.(rest.Watcher).Watch(ctx, &api.ListOptions{ResourceVersion: "1"})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
initWatchFn()
select {
case _, ok := <-watcher.ResultChan():
if !ok {
t.Errorf("watch channel should be open")
}
default:
}
injectErrFn(nil)
if _, ok := <-watcher.ResultChan(); ok {
t.Errorf("watch channel should be closed")
}
watcher.Stop()
}
func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc, emitFn EmitFunc, fieldsPass, fieldsFail []fields.Set, actions []string) {
func (t *Tester) testWatchFields(obj runtime.Object, emitFn EmitFunc, fieldsPass, fieldsFail []fields.Set, actions []string) {
ctx := t.TestContext()
for _, field := range fieldsPass {
@ -980,9 +909,9 @@ func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc,
options := &api.ListOptions{FieldSelector: field.AsSelector(), ResourceVersion: "1"}
watcher, err := t.storage.(rest.Watcher).Watch(ctx, options)
if err != nil {
t.Errorf("unexpected error: %v", err)
t.Errorf("unexpected error: %v, %v", err, action)
}
initWatchFn()
if err := emitFn(obj, action); err != nil {
t.Errorf("unexpected error: %v", err)
}
@ -1006,7 +935,6 @@ func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc,
if err != nil {
t.Errorf("unexpected error: %v", err)
}
initWatchFn()
if err := emitFn(obj, action); err != nil {
t.Errorf("unexpected error: %v", err)
}
@ -1022,7 +950,7 @@ func (t *Tester) testWatchFields(obj runtime.Object, initWatchFn InitWatchFunc,
}
}
func (t *Tester) testWatchLabels(obj runtime.Object, initWatchFn InitWatchFunc, emitFn EmitFunc, labelsPass, labelsFail []labels.Set, actions []string) {
func (t *Tester) testWatchLabels(obj runtime.Object, emitFn EmitFunc, labelsPass, labelsFail []labels.Set, actions []string) {
ctx := t.TestContext()
for _, label := range labelsPass {
@ -1032,7 +960,6 @@ func (t *Tester) testWatchLabels(obj runtime.Object, initWatchFn InitWatchFunc,
if err != nil {
t.Errorf("unexpected error: %v", err)
}
initWatchFn()
if err := emitFn(obj, action); err != nil {
t.Errorf("unexpected error: %v", err)
}
@ -1056,7 +983,6 @@ func (t *Tester) testWatchLabels(obj runtime.Object, initWatchFn InitWatchFunc,
if err != nil {
t.Errorf("unexpected error: %v", err)
}
initWatchFn()
if err := emitFn(obj, action); err != nil {
t.Errorf("unexpected error: %v", err)
}

41
pkg/registry/controller/etcd/etcd_test.go
View File

@ -25,13 +25,13 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
controllerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return controllerStorage, statusStorage, fakeClient
return controllerStorage, statusStorage, server
}
// createController is a helper function that returns a controller with the updated resource version.
@ -76,8 +76,9 @@ func validNewController() *api.ReplicationController {
var validController = validNewController()
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
controller := validNewController()
controller.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -95,8 +96,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewController(),
@ -126,13 +128,15 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewController())
}
func TestGenerationNumber(t *testing.T) {
storage, _, _ := newStorage(t)
storage, _, server := newStorage(t)
defer server.Terminate(t)
modifiedSno := *validNewController()
modifiedSno.Generation = 100
modifiedSno.Status.ObservedGeneration = 10
@ -181,20 +185,23 @@ func TestGenerationNumber(t *testing.T) {
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewController())
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewController())
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validController,
// matching labels

38
pkg/registry/daemonset/etcd/etcd_test.go
View File

@ -26,13 +26,13 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
daemonSetStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return daemonSetStorage, statusStorage, fakeClient
return daemonSetStorage, statusStorage, server
}
func newValidDaemonSet() *extensions.DaemonSet {
@ -66,8 +66,9 @@ func newValidDaemonSet() *extensions.DaemonSet {
var validDaemonSet = newValidDaemonSet()
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
ds := newValidDaemonSet()
ds.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -84,8 +85,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
newValidDaemonSet(),
@ -120,26 +122,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(newValidDaemonSet())
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(newValidDaemonSet())
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(newValidDaemonSet())
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validDaemonSet,
// matching labels

67
pkg/registry/deployment/etcd/etcd_test.go
View File

@ -20,7 +20,6 @@ import (
"testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
@ -28,14 +27,14 @@ import (
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"k8s.io/kubernetes/pkg/util"
)
func newStorage(t *testing.T) (*DeploymentStorage, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
func newStorage(t *testing.T) (*DeploymentStorage, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
deploymentStorage := NewStorage(etcdStorage, generic.UndecoratedStorage)
return &deploymentStorage, fakeClient
return &deploymentStorage, server
}
var namespace = "foo-namespace"
@ -92,8 +91,9 @@ func validNewScale() *extensions.Scale {
var validScale = *validNewScale()
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
deployment := validNewDeployment()
deployment.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -110,8 +110,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test.TestUpdate(
// valid
validNewDeployment(),
@ -146,26 +147,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test.TestDelete(validNewDeployment())
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test.TestGet(validNewDeployment())
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test.TestList(validNewDeployment())
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Deployment.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test.TestWatch(
validNewDeployment(),
// matching labels
@ -188,11 +193,12 @@ func TestWatch(t *testing.T) {
}
func TestScaleGet(t *testing.T) {
storage, fakeClient := newStorage(t)
storage, server := newStorage(t)
defer server.Terminate(t)
ctx := api.WithNamespace(api.NewContext(), namespace)
key := etcdtest.AddPrefix("/deployments/" + namespace + "/" + name)
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Extensions.Codec(), &validDeployment), 0); err != nil {
if err := storage.Deployment.Storage.Set(ctx, key, &validDeployment, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -202,17 +208,17 @@ func TestScaleGet(t *testing.T) {
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if e, a := expect, scale; !api.Semantic.DeepEqual(e, a) {
if e, a := expect, scale; !api.Semantic.DeepDerivative(e, a) {
t.Errorf("unexpected scale: %s", util.ObjectDiff(e, a))
}
}
func TestScaleUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
storage, server := newStorage(t)
defer server.Terminate(t)
ctx := api.WithNamespace(api.NewContext(), namespace)
key := etcdtest.AddPrefix("/deployments/" + namespace + "/" + name)
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Extensions.Codec(), &validDeployment), 0); err != nil {
if err := storage.Deployment.Storage.Set(ctx, key, &validDeployment, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
replicas := 12
@ -226,24 +232,24 @@ func TestScaleUpdate(t *testing.T) {
if _, _, err := storage.Scale.Update(ctx, &update); err != nil {
t.Fatalf("unexpected error: %v", err)
}
response, err := fakeClient.Get(key, false, false)
obj, err := storage.Scale.Get(ctx, name)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
var deployment extensions.Deployment
testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &deployment)
deployment := obj.(*extensions.Scale)
if deployment.Spec.Replicas != replicas {
t.Errorf("wrong replicas count expected: %d got: %d", replicas, deployment.Spec.Replicas)
}
}
func TestStatusUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
storage, server := newStorage(t)
defer server.Terminate(t)
ctx := api.WithNamespace(api.NewContext(), namespace)
key := etcdtest.AddPrefix("/deployments/" + namespace + "/" + name)
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Extensions.Codec(), &validDeployment), 0); err != nil {
if err := storage.Deployment.Storage.Set(ctx, key, &validDeployment, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
update := extensions.Deployment{
@ -259,13 +265,12 @@ func TestStatusUpdate(t *testing.T) {
if _, _, err := storage.Status.Update(ctx, &update); err != nil {
t.Fatalf("unexpected error: %v", err)
}
response, err := fakeClient.Get(key, false, false)
obj, err := storage.Deployment.Get(ctx, name)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
var deployment extensions.Deployment
testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &deployment)
deployment := obj.(*extensions.Deployment)
if deployment.Spec.Replicas != 7 {
t.Errorf("we expected .spec.replicas to not be updated but it was updated to %v", deployment.Spec.Replicas)
}

38
pkg/registry/endpoint/etcd/etcd_test.go
View File

@ -25,12 +25,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), server
}
func validNewEndpoints() *api.Endpoints {
@ -57,8 +57,9 @@ func validChangedEndpoints() *api.Endpoints {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
endpoints := validNewEndpoints()
endpoints.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -72,8 +73,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validNewEndpoints(),
@ -90,26 +92,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewEndpoints())
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewEndpoints())
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewEndpoints())
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewEndpoints(),
// matching labels

24
pkg/registry/event/etcd/etcd_test.go
View File

@ -23,15 +23,14 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
var testTTL uint64 = 60
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
fakeClient.HideExpires = true
return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), server
}
func validNewEvent(namespace string) *api.Event {
@ -49,8 +48,9 @@ func validNewEvent(namespace string) *api.Event {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
event := validNewEvent(test.TestNamespace())
event.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -62,8 +62,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validNewEvent(test.TestNamespace()),
@ -83,7 +84,8 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewEvent(test.TestNamespace()))
}

41
pkg/registry/experimental/controller/etcd/etcd_test.go
View File

@ -20,19 +20,17 @@ import (
"testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*ScaleREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewStorage(etcdStorage, generic.UndecoratedStorage).Scale, fakeClient
func newStorage(t *testing.T) (*ScaleREST, *etcdtesting.EtcdTestServer, storage.Interface) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewStorage(etcdStorage, generic.UndecoratedStorage).Scale, server, etcdStorage
}
var validPodTemplate = api.PodTemplate{
@ -63,7 +61,7 @@ var validControllerSpec = api.ReplicationControllerSpec{
}
var validController = api.ReplicationController{
ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test", ResourceVersion: "1"},
ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test"},
Spec: validControllerSpec,
}
@ -79,31 +77,31 @@ var validScale = extensions.Scale{
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
storage, server, si := newStorage(t)
defer server.Terminate(t)
ctx := api.WithNamespace(api.NewContext(), "test")
key := etcdtest.AddPrefix("/controllers/test/foo")
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &validController), 0); err != nil {
if err := si.Set(ctx, key, &validController, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
expect := &validScale
obj, err := storage.Get(ctx, "foo")
scale := obj.(*extensions.Scale)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if e, a := expect, scale; !api.Semantic.DeepEqual(e, a) {
t.Errorf("unexpected scale: %s", util.ObjectDiff(e, a))
scale := obj.(*extensions.Scale)
if scale.Spec.Replicas != validReplicas {
t.Errorf("wrong replicas count expected: %d got: %d", validReplicas, scale.Spec.Replicas)
}
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
storage, server, si := newStorage(t)
defer server.Terminate(t)
ctx := api.WithNamespace(api.NewContext(), "test")
key := etcdtest.AddPrefix("/controllers/test/foo")
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &validController), 0); err != nil {
if err := si.Set(ctx, key, &validController, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
replicas := 12
@ -117,14 +115,13 @@ func TestUpdate(t *testing.T) {
if _, _, err := storage.Update(ctx, &update); err != nil {
t.Fatalf("unexpected error: %v", err)
}
response, err := fakeClient.Get(key, false, false)
obj, err := storage.Get(ctx, "foo")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
var controller api.ReplicationController
testapi.Extensions.Codec().DecodeInto([]byte(response.Node.Value), &controller)
if controller.Spec.Replicas != replicas {
t.Errorf("wrong replicas count expected: %d got: %d", replicas, controller.Spec.Replicas)
updated := obj.(*extensions.Scale)
if updated.Spec.Replicas != replicas {
t.Errorf("wrong replicas count expected: %d got: %d", replicas, updated.Spec.Replicas)
}
}

2
pkg/registry/generic/etcd/etcd_test.go
View File

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

38
pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go
View File

@ -28,13 +28,13 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
horizontalPodAutoscalerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return horizontalPodAutoscalerStorage, statusStorage, fakeClient
return horizontalPodAutoscalerStorage, statusStorage, server
}
func validNewHorizontalPodAutoscaler(name string) *extensions.HorizontalPodAutoscaler {
@ -56,8 +56,9 @@ func validNewHorizontalPodAutoscaler(name string) *extensions.HorizontalPodAutos
}
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
autoscaler := validNewHorizontalPodAutoscaler("foo")
autoscaler.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -69,8 +70,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewHorizontalPodAutoscaler("foo"),
@ -84,26 +86,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewHorizontalPodAutoscaler("foo"))
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewHorizontalPodAutoscaler("foo"))
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewHorizontalPodAutoscaler("foo"))
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewHorizontalPodAutoscaler("foo"),
// matching labels

38
pkg/registry/ingress/etcd/etcd_test.go
View File

@ -26,14 +26,14 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"k8s.io/kubernetes/pkg/util/intstr"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
ingressStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return ingressStorage, statusStorage, fakeClient
return ingressStorage, statusStorage, server
}
var (
@ -108,8 +108,9 @@ func validIngress() *extensions.Ingress {
}
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
ingress := validIngress()
noDefaultBackendAndRules := validIngress()
noDefaultBackendAndRules.Spec.Backend = &extensions.IngressBackend{}
@ -126,8 +127,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validIngress(),
@ -162,26 +164,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validIngress())
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validIngress())
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validIngress())
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validIngress(),
// matching labels

38
pkg/registry/job/etcd/etcd_test.go
View File

@ -28,13 +28,13 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
jobStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return jobStorage, statusStorage, fakeClient
return jobStorage, statusStorage, server
}
func validNewJob() *extensions.Job {
@ -72,8 +72,9 @@ func validNewJob() *extensions.Job {
}
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
validJob := validNewJob()
validJob.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -91,8 +92,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
two := 2
test.TestUpdate(
// valid
@ -118,26 +120,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewJob())
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewJob())
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewJob())
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewJob(),
// matching labels

38
pkg/registry/limitrange/etcd/etcd_test.go
View File

@ -26,12 +26,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), server
}
func validNewLimitRange() *api.LimitRange {
@ -59,8 +59,9 @@ func validNewLimitRange() *api.LimitRange {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).GeneratesName()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).GeneratesName()
validLimitRange := validNewLimitRange()
validLimitRange.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -74,8 +75,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validNewLimitRange(),
@ -101,26 +103,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewLimitRange())
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewLimitRange())
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewLimitRange())
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewLimitRange(),
// matching labels

48
pkg/registry/namespace/etcd/etcd_test.go
View File

@ -20,21 +20,19 @@ import (
"testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
namespaceStorage, _, _ := NewREST(etcdStorage, generic.UndecoratedStorage)
return namespaceStorage, fakeClient
return namespaceStorage, server
}
func validNewNamespace() *api.Namespace {
@ -46,8 +44,9 @@ func validNewNamespace() *api.Namespace {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
namespace := validNewNamespace()
namespace.ObjectMeta = api.ObjectMeta{GenerateName: "foo"}
test.TestCreate(
@ -61,7 +60,8 @@ func TestCreate(t *testing.T) {
}
func TestCreateSetsFields(t *testing.T) {
storage, _ := newStorage(t)
storage, server := newStorage(t)
defer server.Terminate(t)
namespace := validNewNamespace()
ctx := api.NewContext()
_, err := storage.Create(ctx, namespace)
@ -86,26 +86,30 @@ func TestCreateSetsFields(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope().ReturnDeletedObject()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject()
test.TestDelete(validNewNamespace())
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestGet(validNewNamespace())
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestList(validNewNamespace())
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestWatch(
validNewNamespace(),
// matching labels
@ -127,7 +131,8 @@ func TestWatch(t *testing.T) {
}
func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
storage, fakeClient := newStorage(t)
storage, server := newStorage(t)
defer server.Terminate(t)
key := etcdtest.AddPrefix("namespaces/foo")
ctx := api.NewContext()
now := unversioned.Now()
@ -141,7 +146,7 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
},
Status: api.NamespaceStatus{Phase: api.NamespaceActive},
}
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), namespace), 0); err != nil {
if err := storage.Storage.Set(ctx, key, namespace, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
if _, err := storage.Delete(ctx, "foo", nil); err == nil {
@ -150,7 +155,8 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
}
func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) {
storage, fakeClient := newStorage(t)
storage, server := newStorage(t)
defer server.Terminate(t)
key := etcdtest.AddPrefix("namespaces/foo")
ctx := api.NewContext()
now := unversioned.Now()
@ -164,7 +170,7 @@ func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) {
},
Status: api.NamespaceStatus{Phase: api.NamespaceActive},
}
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), namespace), 0); err != nil {
if err := storage.Storage.Set(ctx, key, namespace, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
if _, err := storage.Delete(ctx, "foo", nil); err != nil {

38
pkg/registry/node/etcd/etcd_test.go
View File

@ -27,7 +27,7 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
type fakeConnectionInfoGetter struct {
@ -37,10 +37,10 @@ func (fakeConnectionInfoGetter) GetConnectionInfo(host string) (string, uint, ht
return "http", 12345, nil, nil
}
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
storage, _ := NewREST(etcdStorage, generic.UndecoratedStorage, fakeConnectionInfoGetter{}, nil)
return storage, fakeClient
return storage, server
}
func validNewNode() *api.Node {
@ -64,8 +64,9 @@ func validNewNode() *api.Node {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
node := validNewNode()
node.ObjectMeta = api.ObjectMeta{GenerateName: "foo"}
test.TestCreate(
@ -79,8 +80,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestUpdate(
// valid
validNewNode(),
@ -94,26 +96,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestDelete(validNewNode())
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestGet(validNewNode())
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestList(validNewNode())
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestWatch(
validNewNode(),
// matching labels

66
pkg/registry/persistentvolume/etcd/etcd_test.go
View File

@ -21,21 +21,20 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"k8s.io/kubernetes/pkg/util"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
persistentVolumeStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return persistentVolumeStorage, statusStorage, fakeClient
return persistentVolumeStorage, statusStorage, server
}
func validNewPersistentVolume(name string) *api.PersistentVolume {
@ -64,13 +63,13 @@ func validNewPersistentVolume(name string) *api.PersistentVolume {
func validChangedPersistentVolume() *api.PersistentVolume {
pv := validNewPersistentVolume("foo")
pv.ResourceVersion = "1"
return pv
}
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
pv := validNewPersistentVolume("foo")
pv.ObjectMeta = api.ObjectMeta{GenerateName: "foo"}
test.TestCreate(
@ -84,8 +83,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestUpdate(
// valid
validNewPersistentVolume("foo"),
@ -101,26 +101,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope().ReturnDeletedObject()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject()
test.TestDelete(validNewPersistentVolume("foo"))
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestGet(validNewPersistentVolume("foo"))
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestList(validNewPersistentVolume("foo"))
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ClusterScope()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test.TestWatch(
validNewPersistentVolume("foo"),
// matching labels
@ -142,39 +146,37 @@ func TestWatch(t *testing.T) {
}
func TestUpdateStatus(t *testing.T) {
storage, statusStorage, fakeClient := newStorage(t)
fakeClient.TestIndex = true
storage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewContext()
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
pvStart := validNewPersistentVolume("foo")
fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), pvStart), 0)
err := storage.Storage.Set(ctx, key, pvStart, nil, 0)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
pvIn := &api.PersistentVolume{
ObjectMeta: api.ObjectMeta{
Name: "foo",
ResourceVersion: "1",
},
Status: api.PersistentVolumeStatus{
Phase: api.VolumeBound,
},
}
expected := *pvStart
expected.ResourceVersion = "2"
expected.Labels = pvIn.Labels
expected.Status = pvIn.Status
_, _, err := statusStorage.Update(ctx, pvIn)
_, _, err = statusStorage.Update(ctx, pvIn)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
pvOut, err := storage.Get(ctx, "foo")
obj, err := storage.Get(ctx, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if !api.Semantic.DeepEqual(&expected, pvOut) {
t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, pvOut))
pvOut := obj.(*api.PersistentVolume)
// only compare the relevant change b/c metadata will differ
if !api.Semantic.DeepEqual(pvIn.Status, pvOut.Status) {
t.Errorf("unexpected object: %s", util.ObjectDiff(pvIn.Status, pvOut.Status))
}
}

61
pkg/registry/persistentvolumeclaim/etcd/etcd_test.go
View File

@ -21,21 +21,20 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"k8s.io/kubernetes/pkg/util"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
persistentVolumeClaimStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return persistentVolumeClaimStorage, statusStorage, fakeClient
return persistentVolumeClaimStorage, statusStorage, server
}
func validNewPersistentVolumeClaim(name, ns string) *api.PersistentVolumeClaim {
@ -60,8 +59,9 @@ func validNewPersistentVolumeClaim(name, ns string) *api.PersistentVolumeClaim {
}
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
pv := validNewPersistentVolumeClaim("foo", api.NamespaceDefault)
pv.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -75,8 +75,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewPersistentVolumeClaim("foo", api.NamespaceDefault),
@ -94,26 +95,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test.TestDelete(validNewPersistentVolumeClaim("foo", api.NamespaceDefault))
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewPersistentVolumeClaim("foo", api.NamespaceDefault))
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewPersistentVolumeClaim("foo", api.NamespaceDefault))
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewPersistentVolumeClaim("foo", api.NamespaceDefault),
// matching labels
@ -135,20 +140,19 @@ func TestWatch(t *testing.T) {
}
func TestUpdateStatus(t *testing.T) {
storage, statusStorage, fakeClient := newStorage(t)
storage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
pvcStart := validNewPersistentVolumeClaim("foo", api.NamespaceDefault)
fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), pvcStart), 0)
err := storage.Storage.Set(ctx, key, pvcStart, nil, 0)
pvc := &api.PersistentVolumeClaim{
ObjectMeta: api.ObjectMeta{
Name: "foo",
Namespace: api.NamespaceDefault,
ResourceVersion: "1",
},
Spec: api.PersistentVolumeClaimSpec{
AccessModes: []api.PersistentVolumeAccessMode{api.ReadWriteOnce},
@ -163,20 +167,17 @@ func TestUpdateStatus(t *testing.T) {
},
}
expected := *pvcStart
expected.ResourceVersion = "2"
expected.Labels = pvc.Labels
expected.Status = pvc.Status
_, _, err := statusStorage.Update(ctx, pvc)
_, _, err = statusStorage.Update(ctx, pvc)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
pvcOut, err := storage.Get(ctx, "foo")
obj, err := storage.Get(ctx, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if !api.Semantic.DeepEqual(&expected, pvcOut) {
t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, pvcOut))
pvcOut := obj.(*api.PersistentVolumeClaim)
// only compare relevant changes b/c of difference in metadata
if !api.Semantic.DeepEqual(pvc.Status, pvcOut.Status) {
t.Errorf("unexpected object: %s", util.ObjectDiff(pvc.Status, pvcOut.Status))
}
}

196
pkg/registry/pod/etcd/etcd_test.go
View File

@ -17,7 +17,6 @@ limitations under the License.
package etcd
import (
"fmt"
"strings"
"testing"
@ -25,7 +24,6 @@ import (
"k8s.io/kubernetes/pkg/api/errors"
etcderrors "k8s.io/kubernetes/pkg/api/errors/etcd"
"k8s.io/kubernetes/pkg/api/rest"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
@ -33,14 +31,14 @@ import (
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/securitycontext"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"k8s.io/kubernetes/pkg/util"
)
func newStorage(t *testing.T) (*REST, *BindingREST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*REST, *BindingREST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
storage := NewStorage(etcdStorage, generic.UndecoratedStorage, nil, nil)
return storage.Pod, storage.Binding, storage.Status, fakeClient
return storage.Pod, storage.Binding, storage.Status, server
}
func validNewPod() *api.Pod {
@ -72,7 +70,6 @@ func validNewPod() *api.Pod {
func validChangedPod() *api.Pod {
pod := validNewPod()
pod.ResourceVersion = "1"
pod.Labels = map[string]string{
"foo": "bar",
}
@ -80,8 +77,9 @@ func validChangedPod() *api.Pod {
}
func TestCreate(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
pod := validNewPod()
pod.ObjectMeta = api.ObjectMeta{}
// Make an invalid pod with an an incorrect label.
@ -105,8 +103,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewPod(),
@ -120,8 +119,9 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test.TestDelete(validNewPod())
scheduledPod := validNewPod()
@ -129,22 +129,12 @@ func TestDelete(t *testing.T) {
test.TestDeleteGraceful(scheduledPod, 30)
}
func TestCreateRegistryError(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
fakeClient.Err = fmt.Errorf("test error")
pod := validNewPod()
_, err := storage.Create(api.NewDefaultContext(), pod)
if err != fakeClient.Err {
t.Fatalf("unexpected error: %v", err)
}
}
func TestCreateSetsFields(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
pod := validNewPod()
_, err := storage.Create(api.NewDefaultContext(), pod)
if err != fakeClient.Err {
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
ctx := api.NewDefaultContext()
@ -255,10 +245,10 @@ func TestResourceLocation(t *testing.T) {
ctx := api.NewDefaultContext()
for _, tc := range testCases {
storage, _, _, fakeClient := newStorage(t)
storage, _, _, server := newStorage(t)
key, _ := storage.KeyFunc(ctx, tc.pod.Name)
key = etcdtest.AddPrefix(key)
if _, err := fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &tc.pod), 0); err != nil {
if err := storage.Storage.Create(ctx, key, &tc.pod, nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -277,24 +267,28 @@ func TestResourceLocation(t *testing.T) {
if location.Host != tc.location {
t.Errorf("Expected %v, but got %v", tc.location, location.Host)
}
server.Terminate(t)
}
}
func TestGet(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewPod())
}
func TestList(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewPod())
}
func TestWatch(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewPod(),
// matching labels
@ -315,12 +309,11 @@ func TestWatch(t *testing.T) {
}
func TestEtcdCreate(t *testing.T) {
storage, bindingStorage, _, fakeClient := newStorage(t)
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.ExpectNotFoundGet(key)
_, err := storage.Create(ctx, validNewPod())
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -335,31 +328,21 @@ func TestEtcdCreate(t *testing.T) {
t.Fatalf("unexpected error: %v", err)
}
resp, err := fakeClient.Get(key, false, false)
_, err = storage.Get(ctx, "foo")
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
var pod api.Pod
err = testapi.Default.Codec().DecodeInto([]byte(resp.Node.Value), &pod)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if pod.Name != "foo" {
t.Errorf("Unexpected pod: %#v %s", pod, resp.Node.Value)
}
}
// Ensure that when scheduler creates a binding for a pod that has already been deleted
// by the API server, API server returns not-found error.
func TestEtcdCreateBindingNoPod(t *testing.T) {
storage, bindingStorage, _, fakeClient := newStorage(t)
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.ExpectNotFoundGet(key)
// Assume that a pod has undergone the following:
// - Create (apiserver)
// - Schedule (scheduler)
@ -385,8 +368,8 @@ func TestEtcdCreateBindingNoPod(t *testing.T) {
}
func TestEtcdCreateFailsWithoutNamespace(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
fakeClient.TestIndex = true
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
pod := validNewPod()
pod.Namespace = ""
_, err := storage.Create(api.NewContext(), pod)
@ -397,12 +380,11 @@ func TestEtcdCreateFailsWithoutNamespace(t *testing.T) {
}
func TestEtcdCreateWithContainersNotFound(t *testing.T) {
storage, bindingStorage, _, fakeClient := newStorage(t)
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.ExpectNotFoundGet(key)
_, err := storage.Create(ctx, validNewPod())
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -421,30 +403,21 @@ func TestEtcdCreateWithContainersNotFound(t *testing.T) {
t.Fatalf("unexpected error: %v", err)
}
resp, err := fakeClient.Get(key, false, false)
obj, err := storage.Get(ctx, "foo")
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
var pod api.Pod
err = testapi.Default.Codec().DecodeInto([]byte(resp.Node.Value), &pod)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
pod := obj.(*api.Pod)
if pod.Name != "foo" {
t.Errorf("Unexpected pod: %#v %s", pod, resp.Node.Value)
}
if !(pod.Annotations != nil && pod.Annotations["label1"] == "value1") {
t.Fatalf("Pod annotations don't match the expected: %v", pod.Annotations)
}
}
func TestEtcdCreateWithConflict(t *testing.T) {
storage, bindingStorage, _, fakeClient := newStorage(t)
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
fakeClient.ExpectNotFoundGet(key)
_, err := storage.Create(ctx, validNewPod())
if err != nil {
@ -472,12 +445,11 @@ func TestEtcdCreateWithConflict(t *testing.T) {
}
func TestEtcdCreateWithExistingContainers(t *testing.T) {
storage, bindingStorage, _, fakeClient := newStorage(t)
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.ExpectNotFoundGet(key)
_, err := storage.Create(ctx, validNewPod())
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -492,19 +464,10 @@ func TestEtcdCreateWithExistingContainers(t *testing.T) {
t.Fatalf("unexpected error: %v", err)
}
resp, err := fakeClient.Get(key, false, false)
_, err = storage.Get(ctx, "foo")
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
var pod api.Pod
err = testapi.Default.Codec().DecodeInto([]byte(resp.Node.Value), &pod)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if pod.Name != "foo" {
t.Errorf("Unexpected pod: %#v %s", pod, resp.Node.Value)
}
}
func TestEtcdCreateBinding(t *testing.T) {
@ -544,10 +507,9 @@ func TestEtcdCreateBinding(t *testing.T) {
},
}
for k, test := range testCases {
storage, bindingStorage, _, fakeClient := newStorage(t)
storage, bindingStorage, _, server := newStorage(t)
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.ExpectNotFoundGet(key)
if _, err := storage.Create(ctx, validNewPod()); err != nil {
t.Fatalf("%s: unexpected error: %v", k, err)
@ -563,42 +525,45 @@ func TestEtcdCreateBinding(t *testing.T) {
t.Errorf("%s: expected: %v, got: %v", k, pod.(*api.Pod).Spec.NodeName, test.binding.Target.Name)
}
}
server.Terminate(t)
}
}
func TestEtcdUpdateNotScheduled(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), validNewPod()), 1)
if _, err := storage.Create(ctx, validNewPod()); err != nil {
t.Fatalf("unexpected error: %v", err)
}
podIn := validChangedPod()
_, _, err := storage.Update(ctx, podIn)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
response, err := fakeClient.Get(key, false, false)
obj, err := storage.Get(ctx, validNewPod().ObjectMeta.Name)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
t.Errorf("unexpected error: %v", err)
}
podOut := &api.Pod{}
testapi.Default.Codec().DecodeInto([]byte(response.Node.Value), podOut)
if !api.Semantic.DeepEqual(podOut, podIn) {
podOut := obj.(*api.Pod)
// validChangedPod only changes the Labels, so were checking the update was valid
if !api.Semantic.DeepEqual(podIn.Labels, podOut.Labels) {
t.Errorf("objects differ: %v", util.ObjectDiff(podOut, podIn))
}
}
func TestEtcdUpdateScheduled(t *testing.T) {
storage, _, _, fakeClient := newStorage(t)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &api.Pod{
err := storage.Storage.Create(ctx, key, &api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "foo",
Namespace: api.NamespaceDefault,
@ -614,13 +579,15 @@ func TestEtcdUpdateScheduled(t *testing.T) {
},
SecurityContext: &api.PodSecurityContext{},
},
}), 1)
}, nil, 1)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
grace := int64(30)
podIn := api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "foo",
ResourceVersion: "1",
Labels: map[string]string{
"foo": "bar",
},
@ -641,26 +608,27 @@ func TestEtcdUpdateScheduled(t *testing.T) {
SecurityContext: &api.PodSecurityContext{},
},
}
_, _, err := storage.Update(ctx, &podIn)
_, _, err = storage.Update(ctx, &podIn)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
response, err := fakeClient.Get(key, false, false)
obj, err := storage.Get(ctx, "foo")
if err != nil {
t.Fatalf("Unexpected error: %v", err)
t.Errorf("Unexpected error: %v", err)
}
var podOut api.Pod
testapi.Default.Codec().DecodeInto([]byte(response.Node.Value), &podOut)
if !api.Semantic.DeepEqual(podOut, podIn) {
t.Errorf("expected: %#v, got: %#v", podOut, podIn)
podOut := obj.(*api.Pod)
// Check to verify the Spec and Label updates match from change above. Those are the fields changed.
if !api.Semantic.DeepEqual(podOut.Spec, podIn.Spec) || !api.Semantic.DeepEqual(podOut.Labels, podIn.Labels) {
t.Errorf("objects differ: %v", util.ObjectDiff(podOut, podIn))
}
}
func TestEtcdUpdateStatus(t *testing.T) {
storage, _, statusStorage, fakeClient := newStorage(t)
storage, _, statusStorage, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
fakeClient.TestIndex = true
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
@ -680,12 +648,14 @@ func TestEtcdUpdateStatus(t *testing.T) {
SecurityContext: &api.PodSecurityContext{},
},
}
fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), &podStart), 0)
err := storage.Storage.Create(ctx, key, &podStart, nil, 0)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
podIn := api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "foo",
ResourceVersion: "1",
Labels: map[string]string{
"foo": "bar",
},
@ -719,15 +689,19 @@ func TestEtcdUpdateStatus(t *testing.T) {
expected.Labels = podIn.Labels
expected.Status = podIn.Status
_, _, err := statusStorage.Update(ctx, &podIn)
_, _, err = statusStorage.Update(ctx, &podIn)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
podOut, err := storage.Get(ctx, "foo")
obj, err := storage.Get(ctx, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if !api.Semantic.DeepEqual(&expected, podOut) {
t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, podOut))
podOut := obj.(*api.Pod)
// Check to verify the Spec, Label, and Status updates match from change above. Those are the fields changed.
if !api.Semantic.DeepEqual(podOut.Spec, podIn.Spec) ||
!api.Semantic.DeepEqual(podOut.Labels, podIn.Labels) ||
!api.Semantic.DeepEqual(podOut.Status, podIn.Status) {
t.Errorf("objects differ: %v", util.ObjectDiff(podOut, podIn))
}
}

38
pkg/registry/podtemplate/etcd/etcd_test.go
View File

@ -25,12 +25,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), server
}
func validNewPodTemplate(name string) *api.PodTemplate {
@ -61,8 +61,9 @@ func validNewPodTemplate(name string) *api.PodTemplate {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
pod := validNewPodTemplate("foo")
pod.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -76,8 +77,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
//valid
validNewPodTemplate("foo"),
@ -91,26 +93,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test.TestDelete(validNewPodTemplate("foo"))
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewPodTemplate("foo"))
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewPodTemplate("foo"))
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewPodTemplate("foo"),
// matching labels

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

@ -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,27 +31,25 @@ import (
"k8s.io/kubernetes/pkg/storage"
etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
storagetesting "k8s.io/kubernetes/pkg/storage/testing"
)
func NewEtcdStorage(t *testing.T, group string) (storage.Interface, *tools.FakeEtcdClient) {
fakeClient := tools.NewFakeEtcdClient(t)
fakeClient.TestIndex = true
etcdStorage := etcdstorage.NewEtcdStorage(fakeClient, testapi.Groups[group].Codec(), etcdtest.PathPrefix())
return etcdStorage, fakeClient
func NewEtcdStorage(t *testing.T, group string) (storage.Interface, *etcdtesting.EtcdTestServer) {
server := etcdtesting.NewEtcdTestClientServer(t)
storage := etcdstorage.NewEtcdStorage(server.Client, testapi.Groups[group].Codec(), etcdtest.PathPrefix())
return storage, server
}
type Tester struct {
tester *resttest.Tester
fakeClient *tools.FakeEtcdClient
storage *etcdgeneric.Etcd
}
type UpdateFunc func(runtime.Object) runtime.Object
func New(t *testing.T, fakeClient *tools.FakeEtcdClient, storage *etcdgeneric.Etcd) *Tester {
func New(t *testing.T, storage *etcdgeneric.Etcd) *Tester {
return &Tester{
tester: resttest.New(t, storage, fakeClient.SetError),
fakeClient: fakeClient,
tester: resttest.New(t, storage),
storage: storage,
}
}
@ -98,7 +95,6 @@ func (t *Tester) TestUpdate(valid runtime.Object, validUpdateFunc UpdateFunc, in
t.tester.TestUpdate(
valid,
t.setObject,
t.setResourceVersion,
t.getObject,
resttest.UpdateFunc(validUpdateFunc),
invalidFuncs...,
@ -110,7 +106,7 @@ func (t *Tester) TestDelete(valid runtime.Object) {
valid,
t.setObject,
t.getObject,
isNotFoundEtcdError,
errors.IsNotFound,
)
}
@ -131,21 +127,19 @@ func (t *Tester) TestList(valid runtime.Object) {
t.tester.TestList(
valid,
t.setObjectsForList,
t.setResourceVersion,
)
}
func (t *Tester) TestWatch(valid runtime.Object, labelsPass, labelsFail []labels.Set, fieldsPass, fieldsFail []fields.Set) {
t.tester.TestWatch(
valid,
t.fakeClient.WaitForWatchCompletion,
t.injectWatchError,
t.emitObject,
labelsPass,
labelsFail,
fieldsPass,
fieldsFail,
[]string{etcdstorage.EtcdCreate, etcdstorage.EtcdSet, etcdstorage.EtcdCAS, etcdstorage.EtcdDelete},
// TODO: This should be filtered, the registry should not be aware of this level of detail
[]string{etcdstorage.EtcdCreate, etcdstorage.EtcdDelete},
)
}
@ -178,24 +172,11 @@ func (t *Tester) getObject(ctx api.Context, obj runtime.Object) (runtime.Object,
if err != nil {
return nil, err
}
key, err := t.storage.KeyFunc(ctx, meta.Name)
if err != nil {
return nil, err
}
key = etcdtest.AddPrefix(key)
resp, err := t.fakeClient.Get(key, false, false)
if err != nil {
return nil, err
}
result := t.storage.NewFunc()
codec, err := getCodec(obj)
result, err := t.storage.Get(ctx, meta.Name)
if err != nil {
return nil, err
}
if err := codec.DecodeInto([]byte(resp.Node.Value), result); err != nil {
return nil, err
}
return result, nil
}
@ -208,82 +189,34 @@ func (t *Tester) setObject(ctx api.Context, obj runtime.Object) error {
if err != nil {
return err
}
key = etcdtest.AddPrefix(key)
codec, err := getCodec(obj)
if err != nil {
return err
}
_, err = t.fakeClient.Set(key, runtime.EncodeOrDie(codec, obj), 0)
return err
return t.storage.Storage.Set(ctx, key, obj, nil, 0)
}
func (t *Tester) setObjectsForList(objects []runtime.Object) []runtime.Object {
result := make([]runtime.Object, len(objects))
key := etcdtest.AddPrefix(t.storage.KeyRootFunc(t.tester.TestContext()))
if len(objects) > 0 {
nodes := make([]*etcd.Node, len(objects))
for i, obj := range objects {
codec, _ := getCodec(obj)
encoded := runtime.EncodeOrDie(codec, obj)
decoded, _ := codec.Decode([]byte(encoded))
nodes[i] = &etcd.Node{Value: encoded}
result[i] = decoded
key := t.storage.KeyRootFunc(t.tester.TestContext())
if err := storagetesting.CreateObjList(key, t.storage.Storage, objects); err != nil {
t.tester.Errorf("unexpected error: %v", err)
return nil
}
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
}
func (t *Tester) setResourceVersion(resourceVersion uint64) {
t.fakeClient.ChangeIndex = resourceVersion
}
func (t *Tester) injectWatchError(err error) {
t.fakeClient.WatchInjectError <- err
return objects
}
func (t *Tester) emitObject(obj runtime.Object, action string) error {
codec, err := getCodec(obj)
ctx := t.tester.TestContext()
var err error
switch action {
case etcdstorage.EtcdCreate:
err = t.setObject(ctx, obj)
case etcdstorage.EtcdDelete:
meta, err := api.ObjectMetaFor(obj)
if err != nil {
return err
}
encoded, err := codec.Encode(obj)
if err != nil {
return err
}
node := &etcd.Node{
Value: string(encoded),
}
var prevNode *etcd.Node = nil
if action == etcdstorage.EtcdDelete {
prevNode = node
}
t.fakeClient.WatchResponse <- &etcd.Response{
Action: action,
Node: node,
PrevNode: prevNode,
}
return nil
_, err = t.storage.Delete(ctx, meta.Name, nil)
default:
err = fmt.Errorf("unexpected action: %v", action)
}
func isNotFoundEtcdError(err error) bool {
etcdError, ok := err.(*etcd.EtcdError)
if !ok {
return false
}
return etcdError.ErrorCode == tools.EtcdErrorCodeNotFound
return err
}

76
pkg/registry/resourcequota/etcd/etcd_test.go
View File

@ -17,26 +17,23 @@ limitations under the License.
package etcd
import (
"fmt"
"testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"k8s.io/kubernetes/pkg/util"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
resourceQuotaStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return resourceQuotaStorage, statusStorage, fakeClient
return resourceQuotaStorage, statusStorage, server
}
func validNewResourceQuota() *api.ResourceQuota {
@ -59,8 +56,9 @@ func validNewResourceQuota() *api.ResourceQuota {
}
func TestCreate(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
resourcequota := validNewResourceQuota()
resourcequota.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -73,23 +71,13 @@ func TestCreate(t *testing.T) {
)
}
func TestCreateRegistryError(t *testing.T) {
storage, _, fakeClient := newStorage(t)
fakeClient.Err = fmt.Errorf("test error")
resourcequota := validNewResourceQuota()
_, err := storage.Create(api.NewDefaultContext(), resourcequota)
if err != fakeClient.Err {
t.Fatalf("unexpected error: %v", err)
}
}
func TestCreateSetsFields(t *testing.T) {
storage, _, fakeClient := newStorage(t)
storage, _, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
resourcequota := validNewResourceQuota()
_, err := storage.Create(api.NewDefaultContext(), resourcequota)
if err != fakeClient.Err {
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -107,26 +95,30 @@ func TestCreateSetsFields(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test.TestDelete(validNewResourceQuota())
}
func TestGet(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewResourceQuota())
}
func TestList(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewResourceQuota())
}
func TestWatch(t *testing.T) {
storage, _, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewResourceQuota(),
// matching labels
@ -147,19 +139,22 @@ func TestWatch(t *testing.T) {
}
func TestUpdateStatus(t *testing.T) {
storage, status, fakeClient := newStorage(t)
storage, status, server := newStorage(t)
defer server.Terminate(t)
ctx := api.NewDefaultContext()
key, _ := storage.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
resourcequotaStart := validNewResourceQuota()
fakeClient.Set(key, runtime.EncodeOrDie(testapi.Default.Codec(), resourcequotaStart), 0)
err := storage.Storage.Set(ctx, key, resourcequotaStart, nil, 0)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
resourcequotaIn := &api.ResourceQuota{
ObjectMeta: api.ObjectMeta{
Name: "foo",
Namespace: api.NamespaceDefault,
ResourceVersion: "1",
},
Status: api.ResourceQuotaStatus{
Used: api.ResourceList{
@ -181,17 +176,14 @@ func TestUpdateStatus(t *testing.T) {
},
}
expected := *resourcequotaStart
expected.ResourceVersion = "2"
expected.Labels = resourcequotaIn.Labels
expected.Status = resourcequotaIn.Status
_, _, err := status.Update(ctx, resourcequotaIn)
_, _, err = status.Update(ctx, resourcequotaIn)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
rqOut, err := storage.Get(ctx, "foo")
if !api.Semantic.DeepEqual(&expected, rqOut) {
t.Errorf("unexpected object: %s", util.ObjectDiff(&expected, rqOut))
obj, err := storage.Get(ctx, "foo")
rqOut := obj.(*api.ResourceQuota)
// only compare the meaningful update b/c we can't compare due to metadata
if !api.Semantic.DeepEqual(resourcequotaIn.Status, rqOut.Status) {
t.Errorf("unexpected object: %s", util.ObjectDiff(resourcequotaIn, rqOut))
}
}

38
pkg/registry/secret/etcd/etcd_test.go
View File

@ -25,12 +25,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), server
}
func validNewSecret(name string) *api.Secret {
@ -46,8 +46,9 @@ func validNewSecret(name string) *api.Secret {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
secret := validNewSecret("foo")
secret.ObjectMeta = api.ObjectMeta{GenerateName: "foo-"}
test.TestCreate(
@ -67,8 +68,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewSecret("foo"),
@ -82,26 +84,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewSecret("foo"))
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewSecret("foo"))
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewSecret("foo"))
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewSecret("foo"),
// matching labels

28
pkg/registry/service/allocator/etcd/etcd_test.go
View File

@ -21,21 +21,19 @@ import (
"testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/registry/service/allocator"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"golang.org/x/net/context"
)
func newStorage(t *testing.T) (*Etcd, *tools.FakeEtcdClient, allocator.Interface) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*Etcd, *etcdtesting.EtcdTestServer, allocator.Interface) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
mem := allocator.NewAllocationMap(100, "rangeSpecValue")
etcd := NewEtcd(mem, "/ranges/serviceips", "serviceipallocation", etcdStorage)
return etcd, fakeClient, mem
return etcd, server, mem
}
func validNewRangeAllocation() *api.RangeAllocation {
@ -50,16 +48,17 @@ func key() string {
}
func TestEmpty(t *testing.T) {
storage, fakeClient, _ := newStorage(t)
fakeClient.ExpectNotFoundGet(key())
storage, server, _ := newStorage(t)
defer server.Terminate(t)
if _, err := storage.Allocate(1); !strings.Contains(err.Error(), "cannot allocate resources of type serviceipallocation at this time") {
t.Fatal(err)
}
}
func TestStore(t *testing.T) {
storage, fakeClient, backing := newStorage(t)
if _, err := fakeClient.Set(key(), runtime.EncodeOrDie(testapi.Default.Codec(), validNewRangeAllocation()), 0); err != nil {
storage, server, backing := newStorage(t)
defer server.Terminate(t)
if err := storage.storage.Set(context.TODO(), key(), validNewRangeAllocation(), nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -77,21 +76,12 @@ func TestStore(t *testing.T) {
t.Fatal("Expected allocation to fail")
}
obj := fakeClient.Data[key()]
if obj.R == nil || obj.R.Node == nil {
t.Fatalf("%s is empty: %#v", key(), obj)
}
t.Logf("data: %#v", obj.R.Node)
other := allocator.NewAllocationMap(100, "rangeSpecValue")
allocation := &api.RangeAllocation{}
if err := storage.storage.Get(context.TODO(), key(), allocation, false); err != nil {
t.Fatal(err)
}
if allocation.ResourceVersion != "2" {
t.Fatalf("%#v", allocation)
}
if allocation.Range != "rangeSpecValue" {
t.Errorf("unexpected stored Range: %s", allocation.Range)
}

38
pkg/registry/service/etcd/etcd_test.go
View File

@ -25,13 +25,13 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"k8s.io/kubernetes/pkg/util/intstr"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), server
}
func validService() *api.Service {
@ -55,8 +55,9 @@ func validService() *api.Service {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
validService := validService()
validService.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -84,8 +85,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validService(),
@ -108,26 +110,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test.TestDelete(validService())
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test.TestGet(validService())
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).AllowCreateOnUpdate()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test.TestList(validService())
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validService(),
// matching labels

31
pkg/registry/service/ipallocator/etcd/etcd_test.go
View File

@ -22,18 +22,19 @@ import (
"testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/registry/service/allocator"
allocatoretcd "k8s.io/kubernetes/pkg/registry/service/allocator/etcd"
"k8s.io/kubernetes/pkg/registry/service/ipallocator"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
"golang.org/x/net/context"
)
func newStorage(t *testing.T) (*tools.FakeEtcdClient, ipallocator.Interface, allocator.Interface) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
func newStorage(t *testing.T) (*etcdtesting.EtcdTestServer, ipallocator.Interface, allocator.Interface, storage.Interface) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
_, cidr, err := net.ParseCIDR("192.168.1.0/24")
if err != nil {
t.Fatal(err)
@ -47,7 +48,7 @@ func newStorage(t *testing.T) (*tools.FakeEtcdClient, ipallocator.Interface, all
return etcd
})
return fakeClient, storage, backing
return server, storage, backing, etcdStorage
}
func validNewRangeAllocation() *api.RangeAllocation {
@ -63,23 +64,25 @@ func key() string {
}
func TestEmpty(t *testing.T) {
fakeClient, storage, _ := newStorage(t)
fakeClient.ExpectNotFoundGet(key())
server, storage, _, _ := newStorage(t)
defer server.Terminate(t)
if err := storage.Allocate(net.ParseIP("192.168.1.2")); !strings.Contains(err.Error(), "cannot allocate resources of type serviceipallocation at this time") {
t.Fatal(err)
}
}
func TestErrors(t *testing.T) {
_, storage, _ := newStorage(t)
server, storage, _, _ := newStorage(t)
defer server.Terminate(t)
if err := storage.Allocate(net.ParseIP("192.168.0.0")); err != ipallocator.ErrNotInRange {
t.Fatal(err)
}
}
func TestStore(t *testing.T) {
fakeClient, storage, backing := newStorage(t)
if _, err := fakeClient.Set(key(), runtime.EncodeOrDie(testapi.Default.Codec(), validNewRangeAllocation()), 0); err != nil {
server, storage, backing, si := newStorage(t)
defer server.Terminate(t)
if err := si.Set(context.TODO(), key(), validNewRangeAllocation(), nil, 0); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -96,10 +99,4 @@ func TestStore(t *testing.T) {
if err := storage.Allocate(net.ParseIP("192.168.1.2")); err != ipallocator.ErrAllocated {
t.Fatal(err)
}
obj := fakeClient.Data[key()]
if obj.R == nil || obj.R.Node == nil {
t.Fatalf("%s is empty: %#v", key(), obj)
}
t.Logf("data: %#v", obj.R.Node)
}

38
pkg/registry/serviceaccount/etcd/etcd_test.go
View File

@ -25,12 +25,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, generic.UndecoratedStorage), server
}
func validNewServiceAccount(name string) *api.ServiceAccount {
@ -44,8 +44,9 @@ func validNewServiceAccount(name string) *api.ServiceAccount {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
serviceAccount := validNewServiceAccount("foo")
serviceAccount.ObjectMeta = api.ObjectMeta{GenerateName: "foo-"}
test.TestCreate(
@ -60,8 +61,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewServiceAccount("foo"),
@ -75,26 +77,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd).ReturnDeletedObject()
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test.TestDelete(validNewServiceAccount("foo"))
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewServiceAccount("foo"))
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewServiceAccount("foo"))
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewServiceAccount("foo"),
// matching labels

38
pkg/registry/thirdpartyresource/etcd/etcd_test.go
View File

@ -28,12 +28,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage, generic.UndecoratedStorage), server
}
func validNewThirdPartyResource(name string) *extensions.ThirdPartyResource {
@ -51,8 +51,9 @@ func validNewThirdPartyResource(name string) *extensions.ThirdPartyResource {
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
rsrc := validNewThirdPartyResource("foo")
rsrc.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -64,8 +65,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewThirdPartyResource("foo"),
@ -79,26 +81,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewThirdPartyResource("foo"))
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewThirdPartyResource("foo"))
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewThirdPartyResource("foo"))
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewThirdPartyResource("foo"),
// matching labels

38
pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go
View File

@ -28,12 +28,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/tools"
etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), fakeClient
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), server
}
func validNewThirdPartyResourceData(name string) *extensions.ThirdPartyResourceData {
@ -47,8 +47,9 @@ func validNewThirdPartyResourceData(name string) *extensions.ThirdPartyResourceD
}
func TestCreate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
rsrc := validNewThirdPartyResourceData("foo")
rsrc.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -60,8 +61,9 @@ func TestCreate(t *testing.T) {
}
func TestUpdate(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestUpdate(
// valid
validNewThirdPartyResourceData("foo"),
@ -75,26 +77,30 @@ func TestUpdate(t *testing.T) {
}
func TestDelete(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestDelete(validNewThirdPartyResourceData("foo"))
}
func TestGet(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestGet(validNewThirdPartyResourceData("foo"))
}
func TestList(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestList(validNewThirdPartyResourceData("foo"))
}
func TestWatch(t *testing.T) {
storage, fakeClient := newStorage(t)
test := registrytest.New(t, fakeClient, storage.Etcd)
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test.TestWatch(
validNewThirdPartyResourceData("foo"),
// matching labels

32
pkg/storage/testing/utils.go
View File

@ -18,7 +18,6 @@ package testing
import (
"path"
"testing"
"golang.org/x/net/context"
"k8s.io/kubernetes/pkg/api/meta"
@ -27,31 +26,36 @@ import (
)
// CreateObj will create a single object using the storage interface
func CreateObj(t *testing.T, helper storage.Interface, name string, obj, out runtime.Object, ttl uint64) error {
err := helper.Set(context.TODO(), name, obj, out, ttl)
if err != nil {
t.Errorf("Unexpected error %v", err)
}
return err
func CreateObj(helper storage.Interface, name string, obj, out runtime.Object, ttl uint64) error {
return helper.Set(context.TODO(), name, obj, out, ttl)
}
// CreateList will properly create a list using the storage interface
func CreateList(t *testing.T, prefix string, helper storage.Interface, list runtime.Object) error {
items, err := runtime.ExtractList(list)
if err != nil {
return err
}
//CreateObjList will create a list from the array of objects
func CreateObjList(prefix string, helper storage.Interface, items []runtime.Object) error {
for i := range items {
obj := items[i]
meta, err := meta.Accessor(obj)
if err != nil {
return err
}
err = CreateObj(t, helper, path.Join(prefix, meta.Name()), obj, obj, 0)
err = CreateObj(helper, path.Join(prefix, meta.Name()), obj, obj, 0)
if err != nil {
return err
}
items[i] = obj
}
return nil
}
// CreateList will properly create a list using the storage interface
func CreateList(prefix string, helper storage.Interface, list runtime.Object) error {
items, err := runtime.ExtractList(list)
if err != nil {
return err
}
err = CreateObjList(prefix, helper, items)
if err != nil {
return err
}
return runtime.SetList(list, items)
}