github.com/Finschia/finschia-sdk@v0.48.1/codec/codec_common_test.go (about)

     1  package codec_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gogo/protobuf/proto"
     7  	"github.com/stretchr/testify/require"
     8  
     9  	"github.com/Finschia/finschia-sdk/codec"
    10  	"github.com/Finschia/finschia-sdk/codec/types"
    11  	"github.com/Finschia/finschia-sdk/testutil/testdata"
    12  )
    13  
    14  type interfaceMarshaler struct {
    15  	marshal   func(i proto.Message) ([]byte, error)
    16  	unmarshal func(bz []byte, ptr interface{}) error
    17  }
    18  
    19  func testInterfaceMarshaling(require *require.Assertions, cdc interfaceMarshaler, isAminoBin bool) {
    20  	_, err := cdc.marshal(nil)
    21  	require.Error(err, "can't marshal a nil value")
    22  
    23  	dog := &testdata.Dog{Name: "rufus"}
    24  	var dogI testdata.Animal = dog
    25  	bz, err := cdc.marshal(dogI)
    26  	require.NoError(err)
    27  
    28  	var animal testdata.Animal
    29  	if isAminoBin {
    30  		require.PanicsWithValue("Unmarshal expects a pointer", func() {
    31  			cdc.unmarshal(bz, animal)
    32  		})
    33  	} else {
    34  		err = cdc.unmarshal(bz, animal)
    35  		require.Error(err)
    36  		require.Contains(err.Error(), "expects a pointer")
    37  	}
    38  	require.NoError(cdc.unmarshal(bz, &animal))
    39  	require.Equal(dog, animal)
    40  
    41  	// Amino doesn't wrap into Any, so it doesn't need to register self type
    42  	if isAminoBin {
    43  		var dog2 testdata.Dog
    44  		require.NoError(cdc.unmarshal(bz, &dog2))
    45  		require.Equal(*dog, dog2)
    46  	}
    47  
    48  	var cat testdata.Cat
    49  	require.Error(cdc.unmarshal(bz, &cat))
    50  }
    51  
    52  type mustMarshaler struct {
    53  	marshal       func(i codec.ProtoMarshaler) ([]byte, error)
    54  	mustMarshal   func(i codec.ProtoMarshaler) []byte
    55  	unmarshal     func(bz []byte, ptr codec.ProtoMarshaler) error
    56  	mustUnmarshal func(bz []byte, ptr codec.ProtoMarshaler)
    57  }
    58  
    59  type testCase struct {
    60  	name         string
    61  	input        codec.ProtoMarshaler
    62  	recv         codec.ProtoMarshaler
    63  	marshalErr   bool
    64  	unmarshalErr bool
    65  }
    66  
    67  func testMarshalingTestCase(require *require.Assertions, tc testCase, m mustMarshaler) {
    68  	bz, err := m.marshal(tc.input)
    69  	if tc.marshalErr {
    70  		require.Error(err)
    71  		require.Panics(func() { m.mustMarshal(tc.input) })
    72  	} else {
    73  		var bz2 []byte
    74  		require.NoError(err)
    75  		require.NotPanics(func() { bz2 = m.mustMarshal(tc.input) })
    76  		require.Equal(bz, bz2)
    77  
    78  		err := m.unmarshal(bz, tc.recv)
    79  		if tc.unmarshalErr {
    80  			require.Error(err)
    81  			require.Panics(func() { m.mustUnmarshal(bz, tc.recv) })
    82  		} else {
    83  			require.NoError(err)
    84  			require.NotPanics(func() { m.mustUnmarshal(bz, tc.recv) })
    85  			require.Equal(tc.input, tc.recv)
    86  		}
    87  	}
    88  }
    89  
    90  func testMarshaling(t *testing.T, cdc codec.Codec) {
    91  	any, err := types.NewAnyWithValue(&testdata.Dog{Name: "rufus"})
    92  	require.NoError(t, err)
    93  
    94  	testCases := []testCase{
    95  		{
    96  			"valid encoding and decoding",
    97  			&testdata.Dog{Name: "rufus"},
    98  			&testdata.Dog{},
    99  			false,
   100  			false,
   101  		}, {
   102  			"invalid decode type",
   103  			&testdata.Dog{Name: "rufus"},
   104  			&testdata.Cat{},
   105  			false,
   106  			true,
   107  		},
   108  	}
   109  	if _, ok := cdc.(*codec.AminoCodec); ok {
   110  		testCases = append(testCases, testCase{
   111  			"any marshaling",
   112  			&testdata.HasAnimal{Animal: any},
   113  			&testdata.HasAnimal{Animal: any},
   114  			false,
   115  			false,
   116  		})
   117  	}
   118  
   119  	for _, tc := range testCases {
   120  		tc := tc
   121  		m1 := mustMarshaler{cdc.Marshal, cdc.MustMarshal, cdc.Unmarshal, cdc.MustUnmarshal}
   122  		m2 := mustMarshaler{cdc.MarshalLengthPrefixed, cdc.MustMarshalLengthPrefixed, cdc.UnmarshalLengthPrefixed, cdc.MustUnmarshalLengthPrefixed}
   123  		m3 := mustMarshaler{
   124  			func(i codec.ProtoMarshaler) ([]byte, error) { return cdc.MarshalJSON(i) },
   125  			func(i codec.ProtoMarshaler) []byte { return cdc.MustMarshalJSON(i) },
   126  			func(bz []byte, ptr codec.ProtoMarshaler) error { return cdc.UnmarshalJSON(bz, ptr) },
   127  			func(bz []byte, ptr codec.ProtoMarshaler) { cdc.MustUnmarshalJSON(bz, ptr) },
   128  		}
   129  
   130  		t.Run(tc.name+"_BinaryBare",
   131  			func(t *testing.T) { testMarshalingTestCase(require.New(t), tc, m1) })
   132  		t.Run(tc.name+"_BinaryLengthPrefixed",
   133  			func(t *testing.T) { testMarshalingTestCase(require.New(t), tc, m2) })
   134  		t.Run(tc.name+"_JSON",
   135  			func(t *testing.T) { testMarshalingTestCase(require.New(t), tc, m3) })
   136  	}
   137  }