diff --git a/Makefile b/Makefile index 25ba29ffb5c5..1a8d2bf46ecc 100644 --- a/Makefile +++ b/Makefile @@ -146,6 +146,7 @@ mocks: $(MOCKS_DIR) mockgen -source=types/router.go -package mocks -destination tests/mocks/types_router.go mockgen -source=types/handler.go -package mocks -destination tests/mocks/types_handler.go mockgen -package mocks -destination tests/mocks/grpc_server.go github.com/gogo/protobuf/grpc Server + mockgen -package mocks -destination tests/mocks/tendermint_tendermint_libs_log_DB.go github.com/tendermint/tendermint/libs/log Logger .PHONY: mocks $(MOCKS_DIR): diff --git a/go.sum b/go.sum index 3b613a29d011..fa49f96b6aba 100644 --- a/go.sum +++ b/go.sum @@ -761,6 +761,7 @@ golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200110213125-a7a6caa82ab2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa h1:5E4dL8+NgFOgjwbTKz+OOEGGhP+ectTmF842l6KjupQ= golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/tests/mocks/tendermint_tendermint_libs_log_DB.go b/tests/mocks/tendermint_tendermint_libs_log_DB.go new file mode 100644 index 000000000000..454fd9c7600d --- /dev/null +++ b/tests/mocks/tendermint_tendermint_libs_log_DB.go @@ -0,0 +1,103 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/tendermint/tendermint/libs/log (interfaces: Logger) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + gomock "github.com/golang/mock/gomock" + log "github.com/tendermint/tendermint/libs/log" + reflect "reflect" +) + +// MockLogger is a mock of Logger interface +type MockLogger struct { + ctrl *gomock.Controller + recorder *MockLoggerMockRecorder +} + +// MockLoggerMockRecorder is the mock recorder for MockLogger +type MockLoggerMockRecorder struct { + mock *MockLogger +} + +// NewMockLogger creates a new mock instance +func NewMockLogger(ctrl *gomock.Controller) *MockLogger { + mock := &MockLogger{ctrl: ctrl} + mock.recorder = &MockLoggerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockLogger) EXPECT() *MockLoggerMockRecorder { + return m.recorder +} + +// Debug mocks base method +func (m *MockLogger) Debug(arg0 string, arg1 ...interface{}) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Debug", varargs...) +} + +// Debug indicates an expected call of Debug +func (mr *MockLoggerMockRecorder) Debug(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), varargs...) +} + +// Error mocks base method +func (m *MockLogger) Error(arg0 string, arg1 ...interface{}) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Error", varargs...) +} + +// Error indicates an expected call of Error +func (mr *MockLoggerMockRecorder) Error(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), varargs...) +} + +// Info mocks base method +func (m *MockLogger) Info(arg0 string, arg1 ...interface{}) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Info", varargs...) +} + +// Info indicates an expected call of Info +func (mr *MockLoggerMockRecorder) Info(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), varargs...) +} + +// With mocks base method +func (m *MockLogger) With(arg0 ...interface{}) log.Logger { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range arg0 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "With", varargs...) + ret0, _ := ret[0].(log.Logger) + return ret0 +} + +// With indicates an expected call of With +func (mr *MockLoggerMockRecorder) With(arg0 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockLogger)(nil).With), arg0...) +} diff --git a/types/address_test.go b/types/address_test.go index ac258a2836bf..a70cd11526ce 100644 --- a/types/address_test.go +++ b/types/address_test.go @@ -9,14 +9,23 @@ import ( "testing" "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/tendermint/tendermint/crypto" - yaml "gopkg.in/yaml.v2" + "gopkg.in/yaml.v2" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" "github.com/cosmos/cosmos-sdk/types" ) +type AddressTestSuite struct { + suite.Suite +} + +func TestAddressTestSuite(t *testing.T) { + suite.Run(t, new(AddressTestSuite)) +} + var invalidStrs = []string{ "hello, world!", "0xAA", @@ -29,34 +38,33 @@ var invalidStrs = []string{ types.Bech32PrefixConsPub + "6789", } -func testMarshal(t *testing.T, original interface{}, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) { +func (s *AddressTestSuite) testMarshal(original interface{}, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) { bz, err := marshal() - require.Nil(t, err) - err = unmarshal(bz) - require.Nil(t, err) - require.Equal(t, original, res) + s.Require().Nil(err) + s.Require().Nil(unmarshal(bz)) + s.Require().Equal(original, res) } -func TestEmptyAddresses(t *testing.T) { - t.Parallel() - require.Equal(t, (types.AccAddress{}).String(), "") - require.Equal(t, (types.ValAddress{}).String(), "") - require.Equal(t, (types.ConsAddress{}).String(), "") +func (s *AddressTestSuite) TestEmptyAddresses() { + s.T().Parallel() + s.Require().Equal((types.AccAddress{}).String(), "") + s.Require().Equal((types.ValAddress{}).String(), "") + s.Require().Equal((types.ConsAddress{}).String(), "") accAddr, err := types.AccAddressFromBech32("") - require.True(t, accAddr.Empty()) - require.Error(t, err) + s.Require().True(accAddr.Empty()) + s.Require().Error(err) valAddr, err := types.ValAddressFromBech32("") - require.True(t, valAddr.Empty()) - require.Error(t, err) + s.Require().True(valAddr.Empty()) + s.Require().Error(err) consAddr, err := types.ConsAddressFromBech32("") - require.True(t, consAddr.Empty()) - require.Error(t, err) + s.Require().True(consAddr.Empty()) + s.Require().Error(err) } -func TestRandBech32PubkeyConsistency(t *testing.T) { +func (s *AddressTestSuite) TestRandBech32PubkeyConsistency() { pubBz := make([]byte, ed25519.PubKeySize) pub := &ed25519.PubKey{Key: pubBz} @@ -65,40 +73,40 @@ func TestRandBech32PubkeyConsistency(t *testing.T) { mustBech32AccPub := types.MustBech32ifyPubKey(types.Bech32PubKeyTypeAccPub, pub) bech32AccPub, err := types.Bech32ifyPubKey(types.Bech32PubKeyTypeAccPub, pub) - require.Nil(t, err) - require.Equal(t, bech32AccPub, mustBech32AccPub) + s.Require().Nil(err) + s.Require().Equal(bech32AccPub, mustBech32AccPub) mustBech32ValPub := types.MustBech32ifyPubKey(types.Bech32PubKeyTypeValPub, pub) bech32ValPub, err := types.Bech32ifyPubKey(types.Bech32PubKeyTypeValPub, pub) - require.Nil(t, err) - require.Equal(t, bech32ValPub, mustBech32ValPub) + s.Require().Nil(err) + s.Require().Equal(bech32ValPub, mustBech32ValPub) mustBech32ConsPub := types.MustBech32ifyPubKey(types.Bech32PubKeyTypeConsPub, pub) bech32ConsPub, err := types.Bech32ifyPubKey(types.Bech32PubKeyTypeConsPub, pub) - require.Nil(t, err) - require.Equal(t, bech32ConsPub, mustBech32ConsPub) + s.Require().Nil(err) + s.Require().Equal(bech32ConsPub, mustBech32ConsPub) mustAccPub := types.MustGetPubKeyFromBech32(types.Bech32PubKeyTypeAccPub, bech32AccPub) accPub, err := types.GetPubKeyFromBech32(types.Bech32PubKeyTypeAccPub, bech32AccPub) - require.Nil(t, err) - require.Equal(t, accPub, mustAccPub) + s.Require().Nil(err) + s.Require().Equal(accPub, mustAccPub) mustValPub := types.MustGetPubKeyFromBech32(types.Bech32PubKeyTypeValPub, bech32ValPub) valPub, err := types.GetPubKeyFromBech32(types.Bech32PubKeyTypeValPub, bech32ValPub) - require.Nil(t, err) - require.Equal(t, valPub, mustValPub) + s.Require().Nil(err) + s.Require().Equal(valPub, mustValPub) mustConsPub := types.MustGetPubKeyFromBech32(types.Bech32PubKeyTypeConsPub, bech32ConsPub) consPub, err := types.GetPubKeyFromBech32(types.Bech32PubKeyTypeConsPub, bech32ConsPub) - require.Nil(t, err) - require.Equal(t, consPub, mustConsPub) + s.Require().Nil(err) + s.Require().Equal(consPub, mustConsPub) - require.Equal(t, valPub, accPub) - require.Equal(t, valPub, consPub) + s.Require().Equal(valPub, accPub) + s.Require().Equal(valPub, consPub) } } -func TestYAMLMarshalers(t *testing.T) { +func (s *AddressTestSuite) TestYAMLMarshalers() { addr := secp256k1.GenPrivKey().PubKey().Address() acc := types.AccAddress(addr) @@ -106,16 +114,16 @@ func TestYAMLMarshalers(t *testing.T) { cons := types.ConsAddress(addr) got, _ := yaml.Marshal(&acc) - require.Equal(t, acc.String()+"\n", string(got)) + s.Require().Equal(acc.String()+"\n", string(got)) got, _ = yaml.Marshal(&val) - require.Equal(t, val.String()+"\n", string(got)) + s.Require().Equal(val.String()+"\n", string(got)) got, _ = yaml.Marshal(&cons) - require.Equal(t, cons.String()+"\n", string(got)) + s.Require().Equal(cons.String()+"\n", string(got)) } -func TestRandBech32AccAddrConsistency(t *testing.T) { +func (s *AddressTestSuite) TestRandBech32AccAddrConsistency() { pubBz := make([]byte, ed25519.PubKeySize) pub := &ed25519.PubKey{Key: pubBz} @@ -125,36 +133,36 @@ func TestRandBech32AccAddrConsistency(t *testing.T) { acc := types.AccAddress(pub.Address()) res := types.AccAddress{} - testMarshal(t, &acc, &res, acc.MarshalJSON, (&res).UnmarshalJSON) - testMarshal(t, &acc, &res, acc.Marshal, (&res).Unmarshal) + s.testMarshal(&acc, &res, acc.MarshalJSON, (&res).UnmarshalJSON) + s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal) str := acc.String() res, err := types.AccAddressFromBech32(str) - require.Nil(t, err) - require.Equal(t, acc, res) + s.Require().Nil(err) + s.Require().Equal(acc, res) str = hex.EncodeToString(acc) res, err = types.AccAddressFromHex(str) - require.Nil(t, err) - require.Equal(t, acc, res) + s.Require().Nil(err) + s.Require().Equal(acc, res) } for _, str := range invalidStrs { _, err := types.AccAddressFromHex(str) - require.NotNil(t, err) + s.Require().NotNil(err) _, err = types.AccAddressFromBech32(str) - require.NotNil(t, err) + s.Require().NotNil(err) err = (*types.AccAddress)(nil).UnmarshalJSON([]byte("\"" + str + "\"")) - require.NotNil(t, err) + s.Require().NotNil(err) } _, err := types.AccAddressFromHex("") - require.Equal(t, "decoding Bech32 address failed: must provide an address", err.Error()) + s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error()) } -func TestValAddr(t *testing.T) { +func (s *AddressTestSuite) TestValAddr() { pubBz := make([]byte, ed25519.PubKeySize) pub := &ed25519.PubKey{Key: pubBz} @@ -164,38 +172,38 @@ func TestValAddr(t *testing.T) { acc := types.ValAddress(pub.Address()) res := types.ValAddress{} - testMarshal(t, &acc, &res, acc.MarshalJSON, (&res).UnmarshalJSON) - testMarshal(t, &acc, &res, acc.Marshal, (&res).Unmarshal) + s.testMarshal(&acc, &res, acc.MarshalJSON, (&res).UnmarshalJSON) + s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal) str := acc.String() res, err := types.ValAddressFromBech32(str) - require.Nil(t, err) - require.Equal(t, acc, res) + s.Require().Nil(err) + s.Require().Equal(acc, res) str = hex.EncodeToString(acc) res, err = types.ValAddressFromHex(str) - require.Nil(t, err) - require.Equal(t, acc, res) + s.Require().Nil(err) + s.Require().Equal(acc, res) } for _, str := range invalidStrs { _, err := types.ValAddressFromHex(str) - require.NotNil(t, err) + s.Require().NotNil(err) _, err = types.ValAddressFromBech32(str) - require.NotNil(t, err) + s.Require().NotNil(err) err = (*types.ValAddress)(nil).UnmarshalJSON([]byte("\"" + str + "\"")) - require.NotNil(t, err) + s.Require().NotNil(err) } // test empty string _, err := types.ValAddressFromHex("") - require.Equal(t, "decoding Bech32 address failed: must provide an address", err.Error()) + s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error()) } -func TestConsAddress(t *testing.T) { +func (s *AddressTestSuite) TestConsAddress() { pubBz := make([]byte, ed25519.PubKeySize) pub := &ed25519.PubKey{Key: pubBz} @@ -205,34 +213,34 @@ func TestConsAddress(t *testing.T) { acc := types.ConsAddress(pub.Address()) res := types.ConsAddress{} - testMarshal(t, &acc, &res, acc.MarshalJSON, (&res).UnmarshalJSON) - testMarshal(t, &acc, &res, acc.Marshal, (&res).Unmarshal) + s.testMarshal(&acc, &res, acc.MarshalJSON, (&res).UnmarshalJSON) + s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal) str := acc.String() res, err := types.ConsAddressFromBech32(str) - require.Nil(t, err) - require.Equal(t, acc, res) + s.Require().Nil(err) + s.Require().Equal(acc, res) str = hex.EncodeToString(acc) res, err = types.ConsAddressFromHex(str) - require.Nil(t, err) - require.Equal(t, acc, res) + s.Require().Nil(err) + s.Require().Equal(acc, res) } for _, str := range invalidStrs { _, err := types.ConsAddressFromHex(str) - require.NotNil(t, err) + s.Require().NotNil(err) _, err = types.ConsAddressFromBech32(str) - require.NotNil(t, err) + s.Require().NotNil(err) err = (*types.ConsAddress)(nil).UnmarshalJSON([]byte("\"" + str + "\"")) - require.NotNil(t, err) + s.Require().NotNil(err) } // test empty string _, err := types.ConsAddressFromHex("") - require.Equal(t, "decoding Bech32 address failed: must provide an address", err.Error()) + s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error()) } const letterBytes = "abcdefghijklmnopqrstuvwxyz" @@ -245,7 +253,7 @@ func RandString(n int) string { return string(b) } -func TestConfiguredPrefix(t *testing.T) { +func (s *AddressTestSuite) TestConfiguredPrefix() { pubBz := make([]byte, ed25519.PubKeySize) pub := &ed25519.PubKey{Key: pubBz} for length := 1; length < 10; length++ { @@ -261,12 +269,12 @@ func TestConfiguredPrefix(t *testing.T) { prefix+types.PrefixPublic) acc := types.AccAddress(pub.Address()) - require.True(t, strings.HasPrefix( + s.Require().True(strings.HasPrefix( acc.String(), prefix+types.PrefixAccount), acc.String()) bech32Pub := types.MustBech32ifyPubKey(types.Bech32PubKeyTypeAccPub, pub) - require.True(t, strings.HasPrefix( + s.Require().True(strings.HasPrefix( bech32Pub, prefix+types.PrefixPublic)) @@ -275,12 +283,12 @@ func TestConfiguredPrefix(t *testing.T) { prefix+types.PrefixValidator+types.PrefixPublic) val := types.ValAddress(pub.Address()) - require.True(t, strings.HasPrefix( + s.Require().True(strings.HasPrefix( val.String(), prefix+types.PrefixValidator+types.PrefixAddress)) bech32ValPub := types.MustBech32ifyPubKey(types.Bech32PubKeyTypeValPub, pub) - require.True(t, strings.HasPrefix( + s.Require().True(strings.HasPrefix( bech32ValPub, prefix+types.PrefixValidator+types.PrefixPublic)) @@ -289,19 +297,19 @@ func TestConfiguredPrefix(t *testing.T) { prefix+types.PrefixConsensus+types.PrefixPublic) cons := types.ConsAddress(pub.Address()) - require.True(t, strings.HasPrefix( + s.Require().True(strings.HasPrefix( cons.String(), prefix+types.PrefixConsensus+types.PrefixAddress)) bech32ConsPub := types.MustBech32ifyPubKey(types.Bech32PubKeyTypeConsPub, pub) - require.True(t, strings.HasPrefix( + s.Require().True(strings.HasPrefix( bech32ConsPub, prefix+types.PrefixConsensus+types.PrefixPublic)) } } } -func TestAddressInterface(t *testing.T) { +func (s *AddressTestSuite) TestAddressInterface() { pubBz := make([]byte, ed25519.PubKeySize) pub := &ed25519.PubKey{Key: pubBz} rand.Read(pub.Key) @@ -316,37 +324,37 @@ func TestAddressInterface(t *testing.T) { switch addr := addr.(type) { case types.AccAddress: _, err := types.AccAddressFromBech32(addr.String()) - require.Nil(t, err) + s.Require().Nil(err) case types.ValAddress: _, err := types.ValAddressFromBech32(addr.String()) - require.Nil(t, err) + s.Require().Nil(err) case types.ConsAddress: _, err := types.ConsAddressFromBech32(addr.String()) - require.Nil(t, err) + s.Require().Nil(err) default: - t.Fail() + s.T().Fail() } } } -func TestVerifyAddressFormat(t *testing.T) { +func (s *AddressTestSuite) TestVerifyAddressFormat() { addr0 := make([]byte, 0) addr5 := make([]byte, 5) addr20 := make([]byte, 20) addr32 := make([]byte, 32) err := types.VerifyAddressFormat(addr0) - require.EqualError(t, err, "incorrect address length (expected: 20, actual: 0)") + s.Require().EqualError(err, "incorrect address length 0") err = types.VerifyAddressFormat(addr5) - require.EqualError(t, err, "incorrect address length (expected: 20, actual: 5)") + s.Require().EqualError(err, "incorrect address length 5") err = types.VerifyAddressFormat(addr20) - require.Nil(t, err) + s.Require().Nil(err) err = types.VerifyAddressFormat(addr32) - require.EqualError(t, err, "incorrect address length (expected: 20, actual: 32)") + s.Require().EqualError(err, "incorrect address length 32") } -func TestCustomAddressVerifier(t *testing.T) { +func (s *AddressTestSuite) TestCustomAddressVerifier() { // Create a 10 byte address addr := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} accBech := types.AccAddress(addr).String() @@ -354,13 +362,13 @@ func TestCustomAddressVerifier(t *testing.T) { consBech := types.ConsAddress(addr).String() // Verifiy that the default logic rejects this 10 byte address err := types.VerifyAddressFormat(addr) - require.NotNil(t, err) + s.Require().NotNil(err) _, err = types.AccAddressFromBech32(accBech) - require.NotNil(t, err) + s.Require().NotNil(err) _, err = types.ValAddressFromBech32(valBech) - require.NotNil(t, err) + s.Require().NotNil(err) _, err = types.ConsAddressFromBech32(consBech) - require.NotNil(t, err) + s.Require().NotNil(err) // Set a custom address verifier that accepts 10 or 20 byte addresses types.GetConfig().SetAddressVerifier(func(bz []byte) error { @@ -373,16 +381,16 @@ func TestCustomAddressVerifier(t *testing.T) { // Verifiy that the custom logic accepts this 10 byte address err = types.VerifyAddressFormat(addr) - require.Nil(t, err) + s.Require().Nil(err) _, err = types.AccAddressFromBech32(accBech) - require.Nil(t, err) + s.Require().Nil(err) _, err = types.ValAddressFromBech32(valBech) - require.Nil(t, err) + s.Require().Nil(err) _, err = types.ConsAddressFromBech32(consBech) - require.Nil(t, err) + s.Require().Nil(err) } -func TestBech32ifyAddressBytes(t *testing.T) { +func (s *AddressTestSuite) TestBech32ifyAddressBytes() { addr10byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19} type args struct { @@ -404,7 +412,7 @@ func TestBech32ifyAddressBytes(t *testing.T) { } for _, tt := range tests { tt := tt - t.Run(tt.name, func(t *testing.T) { + s.T().Run(tt.name, func(t *testing.T) { got, err := types.Bech32ifyAddressBytes(tt.args.prefix, tt.args.bs) if (err != nil) != tt.wantErr { t.Errorf("Bech32ifyBytes() error = %v, wantErr %v", err, tt.wantErr) @@ -415,7 +423,7 @@ func TestBech32ifyAddressBytes(t *testing.T) { } } -func TestMustBech32ifyAddressBytes(t *testing.T) { +func (s *AddressTestSuite) TestMustBech32ifyAddressBytes() { addr10byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19} type args struct { @@ -437,7 +445,7 @@ func TestMustBech32ifyAddressBytes(t *testing.T) { } for _, tt := range tests { tt := tt - t.Run(tt.name, func(t *testing.T) { + s.T().Run(tt.name, func(t *testing.T) { if tt.wantPanic { require.Panics(t, func() { types.MustBech32ifyAddressBytes(tt.args.prefix, tt.args.bs) }) return @@ -447,8 +455,7 @@ func TestMustBech32ifyAddressBytes(t *testing.T) { } } -func TestAddressTypesEquals(t *testing.T) { - t.Parallel() +func (s *AddressTestSuite) TestAddressTypesEquals() { addr1 := secp256k1.GenPrivKey().PubKey().Address() accAddr1 := types.AccAddress(addr1) consAddr1 := types.ConsAddress(addr1) @@ -460,54 +467,52 @@ func TestAddressTypesEquals(t *testing.T) { valAddr2 := types.ValAddress(addr2) // equality - require.True(t, accAddr1.Equals(accAddr1)) - require.True(t, consAddr1.Equals(consAddr1)) - require.True(t, valAddr1.Equals(valAddr1)) + s.Require().True(accAddr1.Equals(accAddr1)) + s.Require().True(consAddr1.Equals(consAddr1)) + s.Require().True(valAddr1.Equals(valAddr1)) // emptiness - require.True(t, types.AccAddress{}.Equals(types.AccAddress{})) - require.True(t, types.AccAddress{}.Equals(types.AccAddress(nil))) - require.True(t, types.AccAddress(nil).Equals(types.AccAddress{})) - require.True(t, types.AccAddress(nil).Equals(types.AccAddress(nil))) - - require.True(t, types.ConsAddress{}.Equals(types.ConsAddress{})) - require.True(t, types.ConsAddress{}.Equals(types.ConsAddress(nil))) - require.True(t, types.ConsAddress(nil).Equals(types.ConsAddress{})) - require.True(t, types.ConsAddress(nil).Equals(types.ConsAddress(nil))) - - require.True(t, types.ValAddress{}.Equals(types.ValAddress{})) - require.True(t, types.ValAddress{}.Equals(types.ValAddress(nil))) - require.True(t, types.ValAddress(nil).Equals(types.ValAddress{})) - require.True(t, types.ValAddress(nil).Equals(types.ValAddress(nil))) - - require.False(t, accAddr1.Equals(accAddr2)) - require.Equal(t, accAddr1.Equals(accAddr2), accAddr2.Equals(accAddr1)) - require.False(t, consAddr1.Equals(consAddr2)) - require.Equal(t, consAddr1.Equals(consAddr2), consAddr2.Equals(consAddr1)) - require.False(t, valAddr1.Equals(valAddr2)) - require.Equal(t, valAddr1.Equals(valAddr2), valAddr2.Equals(valAddr1)) + s.Require().True(types.AccAddress{}.Equals(types.AccAddress{})) + s.Require().True(types.AccAddress{}.Equals(types.AccAddress(nil))) + s.Require().True(types.AccAddress(nil).Equals(types.AccAddress{})) + s.Require().True(types.AccAddress(nil).Equals(types.AccAddress(nil))) + + s.Require().True(types.ConsAddress{}.Equals(types.ConsAddress{})) + s.Require().True(types.ConsAddress{}.Equals(types.ConsAddress(nil))) + s.Require().True(types.ConsAddress(nil).Equals(types.ConsAddress{})) + s.Require().True(types.ConsAddress(nil).Equals(types.ConsAddress(nil))) + + s.Require().True(types.ValAddress{}.Equals(types.ValAddress{})) + s.Require().True(types.ValAddress{}.Equals(types.ValAddress(nil))) + s.Require().True(types.ValAddress(nil).Equals(types.ValAddress{})) + s.Require().True(types.ValAddress(nil).Equals(types.ValAddress(nil))) + + s.Require().False(accAddr1.Equals(accAddr2)) + s.Require().Equal(accAddr1.Equals(accAddr2), accAddr2.Equals(accAddr1)) + s.Require().False(consAddr1.Equals(consAddr2)) + s.Require().Equal(consAddr1.Equals(consAddr2), consAddr2.Equals(consAddr1)) + s.Require().False(valAddr1.Equals(valAddr2)) + s.Require().Equal(valAddr1.Equals(valAddr2), valAddr2.Equals(valAddr1)) } -func TestNilAddressTypesEmpty(t *testing.T) { - t.Parallel() - require.True(t, types.AccAddress(nil).Empty()) - require.True(t, types.ConsAddress(nil).Empty()) - require.True(t, types.ValAddress(nil).Empty()) +func (s *AddressTestSuite) TestNilAddressTypesEmpty() { + s.Require().True(types.AccAddress(nil).Empty()) + s.Require().True(types.ConsAddress(nil).Empty()) + s.Require().True(types.ValAddress(nil).Empty()) } -func TestGetConsAddress(t *testing.T) { - t.Parallel() +func (s *AddressTestSuite) TestGetConsAddress() { pk := secp256k1.GenPrivKey().PubKey() - require.NotEqual(t, types.GetConsAddress(pk), pk.Address()) - require.True(t, bytes.Equal(types.GetConsAddress(pk).Bytes(), pk.Address().Bytes())) - require.Panics(t, func() { types.GetConsAddress(crypto.PubKey(nil)) }) + s.Require().NotEqual(types.GetConsAddress(pk), pk.Address()) + s.Require().True(bytes.Equal(types.GetConsAddress(pk).Bytes(), pk.Address().Bytes())) + s.Require().Panics(func() { types.GetConsAddress(crypto.PubKey(nil)) }) } -func TestGetFromBech32(t *testing.T) { +func (s *AddressTestSuite) TestGetFromBech32() { _, err := types.GetFromBech32("", "prefix") - require.Error(t, err) - require.Equal(t, "decoding Bech32 address failed: must provide an address", err.Error()) + s.Require().Error(err) + s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error()) _, err = types.GetFromBech32("cosmos1qqqsyqcyq5rqwzqfys8f67", "x") - require.Error(t, err) - require.Equal(t, "invalid Bech32 prefix; expected x, got cosmos", err.Error()) + s.Require().Error(err) + s.Require().Equal("invalid Bech32 prefix; expected x, got cosmos", err.Error()) } diff --git a/types/coin_test.go b/types/coin_test.go index fb4b9c4f1f78..91a1fd47e7b1 100644 --- a/types/coin_test.go +++ b/types/coin_test.go @@ -1,14 +1,14 @@ -package types +package types_test import ( "fmt" "strings" "testing" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" ) var ( @@ -16,47 +16,55 @@ var ( testDenom2 = "muon" ) +type CoinTestSuite struct { + suite.Suite +} + +func TestCoinTestSuite(t *testing.T) { + suite.Run(t, new(CoinTestSuite)) +} + // ---------------------------------------------------------------------------- // Coin tests -func TestCoin(t *testing.T) { - require.Panics(t, func() { NewInt64Coin(testDenom1, -1) }) - require.Panics(t, func() { NewCoin(testDenom1, NewInt(-1)) }) - require.Equal(t, NewInt(10), NewInt64Coin(strings.ToUpper(testDenom1), 10).Amount) - require.Equal(t, NewInt(10), NewCoin(strings.ToUpper(testDenom1), NewInt(10)).Amount) - require.Equal(t, NewInt(5), NewInt64Coin(testDenom1, 5).Amount) - require.Equal(t, NewInt(5), NewCoin(testDenom1, NewInt(5)).Amount) +func (s *CoinTestSuite) TestCoin() { + s.Require().Panics(func() { sdk.NewInt64Coin(testDenom1, -1) }) + s.Require().Panics(func() { sdk.NewCoin(testDenom1, sdk.NewInt(-1)) }) + s.Require().Equal(sdk.NewInt(10), sdk.NewInt64Coin(strings.ToUpper(testDenom1), 10).Amount) + s.Require().Equal(sdk.NewInt(10), sdk.NewCoin(strings.ToUpper(testDenom1), sdk.NewInt(10)).Amount) + s.Require().Equal(sdk.NewInt(5), sdk.NewInt64Coin(testDenom1, 5).Amount) + s.Require().Equal(sdk.NewInt(5), sdk.NewCoin(testDenom1, sdk.NewInt(5)).Amount) } -func TestCoin_String(t *testing.T) { - coin := NewCoin(testDenom1, NewInt(10)) - require.Equal(t, fmt.Sprintf("10%s", testDenom1), coin.String()) +func (s *CoinTestSuite) TestCoin_String() { + coin := sdk.NewCoin(testDenom1, sdk.NewInt(10)) + s.Require().Equal(fmt.Sprintf("10%s", testDenom1), coin.String()) } -func TestIsEqualCoin(t *testing.T) { +func (s *CoinTestSuite) TestIsEqualCoin() { cases := []struct { - inputOne Coin - inputTwo Coin + inputOne sdk.Coin + inputTwo sdk.Coin expected bool panics bool }{ - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 1), true, false}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom2, 1), false, true}, - {NewInt64Coin("stake", 1), NewInt64Coin("stake", 10), false, false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), true, false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), false, true}, + {sdk.NewInt64Coin("stake", 1), sdk.NewInt64Coin("stake", 10), false, false}, } for tcIndex, tc := range cases { tc := tc if tc.panics { - require.Panics(t, func() { tc.inputOne.IsEqual(tc.inputTwo) }) + s.Require().Panics(func() { tc.inputOne.IsEqual(tc.inputTwo) }) } else { res := tc.inputOne.IsEqual(tc.inputTwo) - require.Equal(t, tc.expected, res, "coin equality relation is incorrect, tc #%d", tcIndex) + s.Require().Equal(tc.expected, res, "coin equality relation is incorrect, tc #%d", tcIndex) } } } -func TestCoinIsValid(t *testing.T) { +func (s *CoinTestSuite) TestCoinIsValid() { loremIpsum := `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra dui vel nulla aliquet, non dictum elit aliquam. Proin consequat leo in consectetur mattis. Phasellus eget odio luctus, rutrum dolor at, venenatis ante. Praesent metus erat, sodales vitae sagittis eget, commodo non ipsum. Duis eget urna quis erat mattis pulvinar. Vivamus egestas imperdiet sem, porttitor hendrerit lorem pulvinar in. Vivamus laoreet sapien eget libero euismod tristique. Suspendisse tincidunt nulla quis luctus mattis. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed id turpis at erat placerat fermentum id sed sapien. Fusce mattis enim id nulla viverra, eget placerat eros aliquet. Nunc fringilla urna ac condimentum ultricies. Praesent in eros ac neque fringilla sodales. Donec ut venenatis eros. Quisque iaculis lectus neque, a varius sem ullamcorper nec. Cras tincidunt dignissim libero nec volutpat. Donec molestie enim sed metus venenatis, quis elementum sem varius. Curabitur eu venenatis nulla. Cras sit amet ligula vel turpis placerat sollicitudin. Nunc massa odio, eleifend id lacus nec, ultricies elementum arcu. Donec imperdiet nulla lacus, a venenatis lacus fermentum nec. Proin vestibulum dolor enim, vitae posuere velit aliquet non. Suspendisse pharetra condimentum nunc tincidunt viverra. Etiam posuere, ligula ut maximus congue, mauris orci consectetur velit, vel finibus eros metus non tellus. Nullam et dictum metus. Aliquam maximus fermentum mauris elementum aliquet. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Etiam dapibus lectus sed tellus rutrum tincidunt. Nulla at dolor sem. Ut non dictum arcu, eget congue sem.` @@ -66,180 +74,180 @@ func TestCoinIsValid(t *testing.T) { loremIpsum = strings.ReplaceAll(loremIpsum, ",", "") cases := []struct { - coin Coin + coin sdk.Coin expectPass bool }{ - {Coin{testDenom1, NewInt(-1)}, false}, - {Coin{testDenom1, NewInt(0)}, true}, - {Coin{testDenom1, OneInt()}, true}, - {Coin{"Atom", OneInt()}, true}, - {Coin{"ATOM", OneInt()}, true}, - {Coin{"a", OneInt()}, false}, - {Coin{loremIpsum, OneInt()}, false}, - {Coin{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", OneInt()}, true}, - {Coin{"atOm", OneInt()}, true}, - {Coin{" ", OneInt()}, false}, + {sdk.Coin{testDenom1, sdk.NewInt(-1)}, false}, + {sdk.Coin{testDenom1, sdk.NewInt(0)}, true}, + {sdk.Coin{testDenom1, sdk.OneInt()}, true}, + {sdk.Coin{"Atom", sdk.OneInt()}, true}, + {sdk.Coin{"ATOM", sdk.OneInt()}, true}, + {sdk.Coin{"a", sdk.OneInt()}, false}, + {sdk.Coin{loremIpsum, sdk.OneInt()}, false}, + {sdk.Coin{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", sdk.OneInt()}, true}, + {sdk.Coin{"atOm", sdk.OneInt()}, true}, + {sdk.Coin{" ", sdk.OneInt()}, false}, } for i, tc := range cases { - require.Equal(t, tc.expectPass, tc.coin.IsValid(), "unexpected result for IsValid, tc #%d", i) + s.Require().Equal(tc.expectPass, tc.coin.IsValid(), "unexpected result for IsValid, tc #%d", i) } } -func TestAddCoin(t *testing.T) { +func (s *CoinTestSuite) TestAddCoin() { cases := []struct { - inputOne Coin - inputTwo Coin - expected Coin + inputOne sdk.Coin + inputTwo sdk.Coin + expected sdk.Coin shouldPanic bool }{ - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 2), false}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom1, 1), false}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom2, 1), NewInt64Coin(testDenom1, 1), true}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 2), false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom1, 1), false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), sdk.NewInt64Coin(testDenom1, 1), true}, } for tcIndex, tc := range cases { tc := tc if tc.shouldPanic { - require.Panics(t, func() { tc.inputOne.Add(tc.inputTwo) }) + s.Require().Panics(func() { tc.inputOne.Add(tc.inputTwo) }) } else { res := tc.inputOne.Add(tc.inputTwo) - require.Equal(t, tc.expected, res, "sum of coins is incorrect, tc #%d", tcIndex) + s.Require().Equal(tc.expected, res, "sum of coins is incorrect, tc #%d", tcIndex) } } } -func TestSubCoin(t *testing.T) { +func (s *CoinTestSuite) TestSubCoin() { cases := []struct { - inputOne Coin - inputTwo Coin - expected Coin + inputOne sdk.Coin + inputTwo sdk.Coin + expected sdk.Coin shouldPanic bool }{ - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom2, 1), NewInt64Coin(testDenom1, 1), true}, - {NewInt64Coin(testDenom1, 10), NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 9), false}, - {NewInt64Coin(testDenom1, 5), NewInt64Coin(testDenom1, 3), NewInt64Coin(testDenom1, 2), false}, - {NewInt64Coin(testDenom1, 5), NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom1, 5), false}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 5), Coin{}, true}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), sdk.NewInt64Coin(testDenom1, 1), true}, + {sdk.NewInt64Coin(testDenom1, 10), sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 9), false}, + {sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt64Coin(testDenom1, 3), sdk.NewInt64Coin(testDenom1, 2), false}, + {sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom1, 5), false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 5), sdk.Coin{}, true}, } for tcIndex, tc := range cases { tc := tc if tc.shouldPanic { - require.Panics(t, func() { tc.inputOne.Sub(tc.inputTwo) }) + s.Require().Panics(func() { tc.inputOne.Sub(tc.inputTwo) }) } else { res := tc.inputOne.Sub(tc.inputTwo) - require.Equal(t, tc.expected, res, "difference of coins is incorrect, tc #%d", tcIndex) + s.Require().Equal(tc.expected, res, "difference of coins is incorrect, tc #%d", tcIndex) } } tc := struct { - inputOne Coin - inputTwo Coin + inputOne sdk.Coin + inputTwo sdk.Coin expected int64 - }{NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 1), 0} + }{sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), 0} res := tc.inputOne.Sub(tc.inputTwo) - require.Equal(t, tc.expected, res.Amount.Int64()) + s.Require().Equal(tc.expected, res.Amount.Int64()) } -func TestIsGTECoin(t *testing.T) { +func (s *CoinTestSuite) TestIsGTECoin() { cases := []struct { - inputOne Coin - inputTwo Coin + inputOne sdk.Coin + inputTwo sdk.Coin expected bool panics bool }{ - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 1), true, false}, - {NewInt64Coin(testDenom1, 2), NewInt64Coin(testDenom1, 1), true, false}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom2, 1), false, true}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), true, false}, + {sdk.NewInt64Coin(testDenom1, 2), sdk.NewInt64Coin(testDenom1, 1), true, false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), false, true}, } for tcIndex, tc := range cases { tc := tc if tc.panics { - require.Panics(t, func() { tc.inputOne.IsGTE(tc.inputTwo) }) + s.Require().Panics(func() { tc.inputOne.IsGTE(tc.inputTwo) }) } else { res := tc.inputOne.IsGTE(tc.inputTwo) - require.Equal(t, tc.expected, res, "coin GTE relation is incorrect, tc #%d", tcIndex) + s.Require().Equal(tc.expected, res, "coin GTE relation is incorrect, tc #%d", tcIndex) } } } -func TestIsLTCoin(t *testing.T) { +func (s *CoinTestSuite) TestIsLTCoin() { cases := []struct { - inputOne Coin - inputTwo Coin + inputOne sdk.Coin + inputTwo sdk.Coin expected bool panics bool }{ - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 1), false, false}, - {NewInt64Coin(testDenom1, 2), NewInt64Coin(testDenom1, 1), false, false}, - {NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 1), false, true}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom2, 1), false, true}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 1), false, false}, - {NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 2), true, false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), false, false}, + {sdk.NewInt64Coin(testDenom1, 2), sdk.NewInt64Coin(testDenom1, 1), false, false}, + {sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1), false, true}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom2, 1), false, true}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 1), false, false}, + {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt64Coin(testDenom1, 2), true, false}, } for tcIndex, tc := range cases { tc := tc if tc.panics { - require.Panics(t, func() { tc.inputOne.IsLT(tc.inputTwo) }) + s.Require().Panics(func() { tc.inputOne.IsLT(tc.inputTwo) }) } else { res := tc.inputOne.IsLT(tc.inputTwo) - require.Equal(t, tc.expected, res, "coin LT relation is incorrect, tc #%d", tcIndex) + s.Require().Equal(tc.expected, res, "coin LT relation is incorrect, tc #%d", tcIndex) } } } -func TestCoinIsZero(t *testing.T) { - coin := NewInt64Coin(testDenom1, 0) +func (s *CoinTestSuite) TestCoinIsZero() { + coin := sdk.NewInt64Coin(testDenom1, 0) res := coin.IsZero() - require.True(t, res) + s.Require().True(res) - coin = NewInt64Coin(testDenom1, 1) + coin = sdk.NewInt64Coin(testDenom1, 1) res = coin.IsZero() - require.False(t, res) + s.Require().False(res) } -func TestFilteredZeroCoins(t *testing.T) { +func (s *CoinTestSuite) TestFilteredZeroCoins() { cases := []struct { name string - input Coins + input sdk.Coins original string expected string }{ { name: "all greater than zero", - input: Coins{ - {"testa", OneInt()}, - {"testb", NewInt(2)}, - {"testc", NewInt(3)}, - {"testd", NewInt(4)}, - {"teste", NewInt(5)}, + input: sdk.Coins{ + {"testa", sdk.OneInt()}, + {"testb", sdk.NewInt(2)}, + {"testc", sdk.NewInt(3)}, + {"testd", sdk.NewInt(4)}, + {"teste", sdk.NewInt(5)}, }, original: "1testa,2testb,3testc,4testd,5teste", expected: "1testa,2testb,3testc,4testd,5teste", }, { name: "zero coin in middle", - input: Coins{ - {"testa", OneInt()}, - {"testb", NewInt(2)}, - {"testc", NewInt(0)}, - {"testd", NewInt(4)}, - {"teste", NewInt(5)}, + input: sdk.Coins{ + {"testa", sdk.OneInt()}, + {"testb", sdk.NewInt(2)}, + {"testc", sdk.NewInt(0)}, + {"testd", sdk.NewInt(4)}, + {"teste", sdk.NewInt(5)}, }, original: "1testa,2testb,0testc,4testd,5teste", expected: "1testa,2testb,4testd,5teste", }, { name: "zero coin end (unordered)", - input: Coins{ - {"teste", NewInt(5)}, - {"testc", NewInt(3)}, - {"testa", OneInt()}, - {"testd", NewInt(4)}, - {"testb", NewInt(0)}, + input: sdk.Coins{ + {"teste", sdk.NewInt(5)}, + {"testc", sdk.NewInt(3)}, + {"testa", sdk.OneInt()}, + {"testd", sdk.NewInt(4)}, + {"testb", sdk.NewInt(0)}, }, original: "5teste,3testc,1testa,4testd,0testb", expected: "1testa,3testc,4testd,5teste", @@ -247,314 +255,308 @@ func TestFilteredZeroCoins(t *testing.T) { } for _, tt := range cases { - tt := tt - t.Run(tt.name, func(t *testing.T) { - undertest := NewCoins(tt.input...) - require.Equal(t, tt.expected, undertest.String(), "NewCoins must return expected results") - require.Equal(t, tt.original, tt.input.String(), "input must be unmodified and match original") - }) + undertest := sdk.NewCoins(tt.input...) + s.Require().Equal(tt.expected, undertest.String(), "NewCoins must return expected results") + s.Require().Equal(tt.original, tt.input.String(), "input must be unmodified and match original") } } // ---------------------------------------------------------------------------- // Coins tests -func TestCoins_String(t *testing.T) { +func (s *CoinTestSuite) TestCoins_String() { cases := []struct { name string - input Coins + input sdk.Coins expected string }{ { "empty coins", - Coins{}, + sdk.Coins{}, "", }, { "single coin", - Coins{{"tree", OneInt()}}, + sdk.Coins{{"tree", sdk.OneInt()}}, "1tree", }, { "multiple coins", - Coins{ - {"tree", OneInt()}, - {"gas", OneInt()}, - {"mineral", OneInt()}, + sdk.Coins{ + {"tree", sdk.OneInt()}, + {"gas", sdk.OneInt()}, + {"mineral", sdk.OneInt()}, }, "1tree,1gas,1mineral", }, } for _, tt := range cases { - tt := tt - t.Run(tt.name, func(t *testing.T) { - require.Equal(t, tt.expected, tt.input.String()) - }) + s.Require().Equal(tt.expected, tt.input.String()) } } -func TestIsZeroCoins(t *testing.T) { +func (s *CoinTestSuite) TestIsZeroCoins() { cases := []struct { - inputOne Coins + inputOne sdk.Coins expected bool }{ - {Coins{}, true}, - {Coins{NewInt64Coin(testDenom1, 0)}, true}, - {Coins{NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 0)}, true}, - {Coins{NewInt64Coin(testDenom1, 1)}, false}, - {Coins{NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 1)}, false}, + {sdk.Coins{}, true}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, true}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 0)}, true}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 1)}, false}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, false}, } for _, tc := range cases { res := tc.inputOne.IsZero() - require.Equal(t, tc.expected, res) + s.Require().Equal(tc.expected, res) } } -func TestEqualCoins(t *testing.T) { +func (s *CoinTestSuite) TestEqualCoins() { cases := []struct { - inputOne Coins - inputTwo Coins + inputOne sdk.Coins + inputTwo sdk.Coins expected bool panics bool }{ - {Coins{}, Coins{}, true, false}, - {Coins{NewInt64Coin(testDenom1, 0)}, Coins{NewInt64Coin(testDenom1, 0)}, true, false}, - {Coins{NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 1)}, Coins{NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 1)}, true, false}, - {Coins{NewInt64Coin(testDenom1, 0)}, Coins{NewInt64Coin(testDenom2, 0)}, false, true}, - {Coins{NewInt64Coin(testDenom1, 0)}, Coins{NewInt64Coin(testDenom1, 1)}, false, false}, - {Coins{NewInt64Coin(testDenom1, 0)}, Coins{NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 1)}, false, false}, - {Coins{NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 1)}, Coins{NewInt64Coin(testDenom1, 0), NewInt64Coin(testDenom2, 1)}, true, false}, + {sdk.Coins{}, sdk.Coins{}, true, false}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, true, false}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, true, false}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom2, 0)}, false, true}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 1)}, false, false}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, false, false}, + {sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, sdk.Coins{sdk.NewInt64Coin(testDenom1, 0), sdk.NewInt64Coin(testDenom2, 1)}, true, false}, } for tcnum, tc := range cases { tc := tc if tc.panics { - require.Panics(t, func() { tc.inputOne.IsEqual(tc.inputTwo) }) + s.Require().Panics(func() { tc.inputOne.IsEqual(tc.inputTwo) }) } else { res := tc.inputOne.IsEqual(tc.inputTwo) - require.Equal(t, tc.expected, res, "Equality is differed from exported. tc #%d, expected %b, actual %b.", tcnum, tc.expected, res) + s.Require().Equal(tc.expected, res, "Equality is differed from exported. tc #%d, expected %b, actual %b.", tcnum, tc.expected, res) } } } -func TestAddCoins(t *testing.T) { - zero := NewInt(0) - one := OneInt() - two := NewInt(2) +func (s *CoinTestSuite) TestAddCoins() { + zero := sdk.NewInt(0) + one := sdk.OneInt() + two := sdk.NewInt(2) cases := []struct { - inputOne Coins - inputTwo Coins - expected Coins + inputOne sdk.Coins + inputTwo sdk.Coins + expected sdk.Coins }{ - {Coins{{testDenom1, one}, {testDenom2, one}}, Coins{{testDenom1, one}, {testDenom2, one}}, Coins{{testDenom1, two}, {testDenom2, two}}}, - {Coins{{testDenom1, zero}, {testDenom2, one}}, Coins{{testDenom1, zero}, {testDenom2, zero}}, Coins{{testDenom2, one}}}, - {Coins{{testDenom1, two}}, Coins{{testDenom2, zero}}, Coins{{testDenom1, two}}}, - {Coins{{testDenom1, one}}, Coins{{testDenom1, one}, {testDenom2, two}}, Coins{{testDenom1, two}, {testDenom2, two}}}, - {Coins{{testDenom1, zero}, {testDenom2, zero}}, Coins{{testDenom1, zero}, {testDenom2, zero}}, Coins(nil)}, + {sdk.Coins{{testDenom1, one}, {testDenom2, one}}, sdk.Coins{{testDenom1, one}, {testDenom2, one}}, sdk.Coins{{testDenom1, two}, {testDenom2, two}}}, + {sdk.Coins{{testDenom1, zero}, {testDenom2, one}}, sdk.Coins{{testDenom1, zero}, {testDenom2, zero}}, sdk.Coins{{testDenom2, one}}}, + {sdk.Coins{{testDenom1, two}}, sdk.Coins{{testDenom2, zero}}, sdk.Coins{{testDenom1, two}}}, + {sdk.Coins{{testDenom1, one}}, sdk.Coins{{testDenom1, one}, {testDenom2, two}}, sdk.Coins{{testDenom1, two}, {testDenom2, two}}}, + {sdk.Coins{{testDenom1, zero}, {testDenom2, zero}}, sdk.Coins{{testDenom1, zero}, {testDenom2, zero}}, sdk.Coins(nil)}, } for tcIndex, tc := range cases { res := tc.inputOne.Add(tc.inputTwo...) - assert.True(t, res.IsValid()) - require.Equal(t, tc.expected, res, "sum of coins is incorrect, tc #%d", tcIndex) + s.Require().True(res.IsValid()) + s.Require().Equal(tc.expected, res, "sum of coins is incorrect, tc #%d", tcIndex) } } -func TestSubCoins(t *testing.T) { - zero := NewInt(0) - one := OneInt() - two := NewInt(2) +func (s *CoinTestSuite) TestSubCoins() { + zero := sdk.NewInt(0) + one := sdk.OneInt() + two := sdk.NewInt(2) testCases := []struct { - inputOne Coins - inputTwo Coins - expected Coins + inputOne sdk.Coins + inputTwo sdk.Coins + expected sdk.Coins shouldPanic bool }{ - {Coins{{testDenom1, two}}, Coins{{testDenom1, one}, {testDenom2, two}}, Coins{{testDenom1, one}, {testDenom2, two}}, true}, - {Coins{{testDenom1, two}}, Coins{{testDenom2, zero}}, Coins{{testDenom1, two}}, false}, - {Coins{{testDenom1, one}}, Coins{{testDenom2, zero}}, Coins{{testDenom1, one}}, false}, - {Coins{{testDenom1, one}, {testDenom2, one}}, Coins{{testDenom1, one}}, Coins{{testDenom2, one}}, false}, - {Coins{{testDenom1, one}, {testDenom2, one}}, Coins{{testDenom1, two}}, Coins{}, true}, + {sdk.Coins{{testDenom1, two}}, sdk.Coins{{testDenom1, one}, {testDenom2, two}}, sdk.Coins{{testDenom1, one}, {testDenom2, two}}, true}, + {sdk.Coins{{testDenom1, two}}, sdk.Coins{{testDenom2, zero}}, sdk.Coins{{testDenom1, two}}, false}, + {sdk.Coins{{testDenom1, one}}, sdk.Coins{{testDenom2, zero}}, sdk.Coins{{testDenom1, one}}, false}, + {sdk.Coins{{testDenom1, one}, {testDenom2, one}}, sdk.Coins{{testDenom1, one}}, sdk.Coins{{testDenom2, one}}, false}, + {sdk.Coins{{testDenom1, one}, {testDenom2, one}}, sdk.Coins{{testDenom1, two}}, sdk.Coins{}, true}, } for i, tc := range testCases { tc := tc if tc.shouldPanic { - require.Panics(t, func() { tc.inputOne.Sub(tc.inputTwo) }) + s.Require().Panics(func() { tc.inputOne.Sub(tc.inputTwo) }) } else { res := tc.inputOne.Sub(tc.inputTwo) - assert.True(t, res.IsValid()) - require.Equal(t, tc.expected, res, "sum of coins is incorrect, tc #%d", i) + s.Require().True(res.IsValid()) + s.Require().Equal(tc.expected, res, "sum of coins is incorrect, tc #%d", i) } } } -func TestCoins_Validate(t *testing.T) { +func (s *CoinTestSuite) TestCoins_Validate() { testCases := []struct { name string - coins Coins + coins sdk.Coins expPass bool }{ { "valid lowercase coins", - Coins{ - {"gas", OneInt()}, - {"mineral", OneInt()}, - {"tree", OneInt()}, + sdk.Coins{ + {"gas", sdk.OneInt()}, + {"mineral", sdk.OneInt()}, + {"tree", sdk.OneInt()}, }, true, }, { "valid uppercase coins", - Coins{ - {"GAS", OneInt()}, - {"MINERAL", OneInt()}, - {"TREE", OneInt()}, + sdk.Coins{ + {"GAS", sdk.OneInt()}, + {"MINERAL", sdk.OneInt()}, + {"TREE", sdk.OneInt()}, }, true, }, { "valid uppercase coin", - Coins{ - {"ATOM", OneInt()}, + sdk.Coins{ + {"ATOM", sdk.OneInt()}, }, true, }, { "valid lower and uppercase coins (1)", - Coins{ - {"GAS", OneInt()}, - {"gAs", OneInt()}, + sdk.Coins{ + {"GAS", sdk.OneInt()}, + {"gAs", sdk.OneInt()}, }, true, }, { "valid lower and uppercase coins (2)", - Coins{ - {"ATOM", OneInt()}, - {"Atom", OneInt()}, - {"atom", OneInt()}, + sdk.Coins{ + {"ATOM", sdk.OneInt()}, + {"Atom", sdk.OneInt()}, + {"atom", sdk.OneInt()}, }, true, }, { "mixed case (1)", - Coins{ - {"MineraL", OneInt()}, - {"TREE", OneInt()}, - {"gAs", OneInt()}, + sdk.Coins{ + {"MineraL", sdk.OneInt()}, + {"TREE", sdk.OneInt()}, + {"gAs", sdk.OneInt()}, }, true, }, { "mixed case (2)", - Coins{ - {"gAs", OneInt()}, - {"mineral", OneInt()}, + sdk.Coins{ + {"gAs", sdk.OneInt()}, + {"mineral", sdk.OneInt()}, }, true, }, { "mixed case (3)", - Coins{ - {"gAs", OneInt()}, + sdk.Coins{ + {"gAs", sdk.OneInt()}, }, true, }, { "unicode letters and numbers", - Coins{ - {"𐀀𐀆𐀉Ⅲ", OneInt()}, + sdk.Coins{ + {"𐀀𐀆𐀉Ⅲ", sdk.OneInt()}, }, false, }, { "emojis", - Coins{ - {"🤑😋🤔", OneInt()}, + sdk.Coins{ + {"🤑😋🤔", sdk.OneInt()}, }, false, }, { "IBC denominations (ADR 001)", - Coins{ - {"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", OneInt()}, - {"ibc/876563AAAACF739EB061C67CDB5EDF2B7C9FD4AA9D876450CC21210807C2820A", NewInt(2)}, + sdk.Coins{ + {"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", sdk.OneInt()}, + {"ibc/876563AAAACF739EB061C67CDB5EDF2B7C9FD4AA9D876450CC21210807C2820A", sdk.NewInt(2)}, }, true, }, { "empty (1)", - NewCoins(), + sdk.NewCoins(), true, }, { "empty (2)", - Coins{}, + sdk.Coins{}, true, }, { "invalid denomination (1)", - Coins{ - {"MineraL", OneInt()}, - {"0TREE", OneInt()}, - {"gAs", OneInt()}, + sdk.Coins{ + {"MineraL", sdk.OneInt()}, + {"0TREE", sdk.OneInt()}, + {"gAs", sdk.OneInt()}, }, false, }, { "invalid denomination (2)", - Coins{ - {"-GAS", OneInt()}, - {"gAs", OneInt()}, + sdk.Coins{ + {"-GAS", sdk.OneInt()}, + {"gAs", sdk.OneInt()}, }, false, }, { "bad sort (1)", - Coins{ - {"tree", OneInt()}, - {"gas", OneInt()}, - {"mineral", OneInt()}, + sdk.Coins{ + {"tree", sdk.OneInt()}, + {"gas", sdk.OneInt()}, + {"mineral", sdk.OneInt()}, }, false, }, { "bad sort (2)", - Coins{ - {"gas", OneInt()}, - {"tree", OneInt()}, - {"mineral", OneInt()}, + sdk.Coins{ + {"gas", sdk.OneInt()}, + {"tree", sdk.OneInt()}, + {"mineral", sdk.OneInt()}, }, false, }, { "non-positive amount (1)", - Coins{ - {"gas", OneInt()}, - {"tree", NewInt(0)}, - {"mineral", OneInt()}, + sdk.Coins{ + {"gas", sdk.OneInt()}, + {"tree", sdk.NewInt(0)}, + {"mineral", sdk.OneInt()}, }, false, }, { "non-positive amount (2)", - Coins{ - {"gas", NewInt(-1)}, - {"tree", OneInt()}, - {"mineral", OneInt()}, + sdk.Coins{ + {"gas", sdk.NewInt(-1)}, + {"tree", sdk.OneInt()}, + {"mineral", sdk.OneInt()}, }, false, }, { "duplicate denomination", - Coins{ - {"gas", OneInt()}, - {"gas", OneInt()}, - {"mineral", OneInt()}, + sdk.Coins{ + {"gas", sdk.OneInt()}, + {"gas", sdk.OneInt()}, + {"mineral", sdk.OneInt()}, }, false, }, @@ -563,126 +565,126 @@ func TestCoins_Validate(t *testing.T) { for _, tc := range testCases { err := tc.coins.Validate() if tc.expPass { - require.NoError(t, err, tc.name) + s.Require().NoError(err, tc.name) } else { - require.Error(t, err, tc.name) + s.Require().Error(err, tc.name) } } } -func TestCoinsGT(t *testing.T) { - one := OneInt() - two := NewInt(2) +func (s *CoinTestSuite) TestCoinsGT() { + one := sdk.OneInt() + two := sdk.NewInt(2) - assert.False(t, Coins{}.IsAllGT(Coins{})) - assert.True(t, Coins{{testDenom1, one}}.IsAllGT(Coins{})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom2, one}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(Coins{{testDenom2, two}})) + s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{})) + s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom2, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom2, two}})) } -func TestCoinsLT(t *testing.T) { - one := OneInt() - two := NewInt(2) - - assert.False(t, Coins{}.IsAllLT(Coins{})) - assert.False(t, Coins{{testDenom1, one}}.IsAllLT(Coins{})) - assert.False(t, Coins{{testDenom1, one}}.IsAllLT(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllLT(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom2, two}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom1, one}, {testDenom2, one}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom1, two}, {testDenom2, two}})) - assert.True(t, Coins{}.IsAllLT(Coins{{testDenom1, one}})) +func (s *CoinTestSuite) TestCoinsLT() { + one := sdk.OneInt() + two := sdk.NewInt(2) + + s.Require().False(sdk.Coins{}.IsAllLT(sdk.Coins{})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLT(sdk.Coins{})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLT(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLT(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom2, two}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom1, one}, {testDenom2, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(sdk.Coins{{testDenom1, two}, {testDenom2, two}})) + s.Require().True(sdk.Coins{}.IsAllLT(sdk.Coins{{testDenom1, one}})) } -func TestCoinsLTE(t *testing.T) { - one := OneInt() - two := NewInt(2) - - assert.True(t, Coins{}.IsAllLTE(Coins{})) - assert.False(t, Coins{{testDenom1, one}}.IsAllLTE(Coins{})) - assert.True(t, Coins{{testDenom1, one}}.IsAllLTE(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllLTE(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(Coins{{testDenom2, two}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(Coins{{testDenom1, one}, {testDenom2, one}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.True(t, Coins{}.IsAllLTE(Coins{{testDenom1, one}})) +func (s *CoinTestSuite) TestCoinsLTE() { + one := sdk.OneInt() + two := sdk.NewInt(2) + + s.Require().True(sdk.Coins{}.IsAllLTE(sdk.Coins{})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLTE(sdk.Coins{})) + s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllLTE(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLTE(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom2, two}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom1, one}, {testDenom2, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().True(sdk.Coins{}.IsAllLTE(sdk.Coins{{testDenom1, one}})) } -func TestParseCoins(t *testing.T) { - one := OneInt() +func (s *CoinTestSuite) TestParseCoins() { + one := sdk.OneInt() cases := []struct { input string - valid bool // if false, we expect an error on parse - expected Coins // if valid is true, make sure this is returned + valid bool // if false, we expect an error on parse + expected sdk.Coins // if valid is true, make sure this is returned }{ {"", true, nil}, - {"0stake", true, Coins{}}, // remove zero coins - {"0stake,1foo,99bar", true, Coins{{"bar", NewInt(99)}, {"foo", one}}}, // remove zero coins - {"1foo", true, Coins{{"foo", one}}}, + {"0stake", true, sdk.Coins{}}, // remove zero coins + {"0stake,1foo,99bar", true, sdk.Coins{{"bar", sdk.NewInt(99)}, {"foo", one}}}, // remove zero coins + {"1foo", true, sdk.Coins{{"foo", one}}}, {"10btc,1atom,20btc", false, nil}, - {"10bar", true, Coins{{"bar", NewInt(10)}}}, - {"99bar,1foo", true, Coins{{"bar", NewInt(99)}, {"foo", one}}}, - {"98 bar , 1 foo ", true, Coins{{"bar", NewInt(98)}, {"foo", one}}}, - {" 55\t \t bling\n", true, Coins{{"bling", NewInt(55)}}}, - {"2foo, 97 bar", true, Coins{{"bar", NewInt(97)}, {"foo", NewInt(2)}}}, + {"10bar", true, sdk.Coins{{"bar", sdk.NewInt(10)}}}, + {"99bar,1foo", true, sdk.Coins{{"bar", sdk.NewInt(99)}, {"foo", one}}}, + {"98 bar , 1 foo ", true, sdk.Coins{{"bar", sdk.NewInt(98)}, {"foo", one}}}, + {" 55\t \t bling\n", true, sdk.Coins{{"bling", sdk.NewInt(55)}}}, + {"2foo, 97 bar", true, sdk.Coins{{"bar", sdk.NewInt(97)}, {"foo", sdk.NewInt(2)}}}, {"5 mycoin,", false, nil}, // no empty coins in a list {"2 3foo, 97 bar", false, nil}, // 3foo is invalid coin name {"11me coin, 12you coin", false, nil}, // no spaces in coin names {"1.2btc", false, nil}, // amount must be integer {"5foo:bar", false, nil}, // invalid separator - {"10atom10", true, Coins{{"atom10", NewInt(10)}}}, - {"200transfer/channelToA/uatom", true, Coins{{"transfer/channelToA/uatom", NewInt(200)}}}, - {"50ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", true, Coins{{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", NewInt(50)}}}, + {"10atom10", true, sdk.Coins{{"atom10", sdk.NewInt(10)}}}, + {"200transfer/channelToA/uatom", true, sdk.Coins{{"transfer/channelToA/uatom", sdk.NewInt(200)}}}, + {"50ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", true, sdk.Coins{{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", sdk.NewInt(50)}}}, } for tcIndex, tc := range cases { - res, err := ParseCoins(tc.input) + res, err := sdk.ParseCoins(tc.input) if !tc.valid { - require.Error(t, err, "%s: %#v. tc #%d", tc.input, res, tcIndex) - } else if assert.Nil(t, err, "%s: %+v", tc.input, err) { - require.Equal(t, tc.expected, res, "coin parsing was incorrect, tc #%d", tcIndex) + s.Require().Error(err, "%s: %#v. tc #%d", tc.input, res, tcIndex) + } else if s.Assert().Nil(err, "%s: %+v", tc.input, err) { + s.Require().Equal(tc.expected, res, "coin parsing was incorrect, tc #%d", tcIndex) } } } -func TestSortCoins(t *testing.T) { - good := Coins{ - NewInt64Coin("gas", 1), - NewInt64Coin("mineral", 1), - NewInt64Coin("tree", 1), +func (s *CoinTestSuite) TestSortCoins() { + good := sdk.Coins{ + sdk.NewInt64Coin("gas", 1), + sdk.NewInt64Coin("mineral", 1), + sdk.NewInt64Coin("tree", 1), } - empty := Coins{ - NewInt64Coin("gold", 0), + empty := sdk.Coins{ + sdk.NewInt64Coin("gold", 0), } - badSort1 := Coins{ - NewInt64Coin("tree", 1), - NewInt64Coin("gas", 1), - NewInt64Coin("mineral", 1), + badSort1 := sdk.Coins{ + sdk.NewInt64Coin("tree", 1), + sdk.NewInt64Coin("gas", 1), + sdk.NewInt64Coin("mineral", 1), } - badSort2 := Coins{ // both are after the first one, but the second and third are in the wrong order - NewInt64Coin("gas", 1), - NewInt64Coin("tree", 1), - NewInt64Coin("mineral", 1), + badSort2 := sdk.Coins{ // both are after the first one, but the second and third are in the wrong order + sdk.NewInt64Coin("gas", 1), + sdk.NewInt64Coin("tree", 1), + sdk.NewInt64Coin("mineral", 1), } - badAmt := Coins{ - NewInt64Coin("gas", 1), - NewInt64Coin("tree", 0), - NewInt64Coin("mineral", 1), + badAmt := sdk.Coins{ + sdk.NewInt64Coin("gas", 1), + sdk.NewInt64Coin("tree", 0), + sdk.NewInt64Coin("mineral", 1), } - dup := Coins{ - NewInt64Coin("gas", 1), - NewInt64Coin("gas", 1), - NewInt64Coin("mineral", 1), + dup := sdk.Coins{ + sdk.NewInt64Coin("gas", 1), + sdk.NewInt64Coin("gas", 1), + sdk.NewInt64Coin("mineral", 1), } cases := []struct { name string - coins Coins + coins sdk.Coins validBefore, validAfter bool }{ @@ -697,42 +699,42 @@ func TestSortCoins(t *testing.T) { for _, tc := range cases { err := tc.coins.Validate() if tc.validBefore { - require.NoError(t, err, tc.name) + s.Require().NoError(err, tc.name) } else { - require.Error(t, err, tc.name) + s.Require().Error(err, tc.name) } tc.coins.Sort() err = tc.coins.Validate() if tc.validAfter { - require.NoError(t, err, tc.name) + s.Require().NoError(err, tc.name) } else { - require.Error(t, err, tc.name) + s.Require().Error(err, tc.name) } } } -func TestAmountOf(t *testing.T) { - case0 := Coins{} - case1 := Coins{ - NewInt64Coin("gold", 0), +func (s *CoinTestSuite) TestAmountOf() { + case0 := sdk.Coins{} + case1 := sdk.Coins{ + sdk.NewInt64Coin("gold", 0), } - case2 := Coins{ - NewInt64Coin("gas", 1), - NewInt64Coin("mineral", 1), - NewInt64Coin("tree", 1), + case2 := sdk.Coins{ + sdk.NewInt64Coin("gas", 1), + sdk.NewInt64Coin("mineral", 1), + sdk.NewInt64Coin("tree", 1), } - case3 := Coins{ - NewInt64Coin("mineral", 1), - NewInt64Coin("tree", 1), + case3 := sdk.Coins{ + sdk.NewInt64Coin("mineral", 1), + sdk.NewInt64Coin("tree", 1), } - case4 := Coins{ - NewInt64Coin("gas", 8), + case4 := sdk.Coins{ + sdk.NewInt64Coin("gas", 8), } cases := []struct { - coins Coins + coins sdk.Coins amountOf int64 amountOfSpace int64 amountOfGAS int64 @@ -747,178 +749,173 @@ func TestAmountOf(t *testing.T) { } for _, tc := range cases { - assert.Equal(t, NewInt(tc.amountOfGAS), tc.coins.AmountOf("gas")) - assert.Equal(t, NewInt(tc.amountOfMINERAL), tc.coins.AmountOf("mineral")) - assert.Equal(t, NewInt(tc.amountOfTREE), tc.coins.AmountOf("tree")) + s.Require().Equal(sdk.NewInt(tc.amountOfGAS), tc.coins.AmountOf("gas")) + s.Require().Equal(sdk.NewInt(tc.amountOfMINERAL), tc.coins.AmountOf("mineral")) + s.Require().Equal(sdk.NewInt(tc.amountOfTREE), tc.coins.AmountOf("tree")) } - assert.Panics(t, func() { cases[0].coins.AmountOf("10Invalid") }) + s.Require().Panics(func() { cases[0].coins.AmountOf("10Invalid") }) } -func TestCoinsIsAnyGTE(t *testing.T) { - one := OneInt() - two := NewInt(2) - - assert.False(t, Coins{}.IsAnyGTE(Coins{})) - assert.False(t, Coins{{testDenom1, one}}.IsAnyGTE(Coins{})) - assert.False(t, Coins{}.IsAnyGTE(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAnyGTE(Coins{{testDenom1, two}})) - assert.False(t, Coins{{testDenom1, one}}.IsAnyGTE(Coins{{testDenom2, one}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAnyGTE(Coins{{testDenom1, two}, {testDenom2, one}})) - assert.True(t, Coins{{testDenom1, one}}.IsAnyGTE(Coins{{testDenom1, one}})) - assert.True(t, Coins{{testDenom1, two}}.IsAnyGTE(Coins{{testDenom1, one}})) - assert.True(t, Coins{{testDenom1, one}}.IsAnyGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.True(t, Coins{{testDenom2, two}}.IsAnyGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{testDenom2, one}}.IsAnyGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAnyGTE(Coins{{testDenom1, one}, {testDenom2, one}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAnyGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.True(t, Coins{{"xxx", one}, {"yyy", one}}.IsAnyGTE(Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}})) +func (s *CoinTestSuite) TestCoinsIsAnyGTE() { + one := sdk.OneInt() + two := sdk.NewInt(2) + + s.Require().False(sdk.Coins{}.IsAnyGTE(sdk.Coins{})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{})) + s.Require().False(sdk.Coins{}.IsAnyGTE(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom1, two}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom2, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAnyGTE(sdk.Coins{{testDenom1, two}, {testDenom2, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}})) + s.Require().True(sdk.Coins{{testDenom1, two}}.IsAnyGTE(sdk.Coins{{testDenom1, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().True(sdk.Coins{{testDenom2, two}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{testDenom2, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAnyGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().True(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAnyGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}})) } -func TestCoinsIsAllGT(t *testing.T) { - one := OneInt() - two := NewInt(2) - - assert.False(t, Coins{}.IsAllGT(Coins{})) - assert.True(t, Coins{{testDenom1, one}}.IsAllGT(Coins{})) - assert.False(t, Coins{}.IsAllGT(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, two}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(Coins{{testDenom1, two}, {testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, one}})) - assert.True(t, Coins{{testDenom1, two}}.IsAllGT(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{testDenom2, two}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{testDenom2, one}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{"xxx", one}, {"yyy", one}}.IsAllGT(Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}})) +func (s *CoinTestSuite) TestCoinsIsAllGT() { + one := sdk.OneInt() + two := sdk.NewInt(2) + + s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{})) + s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{})) + s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, two}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom1, two}, {testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, one}})) + s.Require().True(sdk.Coins{{testDenom1, two}}.IsAllGT(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGT(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}})) } -func TestCoinsIsAllGTE(t *testing.T) { - one := OneInt() - two := NewInt(2) - - assert.True(t, Coins{}.IsAllGTE(Coins{})) - assert.True(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom2, two}})) - assert.False(t, Coins{}.IsAllGTE(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom1, two}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(Coins{{testDenom1, two}, {testDenom2, one}})) - assert.True(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom1, one}})) - assert.True(t, Coins{{testDenom1, two}}.IsAllGTE(Coins{{testDenom1, one}})) - assert.False(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{testDenom2, two}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{testDenom2, one}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.True(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, one}})) - assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}})) - assert.False(t, Coins{{"xxx", one}, {"yyy", one}}.IsAllGTE(Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}})) +func (s *CoinTestSuite) TestCoinsIsAllGTE() { + one := sdk.OneInt() + two := sdk.NewInt(2) + + s.Require().True(sdk.Coins{}.IsAllGTE(sdk.Coins{})) + s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom2, two}})) + s.Require().False(sdk.Coins{}.IsAllGTE(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom1, two}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(sdk.Coins{{testDenom1, two}, {testDenom2, one}})) + s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}})) + s.Require().True(sdk.Coins{{testDenom1, two}}.IsAllGTE(sdk.Coins{{testDenom1, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{testDenom2, two}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().True(sdk.Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, one}})) + s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(sdk.Coins{{testDenom1, one}, {testDenom2, two}})) + s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}})) } -func TestNewCoins(t *testing.T) { - tenatom := NewInt64Coin("atom", 10) - tenbtc := NewInt64Coin("btc", 10) - zeroeth := NewInt64Coin("eth", 0) - invalidCoin := Coin{"0ETH", OneInt()} +func (s *CoinTestSuite) TestNewCoins() { + tenatom := sdk.NewInt64Coin("atom", 10) + tenbtc := sdk.NewInt64Coin("btc", 10) + zeroeth := sdk.NewInt64Coin("eth", 0) + invalidCoin := sdk.Coin{"0ETH", sdk.OneInt()} tests := []struct { name string - coins Coins - want Coins + coins sdk.Coins + want sdk.Coins wantPanic bool }{ - {"empty args", []Coin{}, Coins{}, false}, - {"one coin", []Coin{tenatom}, Coins{tenatom}, false}, - {"sort after create", []Coin{tenbtc, tenatom}, Coins{tenatom, tenbtc}, false}, - {"sort and remove zeroes", []Coin{zeroeth, tenbtc, tenatom}, Coins{tenatom, tenbtc}, false}, - {"panic on dups", []Coin{tenatom, tenatom}, Coins{}, true}, - {"panic on invalid coin", []Coin{invalidCoin, tenatom}, Coins{}, true}, + {"empty args", []sdk.Coin{}, sdk.Coins{}, false}, + {"one coin", []sdk.Coin{tenatom}, sdk.Coins{tenatom}, false}, + {"sort after create", []sdk.Coin{tenbtc, tenatom}, sdk.Coins{tenatom, tenbtc}, false}, + {"sort and remove zeroes", []sdk.Coin{zeroeth, tenbtc, tenatom}, sdk.Coins{tenatom, tenbtc}, false}, + {"panic on dups", []sdk.Coin{tenatom, tenatom}, sdk.Coins{}, true}, + {"panic on invalid coin", []sdk.Coin{invalidCoin, tenatom}, sdk.Coins{}, true}, } for _, tt := range tests { - tt := tt - t.Run(tt.name, func(t *testing.T) { - if tt.wantPanic { - require.Panics(t, func() { NewCoins(tt.coins...) }) - return - } - got := NewCoins(tt.coins...) - require.True(t, got.IsEqual(tt.want)) - }) + if tt.wantPanic { + s.Require().Panics(func() { sdk.NewCoins(tt.coins...) }) + return + } + got := sdk.NewCoins(tt.coins...) + s.Require().True(got.IsEqual(tt.want)) } } -func TestCoinsIsAnyGT(t *testing.T) { - twoAtom := NewInt64Coin("atom", 2) - fiveAtom := NewInt64Coin("atom", 5) - threeEth := NewInt64Coin("eth", 3) - sixEth := NewInt64Coin("eth", 6) - twoBtc := NewInt64Coin("btc", 2) +func (s *CoinTestSuite) TestCoinsIsAnyGT() { + twoAtom := sdk.NewInt64Coin("atom", 2) + fiveAtom := sdk.NewInt64Coin("atom", 5) + threeEth := sdk.NewInt64Coin("eth", 3) + sixEth := sdk.NewInt64Coin("eth", 6) + twoBtc := sdk.NewInt64Coin("btc", 2) tests := []struct { name string - coinsA Coins - coinsB Coins + coinsA sdk.Coins + coinsB sdk.Coins expPass bool }{ - {"{} ≤ {}", Coins{}, Coins{}, false}, - {"{} ≤ 5atom", Coins{}, Coins{fiveAtom}, false}, - {"5atom > 2atom", Coins{fiveAtom}, Coins{twoAtom}, true}, - {"2atom ≤ 5atom", Coins{twoAtom}, Coins{fiveAtom}, false}, - {"2atom,6eth > 2btc,5atom,3eth", Coins{twoAtom, sixEth}, Coins{twoBtc, fiveAtom, threeEth}, true}, - {"2btc,2atom,3eth ≤ 5atom,6eth", Coins{twoBtc, twoAtom, threeEth}, Coins{fiveAtom, sixEth}, false}, - {"2atom,6eth ≤ 2btc,5atom", Coins{twoAtom, sixEth}, Coins{twoBtc, fiveAtom}, false}, + {"{} ≤ {}", sdk.Coins{}, sdk.Coins{}, false}, + {"{} ≤ 5atom", sdk.Coins{}, sdk.Coins{fiveAtom}, false}, + {"5atom > 2atom", sdk.Coins{fiveAtom}, sdk.Coins{twoAtom}, true}, + {"2atom ≤ 5atom", sdk.Coins{twoAtom}, sdk.Coins{fiveAtom}, false}, + {"2atom,6eth > 2btc,5atom,3eth", sdk.Coins{twoAtom, sixEth}, sdk.Coins{twoBtc, fiveAtom, threeEth}, true}, + {"2btc,2atom,3eth ≤ 5atom,6eth", sdk.Coins{twoBtc, twoAtom, threeEth}, sdk.Coins{fiveAtom, sixEth}, false}, + {"2atom,6eth ≤ 2btc,5atom", sdk.Coins{twoAtom, sixEth}, sdk.Coins{twoBtc, fiveAtom}, false}, } for _, tc := range tests { - require.True(t, tc.expPass == tc.coinsA.IsAnyGT(tc.coinsB), tc.name) + s.Require().True(tc.expPass == tc.coinsA.IsAnyGT(tc.coinsB), tc.name) } } -func TestMarshalJSONCoins(t *testing.T) { +func (s *CoinTestSuite) TestMarshalJSONCoins() { cdc := codec.NewLegacyAmino() - RegisterLegacyAminoCodec(cdc) + sdk.RegisterLegacyAminoCodec(cdc) testCases := []struct { name string - input Coins + input sdk.Coins strOutput string }{ {"nil coins", nil, `[]`}, - {"empty coins", Coins{}, `[]`}, - {"non-empty coins", NewCoins(NewInt64Coin("foo", 50)), `[{"denom":"foo","amount":"50"}]`}, + {"empty coins", sdk.Coins{}, `[]`}, + {"non-empty coins", sdk.NewCoins(sdk.NewInt64Coin("foo", 50)), `[{"denom":"foo","amount":"50"}]`}, } for _, tc := range testCases { - tc := tc - t.Run(tc.name, func(t *testing.T) { - bz, err := cdc.MarshalJSON(tc.input) - require.NoError(t, err) - require.Equal(t, tc.strOutput, string(bz)) + bz, err := cdc.MarshalJSON(tc.input) + s.Require().NoError(err) + s.Require().Equal(tc.strOutput, string(bz)) - var newCoins Coins - require.NoError(t, cdc.UnmarshalJSON(bz, &newCoins)) + var newCoins sdk.Coins + s.Require().NoError(cdc.UnmarshalJSON(bz, &newCoins)) - if tc.input.Empty() { - require.Nil(t, newCoins) - } else { - require.Equal(t, tc.input, newCoins) - } - }) + if tc.input.Empty() { + s.Require().Nil(newCoins) + } else { + s.Require().Equal(tc.input, newCoins) + } } } -func TestCoinAminoEncoding(t *testing.T) { - c := NewInt64Coin(testDenom1, 5) +func (s *CoinTestSuite) TestCoinAminoEncoding() { + cdc := codec.NewLegacyAmino() + c := sdk.NewInt64Coin(testDenom1, 5) bz1, err := cdc.MarshalBinaryBare(c) - require.NoError(t, err) + s.Require().NoError(err) bz2, err := cdc.MarshalBinaryLengthPrefixed(c) - require.NoError(t, err) + s.Require().NoError(err) bz3, err := c.Marshal() - require.NoError(t, err) - require.Equal(t, bz1, bz3) - require.Equal(t, bz2[1:], bz3) + s.Require().NoError(err) + s.Require().Equal(bz1, bz3) + s.Require().Equal(bz2[1:], bz3) } diff --git a/types/context_test.go b/types/context_test.go index 64e4141659e3..12df63bceadb 100644 --- a/types/context_test.go +++ b/types/context_test.go @@ -5,7 +5,8 @@ import ( "testing" "time" - "github.com/stretchr/testify/require" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/suite" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/libs/log" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" @@ -13,82 +14,69 @@ import ( "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" "github.com/cosmos/cosmos-sdk/store" + "github.com/cosmos/cosmos-sdk/tests/mocks" "github.com/cosmos/cosmos-sdk/types" ) -type MockLogger struct { - logs *[]string +type ContextTestSuite struct { + suite.Suite } -func NewMockLogger() MockLogger { - logs := make([]string, 0) - return MockLogger{ - &logs, - } -} - -func (l MockLogger) Debug(msg string, kvs ...interface{}) { - *l.logs = append(*l.logs, msg) -} - -func (l MockLogger) Info(msg string, kvs ...interface{}) { - *l.logs = append(*l.logs, msg) -} - -func (l MockLogger) Error(msg string, kvs ...interface{}) { - *l.logs = append(*l.logs, msg) -} - -func (l MockLogger) With(kvs ...interface{}) log.Logger { - panic("not implemented") +func TestContextTestSuite(t *testing.T) { + suite.Run(t, new(ContextTestSuite)) } -func defaultContext(t *testing.T, key types.StoreKey) types.Context { +func (s *ContextTestSuite) defaultContext(key types.StoreKey) types.Context { db := dbm.NewMemDB() cms := store.NewCommitMultiStore(db) cms.MountStoreWithDB(key, types.StoreTypeIAVL, db) - err := cms.LoadLatestVersion() - require.NoError(t, err) + s.Require().NoError(cms.LoadLatestVersion()) ctx := types.NewContext(cms, tmproto.Header{}, false, log.NewNopLogger()) return ctx } -func TestCacheContext(t *testing.T) { - key := types.NewKVStoreKey(t.Name()) +func (s *ContextTestSuite) TestCacheContext() { + key := types.NewKVStoreKey(s.T().Name() + "_TestCacheContext") k1 := []byte("hello") v1 := []byte("world") k2 := []byte("key") v2 := []byte("value") - ctx := defaultContext(t, key) + ctx := s.defaultContext(key) store := ctx.KVStore(key) store.Set(k1, v1) - require.Equal(t, v1, store.Get(k1)) - require.Nil(t, store.Get(k2)) + s.Require().Equal(v1, store.Get(k1)) + s.Require().Nil(store.Get(k2)) cctx, write := ctx.CacheContext() cstore := cctx.KVStore(key) - require.Equal(t, v1, cstore.Get(k1)) - require.Nil(t, cstore.Get(k2)) + s.Require().Equal(v1, cstore.Get(k1)) + s.Require().Nil(cstore.Get(k2)) cstore.Set(k2, v2) - require.Equal(t, v2, cstore.Get(k2)) - require.Nil(t, store.Get(k2)) + s.Require().Equal(v2, cstore.Get(k2)) + s.Require().Nil(store.Get(k2)) write() - require.Equal(t, v2, store.Get(k2)) + s.Require().Equal(v2, store.Get(k2)) } -func TestLogContext(t *testing.T) { - key := types.NewKVStoreKey(t.Name()) - ctx := defaultContext(t, key) - logger := NewMockLogger() +func (s *ContextTestSuite) TestLogContext() { + key := types.NewKVStoreKey(s.T().Name()) + ctx := s.defaultContext(key) + ctrl := gomock.NewController(s.T()) + s.T().Cleanup(ctrl.Finish) + + logger := mocks.NewMockLogger(ctrl) + logger.EXPECT().Debug("debug") + logger.EXPECT().Info("info") + logger.EXPECT().Error("error") + ctx = ctx.WithLogger(logger) ctx.Logger().Debug("debug") ctx.Logger().Info("info") ctx.Logger().Error("error") - require.Equal(t, *logger.logs, []string{"debug", "info", "error"}) } type dummy int64 //nolint:unused @@ -98,23 +86,26 @@ func (d dummy) Clone() interface{} { } // Testing saving/loading sdk type values to/from the context -func TestContextWithCustom(t *testing.T) { +func (s *ContextTestSuite) TestContextWithCustom() { var ctx types.Context - require.True(t, ctx.IsZero()) + s.Require().True(ctx.IsZero()) + + ctrl := gomock.NewController(s.T()) + s.T().Cleanup(ctrl.Finish) header := tmproto.Header{} height := int64(1) chainid := "chainid" ischeck := true txbytes := []byte("txbytes") - logger := NewMockLogger() + logger := mocks.NewMockLogger(ctrl) voteinfos := []abci.VoteInfo{{}} meter := types.NewGasMeter(10000) blockGasMeter := types.NewGasMeter(20000) minGasPrices := types.DecCoins{types.NewInt64DecCoin("feetoken", 1)} ctx = types.NewContext(nil, header, ischeck, logger) - require.Equal(t, header, ctx.BlockHeader()) + s.Require().Equal(header, ctx.BlockHeader()) ctx = ctx. WithBlockHeight(height). @@ -124,37 +115,36 @@ func TestContextWithCustom(t *testing.T) { WithGasMeter(meter). WithMinGasPrices(minGasPrices). WithBlockGasMeter(blockGasMeter) - require.Equal(t, height, ctx.BlockHeight()) - require.Equal(t, chainid, ctx.ChainID()) - require.Equal(t, ischeck, ctx.IsCheckTx()) - require.Equal(t, txbytes, ctx.TxBytes()) - require.Equal(t, logger, ctx.Logger()) - require.Equal(t, voteinfos, ctx.VoteInfos()) - require.Equal(t, meter, ctx.GasMeter()) - require.Equal(t, minGasPrices, ctx.MinGasPrices()) - require.Equal(t, blockGasMeter, ctx.BlockGasMeter()) - - require.False(t, ctx.WithIsCheckTx(false).IsCheckTx()) + s.Require().Equal(height, ctx.BlockHeight()) + s.Require().Equal(chainid, ctx.ChainID()) + s.Require().Equal(ischeck, ctx.IsCheckTx()) + s.Require().Equal(txbytes, ctx.TxBytes()) + s.Require().Equal(logger, ctx.Logger()) + s.Require().Equal(voteinfos, ctx.VoteInfos()) + s.Require().Equal(meter, ctx.GasMeter()) + s.Require().Equal(minGasPrices, ctx.MinGasPrices()) + s.Require().Equal(blockGasMeter, ctx.BlockGasMeter()) + s.Require().False(ctx.WithIsCheckTx(false).IsCheckTx()) // test IsReCheckTx - require.False(t, ctx.IsReCheckTx()) + s.Require().False(ctx.IsReCheckTx()) ctx = ctx.WithIsCheckTx(false) ctx = ctx.WithIsReCheckTx(true) - require.True(t, ctx.IsCheckTx()) - require.True(t, ctx.IsReCheckTx()) + s.Require().True(ctx.IsCheckTx()) + s.Require().True(ctx.IsReCheckTx()) // test consensus param - require.Nil(t, ctx.ConsensusParams()) + s.Require().Nil(ctx.ConsensusParams()) cp := &abci.ConsensusParams{} - require.Equal(t, cp, ctx.WithConsensusParams(cp).ConsensusParams()) + s.Require().Equal(cp, ctx.WithConsensusParams(cp).ConsensusParams()) // test inner context newContext := context.WithValue(ctx.Context(), "key", "value") //nolint:golint,staticcheck - require.NotEqual(t, ctx.Context(), ctx.WithContext(newContext).Context()) + s.Require().NotEqual(ctx.Context(), ctx.WithContext(newContext).Context()) } // Testing saving/loading of header fields to/from the context -func TestContextHeader(t *testing.T) { +func (s *ContextTestSuite) TestContextHeader() { var ctx types.Context height := int64(5) @@ -168,13 +158,13 @@ func TestContextHeader(t *testing.T) { WithBlockHeight(height). WithBlockTime(time). WithProposer(proposer) - require.Equal(t, height, ctx.BlockHeight()) - require.Equal(t, height, ctx.BlockHeader().Height) - require.Equal(t, time.UTC(), ctx.BlockHeader().Time) - require.Equal(t, proposer.Bytes(), ctx.BlockHeader().ProposerAddress) + s.Require().Equal(height, ctx.BlockHeight()) + s.Require().Equal(height, ctx.BlockHeader().Height) + s.Require().Equal(time.UTC(), ctx.BlockHeader().Time) + s.Require().Equal(proposer.Bytes(), ctx.BlockHeader().ProposerAddress) } -func TestContextHeaderClone(t *testing.T) { +func (s *ContextTestSuite) TestContextHeaderClone() { cases := map[string]struct { h tmproto.Header }{ @@ -216,28 +206,26 @@ func TestContextHeaderClone(t *testing.T) { for name, tc := range cases { tc := tc - t.Run(name, func(t *testing.T) { + s.T().Run(name, func(t *testing.T) { ctx := types.NewContext(nil, tc.h, false, nil) - require.Equal(t, tc.h.Height, ctx.BlockHeight()) - require.Equal(t, tc.h.Time.UTC(), ctx.BlockTime()) + s.Require().Equal(tc.h.Height, ctx.BlockHeight()) + s.Require().Equal(tc.h.Time.UTC(), ctx.BlockTime()) // update only changes one field var newHeight int64 = 17 ctx = ctx.WithBlockHeight(newHeight) - require.Equal(t, newHeight, ctx.BlockHeight()) - require.Equal(t, tc.h.Time.UTC(), ctx.BlockTime()) + s.Require().Equal(newHeight, ctx.BlockHeight()) + s.Require().Equal(tc.h.Time.UTC(), ctx.BlockTime()) }) } } -func TestUnwrapSDKContext(t *testing.T) { +func (s *ContextTestSuite) TestUnwrapSDKContext() { sdkCtx := types.NewContext(nil, tmproto.Header{}, false, nil) ctx := types.WrapSDKContext(sdkCtx) sdkCtx2 := types.UnwrapSDKContext(ctx) - require.Equal(t, sdkCtx, sdkCtx2) + s.Require().Equal(sdkCtx, sdkCtx2) ctx = context.Background() - require.Panics(t, func() { - types.UnwrapSDKContext(ctx) - }) + s.Require().Panics(func() { types.UnwrapSDKContext(ctx) }) } diff --git a/types/dec_coin_test.go b/types/dec_coin_test.go index 6eb89e4a73eb..2554a417074e 100644 --- a/types/dec_coin_test.go +++ b/types/dec_coin_test.go @@ -1,69 +1,71 @@ -package types +package types_test import ( "strings" "testing" "github.com/stretchr/testify/require" + + sdk "github.com/cosmos/cosmos-sdk/types" ) func TestNewDecCoin(t *testing.T) { require.NotPanics(t, func() { - NewInt64DecCoin(testDenom1, 5) + sdk.NewInt64DecCoin(testDenom1, 5) }) require.NotPanics(t, func() { - NewInt64DecCoin(testDenom1, 0) + sdk.NewInt64DecCoin(testDenom1, 0) }) require.NotPanics(t, func() { - NewInt64DecCoin(strings.ToUpper(testDenom1), 5) + sdk.NewInt64DecCoin(strings.ToUpper(testDenom1), 5) }) require.Panics(t, func() { - NewInt64DecCoin(testDenom1, -5) + sdk.NewInt64DecCoin(testDenom1, -5) }) } func TestNewDecCoinFromDec(t *testing.T) { require.NotPanics(t, func() { - NewDecCoinFromDec(testDenom1, NewDec(5)) + sdk.NewDecCoinFromDec(testDenom1, sdk.NewDec(5)) }) require.NotPanics(t, func() { - NewDecCoinFromDec(testDenom1, ZeroDec()) + sdk.NewDecCoinFromDec(testDenom1, sdk.ZeroDec()) }) require.NotPanics(t, func() { - NewDecCoinFromDec(strings.ToUpper(testDenom1), NewDec(5)) + sdk.NewDecCoinFromDec(strings.ToUpper(testDenom1), sdk.NewDec(5)) }) require.Panics(t, func() { - NewDecCoinFromDec(testDenom1, NewDec(-5)) + sdk.NewDecCoinFromDec(testDenom1, sdk.NewDec(-5)) }) } func TestNewDecCoinFromCoin(t *testing.T) { require.NotPanics(t, func() { - NewDecCoinFromCoin(Coin{testDenom1, NewInt(5)}) + sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, sdk.NewInt(5)}) }) require.NotPanics(t, func() { - NewDecCoinFromCoin(Coin{testDenom1, NewInt(0)}) + sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, sdk.NewInt(0)}) }) require.NotPanics(t, func() { - NewDecCoinFromCoin(Coin{strings.ToUpper(testDenom1), NewInt(5)}) + sdk.NewDecCoinFromCoin(sdk.Coin{strings.ToUpper(testDenom1), sdk.NewInt(5)}) }) require.Panics(t, func() { - NewDecCoinFromCoin(Coin{testDenom1, NewInt(-5)}) + sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, sdk.NewInt(-5)}) }) } func TestDecCoinIsPositive(t *testing.T) { - dc := NewInt64DecCoin(testDenom1, 5) + dc := sdk.NewInt64DecCoin(testDenom1, 5) require.True(t, dc.IsPositive()) - dc = NewInt64DecCoin(testDenom1, 0) + dc = sdk.NewInt64DecCoin(testDenom1, 0) require.False(t, dc.IsPositive()) } func TestAddDecCoin(t *testing.T) { - decCoinA1 := NewDecCoinFromDec(testDenom1, NewDecWithPrec(11, 1)) - decCoinA2 := NewDecCoinFromDec(testDenom1, NewDecWithPrec(22, 1)) - decCoinB1 := NewDecCoinFromDec(testDenom2, NewDecWithPrec(11, 1)) + decCoinA1 := sdk.NewDecCoinFromDec(testDenom1, sdk.NewDecWithPrec(11, 1)) + decCoinA2 := sdk.NewDecCoinFromDec(testDenom1, sdk.NewDecWithPrec(22, 1)) + decCoinB1 := sdk.NewDecCoinFromDec(testDenom2, sdk.NewDecWithPrec(11, 1)) // regular add res := decCoinA1.Add(decCoinA1) @@ -76,18 +78,18 @@ func TestAddDecCoin(t *testing.T) { } func TestAddDecCoins(t *testing.T) { - one := NewDec(1) - zero := NewDec(0) - two := NewDec(2) + one := sdk.NewDec(1) + zero := sdk.NewDec(0) + two := sdk.NewDec(2) cases := []struct { - inputOne DecCoins - inputTwo DecCoins - expected DecCoins + inputOne sdk.DecCoins + inputTwo sdk.DecCoins + expected sdk.DecCoins }{ - {DecCoins{{testDenom1, one}, {testDenom2, one}}, DecCoins{{testDenom1, one}, {testDenom2, one}}, DecCoins{{testDenom1, two}, {testDenom2, two}}}, - {DecCoins{{testDenom1, zero}, {testDenom2, one}}, DecCoins{{testDenom1, zero}, {testDenom2, zero}}, DecCoins{{testDenom2, one}}}, - {DecCoins{{testDenom1, zero}, {testDenom2, zero}}, DecCoins{{testDenom1, zero}, {testDenom2, zero}}, DecCoins(nil)}, + {sdk.DecCoins{{testDenom1, one}, {testDenom2, one}}, sdk.DecCoins{{testDenom1, one}, {testDenom2, one}}, sdk.DecCoins{{testDenom1, two}, {testDenom2, two}}}, + {sdk.DecCoins{{testDenom1, zero}, {testDenom2, one}}, sdk.DecCoins{{testDenom1, zero}, {testDenom2, zero}}, sdk.DecCoins{{testDenom2, one}}}, + {sdk.DecCoins{{testDenom1, zero}, {testDenom2, zero}}, sdk.DecCoins{{testDenom1, zero}, {testDenom2, zero}}, sdk.DecCoins(nil)}, } for tcIndex, tc := range cases { @@ -99,42 +101,42 @@ func TestAddDecCoins(t *testing.T) { func TestFilteredZeroDecCoins(t *testing.T) { cases := []struct { name string - input DecCoins + input sdk.DecCoins original string expected string }{ { name: "all greater than zero", - input: DecCoins{ - {"testa", NewDec(1)}, - {"testb", NewDec(2)}, - {"testc", NewDec(3)}, - {"testd", NewDec(4)}, - {"teste", NewDec(5)}, + input: sdk.DecCoins{ + {"testa", sdk.NewDec(1)}, + {"testb", sdk.NewDec(2)}, + {"testc", sdk.NewDec(3)}, + {"testd", sdk.NewDec(4)}, + {"teste", sdk.NewDec(5)}, }, original: "1.000000000000000000testa,2.000000000000000000testb,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste", expected: "1.000000000000000000testa,2.000000000000000000testb,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste", }, { name: "zero coin in middle", - input: DecCoins{ - {"testa", NewDec(1)}, - {"testb", NewDec(2)}, - {"testc", NewDec(0)}, - {"testd", NewDec(4)}, - {"teste", NewDec(5)}, + input: sdk.DecCoins{ + {"testa", sdk.NewDec(1)}, + {"testb", sdk.NewDec(2)}, + {"testc", sdk.NewDec(0)}, + {"testd", sdk.NewDec(4)}, + {"teste", sdk.NewDec(5)}, }, original: "1.000000000000000000testa,2.000000000000000000testb,0.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste", expected: "1.000000000000000000testa,2.000000000000000000testb,4.000000000000000000testd,5.000000000000000000teste", }, { name: "zero coin end (unordered)", - input: DecCoins{ - {"teste", NewDec(5)}, - {"testc", NewDec(3)}, - {"testa", NewDec(1)}, - {"testd", NewDec(4)}, - {"testb", NewDec(0)}, + input: sdk.DecCoins{ + {"teste", sdk.NewDec(5)}, + {"testc", sdk.NewDec(3)}, + {"testa", sdk.NewDec(1)}, + {"testd", sdk.NewDec(4)}, + {"testb", sdk.NewDec(0)}, }, original: "5.000000000000000000teste,3.000000000000000000testc,1.000000000000000000testa,4.000000000000000000testd,0.000000000000000000testb", expected: "1.000000000000000000testa,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste", @@ -144,7 +146,7 @@ func TestFilteredZeroDecCoins(t *testing.T) { for _, tt := range cases { tt := tt t.Run(tt.name, func(t *testing.T) { - undertest := NewDecCoins(tt.input...) + undertest := sdk.NewDecCoins(tt.input...) require.Equal(t, tt.expected, undertest.String(), "NewDecCoins must return expected results") require.Equal(t, tt.original, tt.input.String(), "input must be unmodified and match original") }) @@ -153,27 +155,27 @@ func TestFilteredZeroDecCoins(t *testing.T) { func TestIsValid(t *testing.T) { tests := []struct { - coin DecCoin + coin sdk.DecCoin expectPass bool msg string }{ { - NewDecCoin("mytoken", NewInt(10)), + sdk.NewDecCoin("mytoken", sdk.NewInt(10)), true, "valid coins should have passed", }, { - DecCoin{Denom: "BTC", Amount: NewDec(10)}, + sdk.DecCoin{Denom: "BTC", Amount: sdk.NewDec(10)}, true, "valid uppercase denom", }, { - DecCoin{Denom: "Bitcoin", Amount: NewDec(10)}, + sdk.DecCoin{Denom: "Bitcoin", Amount: sdk.NewDec(10)}, true, "valid mixed case denom", }, { - DecCoin{Denom: "btc", Amount: NewDec(-10)}, + sdk.DecCoin{Denom: "btc", Amount: sdk.NewDec(-10)}, false, "negative amount", }, @@ -191,28 +193,28 @@ func TestIsValid(t *testing.T) { func TestSubDecCoin(t *testing.T) { tests := []struct { - coin DecCoin + coin sdk.DecCoin expectPass bool msg string }{ { - NewDecCoin("mytoken", NewInt(20)), + sdk.NewDecCoin("mytoken", sdk.NewInt(20)), true, "valid coins should have passed", }, { - NewDecCoin("othertoken", NewInt(20)), + sdk.NewDecCoin("othertoken", sdk.NewInt(20)), false, "denom mismatch", }, { - NewDecCoin("mytoken", NewInt(9)), + sdk.NewDecCoin("mytoken", sdk.NewInt(9)), false, "negative amount", }, } - decCoin := NewDecCoin("mytoken", NewInt(10)) + decCoin := sdk.NewDecCoin("mytoken", sdk.NewInt(10)) for _, tc := range tests { tc := tc @@ -227,28 +229,28 @@ func TestSubDecCoin(t *testing.T) { func TestSubDecCoins(t *testing.T) { tests := []struct { - coins DecCoins + coins sdk.DecCoins expectPass bool msg string }{ { - NewDecCoinsFromCoins(NewCoin("mytoken", NewInt(10)), NewCoin("btc", NewInt(20)), NewCoin("eth", NewInt(30))), + sdk.NewDecCoinsFromCoins(sdk.NewCoin("mytoken", sdk.NewInt(10)), sdk.NewCoin("btc", sdk.NewInt(20)), sdk.NewCoin("eth", sdk.NewInt(30))), true, "sorted coins should have passed", }, { - DecCoins{NewDecCoin("mytoken", NewInt(10)), NewDecCoin("btc", NewInt(20)), NewDecCoin("eth", NewInt(30))}, + sdk.DecCoins{sdk.NewDecCoin("mytoken", sdk.NewInt(10)), sdk.NewDecCoin("btc", sdk.NewInt(20)), sdk.NewDecCoin("eth", sdk.NewInt(30))}, false, "unorted coins should panic", }, { - DecCoins{DecCoin{Denom: "BTC", Amount: NewDec(10)}, NewDecCoin("eth", NewInt(15)), NewDecCoin("mytoken", NewInt(5))}, + sdk.DecCoins{sdk.DecCoin{Denom: "BTC", Amount: sdk.NewDec(10)}, sdk.NewDecCoin("eth", sdk.NewInt(15)), sdk.NewDecCoin("mytoken", sdk.NewInt(5))}, false, "invalid denoms", }, } - decCoins := NewDecCoinsFromCoins(NewCoin("btc", NewInt(10)), NewCoin("eth", NewInt(15)), NewCoin("mytoken", NewInt(5))) + decCoins := sdk.NewDecCoinsFromCoins(sdk.NewCoin("btc", sdk.NewInt(10)), sdk.NewCoin("eth", sdk.NewInt(15)), sdk.NewCoin("mytoken", sdk.NewInt(5))) for _, tc := range tests { tc := tc @@ -262,38 +264,38 @@ func TestSubDecCoins(t *testing.T) { } func TestSortDecCoins(t *testing.T) { - good := DecCoins{ - NewInt64DecCoin("gas", 1), - NewInt64DecCoin("mineral", 1), - NewInt64DecCoin("tree", 1), + good := sdk.DecCoins{ + sdk.NewInt64DecCoin("gas", 1), + sdk.NewInt64DecCoin("mineral", 1), + sdk.NewInt64DecCoin("tree", 1), } - empty := DecCoins{ - NewInt64DecCoin("gold", 0), + empty := sdk.DecCoins{ + sdk.NewInt64DecCoin("gold", 0), } - badSort1 := DecCoins{ - NewInt64DecCoin("tree", 1), - NewInt64DecCoin("gas", 1), - NewInt64DecCoin("mineral", 1), + badSort1 := sdk.DecCoins{ + sdk.NewInt64DecCoin("tree", 1), + sdk.NewInt64DecCoin("gas", 1), + sdk.NewInt64DecCoin("mineral", 1), } - badSort2 := DecCoins{ // both are after the first one, but the second and third are in the wrong order - NewInt64DecCoin("gas", 1), - NewInt64DecCoin("tree", 1), - NewInt64DecCoin("mineral", 1), + badSort2 := sdk.DecCoins{ // both are after the first one, but the second and third are in the wrong order + sdk.NewInt64DecCoin("gas", 1), + sdk.NewInt64DecCoin("tree", 1), + sdk.NewInt64DecCoin("mineral", 1), } - badAmt := DecCoins{ - NewInt64DecCoin("gas", 1), - NewInt64DecCoin("tree", 0), - NewInt64DecCoin("mineral", 1), + badAmt := sdk.DecCoins{ + sdk.NewInt64DecCoin("gas", 1), + sdk.NewInt64DecCoin("tree", 0), + sdk.NewInt64DecCoin("mineral", 1), } - dup := DecCoins{ - NewInt64DecCoin("gas", 1), - NewInt64DecCoin("gas", 1), - NewInt64DecCoin("mineral", 1), + dup := sdk.DecCoins{ + sdk.NewInt64DecCoin("gas", 1), + sdk.NewInt64DecCoin("gas", 1), + sdk.NewInt64DecCoin("mineral", 1), } cases := []struct { name string - coins DecCoins + coins sdk.DecCoins before, after bool // valid before/after sort }{ {"valid coins", good, true, true}, @@ -313,20 +315,20 @@ func TestSortDecCoins(t *testing.T) { func TestDecCoinsValidate(t *testing.T) { testCases := []struct { - input DecCoins + input sdk.DecCoins expectedPass bool }{ - {DecCoins{}, true}, - {DecCoins{DecCoin{testDenom1, NewDec(5)}}, true}, - {DecCoins{DecCoin{testDenom1, NewDec(5)}, DecCoin{testDenom2, NewDec(100000)}}, true}, - {DecCoins{DecCoin{testDenom1, NewDec(-5)}}, false}, - {DecCoins{DecCoin{"BTC", NewDec(5)}}, true}, - {DecCoins{DecCoin{"0BTC", NewDec(5)}}, false}, - {DecCoins{DecCoin{testDenom1, NewDec(5)}, DecCoin{"B", NewDec(100000)}}, false}, - {DecCoins{DecCoin{testDenom1, NewDec(5)}, DecCoin{testDenom2, NewDec(-100000)}}, false}, - {DecCoins{DecCoin{testDenom1, NewDec(-5)}, DecCoin{testDenom2, NewDec(100000)}}, false}, - {DecCoins{DecCoin{"BTC", NewDec(5)}, DecCoin{testDenom2, NewDec(100000)}}, true}, - {DecCoins{DecCoin{"0BTC", NewDec(5)}, DecCoin{testDenom2, NewDec(100000)}}, false}, + {sdk.DecCoins{}, true}, + {sdk.DecCoins{sdk.DecCoin{testDenom1, sdk.NewDec(5)}}, true}, + {sdk.DecCoins{sdk.DecCoin{testDenom1, sdk.NewDec(5)}, sdk.DecCoin{testDenom2, sdk.NewDec(100000)}}, true}, + {sdk.DecCoins{sdk.DecCoin{testDenom1, sdk.NewDec(-5)}}, false}, + {sdk.DecCoins{sdk.DecCoin{"BTC", sdk.NewDec(5)}}, true}, + {sdk.DecCoins{sdk.DecCoin{"0BTC", sdk.NewDec(5)}}, false}, + {sdk.DecCoins{sdk.DecCoin{testDenom1, sdk.NewDec(5)}, sdk.DecCoin{"B", sdk.NewDec(100000)}}, false}, + {sdk.DecCoins{sdk.DecCoin{testDenom1, sdk.NewDec(5)}, sdk.DecCoin{testDenom2, sdk.NewDec(-100000)}}, false}, + {sdk.DecCoins{sdk.DecCoin{testDenom1, sdk.NewDec(-5)}, sdk.DecCoin{testDenom2, sdk.NewDec(100000)}}, false}, + {sdk.DecCoins{sdk.DecCoin{"BTC", sdk.NewDec(5)}, sdk.DecCoin{testDenom2, sdk.NewDec(100000)}}, true}, + {sdk.DecCoins{sdk.DecCoin{"0BTC", sdk.NewDec(5)}, sdk.DecCoin{testDenom2, sdk.NewDec(100000)}}, false}, } for i, tc := range testCases { @@ -342,43 +344,43 @@ func TestDecCoinsValidate(t *testing.T) { func TestParseDecCoins(t *testing.T) { testCases := []struct { input string - expectedResult DecCoins + expectedResult sdk.DecCoins expectedErr bool }{ {"", nil, false}, {"4stake", nil, true}, {"5.5atom,4stake", nil, true}, - {"0.0stake", DecCoins{}, false}, // remove zero coins + {"0.0stake", sdk.DecCoins{}, false}, // remove zero coins {"10.0btc,1.0atom,20.0btc", nil, true}, { "0.004STAKE", - DecCoins{NewDecCoinFromDec("STAKE", NewDecWithPrec(4000000000000000, Precision))}, + sdk.DecCoins{sdk.NewDecCoinFromDec("STAKE", sdk.NewDecWithPrec(4000000000000000, sdk.Precision))}, false, }, { "0.004stake", - DecCoins{NewDecCoinFromDec("stake", NewDecWithPrec(4000000000000000, Precision))}, + sdk.DecCoins{sdk.NewDecCoinFromDec("stake", sdk.NewDecWithPrec(4000000000000000, sdk.Precision))}, false, }, { "5.04atom,0.004stake", - DecCoins{ - NewDecCoinFromDec("atom", NewDecWithPrec(5040000000000000000, Precision)), - NewDecCoinFromDec("stake", NewDecWithPrec(4000000000000000, Precision)), + sdk.DecCoins{ + sdk.NewDecCoinFromDec("atom", sdk.NewDecWithPrec(5040000000000000000, sdk.Precision)), + sdk.NewDecCoinFromDec("stake", sdk.NewDecWithPrec(4000000000000000, sdk.Precision)), }, false, }, {"0.0stake,0.004stake,5.04atom", // remove zero coins - DecCoins{ - NewDecCoinFromDec("atom", NewDecWithPrec(5040000000000000000, Precision)), - NewDecCoinFromDec("stake", NewDecWithPrec(4000000000000000, Precision)), + sdk.DecCoins{ + sdk.NewDecCoinFromDec("atom", sdk.NewDecWithPrec(5040000000000000000, sdk.Precision)), + sdk.NewDecCoinFromDec("stake", sdk.NewDecWithPrec(4000000000000000, sdk.Precision)), }, false, }, } for i, tc := range testCases { - res, err := ParseDecCoins(tc.input) + res, err := sdk.ParseDecCoins(tc.input) if tc.expectedErr { require.Error(t, err, "expected error for test case #%d, input: %v", i, tc.input) } else { @@ -390,14 +392,14 @@ func TestParseDecCoins(t *testing.T) { func TestDecCoinsString(t *testing.T) { testCases := []struct { - input DecCoins + input sdk.DecCoins expected string }{ - {DecCoins{}, ""}, + {sdk.DecCoins{}, ""}, { - DecCoins{ - NewDecCoinFromDec("atom", NewDecWithPrec(5040000000000000000, Precision)), - NewDecCoinFromDec("stake", NewDecWithPrec(4000000000000000, Precision)), + sdk.DecCoins{ + sdk.NewDecCoinFromDec("atom", sdk.NewDecWithPrec(5040000000000000000, sdk.Precision)), + sdk.NewDecCoinFromDec("stake", sdk.NewDecWithPrec(4000000000000000, sdk.Precision)), }, "5.040000000000000000atom,0.004000000000000000stake", }, @@ -429,11 +431,11 @@ func TestDecCoinsIntersect(t *testing.T) { } for i, tc := range testCases { - in1, err := ParseDecCoins(tc.input1) + in1, err := sdk.ParseDecCoins(tc.input1) require.NoError(t, err, "unexpected parse error in %v", i) - in2, err := ParseDecCoins(tc.input2) + in2, err := sdk.ParseDecCoins(tc.input2) require.NoError(t, err, "unexpected parse error in %v", i) - exr, err := ParseDecCoins(tc.expectedResult) + exr, err := sdk.ParseDecCoins(tc.expectedResult) require.NoError(t, err, "unexpected parse error in %v", i) require.True(t, in1.Intersect(in2).IsEqual(exr), "in1.cap(in2) != exr in %v", i) @@ -441,24 +443,24 @@ func TestDecCoinsIntersect(t *testing.T) { } func TestDecCoinsTruncateDecimal(t *testing.T) { - decCoinA := NewDecCoinFromDec("bar", MustNewDecFromStr("5.41")) - decCoinB := NewDecCoinFromDec("foo", MustNewDecFromStr("6.00")) + decCoinA := sdk.NewDecCoinFromDec("bar", sdk.MustNewDecFromStr("5.41")) + decCoinB := sdk.NewDecCoinFromDec("foo", sdk.MustNewDecFromStr("6.00")) testCases := []struct { - input DecCoins - truncatedCoins Coins - changeCoins DecCoins + input sdk.DecCoins + truncatedCoins sdk.Coins + changeCoins sdk.DecCoins }{ - {DecCoins{}, Coins(nil), DecCoins(nil)}, + {sdk.DecCoins{}, sdk.Coins(nil), sdk.DecCoins(nil)}, { - DecCoins{decCoinA, decCoinB}, - Coins{NewInt64Coin(decCoinA.Denom, 5), NewInt64Coin(decCoinB.Denom, 6)}, - DecCoins{NewDecCoinFromDec(decCoinA.Denom, MustNewDecFromStr("0.41"))}, + sdk.DecCoins{decCoinA, decCoinB}, + sdk.Coins{sdk.NewInt64Coin(decCoinA.Denom, 5), sdk.NewInt64Coin(decCoinB.Denom, 6)}, + sdk.DecCoins{sdk.NewDecCoinFromDec(decCoinA.Denom, sdk.MustNewDecFromStr("0.41"))}, }, { - DecCoins{decCoinB}, - Coins{NewInt64Coin(decCoinB.Denom, 6)}, - DecCoins(nil), + sdk.DecCoins{decCoinB}, + sdk.Coins{sdk.NewInt64Coin(decCoinB.Denom, 6)}, + sdk.DecCoins(nil), }, } @@ -476,18 +478,18 @@ func TestDecCoinsTruncateDecimal(t *testing.T) { } func TestDecCoinsQuoDecTruncate(t *testing.T) { - x := MustNewDecFromStr("1.00") - y := MustNewDecFromStr("10000000000000000000.00") + x := sdk.MustNewDecFromStr("1.00") + y := sdk.MustNewDecFromStr("10000000000000000000.00") testCases := []struct { - coins DecCoins - input Dec - result DecCoins + coins sdk.DecCoins + input sdk.Dec + result sdk.DecCoins panics bool }{ - {DecCoins{}, ZeroDec(), DecCoins(nil), true}, - {DecCoins{NewDecCoinFromDec("foo", x)}, y, DecCoins(nil), false}, - {DecCoins{NewInt64DecCoin("foo", 5)}, NewDec(2), DecCoins{NewDecCoinFromDec("foo", MustNewDecFromStr("2.5"))}, false}, + {sdk.DecCoins{}, sdk.ZeroDec(), sdk.DecCoins(nil), true}, + {sdk.DecCoins{sdk.NewDecCoinFromDec("foo", x)}, y, sdk.DecCoins(nil), false}, + {sdk.DecCoins{sdk.NewInt64DecCoin("foo", 5)}, sdk.NewDec(2), sdk.DecCoins{sdk.NewDecCoinFromDec("foo", sdk.MustNewDecFromStr("2.5"))}, false}, } for i, tc := range testCases { @@ -502,16 +504,16 @@ func TestDecCoinsQuoDecTruncate(t *testing.T) { } func TestNewDecCoinsWithIsValid(t *testing.T) { - fake1 := append(NewDecCoins(NewDecCoin("mytoken", NewInt(10))), DecCoin{Denom: "10BTC", Amount: NewDec(10)}) - fake2 := append(NewDecCoins(NewDecCoin("mytoken", NewInt(10))), DecCoin{Denom: "BTC", Amount: NewDec(-10)}) + fake1 := append(sdk.NewDecCoins(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), sdk.DecCoin{Denom: "10BTC", Amount: sdk.NewDec(10)}) + fake2 := append(sdk.NewDecCoins(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), sdk.DecCoin{Denom: "BTC", Amount: sdk.NewDec(-10)}) tests := []struct { - coin DecCoins + coin sdk.DecCoins expectPass bool msg string }{ { - NewDecCoins(NewDecCoin("mytoken", NewInt(10))), + sdk.NewDecCoins(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), true, "valid coins should have passed", }, @@ -538,26 +540,26 @@ func TestNewDecCoinsWithIsValid(t *testing.T) { } func TestDecCoins_AddDecCoinWithIsValid(t *testing.T) { - lengthTestDecCoins := NewDecCoins().Add(NewDecCoin("mytoken", NewInt(10))).Add(DecCoin{Denom: "BTC", Amount: NewDec(10)}) + lengthTestDecCoins := sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))).Add(sdk.DecCoin{Denom: "BTC", Amount: sdk.NewDec(10)}) require.Equal(t, 2, len(lengthTestDecCoins), "should be 2") tests := []struct { - coin DecCoins + coin sdk.DecCoins expectPass bool msg string }{ { - NewDecCoins().Add(NewDecCoin("mytoken", NewInt(10))), + sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), true, "valid coins should have passed", }, { - NewDecCoins().Add(NewDecCoin("mytoken", NewInt(10))).Add(DecCoin{Denom: "0BTC", Amount: NewDec(10)}), + sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))).Add(sdk.DecCoin{Denom: "0BTC", Amount: sdk.NewDec(10)}), false, "invalid denoms", }, { - NewDecCoins().Add(NewDecCoin("mytoken", NewInt(10))).Add(DecCoin{Denom: "BTC", Amount: NewDec(-10)}), + sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))).Add(sdk.DecCoin{Denom: "BTC", Amount: sdk.NewDec(-10)}), false, "negative amount", },