github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactoring of get etcd tests.

Browse Source 
Refactoring of get etcd tests: introudced new generic resttest, TestGet; Converted all etcd tests to use it.
This commit is contained in:
Jerzy Szczepkowski
2015-08-11 09:20:21 +02:00
parent 56fb29a83a
commit f09a08d15a
11 changed files with 179 additions and 515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -205,25 +205,6 @@ func TestCreateControllerWithConflictingNamespace(t *testing.T) {
}
}
func TestEtcdGetController(t *testing.T) {
ctx := api.NewDefaultContext()
storage, fakeClient := newStorage(t)
key, _ := makeControllerKey(ctx, validController.Name)
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, &validController), 0)
ctrl, err := storage.Get(ctx, validController.Name)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
controller, ok := ctrl.(*api.ReplicationController)
if !ok {
t.Errorf("Expected a controller, got %#v", ctrl)
}
if controller.Name != validController.Name {
t.Errorf("Unexpected controller: %#v", controller)
}
}
func TestEtcdControllerValidatesUpdate(t *testing.T) {
ctx := api.NewDefaultContext()
storage, _ := newStorage(t)
@@ -331,70 +312,11 @@ func TestGenerationNumber(t *testing.T) {
}
}
// TestEtcdGetControllerDifferentNamespace ensures same-name controllers in different namespaces do not clash
func TestEtcdGetControllerDifferentNamespace(t *testing.T) {
func TestEtcdGetController(t *testing.T) {
storage, fakeClient := newStorage(t)
otherNs := "other"
ctx1 := api.NewDefaultContext()
ctx2 := api.WithNamespace(api.NewContext(), otherNs)
key1, _ := makeControllerKey(ctx1, validController.Name)
key2, _ := makeControllerKey(ctx2, validController.Name)
key1 = etcdtest.AddPrefix(key1)
key2 = etcdtest.AddPrefix(key2)
fakeClient.Set(key1, runtime.EncodeOrDie(latest.Codec, &validController), 0)
otherNsController := validController
otherNsController.Namespace = otherNs
fakeClient.Set(key2, runtime.EncodeOrDie(latest.Codec, &otherNsController), 0)
obj, err := storage.Get(ctx1, validController.Name)
ctrl1, _ := obj.(*api.ReplicationController)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if ctrl1.Name != "foo" {
t.Errorf("Unexpected controller: %#v", ctrl1)
}
if ctrl1.Namespace != "default" {
t.Errorf("Unexpected controller: %#v", ctrl1)
}
obj, err = storage.Get(ctx2, validController.Name)
ctrl2, _ := obj.(*api.ReplicationController)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if ctrl2.Name != "foo" {
t.Errorf("Unexpected controller: %#v", ctrl2)
}
if ctrl2.Namespace != "other" {
t.Errorf("Unexpected controller: %#v", ctrl2)
}
}
func TestEtcdGetControllerNotFound(t *testing.T) {
ctx := api.NewDefaultContext()
storage, fakeClient := newStorage(t)
key, _ := makeControllerKey(ctx, validController.Name)
key = etcdtest.AddPrefix(key)
fakeClient.Data[key] = tools.EtcdResponseWithError{
R: &etcd.Response{
Node: nil,
},
E: tools.EtcdErrorNotFound,
}
ctrl, err := storage.Get(ctx, validController.Name)
if ctrl != nil {
t.Errorf("Unexpected non-nil controller: %#v", ctrl)
}
if !errors.IsNotFound(err) {
t.Errorf("Unexpected error returned: %#v", err)
}
test := resttest.New(t, storage, fakeClient.SetError)
copy := validController
test.TestGet(&copy)
}
func TestEtcdUpdateController(t *testing.T) {

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

@@ -154,34 +154,10 @@ func TestEtcdListEndpoints(t *testing.T) {
}
func TestEtcdGetEndpoints(t *testing.T) {
ctx := api.NewDefaultContext()
storage, fakeClient := newStorage(t)
test := resttest.New(t, storage, fakeClient.SetError)
endpoints := validNewEndpoints()
name := endpoints.Name
key, _ := storage.KeyFunc(ctx, name)
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, endpoints), 0)
response, err := fakeClient.Get(key, false, false)
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
var endpointsOut api.Endpoints
err = latest.Codec.DecodeInto([]byte(response.Node.Value), &endpointsOut)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
obj, err := storage.Get(ctx, name)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
got := obj.(*api.Endpoints)
endpoints.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion
if e, a := endpoints, got; !api.Semantic.DeepEqual(*e, *a) {
t.Errorf("Unexpected endpoints: %#v, expected %#v", e, a)
}
test.TestGet(endpoints)
}
func TestListEmptyEndpointsList(t *testing.T) {

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

@@ -136,32 +136,11 @@ func TestDelete(t *testing.T) {
test.TestDeleteNoGraceful(createFn, gracefulSetFn)
}
func TestEtcdGet(t *testing.T) {
ctx := api.NewDefaultContext()
registry, fakeClient, _ := newStorage(t)
autoscaler := validNewHorizontalPodAutoscaler("foo3")
name := autoscaler.Name
key, _ := registry.KeyFunc(ctx, name)
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(testapi.Codec(), autoscaler), 0)
response, err := fakeClient.Get(key, false, false)
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
var autoscalerOut expapi.HorizontalPodAutoscaler
err = testapi.Codec().DecodeInto([]byte(response.Node.Value), &autoscalerOut)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
obj, err := registry.Get(ctx, name)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
got := obj.(*expapi.HorizontalPodAutoscaler)
autoscaler.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion
if e, a := autoscaler, got; !api.Semantic.DeepEqual(*e, *a) {
t.Errorf("Unexpected autoscaler: %#v, expected %#v", e, a)
}
func TestGet(t *testing.T) {
storage, fakeEtcdClient, _ := newStorage(t)
test := resttest.New(t, storage, fakeEtcdClient.SetError)
autoscaler := validNewHorizontalPodAutoscaler("foo")
test.TestGet(autoscaler)
}
func TestEmptyList(t *testing.T) {

35
pkg/registry/minion/etcd/etcd_test.go
View File

@@ -22,7 +22,6 @@ import (
"time"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/api/rest/resttest"
@@ -211,23 +210,10 @@ func TestEtcdListNodesMatch(t *testing.T) {
}
func TestEtcdGetNode(t *testing.T) {
ctx := api.NewContext()
storage, fakeClient := newStorage(t)
test := resttest.New(t, storage, fakeClient.SetError).ClusterScope()
node := validNewNode()
key, _ := storage.KeyFunc(ctx, node.Name)
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, node), 0)
nodeObj, err := storage.Get(ctx, node.Name)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
got := nodeObj.(*api.Node)
node.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion
if e, a := node, got; !api.Semantic.DeepEqual(*e, *a) {
t.Errorf("Unexpected node: %#v, expected %#v", e, a)
}
test.TestGet(node)
}
func TestEtcdUpdateEndpoints(t *testing.T) {
@@ -260,23 +246,6 @@ func TestEtcdUpdateEndpoints(t *testing.T) {
}
}
func TestEtcdGetNodeNotFound(t *testing.T) {
ctx := api.NewContext()
storage, fakeClient := newStorage(t)
key := etcdtest.AddPrefix("minions/foo")
fakeClient.Data[key] = tools.EtcdResponseWithError{
R: &etcd.Response{
Node: nil,
},
E: tools.EtcdErrorNotFound,
}
_, err := storage.Get(ctx, "foo")
if !errors.IsNotFound(err) {
t.Errorf("Unexpected error returned: %#v", err)
}
}
func TestEtcdDeleteNode(t *testing.T) {
ctx := api.NewContext()
storage, fakeClient := newStorage(t)

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

@@ -284,32 +284,10 @@ func TestNamespaceDecode(t *testing.T) {
}
func TestGet(t *testing.T) {
expect := validNewNamespace()
expect.Status.Phase = api.NamespaceActive
storage, fakeEtcdClient, _ := newStorage(t)
ctx := api.NewContext()
key, err := storage.Etcd.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
if err != nil {
t.Fatalf("unexpected key error: %v", err)
}
fakeEtcdClient.Data[key] = tools.EtcdResponseWithError{
R: &etcd.Response{
Node: &etcd.Node{
Value: runtime.EncodeOrDie(latest.Codec, expect),
},
},
}
obj, err := storage.Get(api.NewContext(), "foo")
namespace := obj.(*api.Namespace)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
expect.Status.Phase = api.NamespaceActive
if e, a := expect, namespace; !api.Semantic.DeepEqual(e, a) {
t.Errorf("Unexpected namespace: %s", util.ObjectDiff(e, a))
}
test := resttest.New(t, storage, fakeEtcdClient.SetError).ClusterScope()
namespace := validNewNamespace()
test.TestGet(namespace)
}
func TestDeleteNamespace(t *testing.T) {

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

@@ -149,34 +149,10 @@ func TestEtcdListPersistentVolumes(t *testing.T) {
}
func TestEtcdGetPersistentVolumes(t *testing.T) {
ctx := api.NewContext()
storage, _, fakeClient, _ := newStorage(t)
test := resttest.New(t, storage, fakeClient.SetError).ClusterScope()
persistentVolume := validNewPersistentVolume("foo")
name := persistentVolume.Name
key, _ := storage.KeyFunc(ctx, name)
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, persistentVolume), 0)
response, err := fakeClient.Get(key, false, false)
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
var persistentVolumeOut api.PersistentVolume
err = latest.Codec.DecodeInto([]byte(response.Node.Value), &persistentVolumeOut)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
obj, err := storage.Get(ctx, name)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
got := obj.(*api.PersistentVolume)
persistentVolume.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion
if e, a := persistentVolume, got; !api.Semantic.DeepEqual(*e, *a) {
t.Errorf("Unexpected persistentVolume: %#v, expected %#v", e, a)
}
test.TestGet(persistentVolume)
}
func TestListEmptyPersistentVolumesList(t *testing.T) {

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

@@ -147,34 +147,10 @@ func TestEtcdListPersistentVolumeClaims(t *testing.T) {
}
func TestEtcdGetPersistentVolumeClaims(t *testing.T) {
ctx := api.NewDefaultContext()
registry, _, fakeClient, _ := newStorage(t)
persistentVolume := validNewPersistentVolumeClaim("foo", api.NamespaceDefault)
name := persistentVolume.Name
key, _ := registry.KeyFunc(ctx, name)
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, persistentVolume), 0)
response, err := fakeClient.Get(key, false, false)
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
var persistentVolumeOut api.PersistentVolumeClaim
err = latest.Codec.DecodeInto([]byte(response.Node.Value), &persistentVolumeOut)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
obj, err := registry.Get(ctx, name)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
got := obj.(*api.PersistentVolumeClaim)
persistentVolume.ObjectMeta.ResourceVersion = got.ObjectMeta.ResourceVersion
if e, a := persistentVolume, got; !api.Semantic.DeepEqual(*e, *a) {
t.Errorf("Unexpected persistentVolume: %#v, expected %#v", e, a)
}
storage, _, fakeClient, _ := newStorage(t)
test := resttest.New(t, storage, fakeClient.SetError)
claim := validNewPersistentVolumeClaim("foo", api.NamespaceDefault)
test.TestGet(claim)
}
func TestListEmptyPersistentVolumeClaimsList(t *testing.T) {

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

@@ -388,33 +388,6 @@ func TestPodDecode(t *testing.T) {
}
}
func TestGet(t *testing.T) {
expect := validNewPod()
expect.Status.Phase = api.PodRunning
expect.Spec.NodeName = "machine"
fakeEtcdClient, etcdStorage := newEtcdStorage(t)
key := etcdtest.AddPrefix("/pods/test/foo")
fakeEtcdClient.Data[key] = tools.EtcdResponseWithError{
R: &etcd.Response{
Node: &etcd.Node{
Value: runtime.EncodeOrDie(latest.Codec, expect),
},
},
}
storage := NewStorage(etcdStorage, nil).Pod
obj, err := storage.Get(api.WithNamespace(api.NewContext(), "test"), "foo")
pod := obj.(*api.Pod)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if e, a := expect, pod; !api.Semantic.DeepEqual(e, a) {
t.Errorf("Unexpected pod: %s", util.ObjectDiff(e, a))
}
}
// TODO: remove, this is covered by RESTTest.TestCreate
func TestPodStorageValidatesCreate(t *testing.T) {
fakeEtcdClient, etcdStorage := newEtcdStorage(t)
@@ -661,79 +634,12 @@ func TestDeletePod(t *testing.T) {
}
}
// TestEtcdGetDifferentNamespace ensures same-name pods in different namespaces do not clash
func TestEtcdGetDifferentNamespace(t *testing.T) {
registry, _, _, fakeClient, _ := newStorage(t)
ctx1 := api.NewDefaultContext()
ctx2 := api.WithNamespace(api.NewContext(), "other")
key1, _ := registry.KeyFunc(ctx1, "foo")
key2, _ := registry.KeyFunc(ctx2, "foo")
key1 = etcdtest.AddPrefix(key1)
key2 = etcdtest.AddPrefix(key2)
fakeClient.Set(key1, runtime.EncodeOrDie(latest.Codec, &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: "default", Name: "foo"}}), 0)
fakeClient.Set(key2, runtime.EncodeOrDie(latest.Codec, &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: "other", Name: "foo"}}), 0)
obj, err := registry.Get(ctx1, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
pod1 := obj.(*api.Pod)
if pod1.Name != "foo" {
t.Errorf("Unexpected pod: %#v", pod1)
}
if pod1.Namespace != "default" {
t.Errorf("Unexpected pod: %#v", pod1)
}
obj, err = registry.Get(ctx2, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
pod2 := obj.(*api.Pod)
if pod2.Name != "foo" {
t.Errorf("Unexpected pod: %#v", pod2)
}
if pod2.Namespace != "other" {
t.Errorf("Unexpected pod: %#v", pod2)
}
}
func TestEtcdGet(t *testing.T) {
registry, _, _, fakeClient, _ := newStorage(t)
ctx := api.NewDefaultContext()
key, _ := registry.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}), 0)
obj, err := registry.Get(ctx, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
pod := obj.(*api.Pod)
if pod.Name != "foo" {
t.Errorf("Unexpected pod: %#v", pod)
}
}
func TestEtcdGetNotFound(t *testing.T) {
registry, _, _, fakeClient, _ := newStorage(t)
ctx := api.NewDefaultContext()
key, _ := registry.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.Data[key] = tools.EtcdResponseWithError{
R: &etcd.Response{
Node: nil,
},
E: tools.EtcdErrorNotFound,
}
_, err := registry.Get(ctx, "foo")
if !errors.IsNotFound(err) {
t.Errorf("Unexpected error returned: %#v", err)
}
fakeEtcdClient, etcdStorage := newEtcdStorage(t)
storage := NewStorage(etcdStorage, nil).Pod
test := resttest.New(t, storage, fakeEtcdClient.SetError)
pod := validNewPod()
test.TestGet(pod)
}
func TestEtcdCreate(t *testing.T) {

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

@@ -314,30 +314,6 @@ func TestResourceQuotaDecode(t *testing.T) {
}
}
func TestGet(t *testing.T) {
expect := validNewResourceQuota()
fakeEtcdClient, etcdStorage := newEtcdStorage(t)
storage, _ := NewStorage(etcdStorage)
key := "/resourcequotas/test/foo"
key = etcdtest.AddPrefix(key)
fakeEtcdClient.Data[key] = tools.EtcdResponseWithError{
R: &etcd.Response{
Node: &etcd.Node{
Value: runtime.EncodeOrDie(latest.Codec, expect),
},
},
}
obj, err := storage.Get(api.WithNamespace(api.NewContext(), "test"), "foo")
resourcequota := obj.(*api.ResourceQuota)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if e, a := expect, resourcequota; !api.Semantic.DeepEqual(e, a) {
t.Errorf("Unexpected resourcequota: %s", util.ObjectDiff(e, a))
}
}
func TestDeleteResourceQuota(t *testing.T) {
fakeEtcdClient, etcdStorage := newEtcdStorage(t)
fakeEtcdClient.ChangeIndex = 1
@@ -366,79 +342,12 @@ func TestDeleteResourceQuota(t *testing.T) {
}
}
// TestEtcdGetDifferentNamespace ensures same-name resourcequotas in different namespaces do not clash
func TestEtcdGetDifferentNamespace(t *testing.T) {
registry, _, fakeClient, _ := newStorage(t)
ctx1 := api.NewDefaultContext()
ctx2 := api.WithNamespace(api.NewContext(), "other")
key1, _ := registry.KeyFunc(ctx1, "foo")
key2, _ := registry.KeyFunc(ctx2, "foo")
key1 = etcdtest.AddPrefix(key1)
key2 = etcdtest.AddPrefix(key2)
fakeClient.Set(key1, runtime.EncodeOrDie(latest.Codec, &api.ResourceQuota{ObjectMeta: api.ObjectMeta{Namespace: "default", Name: "foo"}}), 0)
fakeClient.Set(key2, runtime.EncodeOrDie(latest.Codec, &api.ResourceQuota{ObjectMeta: api.ObjectMeta{Namespace: "other", Name: "foo"}}), 0)
obj, err := registry.Get(ctx1, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
resourcequota1 := obj.(*api.ResourceQuota)
if resourcequota1.Name != "foo" {
t.Errorf("Unexpected resourcequota: %#v", resourcequota1)
}
if resourcequota1.Namespace != "default" {
t.Errorf("Unexpected resourcequota: %#v", resourcequota1)
}
obj, err = registry.Get(ctx2, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
resourcequota2 := obj.(*api.ResourceQuota)
if resourcequota2.Name != "foo" {
t.Errorf("Unexpected resourcequota: %#v", resourcequota2)
}
if resourcequota2.Namespace != "other" {
t.Errorf("Unexpected resourcequota: %#v", resourcequota2)
}
}
func TestEtcdGet(t *testing.T) {
registry, _, fakeClient, _ := newStorage(t)
ctx := api.NewDefaultContext()
key, _ := registry.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, &api.ResourceQuota{ObjectMeta: api.ObjectMeta{Name: "foo"}}), 0)
obj, err := registry.Get(ctx, "foo")
if err != nil {
t.Errorf("unexpected error: %v", err)
}
resourcequota := obj.(*api.ResourceQuota)
if resourcequota.Name != "foo" {
t.Errorf("Unexpected resourcequota: %#v", resourcequota)
}
}
func TestEtcdGetNotFound(t *testing.T) {
registry, _, fakeClient, _ := newStorage(t)
ctx := api.NewDefaultContext()
key, _ := registry.KeyFunc(ctx, "foo")
key = etcdtest.AddPrefix(key)
fakeClient.Data[key] = tools.EtcdResponseWithError{
R: &etcd.Response{
Node: nil,
},
E: tools.EtcdErrorNotFound,
}
_, err := registry.Get(ctx, "foo")
if !errors.IsNotFound(err) {
t.Errorf("Unexpected error returned: %#v", err)
}
fakeEtcdClient, etcdStorage := newEtcdStorage(t)
storage, _ := NewStorage(etcdStorage)
test := resttest.New(t, storage, fakeEtcdClient.SetError)
resourcequota := validNewResourceQuota()
test.TestGet(resourcequota)
}
func TestEtcdCreateFailsWithoutNamespace(t *testing.T) {