293 lines
9.1 KiB
Go
293 lines
9.1 KiB
Go
package app
|
|
|
|
// import (
|
|
// "encoding/hex"
|
|
// "testing"
|
|
|
|
// "github.com/stretchr/testify/assert"
|
|
// "github.com/stretchr/testify/require"
|
|
|
|
// sdk "github.com/cosmos/cosmos-sdk"
|
|
// "github.com/cosmos/cosmos-sdk/modules/auth"
|
|
// "github.com/cosmos/cosmos-sdk/modules/base"
|
|
// "github.com/cosmos/cosmos-sdk/modules/coin"
|
|
// "github.com/cosmos/cosmos-sdk/modules/fee"
|
|
// "github.com/cosmos/cosmos-sdk/modules/nonce"
|
|
// "github.com/cosmos/cosmos-sdk/stack"
|
|
// "github.com/cosmos/cosmos-sdk/state"
|
|
// "github.com/cosmos/cosmos-sdk/util"
|
|
// abci "github.com/tendermint/abci/types"
|
|
// wire "github.com/tendermint/go-wire"
|
|
// "github.com/tendermint/tmlibs/log"
|
|
// )
|
|
|
|
// // DefaultHandler for the tests (coin, roles, ibc)
|
|
// func DefaultHandler(feeDenom string) sdk.Handler {
|
|
// // use the default stack
|
|
// // r := roles.NewHandler()
|
|
// // i := ibc.NewHandler()
|
|
|
|
// return sdk.ChainDecorators(
|
|
// util.Logger{},
|
|
// util.Recovery{},
|
|
// auth.Signatures{},
|
|
// util.Chain{},
|
|
// // stack.Checkpoint{OnCheck: true},
|
|
// // nonce.ReplayCheck{},
|
|
// ).
|
|
// // IBC(ibc.NewMiddleware()).
|
|
// // Apps(
|
|
// // roles.NewMiddleware(),
|
|
// // fee.NewSimpleFeeMiddleware(coin.Coin{feeDenom, 0}, fee.Bank),
|
|
// // stack.Checkpoint{OnDeliver: true},
|
|
// // ).
|
|
// WithHandler(
|
|
// coin.NewHandler(),
|
|
// // stack.WrapHandler(r),
|
|
// // stack.WrapHandler(i),
|
|
// )
|
|
// }
|
|
|
|
// //--------------------------------------------------------
|
|
// // test environment is a list of input and output accounts
|
|
|
|
// type appTest struct {
|
|
// t *testing.T
|
|
// chainID string
|
|
// app *BaseApp
|
|
// acctIn *coin.AccountWithKey
|
|
// acctOut *coin.AccountWithKey
|
|
// }
|
|
|
|
// func newAppTest(t *testing.T) *appTest {
|
|
// at := &appTest{
|
|
// t: t,
|
|
// chainID: "test_chain_id",
|
|
// }
|
|
// at.reset()
|
|
// return at
|
|
// }
|
|
|
|
// // baseTx is the
|
|
// func (at *appTest) baseTx(coins coin.Coins) sdk.Tx {
|
|
// in := []coin.TxInput{{Address: at.acctIn.Actor(), Coins: coins}}
|
|
// out := []coin.TxOutput{{Address: at.acctOut.Actor(), Coins: coins}}
|
|
// tx := coin.NewSendTx(in, out)
|
|
// return tx
|
|
// }
|
|
|
|
// func (at *appTest) signTx(tx sdk.Tx) sdk.Tx {
|
|
// stx := auth.NewMulti(tx)
|
|
// auth.Sign(stx, at.acctIn.Key)
|
|
// return stx.Wrap()
|
|
// }
|
|
|
|
// func (at *appTest) getTx(coins coin.Coins, sequence uint32) sdk.Tx {
|
|
// tx := at.baseTx(coins)
|
|
// tx = nonce.NewTx(sequence, []sdk.Actor{at.acctIn.Actor()}, tx)
|
|
// tx = base.NewChainTx(at.chainID, 0, tx)
|
|
// return at.signTx(tx)
|
|
// }
|
|
|
|
// func (at *appTest) feeTx(coins coin.Coins, toll coin.Coin, sequence uint32) sdk.Tx {
|
|
// tx := at.baseTx(coins)
|
|
// tx = fee.NewFee(tx, toll, at.acctIn.Actor())
|
|
// tx = nonce.NewTx(sequence, []sdk.Actor{at.acctIn.Actor()}, tx)
|
|
// tx = base.NewChainTx(at.chainID, 0, tx)
|
|
// return at.signTx(tx)
|
|
// }
|
|
|
|
// // set the account on the app through InitState
|
|
// func (at *appTest) initAccount(acct *coin.AccountWithKey) {
|
|
// err := at.app.InitState("coin", "account", acct.MakeOption())
|
|
// require.Nil(at.t, err, "%+v", err)
|
|
// }
|
|
|
|
// // reset the in and out accs to be one account each with 7mycoin
|
|
// func (at *appTest) reset() {
|
|
// at.acctIn = coin.NewAccountWithKey(coin.Coins{{"mycoin", 7}})
|
|
// at.acctOut = coin.NewAccountWithKey(coin.Coins{{"mycoin", 7}})
|
|
|
|
// // Note: switch logger if you want to get more info
|
|
// logger := log.TestingLogger()
|
|
// // logger := log.NewTracingLogger(log.NewTMLogger(os.Stdout))
|
|
|
|
// store, err := NewStoreApp("app-test", "", 0, logger)
|
|
// require.Nil(at.t, err, "%+v", err)
|
|
// at.app = NewBaseApp(store, DefaultHandler("mycoin"), nil)
|
|
|
|
// err = at.app.InitState("base", "chain_id", at.chainID)
|
|
// require.Nil(at.t, err, "%+v", err)
|
|
|
|
// at.initAccount(at.acctIn)
|
|
// at.initAccount(at.acctOut)
|
|
|
|
// resabci := at.app.Commit()
|
|
// require.True(at.t, resabci.IsOK(), resabci)
|
|
// }
|
|
|
|
// func getBalance(key sdk.Actor, store state.SimpleDB) (coin.Coins, error) {
|
|
// cspace := stack.PrefixedStore(coin.NameCoin, store)
|
|
// acct, err := coin.GetAccount(cspace, key)
|
|
// return acct.Coins, err
|
|
// }
|
|
|
|
// func getAddr(addr []byte, state state.SimpleDB) (coin.Coins, error) {
|
|
// actor := auth.SigPerm(addr)
|
|
// return getBalance(actor, state)
|
|
// }
|
|
|
|
// // returns the final balance and expected balance for input and output accounts
|
|
// func (at *appTest) exec(t *testing.T, tx sdk.Tx, checkTx bool) (res abci.Result, diffIn, diffOut coin.Coins) {
|
|
// require := require.New(t)
|
|
|
|
// initBalIn, err := getBalance(at.acctIn.Actor(), at.app.Append())
|
|
// require.Nil(err, "%+v", err)
|
|
// initBalOut, err := getBalance(at.acctOut.Actor(), at.app.Append())
|
|
// require.Nil(err, "%+v", err)
|
|
|
|
// txBytes := wire.BinaryBytes(tx)
|
|
// if checkTx {
|
|
// res = at.app.CheckTx(txBytes)
|
|
// } else {
|
|
// res = at.app.DeliverTx(txBytes)
|
|
// }
|
|
|
|
// endBalIn, err := getBalance(at.acctIn.Actor(), at.app.Append())
|
|
// require.Nil(err, "%+v", err)
|
|
// endBalOut, err := getBalance(at.acctOut.Actor(), at.app.Append())
|
|
// require.Nil(err, "%+v", err)
|
|
// return res, endBalIn.Minus(initBalIn), endBalOut.Minus(initBalOut)
|
|
// }
|
|
|
|
// //--------------------------------------------------------
|
|
|
|
// func TestInitState(t *testing.T) {
|
|
// assert := assert.New(t)
|
|
// require := require.New(t)
|
|
|
|
// logger := log.TestingLogger()
|
|
// store, err := NewStoreApp("app-test", "", 0, logger)
|
|
// require.Nil(err, "%+v", err)
|
|
// app := NewBaseApp(store, DefaultHandler("atom"), nil)
|
|
|
|
// //testing ChainID
|
|
// chainID := "testChain"
|
|
// err = app.InitState("base", "chain_id", chainID)
|
|
// require.Nil(err, "%+v", err)
|
|
// assert.EqualValues(app.GetChainID(), chainID)
|
|
|
|
// // make a nice account...
|
|
// bal := coin.Coins{{"atom", 77}, {"eth", 12}}
|
|
// acct := coin.NewAccountWithKey(bal)
|
|
// err = app.InitState("coin", "account", acct.MakeOption())
|
|
// require.Nil(err, "%+v", err)
|
|
|
|
// // make sure it is set correctly, with some balance
|
|
// coins, err := getBalance(acct.Actor(), app.Append())
|
|
// require.Nil(err)
|
|
// assert.Equal(bal, coins)
|
|
|
|
// // let's parse an account with badly sorted coins...
|
|
// unsortAddr, err := hex.DecodeString("C471FB670E44D219EE6DF2FC284BE38793ACBCE1")
|
|
// require.Nil(err)
|
|
// unsortCoins := coin.Coins{{"BTC", 789}, {"eth", 123}}
|
|
// unsortAcc := `{
|
|
// "pub_key": {
|
|
// "type": "ed25519",
|
|
// "data": "AD084F0572C116D618B36F2EB08240D1BAB4B51716CCE0E7734B89C8936DCE9A"
|
|
// },
|
|
// "coins": [
|
|
// {
|
|
// "denom": "eth",
|
|
// "amount": 123
|
|
// },
|
|
// {
|
|
// "denom": "BTC",
|
|
// "amount": 789
|
|
// }
|
|
// ]
|
|
// }`
|
|
// err = app.InitState("coin", "account", unsortAcc)
|
|
// require.Nil(err, "%+v", err)
|
|
|
|
// coins, err = getAddr(unsortAddr, app.Append())
|
|
// require.Nil(err)
|
|
// assert.True(coins.IsValid())
|
|
// assert.Equal(unsortCoins, coins)
|
|
|
|
// err = app.InitState("base", "dslfkgjdas", "")
|
|
// require.Error(err)
|
|
|
|
// err = app.InitState("", "dslfkgjdas", "")
|
|
// require.Error(err)
|
|
|
|
// err = app.InitState("dslfkgjdas", "szfdjzs", "")
|
|
// require.Error(err)
|
|
// }
|
|
|
|
// // Test CheckTx and DeliverTx with insufficient and sufficient balance
|
|
// func TestTx(t *testing.T) {
|
|
// assert := assert.New(t)
|
|
// at := newAppTest(t)
|
|
|
|
// //Bad Balance
|
|
// at.acctIn.Coins = coin.Coins{{"mycoin", 2}}
|
|
// at.initAccount(at.acctIn)
|
|
// at.app.Commit()
|
|
|
|
// res, _, _ := at.exec(t, at.getTx(coin.Coins{{"mycoin", 5}}, 1), true)
|
|
// assert.True(res.IsErr(), "ExecTx/Bad CheckTx: Expected error return from ExecTx, returned: %v", res)
|
|
// res, diffIn, diffOut := at.exec(t, at.getTx(coin.Coins{{"mycoin", 5}}, 1), false)
|
|
// assert.True(res.IsErr(), "ExecTx/Bad DeliverTx: Expected error return from ExecTx, returned: %v", res)
|
|
// assert.True(diffIn.IsZero())
|
|
// assert.True(diffOut.IsZero())
|
|
|
|
// //Regular CheckTx
|
|
// at.reset()
|
|
// res, _, _ = at.exec(t, at.getTx(coin.Coins{{"mycoin", 5}}, 1), true)
|
|
// assert.True(res.IsOK(), "ExecTx/Good CheckTx: Expected OK return from ExecTx, Error: %v", res)
|
|
|
|
// //Regular DeliverTx
|
|
// at.reset()
|
|
// amt := coin.Coins{{"mycoin", 3}}
|
|
// res, diffIn, diffOut = at.exec(t, at.getTx(amt, 1), false)
|
|
// assert.True(res.IsOK(), "ExecTx/Good DeliverTx: Expected OK return from ExecTx, Error: %v", res)
|
|
// assert.Equal(amt.Negative(), diffIn)
|
|
// assert.Equal(amt, diffOut)
|
|
|
|
// //DeliverTx with fee.... 4 get to recipient, 1 extra taxed
|
|
// at.reset()
|
|
// amt = coin.Coins{{"mycoin", 4}}
|
|
// toll := coin.Coin{"mycoin", 1}
|
|
// res, diffIn, diffOut = at.exec(t, at.feeTx(amt, toll, 1), false)
|
|
// assert.True(res.IsOK(), "ExecTx/Good DeliverTx: Expected OK return from ExecTx, Error: %v", res)
|
|
// payment := amt.Plus(coin.Coins{toll}).Negative()
|
|
// assert.Equal(payment, diffIn)
|
|
// assert.Equal(amt, diffOut)
|
|
|
|
// }
|
|
|
|
// func TestQuery(t *testing.T) {
|
|
// assert := assert.New(t)
|
|
// at := newAppTest(t)
|
|
|
|
// res, _, _ := at.exec(t, at.getTx(coin.Coins{{"mycoin", 5}}, 1), false)
|
|
// assert.True(res.IsOK(), "Commit, DeliverTx: Expected OK return from DeliverTx, Error: %v", res)
|
|
|
|
// resQueryPreCommit := at.app.Query(abci.RequestQuery{
|
|
// Path: "/account",
|
|
// Data: at.acctIn.Address(),
|
|
// })
|
|
|
|
// res = at.app.Commit()
|
|
// assert.True(res.IsOK(), res)
|
|
|
|
// key := stack.PrefixedKey(coin.NameCoin, at.acctIn.Address())
|
|
// resQueryPostCommit := at.app.Query(abci.RequestQuery{
|
|
// Path: "/key",
|
|
// Data: key,
|
|
// })
|
|
// assert.NotEqual(resQueryPreCommit, resQueryPostCommit, "Query should change before/after commit")
|
|
// }
|