cosmos-sdk/x/ibc/ibc_test.go

161 lines
4.1 KiB
Go
Raw Normal View History

2018-03-18 15:38:18 -07:00
package ibc
import (
"testing"
"github.com/stretchr/testify/require"
2018-03-18 15:38:18 -07:00
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/ed25519"
dbm "github.com/tendermint/tendermint/libs/db"
"github.com/tendermint/tendermint/libs/log"
2018-03-18 15:38:18 -07:00
"github.com/cosmos/cosmos-sdk/codec"
2018-03-18 15:38:18 -07:00
"github.com/cosmos/cosmos-sdk/store"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/bank"
2018-12-20 11:09:43 -08:00
"github.com/cosmos/cosmos-sdk/x/params"
2018-03-18 15:38:18 -07:00
)
// AccountKeeper(/Keeper) and IBCMapper should use different StoreKey later
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
type testInput struct {
cdc *codec.Codec
ctx sdk.Context
ak auth.AccountKeeper
bk bank.BaseKeeper
ibcKey *sdk.KVStoreKey
2018-03-18 15:38:18 -07:00
}
2018-12-20 11:09:43 -08:00
func setupTestInput() testInput {
db := dbm.NewMemDB()
cdc := makeCodec()
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
ibcKey := sdk.NewKVStoreKey("ibcCapKey")
authCapKey := sdk.NewKVStoreKey("authCapKey")
fckCapKey := sdk.NewKVStoreKey("fckCapKey")
keyParams := sdk.NewKVStoreKey("params")
tkeyParams := sdk.NewTransientStoreKey("transient_params")
ms := store.NewCommitMultiStore(db)
ms.MountStoreWithDB(ibcKey, sdk.StoreTypeIAVL, db)
ms.MountStoreWithDB(authCapKey, sdk.StoreTypeIAVL, db)
ms.MountStoreWithDB(fckCapKey, sdk.StoreTypeIAVL, db)
ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db)
ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db)
ms.LoadLatestVersion()
pk := params.NewKeeper(cdc, keyParams, tkeyParams)
ak := auth.NewAccountKeeper(
cdc, authCapKey, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount,
)
bk := bank.NewBaseKeeper(ak, pk.Subspace(bank.DefaultParamspace), bank.DefaultCodespace)
2018-12-20 11:09:43 -08:00
ctx := sdk.NewContext(ms, abci.Header{ChainID: "test-chain-id"}, false, log.NewNopLogger())
ak.SetParams(ctx, auth.DefaultParams())
return testInput{cdc: cdc, ctx: ctx, ak: ak, bk: bk, ibcKey: ibcKey}
2018-03-18 15:38:18 -07:00
}
func makeCodec() *codec.Codec {
var cdc = codec.New()
2018-04-06 17:25:08 -07:00
// Register Msgs
cdc.RegisterInterface((*sdk.Msg)(nil), nil)
2018-04-18 21:49:24 -07:00
cdc.RegisterConcrete(bank.MsgSend{}, "test/ibc/Send", nil)
2018-04-06 17:25:08 -07:00
cdc.RegisterConcrete(IBCTransferMsg{}, "test/ibc/IBCTransferMsg", nil)
cdc.RegisterConcrete(IBCReceiveMsg{}, "test/ibc/IBCReceiveMsg", nil)
// Register AppAccount
2018-05-23 22:09:01 -07:00
cdc.RegisterInterface((*auth.Account)(nil), nil)
2018-04-06 17:25:08 -07:00
cdc.RegisterConcrete(&auth.BaseAccount{}, "test/ibc/Account", nil)
codec.RegisterCrypto(cdc)
2018-03-18 15:38:18 -07:00
cdc.Seal()
2018-03-18 15:38:18 -07:00
return cdc
}
2018-12-20 11:09:43 -08:00
func newAddress() sdk.AccAddress {
return sdk.AccAddress(ed25519.GenPrivKey().PubKey().Address())
}
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
func getCoins(ck bank.Keeper, ctx sdk.Context, addr sdk.AccAddress) (sdk.Coins, sdk.Error) {
zero := sdk.Coins(nil)
coins, _, err := ck.AddCoins(ctx, addr, zero)
return coins, err
}
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
func TestIBC(t *testing.T) {
input := setupTestInput()
ctx := input.ctx
2018-03-18 15:38:18 -07:00
src := newAddress()
dest := newAddress()
chainid := "ibcchain"
2018-04-07 00:02:00 -07:00
zero := sdk.Coins(nil)
2018-07-30 17:09:50 -07:00
mycoins := sdk.Coins{sdk.NewInt64Coin("mycoin", 10)}
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
coins, _, err := input.bk.AddCoins(ctx, src, mycoins)
require.Nil(t, err)
require.Equal(t, mycoins, coins)
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
ibcm := NewMapper(input.cdc, input.ibcKey, DefaultCodespace)
h := NewHandler(ibcm, input.bk)
2018-03-18 15:38:18 -07:00
packet := IBCPacket{
SrcAddr: src,
DestAddr: dest,
Coins: mycoins,
SrcChain: chainid,
DestChain: chainid,
}
2018-12-20 11:09:43 -08:00
store := ctx.KVStore(input.ibcKey)
2018-03-18 15:38:18 -07:00
var msg sdk.Msg
var res sdk.Result
var egl uint64
var igs uint64
2018-03-18 15:38:18 -07:00
egl = ibcm.getEgressLength(store, chainid)
require.Equal(t, egl, uint64(0))
2018-03-18 15:38:18 -07:00
msg = IBCTransferMsg{
IBCPacket: packet,
}
res = h(ctx, msg)
require.True(t, res.IsOK())
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
coins, err = getCoins(input.bk, ctx, src)
require.Nil(t, err)
require.Equal(t, zero, coins)
2018-03-18 15:38:18 -07:00
egl = ibcm.getEgressLength(store, chainid)
require.Equal(t, egl, uint64(1))
2018-03-18 15:38:18 -07:00
igs = ibcm.GetIngressSequence(ctx, chainid)
require.Equal(t, igs, uint64(0))
2018-03-18 15:38:18 -07:00
msg = IBCReceiveMsg{
IBCPacket: packet,
Relayer: src,
Sequence: 0,
}
res = h(ctx, msg)
require.True(t, res.IsOK())
2018-03-18 15:38:18 -07:00
2018-12-20 11:09:43 -08:00
coins, err = getCoins(input.bk, ctx, dest)
require.Nil(t, err)
require.Equal(t, mycoins, coins)
2018-03-18 15:38:18 -07:00
igs = ibcm.GetIngressSequence(ctx, chainid)
require.Equal(t, igs, uint64(1))
2018-03-18 15:38:18 -07:00
res = h(ctx, msg)
require.False(t, res.IsOK())
2018-03-18 15:38:18 -07:00
igs = ibcm.GetIngressSequence(ctx, chainid)
require.Equal(t, igs, uint64(1))
2018-03-18 15:38:18 -07:00
}