255 lines
9.0 KiB
Go
255 lines
9.0 KiB
Go
package types
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
)
|
|
|
|
func TestMsgSendRoute(t *testing.T) {
|
|
addr1 := sdk.AccAddress([]byte("from"))
|
|
addr2 := sdk.AccAddress([]byte("to"))
|
|
coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
|
|
var msg = NewMsgSend(addr1, addr2, coins)
|
|
|
|
require.Equal(t, msg.Route(), RouterKey)
|
|
require.Equal(t, msg.Type(), "send")
|
|
}
|
|
|
|
func TestMsgSendValidation(t *testing.T) {
|
|
addr1 := sdk.AccAddress([]byte("from________________"))
|
|
addr2 := sdk.AccAddress([]byte("to__________________"))
|
|
addrEmpty := sdk.AccAddress([]byte(""))
|
|
addrLong := sdk.AccAddress([]byte("Purposefully long address"))
|
|
|
|
atom123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
|
|
atom0 := sdk.NewCoins(sdk.NewInt64Coin("atom", 0))
|
|
atom123eth123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 123))
|
|
atom123eth0 := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 0)}
|
|
|
|
cases := []struct {
|
|
expectedErr string // empty means no error expected
|
|
msg *MsgSend
|
|
}{
|
|
{"", NewMsgSend(addr1, addr2, atom123)}, // valid send
|
|
{"", NewMsgSend(addr1, addr2, atom123eth123)}, // valid send with multiple coins
|
|
{"", NewMsgSend(addrLong, addr2, atom123)}, // valid send with long addr sender
|
|
{"", NewMsgSend(addr1, addrLong, atom123)}, // valid send with long addr recipient
|
|
{": invalid coins", NewMsgSend(addr1, addr2, atom0)}, // non positive coin
|
|
{"123atom,0eth: invalid coins", NewMsgSend(addr1, addr2, atom123eth0)}, // non positive coin in multicoins
|
|
{"invalid from address: empty address string is not allowed: invalid address", NewMsgSend(addrEmpty, addr2, atom123)},
|
|
{"invalid to address: empty address string is not allowed: invalid address", NewMsgSend(addr1, addrEmpty, atom123)},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
err := tc.msg.ValidateBasic()
|
|
if tc.expectedErr == "" {
|
|
require.Nil(t, err)
|
|
} else {
|
|
require.EqualError(t, err, tc.expectedErr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMsgSendGetSignBytes(t *testing.T) {
|
|
addr1 := sdk.AccAddress([]byte("input"))
|
|
addr2 := sdk.AccAddress([]byte("output"))
|
|
coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
|
|
var msg = NewMsgSend(addr1, addr2, coins)
|
|
res := msg.GetSignBytes()
|
|
|
|
expected := `{"type":"cosmos-sdk/MsgSend","value":{"amount":[{"amount":"10","denom":"atom"}],"from_address":"cosmos1d9h8qat57ljhcm","to_address":"cosmos1da6hgur4wsmpnjyg"}}`
|
|
require.Equal(t, expected, string(res))
|
|
}
|
|
|
|
func TestMsgMultiSendRoute(t *testing.T) {
|
|
// Construct a MsgSend
|
|
addr1 := sdk.AccAddress([]byte("input"))
|
|
addr2 := sdk.AccAddress([]byte("output"))
|
|
coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
|
|
var msg = MsgMultiSend{
|
|
Inputs: []Input{NewInput(addr1, coins)},
|
|
Outputs: []Output{NewOutput(addr2, coins)},
|
|
}
|
|
|
|
// TODO some failures for bad result
|
|
require.Equal(t, msg.Route(), RouterKey)
|
|
require.Equal(t, msg.Type(), "multisend")
|
|
}
|
|
|
|
func TestInputValidation(t *testing.T) {
|
|
addr1 := sdk.AccAddress([]byte("_______alice________"))
|
|
addr2 := sdk.AccAddress([]byte("________bob_________"))
|
|
addrEmpty := sdk.AccAddress([]byte(""))
|
|
addrLong := sdk.AccAddress([]byte("Purposefully long address"))
|
|
|
|
someCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
|
|
multiCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20))
|
|
|
|
emptyCoins := sdk.NewCoins()
|
|
emptyCoins2 := sdk.NewCoins(sdk.NewInt64Coin("eth", 0))
|
|
someEmptyCoins := sdk.Coins{sdk.NewInt64Coin("eth", 10), sdk.NewInt64Coin("atom", 0)}
|
|
unsortedCoins := sdk.Coins{sdk.NewInt64Coin("eth", 1), sdk.NewInt64Coin("atom", 1)}
|
|
|
|
cases := []struct {
|
|
expectedErr string // empty means no error expected
|
|
txIn Input
|
|
}{
|
|
// auth works with different apps
|
|
{"", NewInput(addr1, someCoins)},
|
|
{"", NewInput(addr2, someCoins)},
|
|
{"", NewInput(addr2, multiCoins)},
|
|
{"", NewInput(addrLong, someCoins)},
|
|
|
|
{"invalid input address: empty address string is not allowed: invalid address", NewInput(addrEmpty, someCoins)},
|
|
{": invalid coins", NewInput(addr1, emptyCoins)}, // invalid coins
|
|
{": invalid coins", NewInput(addr1, emptyCoins2)}, // invalid coins
|
|
{"10eth,0atom: invalid coins", NewInput(addr1, someEmptyCoins)}, // invalid coins
|
|
{"1eth,1atom: invalid coins", NewInput(addr1, unsortedCoins)}, // unsorted coins
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
err := tc.txIn.ValidateBasic()
|
|
if tc.expectedErr == "" {
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
} else {
|
|
require.EqualError(t, err, tc.expectedErr, "%d", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestOutputValidation(t *testing.T) {
|
|
addr1 := sdk.AccAddress([]byte("_______alice________"))
|
|
addr2 := sdk.AccAddress([]byte("________bob_________"))
|
|
addrEmpty := sdk.AccAddress([]byte(""))
|
|
addrLong := sdk.AccAddress([]byte("Purposefully long address"))
|
|
|
|
someCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
|
|
multiCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20))
|
|
|
|
emptyCoins := sdk.NewCoins()
|
|
emptyCoins2 := sdk.NewCoins(sdk.NewInt64Coin("eth", 0))
|
|
someEmptyCoins := sdk.Coins{sdk.NewInt64Coin("eth", 10), sdk.NewInt64Coin("atom", 0)}
|
|
unsortedCoins := sdk.Coins{sdk.NewInt64Coin("eth", 1), sdk.NewInt64Coin("atom", 1)}
|
|
|
|
cases := []struct {
|
|
expectedErr string // empty means no error expected
|
|
txOut Output
|
|
}{
|
|
// auth works with different apps
|
|
{"", NewOutput(addr1, someCoins)},
|
|
{"", NewOutput(addr2, someCoins)},
|
|
{"", NewOutput(addr2, multiCoins)},
|
|
{"", NewOutput(addrLong, someCoins)},
|
|
|
|
{"invalid output address: empty address string is not allowed: invalid address", NewOutput(addrEmpty, someCoins)},
|
|
{": invalid coins", NewOutput(addr1, emptyCoins)}, // invalid coins
|
|
{": invalid coins", NewOutput(addr1, emptyCoins2)}, // invalid coins
|
|
{"10eth,0atom: invalid coins", NewOutput(addr1, someEmptyCoins)}, // invalid coins
|
|
{"1eth,1atom: invalid coins", NewOutput(addr1, unsortedCoins)}, // unsorted coins
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
err := tc.txOut.ValidateBasic()
|
|
if tc.expectedErr == "" {
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
} else {
|
|
require.EqualError(t, err, tc.expectedErr, "%d", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMsgMultiSendValidation(t *testing.T) {
|
|
addr1 := sdk.AccAddress([]byte("_______alice________"))
|
|
addr2 := sdk.AccAddress([]byte("________bob_________"))
|
|
atom123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
|
|
atom124 := sdk.NewCoins(sdk.NewInt64Coin("atom", 124))
|
|
eth123 := sdk.NewCoins(sdk.NewInt64Coin("eth", 123))
|
|
atom123eth123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 123))
|
|
|
|
input1 := NewInput(addr1, atom123)
|
|
input2 := NewInput(addr1, eth123)
|
|
output1 := NewOutput(addr2, atom123)
|
|
output2 := NewOutput(addr2, atom124)
|
|
outputMulti := NewOutput(addr2, atom123eth123)
|
|
|
|
var emptyAddr sdk.AccAddress
|
|
|
|
cases := []struct {
|
|
valid bool
|
|
tx MsgMultiSend
|
|
}{
|
|
{false, MsgMultiSend{}}, // no input or output
|
|
{false, MsgMultiSend{Inputs: []Input{input1}}}, // just input
|
|
{false, MsgMultiSend{Outputs: []Output{output1}}}, // just output
|
|
{false, MsgMultiSend{
|
|
Inputs: []Input{NewInput(emptyAddr, atom123)}, // invalid input
|
|
Outputs: []Output{output1}}},
|
|
{false, MsgMultiSend{
|
|
Inputs: []Input{input1},
|
|
Outputs: []Output{{emptyAddr.String(), atom123}}}, // invalid output
|
|
},
|
|
{false, MsgMultiSend{
|
|
Inputs: []Input{input1},
|
|
Outputs: []Output{output2}}, // amounts dont match
|
|
},
|
|
{true, MsgMultiSend{
|
|
Inputs: []Input{input1},
|
|
Outputs: []Output{output1}},
|
|
},
|
|
{true, MsgMultiSend{
|
|
Inputs: []Input{input1, input2},
|
|
Outputs: []Output{outputMulti}},
|
|
},
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
err := tc.tx.ValidateBasic()
|
|
if tc.valid {
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
} else {
|
|
require.NotNil(t, err, "%d", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMsgMultiSendGetSignBytes(t *testing.T) {
|
|
addr1 := sdk.AccAddress([]byte("input"))
|
|
addr2 := sdk.AccAddress([]byte("output"))
|
|
coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
|
|
var msg = MsgMultiSend{
|
|
Inputs: []Input{NewInput(addr1, coins)},
|
|
Outputs: []Output{NewOutput(addr2, coins)},
|
|
}
|
|
res := msg.GetSignBytes()
|
|
|
|
expected := `{"type":"cosmos-sdk/MsgMultiSend","value":{"inputs":[{"address":"cosmos1d9h8qat57ljhcm","coins":[{"amount":"10","denom":"atom"}]}],"outputs":[{"address":"cosmos1da6hgur4wsmpnjyg","coins":[{"amount":"10","denom":"atom"}]}]}}`
|
|
require.Equal(t, expected, string(res))
|
|
}
|
|
|
|
func TestMsgMultiSendGetSigners(t *testing.T) {
|
|
addrs := make([]string, 3)
|
|
inputs := make([]Input, 3)
|
|
for i, v := range []string{"input111111111111111", "input222222222222222", "input333333333333333"} {
|
|
addr := sdk.AccAddress([]byte(v))
|
|
inputs[i] = NewInput(addr, nil)
|
|
addrs[i] = addr.String()
|
|
}
|
|
var msg = NewMsgMultiSend(inputs, nil)
|
|
|
|
res := msg.GetSigners()
|
|
for i, signer := range res {
|
|
require.Equal(t, signer.String(), addrs[i])
|
|
}
|
|
}
|
|
|
|
func TestMsgSendGetSigners(t *testing.T) {
|
|
from := sdk.AccAddress([]byte("input111111111111111"))
|
|
msg := NewMsgSend(from, sdk.AccAddress{}, sdk.NewCoins())
|
|
res := msg.GetSigners()
|
|
require.Equal(t, 1, len(res))
|
|
require.True(t, from.Equals(res[0]))
|
|
}
|