func TestRESTUpdate(t *testing.T) { _, rest := NewTestREST() eventA := testEvent("foo") _, err := rest.Create(api.NewDefaultContext(), eventA) if err != nil { t.Fatalf("Unexpected error %v", err) } got, err := rest.Get(api.NewDefaultContext(), eventA.Name) if err != nil { t.Fatalf("Unexpected error %v", err) } if e, a := eventA, got; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } eventB := testEvent("bar") _, _, err = rest.Update(api.NewDefaultContext(), eventB) if err != nil { t.Fatalf("Unexpected error %v", err) } got2, err := rest.Get(api.NewDefaultContext(), eventB.Name) if err != nil { t.Fatalf("Unexpected error %v", err) } if e, a := eventB, got2; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func roundTrip(t *testing.T, codec runtime.Codec, originalItem runtime.Object) { // Make a copy of the originalItem to give to conversion functions // This lets us know if conversion messed with the input object deepCopy, err := api.Scheme.DeepCopy(originalItem) if err != nil { t.Errorf("Could not copy object: %v", err) return } item := deepCopy.(runtime.Object) name := reflect.TypeOf(item).Elem().Name() data, err := codec.Encode(item) if err != nil { if conversion.IsNotRegisteredError(err) { t.Logf("%v is not registered", name) return } t.Errorf("%v: %v (%#v)", name, err, item) return } obj2, err := codec.Decode(data) if err != nil { t.Errorf("0: %v: %v\nCodec: %v\nData: %s\nSource: %#v", name, err, codec, string(data), originalItem) return } if reflect.TypeOf(item) != reflect.TypeOf(obj2) { obj2conv := reflect.New(reflect.TypeOf(item).Elem()).Interface().(runtime.Object) if err := api.Scheme.Convert(obj2, obj2conv); err != nil { t.Errorf("0X: no conversion from %v to %v: %v", reflect.TypeOf(item), reflect.TypeOf(obj2), err) return } obj2 = obj2conv } if !api.Semantic.DeepEqual(originalItem, obj2) { t.Errorf("1: %v: diff: %v\nCodec: %v\nData: %s\nSource: %s", name, util.ObjectDiff(originalItem, obj2), codec, string(data), util.ObjectGoPrintSideBySide(originalItem, obj2)) return } obj3 := reflect.New(reflect.TypeOf(item).Elem()).Interface().(runtime.Object) err = codec.DecodeInto(data, obj3) if err != nil { t.Errorf("2: %v: %v", name, err) return } if !api.Semantic.DeepEqual(originalItem, obj3) { t.Errorf("3: %v: diff: %v\nCodec: %v", name, util.ObjectDiff(originalItem, obj3), codec) return } }
func TestRoundTripVersionedObject(t *testing.T) { d := &newer.DockerImage{ Config: newer.DockerConfig{ Env: []string{"A=1", "B=2"}, }, } i := &newer.Image{ ObjectMeta: kapi.ObjectMeta{Name: "foo"}, DockerImageMetadata: *d, DockerImageReference: "foo/bar/baz", } data, err := kapi.Scheme.EncodeToVersion(i, "v1beta3") if err != nil { t.Fatalf("unexpected error: %v", err) } obj, err := kapi.Scheme.Decode(data) if err != nil { t.Fatalf("unexpected error: %v", err) } image := obj.(*newer.Image) if image.DockerImageMetadataVersion != "1.0" { t.Errorf("did not default to correct metadata version: %#v", image) } image.DockerImageMetadataVersion = "" if !reflect.DeepEqual(i, image) { t.Errorf("unable to round trip object: %s", util.ObjectDiff(i, image)) } }
func roundTrip(t *testing.T, codec runtime.Codec, item runtime.Object) { printer := spew.ConfigState{DisableMethods: true} name := reflect.TypeOf(item).Elem().Name() data, err := codec.Encode(item) if err != nil { t.Errorf("%v: %v (%s)", name, err, printer.Sprintf("%#v", item)) return } obj2, err := codec.Decode(data) if err != nil { t.Errorf("0: %v: %v\nCodec: %v\nData: %s\nSource: %#v", name, err, codec, string(data), printer.Sprintf("%#v", item)) return } if !api.Semantic.DeepEqual(item, obj2) { t.Errorf("1: %v: diff: %v\nCodec: %v\nData: %s\nSource: %#v\nFinal: %#v", name, util.ObjectGoPrintDiff(item, obj2), codec, string(data), printer.Sprintf("%#v", item), printer.Sprintf("%#v", obj2)) return } obj3 := reflect.New(reflect.TypeOf(item).Elem()).Interface().(runtime.Object) err = codec.DecodeInto(data, obj3) if err != nil { t.Errorf("2: %v: %v", name, err) return } if !api.Semantic.DeepEqual(item, obj3) { t.Errorf("3: %v: diff: %v\nCodec: %v", name, util.ObjectDiff(item, obj3), codec) return } }
func TestGet(t *testing.T) { expect := validNewPod() expect.Status.Host = "machine" fakeEtcdClient, helper := newHelper(t) fakeEtcdClient.Data["/registry/pods/test/foo"] = tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(latest.Codec, expect), }, }, } storage, _, _ := NewREST(helper) cache := &fakeCache{statusToReturn: &api.PodStatus{Phase: api.PodRunning}} storage = storage.WithPodStatus(cache) obj, err := storage.Get(api.WithNamespace(api.NewContext(), "test"), "foo") pod := obj.(*api.Pod) if err != nil { t.Fatalf("unexpected error: %v", err) } expect.Status.Phase = api.PodRunning if e, a := expect, pod; !api.Semantic.DeepEqual(e, a) { t.Errorf("Unexpected pod: %s", util.ObjectDiff(e, a)) } }
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)) } }
func TestRESTWatch(t *testing.T) { eventA := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "foo", UID: "long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", } reg, rest := NewTestREST() wi, err := rest.Watch(api.NewContext(), labels.Everything(), fields.Everything(), "0") if err != nil { t.Fatalf("Unexpected error %v", err) } go func() { reg.Broadcaster.Action(watch.Added, eventA) }() got := <-wi.ResultChan() if e, a := eventA, got.Object; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
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)) } }
func TestEtcdWatch(t *testing.T) { podA := &api.Pod{ ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "1"}, Status: api.PodStatus{Host: "machine"}, } respWithPodA := &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(testapi.Codec(), podA), ModifiedIndex: 1, CreatedIndex: 1, }, Action: "create", } fakeClient, registry := NewTestGenericEtcdRegistry(t) wi, err := registry.Watch(api.NewContext(), EverythingMatcher{}, "1") if err != nil { t.Fatalf("unexpected error: %v", err) } fakeClient.WaitForWatchCompletion() go func() { fakeClient.WatchResponse <- respWithPodA }() got, open := <-wi.ResultChan() if !open { t.Fatalf("unexpected channel close") } if e, a := podA, got.Object; !reflect.DeepEqual(e, a) { t.Errorf("difference: %s", util.ObjectDiff(e, a)) } }
func TestGetCacheError(t *testing.T) { expect := validNewPod() expect.Status.Host = "machine" fakeEtcdClient, helper := newHelper(t) fakeEtcdClient.Data["/registry/pods/default/foo"] = tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(latest.Codec, expect), }, }, } storage, _, _ := NewREST(helper) cache := &fakeCache{errorToReturn: client.ErrPodInfoNotAvailable} storage = storage.WithPodStatus(cache) obj, err := storage.Get(api.NewDefaultContext(), "foo") pod := obj.(*api.Pod) if err != nil { t.Fatalf("unexpected error: %v", err) } expect.Status.Phase = api.PodUnknown if e, a := expect, pod; !api.Semantic.DeepEqual(e, a) { t.Errorf("unexpected object: %s", util.ObjectDiff(e, a)) } }
func TestRESTgetAttrs(t *testing.T) { _, rest := NewTestREST() secretA := testSecret("foo") label, field, err := rest.getAttrs(secretA) if err != nil { t.Fatalf("Unexpected error %v", err) } if e, a := label, (labels.Set{}); !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } expect := fields.Set{ "type": string(api.SecretTypeOpaque), } if e, a := expect, field; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func TestEtcdDelete(t *testing.T) { podA := &api.Pod{ ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "1"}, Spec: api.PodSpec{Host: "machine"}, } nodeWithPodA := tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(testapi.Codec(), podA), ModifiedIndex: 1, CreatedIndex: 1, }, }, E: nil, } emptyNode := tools.EtcdResponseWithError{ R: &etcd.Response{}, E: tools.EtcdErrorNotFound, } key := "foo" table := map[string]struct { existing tools.EtcdResponseWithError expect tools.EtcdResponseWithError errOK func(error) bool }{ "normal": { existing: nodeWithPodA, expect: emptyNode, errOK: func(err error) bool { return err == nil }, }, "notExisting": { existing: emptyNode, expect: emptyNode, errOK: func(err error) bool { return errors.IsNotFound(err) }, }, } for name, item := range table { fakeClient, registry := NewTestGenericEtcdRegistry(t) path := etcdtest.AddPrefix("pods/foo") fakeClient.Data[path] = item.existing obj, err := registry.Delete(api.NewContext(), key, nil) if !item.errOK(err) { t.Errorf("%v: unexpected error: %v (%#v)", name, err, obj) } if item.expect.E != nil { item.expect.E.(*etcd.EtcdError).Index = fakeClient.ChangeIndex } if e, a := item.expect, fakeClient.Data[path]; !api.Semantic.DeepDerivative(e, a) { t.Errorf("%v:\n%s", name, util.ObjectDiff(e, a)) } } }
func testPrinter(t *testing.T, printer ResourcePrinter, unmarshalFunc func(data []byte, v interface{}) error) { buf := bytes.NewBuffer([]byte{}) err := printer.PrintObj(&testData, buf) if err != nil { t.Fatal(err) } var poutput testStruct // Verify that given function runs without error. err = unmarshalFunc(buf.Bytes(), &poutput) if err != nil { t.Fatal(err) } // Use real decode function to undo the versioning process. poutput = testStruct{} err = runtime.YAMLDecoder(testapi.Codec()).DecodeInto(buf.Bytes(), &poutput) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(testData, poutput) { t.Errorf("Test data and unmarshaled data are not equal: %v", util.ObjectDiff(poutput, testData)) } obj := &api.Pod{ ObjectMeta: api.ObjectMeta{Name: "foo"}, } buf.Reset() printer.PrintObj(obj, buf) var objOut api.Pod // Verify that given function runs without error. err = unmarshalFunc(buf.Bytes(), &objOut) if err != nil { t.Fatalf("unexpected error: %#v", err) } // Use real decode function to undo the versioning process. objOut = api.Pod{} err = runtime.YAMLDecoder(testapi.Codec()).DecodeInto(buf.Bytes(), &objOut) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(obj, &objOut) { t.Errorf("Unexpected inequality:\n%v", util.ObjectDiff(obj, &objOut)) } }
func TestCreateSecurityContextNonmutating(t *testing.T) { // Create a pod with a security context that needs filling in createPod := func() *api.Pod { return &api.Pod{ Spec: api.PodSpec{ Containers: []api.Container{{ SecurityContext: &api.SecurityContext{}, }}, }, } } // Create an SCC with strategies that will populate a blank security context createSCC := func() *api.SecurityContextConstraints { var uid int64 = 1 return &api.SecurityContextConstraints{ ObjectMeta: api.ObjectMeta{ Name: "scc-sa", }, RunAsUser: api.RunAsUserStrategyOptions{ Type: api.RunAsUserStrategyMustRunAs, UID: &uid, }, SELinuxContext: api.SELinuxContextStrategyOptions{ Type: api.SELinuxStrategyMustRunAs, SELinuxOptions: &api.SELinuxOptions{User: "******"}, }, } } pod := createPod() scc := createSCC() provider, err := NewSimpleProvider(scc) if err != nil { t.Fatal("unable to create provider %v", err) } sc, err := provider.CreateSecurityContext(pod, &pod.Spec.Containers[0]) if err != nil { t.Fatal("unable to create provider %v", err) } // The generated security context should have filled in missing options, so they should differ if reflect.DeepEqual(sc, &pod.Spec.Containers[0].SecurityContext) { t.Error("expected created security context to be different than container's, but they were identical") } // Creating the provider or the security context should not have mutated the scc or pod if !reflect.DeepEqual(createPod(), pod) { diff := util.ObjectDiff(createPod(), pod) t.Errorf("pod was mutated by CreateSecurityContext. diff:\n%s", diff) } if !reflect.DeepEqual(createSCC(), scc) { t.Error("different") } }
func TestEtcdDelete(t *testing.T) { podA := &api.Pod{ ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "1"}, Status: api.PodStatus{Host: "machine"}, } nodeWithPodA := tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(testapi.Codec(), podA), ModifiedIndex: 1, CreatedIndex: 1, }, }, E: nil, } emptyNode := tools.EtcdResponseWithError{ R: &etcd.Response{}, E: tools.EtcdErrorNotFound, } path := "/registry/pods/foo" key := "foo" table := map[string]struct { existing tools.EtcdResponseWithError expect tools.EtcdResponseWithError errOK func(error) bool }{ "normal": { existing: nodeWithPodA, expect: emptyNode, errOK: func(err error) bool { return err == nil }, }, "notExisting": { existing: emptyNode, expect: emptyNode, errOK: func(err error) bool { return err == nil }, }, } for name, item := range table { fakeClient, registry := NewTestGenericEtcdRegistry(t) fakeClient.Data[path] = item.existing err := registry.Delete(api.NewContext(), key) if !item.errOK(err) { t.Errorf("%v: unexpected error: %v", name, err) } if e, a := item.expect, fakeClient.Data[path]; !reflect.DeepEqual(e, a) { t.Errorf("%v:\n%s", name, util.ObjectDiff(e, a)) } } }
func (test configCommandTest) run(t *testing.T) { _, actualConfig := testConfigCommand(test.args, test.startingConfig) testSetNilMapsToEmpties(reflect.ValueOf(&test.expectedConfig)) testSetNilMapsToEmpties(reflect.ValueOf(&actualConfig)) if !reflect.DeepEqual(test.expectedConfig, actualConfig) { t.Errorf("diff: %v", util.ObjectDiff(test.expectedConfig, actualConfig)) t.Errorf("expected: %#v\n actual: %#v", test.expectedConfig, actualConfig) } }
func TestGet_NoError(t *testing.T) { r := NewTestREST(testResponse{code: 200, data: "ok"}) got, err := r.Get(api.NewContext(), "test1") if err != nil { t.Fatalf("Unexpected error: %v", err) } expect := createTestStatus("test1", api.ConditionTrue, "ok", "nil") if e, a := expect, got; !reflect.DeepEqual(e, a) { t.Errorf("Got unexpected object. Diff: %s", util.ObjectDiff(e, a)) } }
func TestEtcdUpdateStatus(t *testing.T) { registry, status, fakeClient, etcdStorage := newStorage(t) ctx := api.NewDefaultContext() fakeClient.TestIndex = true key, _ := registry.KeyFunc(ctx, "foo") key = etcdtest.AddPrefix(key) resourcequotaStart := validNewResourceQuota() fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, resourcequotaStart), 1) resourcequotaIn := &api.ResourceQuota{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: api.NamespaceDefault, ResourceVersion: "1", }, Status: api.ResourceQuotaStatus{ Used: api.ResourceList{ api.ResourceCPU: resource.MustParse("1"), api.ResourceMemory: resource.MustParse("1Gi"), api.ResourcePods: resource.MustParse("1"), api.ResourceServices: resource.MustParse("1"), api.ResourceReplicationControllers: resource.MustParse("1"), api.ResourceQuotas: resource.MustParse("1"), }, Hard: api.ResourceList{ api.ResourceCPU: resource.MustParse("100"), api.ResourceMemory: resource.MustParse("4Gi"), api.ResourcePods: resource.MustParse("10"), api.ResourceServices: resource.MustParse("10"), api.ResourceReplicationControllers: resource.MustParse("10"), api.ResourceQuotas: resource.MustParse("1"), }, }, } expected := *resourcequotaStart expected.ResourceVersion = "2" expected.Labels = resourcequotaIn.Labels expected.Status = resourcequotaIn.Status _, _, err := status.Update(ctx, resourcequotaIn) if err != nil { t.Fatalf("Unexpected error: %v", err) } var resourcequotaOut api.ResourceQuota key, _ = registry.KeyFunc(ctx, "foo") if err := etcdStorage.Get(key, &resourcequotaOut, false); err != nil { t.Fatalf("Unexpected error: %v", err) } if !api.Semantic.DeepEqual(expected, resourcequotaOut) { t.Errorf("unexpected object: %s", util.ObjectDiff(expected, resourcequotaOut)) } }
func TestRESTgetAttrs(t *testing.T) { _, rest := NewTestREST() eventA := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "foo", Namespace: "baz", UID: "long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Condition: "Tested", Reason: "ForTesting", Source: api.EventSource{Component: "test"}, } label, field, err := rest.getAttrs(eventA) if err != nil { t.Fatalf("Unexpected error %v", err) } if e, a := label, (labels.Set{}); !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } expect := labels.Set{ "involvedObject.kind": "Pod", "involvedObject.name": "foo", "involvedObject.namespace": "baz", "involvedObject.uid": "long uid string", "involvedObject.apiVersion": testapi.Version(), "involvedObject.resourceVersion": "0", "involvedObject.fieldPath": "", "condition": "Tested", "status": "Tested", "reason": "ForTesting", "source": "test", } if e, a := expect, field; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func TestRESTList(t *testing.T) { reg, rest := NewTestREST() eventA := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "foo", UID: "long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", Source: api.EventSource{Component: "GoodSource"}, } eventB := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "bar", UID: "other long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", Source: api.EventSource{Component: "GoodSource"}, } eventC := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "baz", UID: "yet another long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", Source: api.EventSource{Component: "OtherSource"}, } reg.ObjectList = &api.EventList{ Items: []api.Event{*eventA, *eventB, *eventC}, } got, err := rest.List(api.NewContext(), labels.Everything(), fields.Set{"source": "GoodSource"}.AsSelector()) if err != nil { t.Fatalf("Unexpected error %v", err) } expect := &api.EventList{ Items: []api.Event{*eventA, *eventB}, } if e, a := expect, got; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func TestList_NoError(t *testing.T) { r := NewTestREST(testResponse{code: 200, data: "ok"}) got, err := r.List(api.NewContext(), labels.Everything(), fields.Everything()) if err != nil { t.Fatalf("Unexpected error: %v", err) } expect := &api.ComponentStatusList{ Items: []api.ComponentStatus{*(createTestStatus("test1", api.ConditionTrue, "ok", "nil"))}, } if e, a := expect, got; !reflect.DeepEqual(e, a) { t.Errorf("Got unexpected object. Diff: %s", util.ObjectDiff(e, a)) } }
func runTest(t *testing.T, codec runtime.Codec, source runtime.Object) { name := reflect.TypeOf(source).Elem().Name() apiObjectFuzzer.Fuzz(source) j, err := meta.Accessor(source) if err != nil { t.Fatalf("Unexpected error %v for %#v", err, source) } j.SetKind("") j.SetAPIVersion("") data, err := codec.Encode(source) if err != nil { t.Errorf("%v: %v (%#v)", name, err, source) return } obj2, err := codec.Decode(data) if err != nil { t.Errorf("%v: %v", name, err) return } else { if !reflect.DeepEqual(source, obj2) { t.Errorf("1: %v: diff: %v\nCodec: %v\nData: %s\nSource: %#v", name, util.ObjectDiff(source, obj2), codec, string(data), source) return } } obj3 := reflect.New(reflect.TypeOf(source).Elem()).Interface().(runtime.Object) err = codec.DecodeInto(data, obj3) if err != nil { t.Errorf("2: %v: %v", name, err) return } else { if !reflect.DeepEqual(source, obj3) { t.Errorf("3: %v: diff: %v\nCodec: %v", name, util.ObjectDiff(source, obj3), codec) return } } }
func TestRESTCreate(t *testing.T) { _, rest := NewTestREST() eventA := &api.Event{ ObjectMeta: api.ObjectMeta{Name: "foo"}, Reason: "forTesting", } c, err := rest.Create(api.NewContext(), eventA) if err != nil { t.Fatalf("Unexpected error %v", err) } if e, a := eventA, (<-c).Object; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func TestList_UnknownError(t *testing.T) { r := NewTestREST(testResponse{code: 500, data: "", err: fmt.Errorf("fizzbuzz error")}) got, err := r.List(api.NewContext(), labels.Everything(), fields.Everything()) if err != nil { t.Fatalf("Unexpected error: %v", err) } expect := &api.ComponentStatusList{ Items: []api.ComponentStatus{ *(createTestStatus("test1", api.ConditionUnknown, "", "Get http://testserver1:8000/healthz: fizzbuzz error"))}, } if e, a := expect, got; !reflect.DeepEqual(e, a) { t.Errorf("Got unexpected object. Diff: %s", util.ObjectDiff(e, a)) } }
func TestRESTWatch(t *testing.T) { secretA := testSecret("a") reg, rest := NewTestREST() wi, err := rest.Watch(api.NewContext(), labels.Everything(), fields.Everything(), "0") if err != nil { t.Fatalf("Unexpected error %v", err) } go func() { reg.Broadcaster.Action(watch.Added, secretA) }() got := <-wi.ResultChan() if e, a := secretA, got.Object; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func TestRESTGet(t *testing.T) { _, rest := NewTestREST() secretA := testSecret("foo") _, err := rest.Create(api.NewDefaultContext(), secretA) if err != nil { t.Fatalf("Unexpected error %v", err) } got, err := rest.Get(api.NewDefaultContext(), secretA.Name) if err != nil { t.Fatalf("Unexpected error %v", err) } if e, a := secretA, got; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func TestEtcdWatch(t *testing.T) { table := map[string]generic.Matcher{ "single": setMatcher{util.NewStringSet("foo")}, "multi": setMatcher{util.NewStringSet("foo", "bar")}, } for name, m := range table { podA := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: api.NamespaceDefault, ResourceVersion: "1", }, Spec: api.PodSpec{Host: "machine"}, } respWithPodA := &etcd.Response{ Node: &etcd.Node{ Key: "/registry/pods/default/foo", Value: runtime.EncodeOrDie(testapi.Codec(), podA), ModifiedIndex: 1, CreatedIndex: 1, }, Action: "create", } fakeClient, registry := NewTestGenericEtcdRegistry(t) wi, err := registry.WatchPredicate(api.NewContext(), m, "1") if err != nil { t.Errorf("%v: unexpected error: %v", name, err) continue } fakeClient.WaitForWatchCompletion() go func() { fakeClient.WatchResponse <- respWithPodA }() got, open := <-wi.ResultChan() if !open { t.Errorf("%v: unexpected channel close", name) continue } if e, a := podA, got.Object; !api.Semantic.DeepDerivative(e, a) { t.Errorf("%v: difference: %s", name, util.ObjectDiff(e, a)) } } }
func TestEtcdUpdateStatus(t *testing.T) { storage, statusStorage, fakeClient, helper := newStorage(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(latest.Codec, pvcStart), 1) pvc := &api.PersistentVolumeClaim{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: api.NamespaceDefault, ResourceVersion: "1", }, Spec: api.PersistentVolumeClaimSpec{ AccessModes: []api.PersistentVolumeAccessMode{api.ReadWriteOnce}, Resources: api.ResourceRequirements{ Requests: api.ResourceList{ api.ResourceName(api.ResourceStorage): resource.MustParse("3Gi"), }, }, }, Status: api.PersistentVolumeClaimStatus{ Phase: api.ClaimBound, }, } expected := *pvcStart expected.ResourceVersion = "2" expected.Labels = pvc.Labels expected.Status = pvc.Status _, _, err := statusStorage.Update(ctx, pvc) if err != nil { t.Fatalf("Unexpected error: %v", err) } var pvcOut api.PersistentVolumeClaim key, _ = storage.KeyFunc(ctx, "foo") if err := helper.ExtractObj(key, &pvcOut, false); err != nil { t.Fatalf("Unexpected error: %v", err) } if !api.Semantic.DeepEqual(expected, pvcOut) { t.Errorf("unexpected object: %s", util.ObjectDiff(expected, pvcOut)) } }
func TestPersistentVolumeClaimsDecode(t *testing.T) { registry, _, _, _ := newStorage(t) expected := validNewPersistentVolumeClaim("foo", api.NamespaceDefault) body, err := latest.Codec.Encode(expected) if err != nil { t.Fatalf("unexpected error: %v", err) } actual := registry.New() if err := latest.Codec.DecodeInto(body, actual); err != nil { t.Fatalf("unexpected error: %v", err) } if !api.Semantic.DeepEqual(expected, actual) { t.Errorf("mismatch: %s", util.ObjectDiff(expected, actual)) } }
func TestEndpointsDecode(t *testing.T) { storage, _ := newStorage(t) expected := validNewEndpoints() body, err := latest.Codec.Encode(expected) if err != nil { t.Fatalf("unexpected error: %v", err) } actual := storage.New() if err := latest.Codec.DecodeInto(body, actual); err != nil { t.Fatalf("unexpected error: %v", err) } if !api.Semantic.DeepEqual(expected, actual) { t.Errorf("mismatch: %s", util.ObjectDiff(expected, actual)) } }