clean up test case

codec/aminojson/json_marshaller.go

@@ -5,11 +5,12 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"io"
+
 	"github.com/pkg/errors"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/reflect/protoreflect"
 	"google.golang.org/protobuf/reflect/protoregistry"
-	"io"
 )
 
 type JSONMarshaller interface {
@@ -29,38 +30,29 @@ func (aj AminoJson) marshal(
 	value protoreflect.Value,
 	field protoreflect.FieldDescriptor,
 	writer io.Writer) error {
-	//switch message.Descriptor().FullName() {
-	//case timestampFullName:
-	//	return marshalTimestamp(writer, message)
-	//case durationFullName:
-	//	return marshalDuration(writer, message)
-	//}
-
-	//fmt.Printf("value: %v\n", value)
 
 	switch typedValue := value.Interface().(type) {
 	case protoreflect.Message:
 		return aj.marshalMessage(typedValue, writer)
 
+	case protoreflect.Map:
+		return aj.marshalMap(field, typedValue, writer)
+
+	case protoreflect.List:
+		return aj.marshalList(field, typedValue, writer)
+
 	case string, bool, int32, uint32, protoreflect.EnumNumber:
 		return invokeStdlibJSONMarshal(writer, typedValue)
 
 	case uint64, int64:
 		_, err := fmt.Fprintf(writer, `"%d"`, typedValue) // quoted
 		return err
 
-	case protoreflect.Map:
-		return aj.marshalMap(field, typedValue, writer)
-
-	case protoreflect.List:
-		return aj.marshalList(field, typedValue, writer)
-
 	case []byte:
 		_, err := fmt.Fprintf(writer, `"%s"`,
 			base64.StdEncoding.EncodeToString([]byte(typedValue)))
 		return err
 	}
-	//fmt.Printf("marshal field: %s, value: %v\n", field.FullName(), value)
 
 	return nil
 }
@@ -90,16 +82,15 @@ func (aj AminoJson) marshalMessage(msg protoreflect.Message, writer io.Writer) e
 		}
 
 		v := msg.Get(f)
-		//fmt.Printf("field: %s, value: %v\n", f.FullName(), v)
 
 		if !first {
-			_, err := writer.Write([]byte(","))
+			_, err = writer.Write([]byte(","))
 			if err != nil {
 				return err
 			}
 		}
 
-		err := invokeStdlibJSONMarshal(writer, f.Name())
+		err = invokeStdlibJSONMarshal(writer, f.Name())
 		if err != nil {
 			return err
 		}

codec/aminojson/marshal_test.go

@@ -2,15 +2,17 @@ package aminojson_test
 
 import (
 	"fmt"
-	"github.com/cosmos/cosmos-sdk/codec/aminojson"
-	"github.com/cosmos/cosmos-sdk/testutil/rapidproto"
+	"testing"
+	"time"
+
 	"github.com/stretchr/testify/require"
 	"github.com/tendermint/go-amino"
 	"google.golang.org/protobuf/encoding/protojson"
 	"google.golang.org/protobuf/proto"
 	"pgregory.net/rapid"
-	"testing"
-	"time"
+
+	"github.com/cosmos/cosmos-sdk/codec/aminojson"
+	"github.com/cosmos/cosmos-sdk/testutil/rapidproto"
 
 	"google.golang.org/protobuf/types/known/anypb"
 	"google.golang.org/protobuf/types/known/durationpb"
@@ -33,25 +35,40 @@ func TestAminonJSON_Empty(t *testing.T) {
 	assert.Equal(t, "{}", string(bz))
 }
 
-func TestAminoJSON_Failures(t *testing.T) {
-	msg := &testpb.ABitOfEverything{
-		Duration: durationpb.New(time.Second * 0),
+func TestAminoJSON_EdgeCases(t *testing.T) {
+	cases := map[string]struct {
+		msg       proto.Message
+		shouldErr bool
+	}{
+		"empty":         {msg: &testpb.ABitOfEverything{}},
+		"any type":      {msg: &testpb.ABitOfEverything{Any: &anypb.Any{}}},
+		"zero duration": {msg: &testpb.ABitOfEverything{Duration: durationpb.New(time.Second * 0)}},
 	}
-	msg2 := &testpb.ABitOfEverything{}
 
-	bz, err := aminojson.MarshalAmino(msg)
-	assert.NilError(t, err)
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			bz, err := aminojson.MarshalAmino(tc.msg)
 
-	cdc := amino.NewCodec()
-	legacyBz, err := cdc.MarshalJSON(msg)
-	assert.NilError(t, err)
+			if tc.shouldErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+
+			msg2 := &testpb.ABitOfEverything{}
+
+			cdc := amino.NewCodec()
+			legacyBz, err := cdc.MarshalJSON(tc.msg)
+			assert.NilError(t, err)
 
-	goProtoJson, err := protojson.Marshal(msg)
-	err = protojson.UnmarshalOptions{}.Unmarshal(bz, msg2)
-	assert.NilError(t, err, "protojson unmarshal failed; %s", goProtoJson)
+			goProtoJson, err := protojson.Marshal(tc.msg)
+			err = protojson.UnmarshalOptions{}.Unmarshal(bz, msg2)
+			assert.NilError(t, err, "unmarshal failed: %s vs %s", legacyBz, goProtoJson)
+
+			require.Equal(t, legacyBz, bz, "legacy: %s vs %s", legacyBz, bz)
+		})
+	}
 
-	fmt.Printf("%s vs legacy: %s\n", string(bz), string(legacyBz))
-	assert.Equal(t, string(legacyBz), string(bz))
 }
 
 func TestAminoJSON(t *testing.T) {