KEP-4222: Adopt text and JSON transcoding support for CBOR.

Kubernetes-commit: 0b60c12194766e1473e65790369d5a8bcee537c6

Author: benluddy

pkg/runtime/serializer/cbor/cbor.go

@@ -152,10 +152,6 @@ func (s *serializer) encode(mode modes.EncMode, obj runtime.Object, w io.Writer)
 		v = u.UnstructuredContent()
 	}
 
-	if err := modes.RejectCustomMarshalers(v); err != nil {
-		return err
-	}
-
 	if _, err := w.Write(selfDescribedCBOR); err != nil {
 		return err
 	}
@@ -270,8 +266,6 @@ func (s *serializer) unmarshal(data []byte, into interface{}) (strict, lax error
 			}
 		}()
 		into = &content
-	} else if err := modes.RejectCustomMarshalers(into); err != nil {
-		return nil, err
 	}
 
 	if !s.options.strict {

pkg/runtime/serializer/cbor/cbor_test.go

@@ -209,38 +209,38 @@ func TestEncode(t *testing.T) {
 			},
 		},
 		{
-			name: "unsupported marshaler",
+			name: "text marshaler",
 			in:   &textMarshalerObject{},
 			assertOnWriter: func() (io.Writer, func(*testing.T)) {
 				var b bytes.Buffer
 				return &b, func(t *testing.T) {
-					if b.Len() != 0 {
-						t.Errorf("expected no bytes to be written, got %d", b.Len())
+					if diff := cmp.Diff(b.Bytes(), []byte{0xd9, 0xd9, 0xf7, 0x64, 't', 'e', 's', 't'}); diff != "" {
+						t.Errorf("unexpected diff:\n%s", diff)
 					}
 				}
 			},
 			assertOnError: func(t *testing.T, err error) {
-				if want := "unable to serialize *cbor.textMarshalerObject: *cbor.textMarshalerObject implements encoding.TextMarshaler without corresponding cbor interface"; err == nil || err.Error() != want {
-					t.Errorf("expected error %q, got: %v", want, err)
+				if err != nil {
+					t.Errorf("expected nil error, got: %v", err)
 				}
 			},
 		},
 		{
-			name: "unsupported marshaler within unstructured content",
+			name: "text marshaler within unstructured content",
 			in: &unstructured.Unstructured{
 				Object: map[string]interface{}{"": textMarshalerObject{}},
 			},
 			assertOnWriter: func() (io.Writer, func(*testing.T)) {
 				var b bytes.Buffer
 				return &b, func(t *testing.T) {
-					if b.Len() != 0 {
-						t.Errorf("expected no bytes to be written, got %d", b.Len())
+					if diff := cmp.Diff(b.Bytes(), []byte{0xd9, 0xd9, 0xf7, 0xa1, 0x40, 0x64, 't', 'e', 's', 't'}); diff != "" {
+						t.Errorf("unexpected diff:\n%s", diff)
 					}
 				}
 			},
 			assertOnError: func(t *testing.T, err error) {
-				if want := "unable to serialize map[string]interface {}: cbor.textMarshalerObject implements encoding.TextMarshaler without corresponding cbor interface"; err == nil || err.Error() != want {
-					t.Errorf("expected error %q, got: %v", want, err)
+				if err != nil {
+					t.Errorf("expected nil error, got: %v", err)
 				}
 			},
 		},
@@ -689,19 +689,6 @@ func TestDecode(t *testing.T) {
 				}
 			},
 		},
-		{
-			name:        "into unsupported marshaler",
-			data:        []byte("\xa0"),
-			into:        &textMarshalerObject{},
-			metaFactory: stubMetaFactory{gvk: &schema.GroupVersionKind{}},
-			typer:       stubTyper{gvks: []schema.GroupVersionKind{{Version: "v", Kind: "k"}}},
-			expectedGVK: &schema.GroupVersionKind{Version: "v", Kind: "k"},
-			assertOnError: func(t *testing.T, err error) {
-				if want := "unable to serialize *cbor.textMarshalerObject: *cbor.textMarshalerObject implements encoding.TextMarshaler without corresponding cbor interface"; err == nil || err.Error() != want {
-					t.Errorf("expected error %q, got: %v", want, err)
-				}
-			},
-		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			s := newSerializer(tc.metaFactory, tc.creater, tc.typer, tc.options...)
@@ -731,7 +718,7 @@ func (textMarshalerObject) DeepCopyObject() runtime.Object {
 }
 
 func (textMarshalerObject) MarshalText() ([]byte, error) {
-	return nil, nil
+	return []byte("test"), nil
 }
 
 func TestMetaFactoryInterpret(t *testing.T) {

pkg/runtime/serializer/cbor/direct/direct.go

@@ -25,31 +25,13 @@ import (
 
 // Marshal serializes a value to CBOR. If there is more than one way to encode the value, it will
 // make the same choice as the CBOR implementation of runtime.Serializer.
-//
-// Note: Support for CBOR is at an alpha stage. If the value (or, for composite types, any of its
-// nested values) implement any of the interfaces encoding.TextMarshaler, encoding.TextUnmarshaler,
-// encoding/json.Marshaler, or encoding/json.Unmarshaler, a non-nil error will be returned unless
-// the value also implements the corresponding CBOR interfaces. This limitation will ultimately be
-// removed in favor of automatic transcoding to CBOR.
-func Marshal(src interface{}) ([]byte, error) {
-	if err := modes.RejectCustomMarshalers(src); err != nil {
-		return nil, err
-	}
+func Marshal(src any) ([]byte, error) {
 	return modes.Encode.Marshal(src)
 }
 
 // Unmarshal deserializes from CBOR into an addressable value. If there is more than one way to
 // unmarshal a value, it will make the same choice as the CBOR implementation of runtime.Serializer.
-//
-// Note: Support for CBOR is at an alpha stage. If the value (or, for composite types, any of its
-// nested values) implement any of the interfaces encoding.TextMarshaler, encoding.TextUnmarshaler,
-// encoding/json.Marshaler, or encoding/json.Unmarshaler, a non-nil error will be returned unless
-// the value also implements the corresponding CBOR interfaces. This limitation will ultimately be
-// removed in favor of automatic transcoding to CBOR.
-func Unmarshal(src []byte, dst interface{}) error {
-	if err := modes.RejectCustomMarshalers(dst); err != nil {
-		return err
-	}
+func Unmarshal(src []byte, dst any) error {
 	return modes.Decode.Unmarshal(src, dst)
 }