func TestValidateOk(t *testing.T) { schema, err := loadSchemaForTest() if err != nil { t.Errorf("Failed to load: %v", err) } tests := []struct { obj runtime.Object typeName string }{ {obj: &api.Pod{}}, {obj: &api.Service{}}, {obj: &api.ReplicationController{}}, } seed := rand.Int63() apiObjectFuzzer := apitesting.FuzzerFor(nil, testapi.Default.InternalGroupVersion(), rand.NewSource(seed)) for i := 0; i < 5; i++ { for _, test := range tests { testObj := test.obj apiObjectFuzzer.Fuzz(testObj) data, err := runtime.Encode(testapi.Default.Codec(), testObj) if err != nil { t.Errorf("unexpected error: %v", err) } err = schema.ValidateBytes(data) if err != nil { t.Errorf("unexpected error: %v", err) } } } }
func benchmarkItems() []api.Pod { apiObjectFuzzer := apitesting.FuzzerFor(nil, api.SchemeGroupVersion, rand.NewSource(benchmarkSeed)) items := make([]api.Pod, 3) for i := range items { apiObjectFuzzer.Fuzz(&items[i]) items[i].Spec.InitContainers, items[i].Status.InitContainerStatuses = nil, nil } return items }
func fuzzInternalObject(t *testing.T, forVersion unversioned.GroupVersion, item runtime.Object, seed int64) runtime.Object { apitesting.FuzzerFor(t, forVersion, rand.NewSource(seed)).Fuzz(item) j, err := meta.TypeAccessor(item) if err != nil { t.Fatalf("Unexpected error %v for %#v", err, item) } j.SetKind("") j.SetAPIVersion("") return item }
func benchmarkItems() []v1.Pod { apiObjectFuzzer := apitesting.FuzzerFor(nil, api.SchemeGroupVersion, rand.NewSource(benchmarkSeed)) items := make([]v1.Pod, 2) for i := range items { var pod api.Pod apiObjectFuzzer.Fuzz(&pod) pod.Spec.InitContainers, pod.Status.InitContainerStatuses = nil, nil out, err := api.Scheme.ConvertToVersion(&pod, v1.SchemeGroupVersion) if err != nil { panic(err) } items[i] = *out.(*v1.Pod) } return items }
func TestProtobufRoundTrip(t *testing.T) { obj := &v1.Pod{} apitesting.FuzzerFor(t, v1.SchemeGroupVersion, rand.NewSource(benchmarkSeed)).Fuzz(obj) // InitContainers are turned into annotations by conversion. obj.Spec.InitContainers = nil obj.Status.InitContainerStatuses = nil data, err := obj.Marshal() if err != nil { t.Fatal(err) } out := &v1.Pod{} if err := out.Unmarshal(data); err != nil { t.Fatal(err) } if !api.Semantic.Equalities.DeepEqual(out, obj) { t.Logf("marshal\n%s", hex.Dump(data)) t.Fatalf("Unmarshal is unequal\n%s", diff.ObjectGoPrintDiff(out, obj)) } }
func TestObjectWatchFraming(t *testing.T) { f := apitesting.FuzzerFor(nil, api.SchemeGroupVersion, rand.NewSource(benchmarkSeed)) secret := &api.Secret{} f.Fuzz(secret) secret.Data["binary"] = []byte{0x00, 0x10, 0x30, 0x55, 0xff, 0x00} secret.Data["utf8"] = []byte("a string with \u0345 characters") secret.Data["long"] = bytes.Repeat([]byte{0x01, 0x02, 0x03, 0x00}, 1000) converted, _ := api.Scheme.ConvertToVersion(secret, v1.SchemeGroupVersion) v1secret := converted.(*v1.Secret) for _, streamingMediaType := range api.Codecs.SupportedStreamingMediaTypes() { s, _ := api.Codecs.StreamingSerializerForMediaType(streamingMediaType, nil) framer := s.Framer embedded := s.Embedded.Serializer if embedded == nil { t.Errorf("no embedded serializer for %s", streamingMediaType) continue } innerDecode := api.Codecs.DecoderToVersion(embedded, api.SchemeGroupVersion) // write a single object through the framer and back out obj := &bytes.Buffer{} if err := s.Encode(v1secret, obj); err != nil { t.Fatal(err) } out := &bytes.Buffer{} w := framer.NewFrameWriter(out) if n, err := w.Write(obj.Bytes()); err != nil || n != len(obj.Bytes()) { t.Fatal(err) } sr := streaming.NewDecoder(framer.NewFrameReader(ioutil.NopCloser(out)), s) resultSecret := &v1.Secret{} res, _, err := sr.Decode(nil, resultSecret) if err != nil { t.Fatalf("%v:\n%s", err, hex.Dump(obj.Bytes())) } resultSecret.Kind = "Secret" resultSecret.APIVersion = "v1" if !api.Semantic.DeepEqual(v1secret, res) { t.Fatalf("objects did not match: %s", diff.ObjectGoPrintDiff(v1secret, res)) } // write a watch event through and back out obj = &bytes.Buffer{} if err := embedded.Encode(v1secret, obj); err != nil { t.Fatal(err) } event := &versioned.Event{Type: string(watch.Added)} event.Object.Raw = obj.Bytes() obj = &bytes.Buffer{} if err := s.Encode(event, obj); err != nil { t.Fatal(err) } out = &bytes.Buffer{} w = framer.NewFrameWriter(out) if n, err := w.Write(obj.Bytes()); err != nil || n != len(obj.Bytes()) { t.Fatal(err) } sr = streaming.NewDecoder(framer.NewFrameReader(ioutil.NopCloser(out)), s) outEvent := &versioned.Event{} res, _, err = sr.Decode(nil, outEvent) if err != nil || outEvent.Type != string(watch.Added) { t.Fatalf("%v: %#v", err, outEvent) } if outEvent.Object.Object == nil && outEvent.Object.Raw != nil { outEvent.Object.Object, err = runtime.Decode(innerDecode, outEvent.Object.Raw) if err != nil { t.Fatalf("%v:\n%s", err, hex.Dump(outEvent.Object.Raw)) } } if !api.Semantic.DeepEqual(secret, outEvent.Object.Object) { t.Fatalf("%s: did not match after frame decoding: %s", streamingMediaType, diff.ObjectGoPrintDiff(secret, outEvent.Object.Object)) } } }