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 } }
// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get. func TestGetSchemaObject(t *testing.T) { f, tf, _ := NewTestFactory() f.Mapper = latest.RESTMapper f.Typer = api.Scheme codec := latest.Codec tf.Printer = &testPrinter{} tf.Client = &client.FakeRESTClient{ Codec: codec, Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}})}, } buf := bytes.NewBuffer([]byte{}) cmd := f.NewCmdGet(buf) cmd.Flags().String("api-version", "v1beta3", "") cmd.Flags().String("namespace", "test", "") cmd.Run(cmd, []string{"replicationcontrollers", "foo"}) expected := &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}, Spec: api.ReplicationControllerSpec{Template: &api.PodTemplateSpec{}}} actual := tf.Printer.(*testPrinter).Obj if !reflect.DeepEqual(expected, actual) { t.Errorf("unexpected object: %s", util.ObjectGoPrintDiff(expected, actual)) } if !strings.Contains(buf.String(), "\"foo\"") { t.Errorf("unexpected output: %s", buf.String()) } }
func validateEvent(actualEvent *api.Event, expectedEvent *api.Event, t *testing.T) (*api.Event, error) { expectCompression := expectedEvent.Count > 1 // Just check that the timestamp was set. if actualEvent.FirstTimestamp.IsZero() || actualEvent.LastTimestamp.IsZero() { t.Errorf("timestamp wasn't set: %#v", *actualEvent) } if actualEvent.FirstTimestamp.Equal(actualEvent.LastTimestamp.Time) { if expectCompression { t.Errorf("FirstTimestamp (%q) and LastTimestamp (%q) must be equal to indicate only one occurance of the event, but were different. Actual Event: %#v", actualEvent.FirstTimestamp, actualEvent.LastTimestamp, *actualEvent) } } else { if !expectCompression { t.Errorf("FirstTimestamp (%q) and LastTimestamp (%q) must be different to indicate event compression happened, but were the same. Actual Event: %#v", actualEvent.FirstTimestamp, actualEvent.LastTimestamp, *actualEvent) } } actualFirstTimestamp := actualEvent.FirstTimestamp actualLastTimestamp := actualEvent.LastTimestamp // Temp clear time stamps for comparison because actual values don't matter for comparison actualEvent.FirstTimestamp = expectedEvent.FirstTimestamp actualEvent.LastTimestamp = expectedEvent.LastTimestamp // Check that name has the right prefix. if n, en := actualEvent.Name, expectedEvent.Name; !strings.HasPrefix(n, en) { t.Errorf("Name '%v' does not contain prefix '%v'", n, en) } actualEvent.Name = expectedEvent.Name if e, a := expectedEvent, actualEvent; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectGoPrintDiff(e, a)) } actualEvent.FirstTimestamp = actualFirstTimestamp actualEvent.LastTimestamp = actualLastTimestamp return actualEvent, nil }
func (r *subjectAccessTest) runTest(t *testing.T) { const namespace = "unittest" storage := REST{r.authorizer} expectedResponse := &authorizationapi.SubjectAccessReviewResponse{ Namespace: namespace, Allowed: r.authorizer.allowed, Reason: r.authorizer.reason, } expectedAttributes := &authorizer.DefaultAuthorizationAttributes{ Verb: r.reviewRequest.Verb, Resource: r.reviewRequest.Resource, } ctx := kapi.WithNamespace(kapi.NewContext(), namespace) obj, err := storage.Create(ctx, r.reviewRequest) if err != nil && len(r.authorizer.err) == 0 { t.Fatalf("unexpected error: %v", err) } if err == nil && len(r.authorizer.err) != 0 { t.Fatalf("unexpected non-error: %v", err) } switch obj.(type) { case *authorizationapi.SubjectAccessReviewResponse: if !reflect.DeepEqual(expectedResponse, obj) { t.Errorf("diff %v", util.ObjectGoPrintDiff(expectedResponse, obj)) } case nil: if len(r.authorizer.err) == 0 { t.Fatal("unexpected nil object") } default: t.Errorf("Unexpected obj type: %v", obj) } if !reflect.DeepEqual(expectedAttributes, r.authorizer.actualAttributes) { t.Errorf("diff %v", util.ObjectGoPrintDiff(expectedAttributes, r.authorizer.actualAttributes)) } }
func TestEventUpdate(t *testing.T) { eventA := &api.Event{ ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: api.NamespaceDefault}, Reason: "forTesting", } eventB := &api.Event{ ObjectMeta: api.ObjectMeta{Name: "bar", Namespace: api.NamespaceDefault}, Reason: "for testing again", } eventC := &api.Event{ ObjectMeta: api.ObjectMeta{Name: "pan", Namespace: api.NamespaceDefault, ResourceVersion: "1"}, Reason: "for testing again something else", } nodeWithEventA := tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(testapi.Codec(), eventA), ModifiedIndex: 1, CreatedIndex: 1, TTL: int64(testTTL), }, }, E: nil, } nodeWithEventB := tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(testapi.Codec(), eventB), ModifiedIndex: 1, CreatedIndex: 1, TTL: int64(testTTL), }, }, E: nil, } nodeWithEventC := tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(testapi.Codec(), eventC), ModifiedIndex: 1, CreatedIndex: 1, TTL: int64(testTTL), }, }, E: nil, } emptyNode := tools.EtcdResponseWithError{ R: &etcd.Response{}, E: tools.EtcdErrorNotFound, } ctx := api.NewDefaultContext() key := "foo" path, err := etcdgeneric.NamespaceKeyFunc(ctx, "/events", key) path = etcdtest.AddPrefix(path) if err != nil { t.Errorf("Unexpected error: %v", err) } table := map[string]struct { existing tools.EtcdResponseWithError expect tools.EtcdResponseWithError toUpdate runtime.Object errOK func(error) bool }{ "doesNotExist": { existing: emptyNode, expect: nodeWithEventA, toUpdate: eventA, errOK: func(err error) bool { return err == nil }, }, "doesNotExist2": { existing: emptyNode, expect: nodeWithEventB, toUpdate: eventB, errOK: func(err error) bool { return err == nil }, }, "replaceExisting": { existing: nodeWithEventA, expect: nodeWithEventC, toUpdate: eventC, errOK: func(err error) bool { return err == nil }, }, } for name, item := range table { fakeClient, registry := NewTestEventEtcdRegistry(t) fakeClient.Data[path] = item.existing err := registry.UpdateWithName(ctx, key, item.toUpdate) 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.ObjectGoPrintDiff(e, a)) } } }