func HashObject(obj runtime.Object, codec runtime.Codec) (string, error) { data, err := runtime.Encode(codec, obj) if err != nil { return "", err } return fmt.Sprintf("%x", md5.Sum(data)), nil }
// Object converts a watch.Event into an appropriately serializable JSON object func Object(codec runtime.Codec, event *watch.Event) (interface{}, error) { obj, ok := event.Object.(runtime.Object) if !ok { return nil, fmt.Errorf("the event object cannot be safely converted to JSON: %v", reflect.TypeOf(event.Object).Name()) } data, err := runtime.Encode(codec, obj) if err != nil { return nil, err } return &WatchEvent{event.Type, runtime.RawExtension{RawJSON: json.RawMessage(data)}}, nil }
// Body makes the request use obj as the body. Optional. // If obj is a string, try to read a file of that name. // If obj is a []byte, send it directly. // If obj is an io.Reader, use it directly. // If obj is a runtime.Object, marshal it correctly, and set Content-Type header. // If obj is a runtime.Object and nil, do nothing. // Otherwise, set an error. func (r *Request) Body(obj interface{}) *Request { if r.err != nil { return r } switch t := obj.(type) { case string: data, err := ioutil.ReadFile(t) if err != nil { r.err = err return r } glog.V(8).Infof("Request Body: %s", string(data)) r.body = bytes.NewBuffer(data) case []byte: glog.V(8).Infof("Request Body: %s", string(t)) r.body = bytes.NewBuffer(t) case io.Reader: r.body = t case runtime.Object: // callers may pass typed interface pointers, therefore we must check nil with reflection if reflect.ValueOf(t).IsNil() { return r } data, err := runtime.Encode(r.codec, t) if err != nil { r.err = err return r } glog.V(8).Infof("Request Body: %s", string(data)) r.body = bytes.NewBuffer(data) r.SetHeader("Content-Type", "application/json") default: r.err = fmt.Errorf("unknown type used for body: %+v", obj) } return r }
// Based on: https://github.com/openshift/origin/blob/master/pkg/api/compatibility_test.go // // TestCompatibility reencodes the input using the codec for the given // version and checks for the presence of the expected keys and absent // keys in the resulting JSON. func TestCompatibility( t *testing.T, version unversioned.GroupVersion, input []byte, validator func(obj runtime.Object) field.ErrorList, expectedKeys map[string]string, absentKeys []string, ) { // Decode codec := runtime.CodecFor(api.Scheme, version) obj, err := runtime.Decode(codec, input) if err != nil { t.Fatalf("Unexpected error: %v", err) } // Validate errs := validator(obj) if len(errs) != 0 { t.Fatalf("Unexpected validation errors: %v", errs) } // Encode output, err := runtime.Encode(codec, obj) if err != nil { t.Fatalf("Unexpected error: %v", err) } // Validate old and new fields are encoded generic := map[string]interface{}{} if err := json.Unmarshal(output, &generic); err != nil { t.Fatalf("Unexpected error: %v", err) } hasError := false for k, expectedValue := range expectedKeys { keys := strings.Split(k, ".") if actualValue, ok, err := getJSONValue(generic, keys...); err != nil || !ok { t.Errorf("Unexpected error for %s: %v", k, err) hasError = true } else if !reflect.DeepEqual(expectedValue, fmt.Sprintf("%v", actualValue)) { hasError = true t.Errorf("Unexpected value for %v: expected %v, got %v", k, expectedValue, actualValue) } } for _, absentKey := range absentKeys { keys := strings.Split(absentKey, ".") actualValue, ok, err := getJSONValue(generic, keys...) if err == nil || ok { t.Errorf("Unexpected value found for for key %s: %v", absentKey, actualValue) hasError = true } } if hasError { printer := new(kubectl.JSONPrinter) printer.PrintObj(obj, os.Stdout) t.Logf("2: Encoded value: %#v", string(output)) } }