Alessio Treglia
GitHub
parent
f446c91329
commit
04ff40a8df
1
Makefile
1
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):
|
||||
|
|
|
|||
1
go.sum
1
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=
|
||||
|
|
|
|||
|
|
@ -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...)
|
||||
}
|
||||
|
|
@ -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)))
|
||||
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)))
|
||||
|
||||
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)))
|
||||
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)))
|
||||
|
||||
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)))
|
||||
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)))
|
||||
|
||||
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().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())
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -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 TestContextTestSuite(t *testing.T) {
|
||||
suite.Run(t, new(ContextTestSuite))
|
||||
}
|
||||
|
||||
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 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) })
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
},
|
||||
|
|
|
|||
Loading…
Reference in New Issue