certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge PR #4909: Refactor x/bank Tests

This commit is contained in:
colin axner 2019-08-19 06:29:17 -07:00 committed by Alexander Bezobchuk
parent 91b53f2698
commit a697be15fe
9 changed files with 373 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
simapp/helpers.go
View File

@ -1,33 +0,0 @@
package simapp
import (
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/libs/log"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/codec"
)
// Setup initializes a new SimApp. A Nop logger is set in SimApp.
func Setup(isCheckTx bool) *SimApp {
db := dbm.NewMemDB()
app := NewSimApp(log.NewNopLogger(), db, nil, true, 0)
if !isCheckTx {
// init chain must be called to stop deliverState from being nil
genesisState := NewDefaultGenesisState()
stateBytes, err := codec.MarshalJSONIndent(app.cdc, genesisState)
if err != nil {
panic(err)
}
// Initialize the chain
app.InitChain(
abci.RequestInitChain{
Validators: []abci.ValidatorUpdate{},
AppStateBytes: stateBytes,
},
)
}
return app
}

163
simapp/test_helpers.go Normal file
View File

@ -0,0 +1,163 @@
package simapp
import (
"os"
"testing"
"github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/libs/log"
dbm "github.com/tendermint/tm-db"
bam "github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/genaccounts"
)
// Setup initializes a new SimApp. A Nop logger is set in SimApp.
func Setup(isCheckTx bool) *SimApp {
db := dbm.NewMemDB()
app := NewSimApp(log.NewNopLogger(), db, nil, true, 0)
if !isCheckTx {
// init chain must be called to stop deliverState from being nil
genesisState := NewDefaultGenesisState()
stateBytes, err := codec.MarshalJSONIndent(app.cdc, genesisState)
if err != nil {
panic(err)
}
// Initialize the chain
app.InitChain(
abci.RequestInitChain{
Validators: []abci.ValidatorUpdate{},
AppStateBytes: stateBytes,
},
)
}
return app
}
// SetupWithGenesisAccounts initializes a new SimApp with the passed in
// genesis accounts.
func SetupWithGenesisAccounts(genAccs genaccounts.GenesisAccounts) *SimApp {
db := dbm.NewMemDB()
app := NewSimApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, 0)
// initialize the chain with the passed in genesis accounts
genesisState := NewDefaultGenesisState()
genesisState = genaccounts.SetGenesisStateInAppState(app.Codec(), genesisState, genaccounts.GenesisState(genAccs))
stateBytes, err := codec.MarshalJSONIndent(app.cdc, genesisState)
if err != nil {
panic(err)
}
// Initialize the chain
app.InitChain(
abci.RequestInitChain{
Validators: []abci.ValidatorUpdate{},
AppStateBytes: stateBytes,
},
)
app.Commit()
app.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: app.LastBlockHeight() + 1}})
return app
}
// CheckBalance checks the balance of an account.
func CheckBalance(t *testing.T, app *SimApp, addr sdk.AccAddress, exp sdk.Coins) {
ctxCheck := app.BaseApp.NewContext(true, abci.Header{})
res := app.AccountKeeper.GetAccount(ctxCheck, addr)
require.Equal(t, exp, res.GetCoins())
}
// GenTx generates a signed mock transaction.
func GenTx(msgs []sdk.Msg, accnums []uint64, seq []uint64, priv ...crypto.PrivKey) auth.StdTx {
// Make the transaction free
fee := auth.StdFee{
Amount: sdk.NewCoins(sdk.NewInt64Coin("foocoin", 0)),
Gas: 100000,
}
sigs := make([]auth.StdSignature, len(priv))
memo := "testmemotestmemo"
for i, p := range priv {
// use a empty chainID for ease of testing
sig, err := p.Sign(auth.StdSignBytes("", accnums[i], seq[i], fee, msgs, memo))
if err != nil {
panic(err)
}
sigs[i] = auth.StdSignature{
PubKey: p.PubKey(),
Signature: sig,
}
}
return auth.NewStdTx(msgs, fee, sigs, memo)
}
// SignCheckDeliver checks a generated signed transaction and simulates a
// block commitment with the given transaction. A test assertion is made using
// the parameter 'expPass' against the result. A corresponding result is
// returned.
func SignCheckDeliver(
t *testing.T, cdc *codec.Codec, app *bam.BaseApp, header abci.Header, msgs []sdk.Msg,
accNums, seq []uint64, expSimPass, expPass bool, priv ...crypto.PrivKey,
) sdk.Result {
tx := GenTx(msgs, accNums, seq, priv...)
txBytes, err := cdc.MarshalBinaryLengthPrefixed(tx)
require.Nil(t, err)
// Must simulate now as CheckTx doesn't run Msgs anymore
res := app.Simulate(txBytes, tx)
if expSimPass {
require.Equal(t, sdk.CodeOK, res.Code, res.Log)
} else {
require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
}
// Simulate a sending a transaction and committing a block
app.BeginBlock(abci.RequestBeginBlock{Header: header})
res = app.Deliver(tx)
if expPass {
require.Equal(t, sdk.CodeOK, res.Code, res.Log)
} else {
require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
}
app.EndBlock(abci.RequestEndBlock{})
app.Commit()
return res
}
// GenSequenceOfTxs generates a set of signed transactions of messages, such
// that they differ only by having the sequence numbers incremented between
// every transaction.
func GenSequenceOfTxs(msgs []sdk.Msg, accnums []uint64, initSeqNums []uint64, numToGenerate int, priv ...crypto.PrivKey) []auth.StdTx {
txs := make([]auth.StdTx, numToGenerate)
for i := 0; i < numToGenerate; i++ {
txs[i] = GenTx(msgs, accnums, initSeqNums, priv...)
incrementAllSequenceNumbers(initSeqNums)
}
return txs
}
func incrementAllSequenceNumbers(initSeqNums []uint64) {
for i := 0; i < len(initSeqNums); i++ {
initSeqNums[i]++
}
}

107
x/bank/app_test.go
View File

@ -3,16 +3,17 @@ package bank_test
import (
"testing"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/bank/internal/types"
"github.com/cosmos/cosmos-sdk/x/mock"
"github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/secp256k1"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/bank/internal/types"
"github.com/cosmos/cosmos-sdk/x/genaccounts"
)
type (
@ -97,17 +98,17 @@ var (
)
func TestSendNotEnoughBalance(t *testing.T) {
mapp := getMockApp(t)
acc := &auth.BaseAccount{
Address: addr1,
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 67)},
}
mock.SetGenesis(mapp, []auth.Account{acc})
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(acc)}
app := simapp.SetupWithGenesisAccounts(genAccs)
ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{})
ctxCheck := app.BaseApp.NewContext(true, abci.Header{})
res1 := mapp.AccountKeeper.GetAccount(ctxCheck, addr1)
res1 := app.AccountKeeper.GetAccount(ctxCheck, addr1)
require.NotNil(t, res1)
require.Equal(t, acc, res1.(*auth.BaseAccount))
@ -115,69 +116,62 @@ func TestSendNotEnoughBalance(t *testing.T) {
origSeq := res1.GetSequence()
sendMsg := types.NewMsgSend(addr1, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 100)})
header := abci.Header{Height: mapp.LastBlockHeight() + 1}
mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{sendMsg}, []uint64{origAccNum}, []uint64{origSeq}, false, false, priv1)
header := abci.Header{Height: app.LastBlockHeight() + 1}
simapp.SignCheckDeliver(t, app.Codec(), app.BaseApp, header, []sdk.Msg{sendMsg}, []uint64{origAccNum}, []uint64{origSeq}, false, false, priv1)
mock.CheckBalance(t, mapp, addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 67)})
simapp.CheckBalance(t, app, addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 67)})
res2 := mapp.AccountKeeper.GetAccount(mapp.NewContext(true, abci.Header{}), addr1)
res2 := app.AccountKeeper.GetAccount(app.NewContext(true, abci.Header{}), addr1)
require.NotNil(t, res2)
require.True(t, res2.GetAccountNumber() == origAccNum)
require.True(t, res2.GetSequence() == origSeq+1)
require.Equal(t, res2.GetAccountNumber(), origAccNum)
require.Equal(t, res2.GetSequence(), origSeq+1)
}
// A module account cannot be the recipient of bank sends
func TestSendToModuleAcc(t *testing.T) {
mapp := getMockApp(t)
acc := &auth.BaseAccount{
Address: addr1,
Coins: coins,
}
macc := &auth.BaseAccount{
Address: moduleAccAddr,
}
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(acc)}
app := simapp.SetupWithGenesisAccounts(genAccs)
mock.SetGenesis(mapp, []auth.Account{acc, macc})
ctxCheck := app.BaseApp.NewContext(true, abci.Header{})
ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{})
res1 := mapp.AccountKeeper.GetAccount(ctxCheck, addr1)
res1 := app.AccountKeeper.GetAccount(ctxCheck, addr1)
require.NotNil(t, res1)
require.Equal(t, acc, res1.(*auth.BaseAccount))
origAccNum := res1.GetAccountNumber()
origSeq := res1.GetSequence()
header := abci.Header{Height: mapp.LastBlockHeight() + 1}
mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{sendMsg2}, []uint64{origAccNum}, []uint64{origSeq}, false, false, priv1)
header := abci.Header{Height: app.LastBlockHeight() + 1}
simapp.SignCheckDeliver(t, app.Codec(), app.BaseApp, header, []sdk.Msg{sendMsg2}, []uint64{origAccNum}, []uint64{origSeq}, false, false, priv1)
mock.CheckBalance(t, mapp, addr1, coins)
mock.CheckBalance(t, mapp, moduleAccAddr, sdk.Coins(nil))
simapp.CheckBalance(t, app, addr1, coins)
simapp.CheckBalance(t, app, moduleAccAddr, sdk.Coins(nil))
res2 := mapp.AccountKeeper.GetAccount(mapp.NewContext(true, abci.Header{}), addr1)
res2 := app.AccountKeeper.GetAccount(app.NewContext(true, abci.Header{}), addr1)
require.NotNil(t, res2)
require.True(t, res2.GetAccountNumber() == origAccNum)
require.True(t, res2.GetSequence() == origSeq+1)
require.Equal(t, res2.GetAccountNumber(), origAccNum)
require.Equal(t, res2.GetSequence(), origSeq+1)
}
func TestMsgMultiSendWithAccounts(t *testing.T) {
mapp := getMockApp(t)
acc := &auth.BaseAccount{
Address: addr1,
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 67)},
}
macc := &auth.BaseAccount{
Address: moduleAccAddr,
}
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(acc)}
app := simapp.SetupWithGenesisAccounts(genAccs)
mock.SetGenesis(mapp, []auth.Account{acc, macc})
ctxCheck := app.BaseApp.NewContext(true, abci.Header{})
ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{})
res1 := mapp.AccountKeeper.GetAccount(ctxCheck, addr1)
res1 := app.AccountKeeper.GetAccount(ctxCheck, addr1)
require.NotNil(t, res1)
require.Equal(t, acc, res1.(*auth.BaseAccount))
@ -213,17 +207,16 @@ func TestMsgMultiSendWithAccounts(t *testing.T) {
}
for _, tc := range testCases {
header := abci.Header{Height: mapp.LastBlockHeight() + 1}
mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
header := abci.Header{Height: app.LastBlockHeight() + 1}
simapp.SignCheckDeliver(t, app.Codec(), app.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
for _, eb := range tc.expectedBalances {
mock.CheckBalance(t, mapp, eb.addr, eb.coins)
simapp.CheckBalance(t, app, eb.addr, eb.coins)
}
}
}
func TestMsgMultiSendMultipleOut(t *testing.T) {
mapp := getMockApp(t)
acc1 := &auth.BaseAccount{
Address: addr1,
@ -234,7 +227,8 @@ func TestMsgMultiSendMultipleOut(t *testing.T) {
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
mock.SetGenesis(mapp, []auth.Account{acc1, acc2})
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(acc1), genaccounts.NewGenesisAccount(acc2)}
app := simapp.SetupWithGenesisAccounts(genAccs)
testCases := []appTestCase{
{
@ -253,17 +247,16 @@ func TestMsgMultiSendMultipleOut(t *testing.T) {
}
for _, tc := range testCases {
header := abci.Header{Height: mapp.LastBlockHeight() + 1}
mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
header := abci.Header{Height: app.LastBlockHeight() + 1}
simapp.SignCheckDeliver(t, app.Codec(), app.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
for _, eb := range tc.expectedBalances {
mock.CheckBalance(t, mapp, eb.addr, eb.coins)
simapp.CheckBalance(t, app, eb.addr, eb.coins)
}
}
}
func TestMsgMultiSendMultipleInOut(t *testing.T) {
mapp := getMockApp(t)
acc1 := &auth.BaseAccount{
Address: addr1,
@ -278,7 +271,8 @@ func TestMsgMultiSendMultipleInOut(t *testing.T) {
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
mock.SetGenesis(mapp, []auth.Account{acc1, acc2, acc4})
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(acc1), genaccounts.NewGenesisAccount(acc2), genaccounts.NewGenesisAccount(acc4)}
app := simapp.SetupWithGenesisAccounts(genAccs)
testCases := []appTestCase{
{
@ -298,18 +292,16 @@ func TestMsgMultiSendMultipleInOut(t *testing.T) {
}
for _, tc := range testCases {
header := abci.Header{Height: mapp.LastBlockHeight() + 1}
mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
header := abci.Header{Height: app.LastBlockHeight() + 1}
simapp.SignCheckDeliver(t, app.Codec(), app.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
for _, eb := range tc.expectedBalances {
mock.CheckBalance(t, mapp, eb.addr, eb.coins)
simapp.CheckBalance(t, app, eb.addr, eb.coins)
}
}
}
func TestMsgMultiSendDependent(t *testing.T) {
mapp := getMockApp(t)
acc1 := auth.NewBaseAccountWithAddress(addr1)
acc2 := auth.NewBaseAccountWithAddress(addr2)
err := acc1.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 42)))
@ -317,7 +309,8 @@ func TestMsgMultiSendDependent(t *testing.T) {
err = acc2.SetAccountNumber(1)
require.NoError(t, err)
mock.SetGenesis(mapp, []auth.Account{&acc1, &acc2})
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(&acc1), genaccounts.NewGenesisAccount(&acc2)}
app := simapp.SetupWithGenesisAccounts(genAccs)
testCases := []appTestCase{
{
@ -346,11 +339,11 @@ func TestMsgMultiSendDependent(t *testing.T) {
}
for _, tc := range testCases {
header := abci.Header{Height: mapp.LastBlockHeight() + 1}
mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
header := abci.Header{Height: app.LastBlockHeight() + 1}
simapp.SignCheckDeliver(t, app.Codec(), app.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
for _, eb := range tc.expectedBalances {
mock.CheckBalance(t, mapp, eb.addr, eb.coins)
simapp.CheckBalance(t, app, eb.addr, eb.coins)
}
}
}

69
x/bank/bench_test.go
View File

@ -3,76 +3,32 @@ package bank_test
import (
"testing"
"github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/bank"
"github.com/cosmos/cosmos-sdk/x/bank/internal/keeper"
"github.com/cosmos/cosmos-sdk/x/bank/internal/types"
"github.com/cosmos/cosmos-sdk/x/mock"
"github.com/cosmos/cosmos-sdk/x/genaccounts"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/supply"
)
var moduleAccAddr = sdk.AccAddress([]byte("moduleAcc"))
// initialize the mock application for this module
func getMockApp(t *testing.T) *mock.App {
mapp, err := getBenchmarkMockApp()
supply.RegisterCodec(mapp.Cdc)
require.NoError(t, err)
return mapp
}
// overwrite the mock init chainer
func getInitChainer(mapp *mock.App, keeper keeper.BaseKeeper) sdk.InitChainer {
return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
mapp.InitChainer(ctx, req)
bankGenesis := bank.DefaultGenesisState()
bank.InitGenesis(ctx, keeper, bankGenesis)
return abci.ResponseInitChain{}
}
}
// getBenchmarkMockApp initializes a mock application for this module, for purposes of benchmarking
// Any long term API support commitments do not apply to this function.
func getBenchmarkMockApp() (*mock.App, error) {
mapp := mock.NewApp()
types.RegisterCodec(mapp.Cdc)
blacklistedAddrs := make(map[string]bool)
blacklistedAddrs[moduleAccAddr.String()] = true
bankKeeper := keeper.NewBaseKeeper(
mapp.AccountKeeper,
mapp.ParamsKeeper.Subspace(types.DefaultParamspace),
types.DefaultCodespace,
blacklistedAddrs,
)
mapp.Router().AddRoute(types.RouterKey, bank.NewHandler(bankKeeper))
mapp.SetInitChainer(getInitChainer(mapp, bankKeeper))
err := mapp.CompleteSetup()
return mapp, err
}
var moduleAccAddr = supply.NewModuleAddress(staking.BondedPoolName)
func BenchmarkOneBankSendTxPerBlock(b *testing.B) {
benchmarkApp, _ := getBenchmarkMockApp()
// Add an account at genesis
acc := &auth.BaseAccount{
Address: addr1,
// Some value conceivably higher than the benchmarks would ever go
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 100000000000)},
}
accs := []auth.Account{acc}
// Construct genesis state
mock.SetGenesis(benchmarkApp, accs)
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(acc)}
benchmarkApp := simapp.SetupWithGenesisAccounts(genAccs)
// Precompute all txs
txs := mock.GenSequenceOfTxs([]sdk.Msg{sendMsg1}, []uint64{0}, []uint64{uint64(0)}, b.N, priv1)
txs := simapp.GenSequenceOfTxs([]sdk.Msg{sendMsg1}, []uint64{0}, []uint64{uint64(0)}, b.N, priv1)
b.ResetTimer()
// Run this with a profiler, so its easy to distinguish what time comes from
// Committing, and what time comes from Check/Deliver Tx.
@ -89,20 +45,19 @@ func BenchmarkOneBankSendTxPerBlock(b *testing.B) {
}
func BenchmarkOneBankMultiSendTxPerBlock(b *testing.B) {
benchmarkApp, _ := getBenchmarkMockApp()
// Add an account at genesis
acc := &auth.BaseAccount{
Address: addr1,
// Some value conceivably higher than the benchmarks would ever go
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 100000000000)},
}
accs := []auth.Account{acc}
// Construct genesis state
mock.SetGenesis(benchmarkApp, accs)
genAccs := []genaccounts.GenesisAccount{genaccounts.NewGenesisAccount(acc)}
benchmarkApp := simapp.SetupWithGenesisAccounts(genAccs)
// Precompute all txs
txs := mock.GenSequenceOfTxs([]sdk.Msg{multiSendMsg1}, []uint64{0}, []uint64{uint64(0)}, b.N, priv1)
txs := simapp.GenSequenceOfTxs([]sdk.Msg{multiSendMsg1}, []uint64{0}, []uint64{uint64(0)}, b.N, priv1)
b.ResetTimer()
// Run this with a profiler, so its easy to distinguish what time comes from
// Committing, and what time comes from Check/Deliver Tx.

59
x/bank/internal/keeper/common_test.go
View File

@ -1,59 +0,0 @@
package keeper
// DONTCOVER
import (
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/libs/log"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/codec"
"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/internal/types"
"github.com/cosmos/cosmos-sdk/x/params"
)
type testInput struct {
cdc *codec.Codec
ctx sdk.Context
k Keeper
ak auth.AccountKeeper
pk params.Keeper
}
func setupTestInput() testInput {
db := dbm.NewMemDB()
cdc := codec.New()
auth.RegisterCodec(cdc)
codec.RegisterCrypto(cdc)
authCapKey := sdk.NewKVStoreKey("authCapKey")
keyParams := sdk.NewKVStoreKey("params")
tkeyParams := sdk.NewTransientStoreKey("transient_params")
ms := store.NewCommitMultiStore(db)
ms.MountStoreWithDB(authCapKey, sdk.StoreTypeIAVL, db)
ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db)
ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db)
ms.LoadLatestVersion()
blacklistedAddrs := make(map[string]bool)
blacklistedAddrs[sdk.AccAddress([]byte("moduleAcc")).String()] = true
pk := params.NewKeeper(cdc, keyParams, tkeyParams, params.DefaultCodespace)
ak := auth.NewAccountKeeper(
cdc, authCapKey, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount,
)
ctx := sdk.NewContext(ms, abci.Header{ChainID: "test-chain-id"}, false, log.NewNopLogger())
ak.SetParams(ctx, auth.DefaultParams())
bankKeeper := NewBaseKeeper(ak, pk.Subspace(types.DefaultParamspace), types.DefaultCodespace, blacklistedAddrs)
bankKeeper.SetSendEnabled(ctx, true)
return testInput{cdc: cdc, ctx: ctx, k: bankKeeper, ak: ak, pk: pk}
}

19
x/bank/internal/keeper/integration_test.go Normal file
View File

@ -0,0 +1,19 @@
package keeper_test
import (
abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
)
func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
app := simapp.Setup(isCheckTx)
ctx := app.BaseApp.NewContext(isCheckTx, abci.Header{})
app.AccountKeeper.SetParams(ctx, auth.DefaultParams())
app.BankKeeper.SetSendEnabled(ctx, true)
return app, ctx
}

219
x/bank/internal/keeper/keeper_test.go
View File

@ -1,4 +1,4 @@
package keeper
package keeper_test
import (
"testing"
@ -9,73 +9,74 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
tmtime "github.com/tendermint/tendermint/types/time"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
keep "github.com/cosmos/cosmos-sdk/x/bank/internal/keeper"
"github.com/cosmos/cosmos-sdk/x/bank/internal/types"
)
func TestKeeper(t *testing.T) {
input := setupTestInput()
ctx := input.ctx
app, ctx := createTestApp(false)
addr := sdk.AccAddress([]byte("addr1"))
addr2 := sdk.AccAddress([]byte("addr2"))
addr3 := sdk.AccAddress([]byte("addr3"))
acc := input.ak.NewAccountWithAddress(ctx, addr)
acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr)
// Test GetCoins/SetCoins
input.ak.SetAccount(ctx, acc)
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins()))
app.AccountKeeper.SetAccount(ctx, acc)
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins()))
input.k.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
app.BankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
// Test HasCoins
require.True(t, input.k.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
require.True(t, input.k.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
require.False(t, input.k.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
require.False(t, input.k.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5))))
require.True(t, app.BankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
require.True(t, app.BankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
require.False(t, app.BankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
require.False(t, app.BankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5))))
// Test AddCoins
input.k.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 25))))
app.BankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 25))))
input.k.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 15)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 15), sdk.NewInt64Coin("foocoin", 25))))
app.BankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 15)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 15), sdk.NewInt64Coin("foocoin", 25))))
// Test SubtractCoins
input.k.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
input.k.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15))))
app.BankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
app.BankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15))))
input.k.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 11)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15))))
app.BankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 11)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15))))
input.k.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
require.False(t, input.k.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 1))))
app.BankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
require.False(t, app.BankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 1))))
// Test SendCoins
input.k.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
require.True(t, input.k.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
app.BankKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
require.True(t, app.BankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
err2 := input.k.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 50)))
err2 := app.BankKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 50)))
require.Implements(t, (*sdk.Error)(nil), err2)
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
require.True(t, input.k.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
require.True(t, app.BankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
input.k.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 30)))
input.k.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)))
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5))))
require.True(t, input.k.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10))))
app.BankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 30)))
app.BankKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)))
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5))))
require.True(t, app.BankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10))))
// Test InputOutputCoins
input1 := types.NewInput(addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 2)))
output1 := types.NewOutput(addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 2)))
input.k.InputOutputCoins(ctx, []types.Input{input1}, []types.Output{output1})
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 7))))
require.True(t, input.k.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 8))))
app.BankKeeper.InputOutputCoins(ctx, []types.Input{input1}, []types.Output{output1})
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 7))))
require.True(t, app.BankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 8))))
inputs := []types.Input{
types.NewInput(addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 3))),
@ -86,31 +87,35 @@ func TestKeeper(t *testing.T) {
types.NewOutput(addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 1))),
types.NewOutput(addr3, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5))),
}
input.k.InputOutputCoins(ctx, inputs, outputs)
require.True(t, input.k.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 21), sdk.NewInt64Coin("foocoin", 4))))
require.True(t, input.k.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 7), sdk.NewInt64Coin("foocoin", 6))))
require.True(t, input.k.GetCoins(ctx, addr3).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5))))
app.BankKeeper.InputOutputCoins(ctx, inputs, outputs)
require.True(t, app.BankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 21), sdk.NewInt64Coin("foocoin", 4))))
require.True(t, app.BankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 7), sdk.NewInt64Coin("foocoin", 6))))
require.True(t, app.BankKeeper.GetCoins(ctx, addr3).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5))))
// Test retrieving black listed accounts
for acc := range simapp.GetMaccPerms() {
require.True(t, app.BankKeeper.BlacklistedAddr(app.SupplyKeeper.GetModuleAddress(acc)))
}
}
func TestSendKeeper(t *testing.T) {
input := setupTestInput()
ctx := input.ctx
app, ctx := createTestApp(false)
blacklistedAddrs := make(map[string]bool)
paramSpace := input.pk.Subspace("newspace")
sendKeeper := NewBaseSendKeeper(input.ak, paramSpace, types.DefaultCodespace, blacklistedAddrs)
input.k.SetSendEnabled(ctx, true)
paramSpace := app.ParamsKeeper.Subspace("newspace")
sendKeeper := keep.NewBaseSendKeeper(app.AccountKeeper, paramSpace, types.DefaultCodespace, blacklistedAddrs)
app.BankKeeper.SetSendEnabled(ctx, true)
addr := sdk.AccAddress([]byte("addr1"))
addr2 := sdk.AccAddress([]byte("addr2"))
acc := input.ak.NewAccountWithAddress(ctx, addr)
acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr)
// Test GetCoins/SetCoins
input.ak.SetAccount(ctx, acc)
app.AccountKeeper.SetAccount(ctx, acc)
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins()))
input.k.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
app.BankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
// Test HasCoins
@ -119,7 +124,7 @@ func TestSendKeeper(t *testing.T) {
require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5))))
input.k.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15)))
app.BankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15)))
// Test SendCoins
sendKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5)))
@ -131,7 +136,7 @@ func TestSendKeeper(t *testing.T) {
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
input.k.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 30)))
app.BankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 30)))
sendKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)))
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5))))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10))))
@ -144,19 +149,19 @@ func TestSendKeeper(t *testing.T) {
}
func TestViewKeeper(t *testing.T) {
input := setupTestInput()
ctx := input.ctx
//paramSpace := input.pk.Subspace(types.DefaultParamspace)
viewKeeper := NewBaseViewKeeper(input.ak, types.DefaultCodespace)
app, ctx := createTestApp(false)
//paramSpace := app.ParamsKeeper.Subspace(types.DefaultParamspace)
viewKeeper := keep.NewBaseViewKeeper(app.AccountKeeper, types.DefaultCodespace)
addr := sdk.AccAddress([]byte("addr1"))
acc := input.ak.NewAccountWithAddress(ctx, addr)
acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr)
// Test GetCoins/SetCoins
input.ak.SetAccount(ctx, acc)
app.AccountKeeper.SetAccount(ctx, acc)
require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins()))
input.k.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
app.BankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
// Test HasCoins
@ -167,9 +172,9 @@ func TestViewKeeper(t *testing.T) {
}
func TestVestingAccountSend(t *testing.T) {
input := setupTestInput()
app, ctx := createTestApp(false)
now := tmtime.Now()
ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
ctx = ctx.WithBlockHeader(abci.Header{Time: now})
endTime := now.Add(24 * time.Hour)
origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
@ -180,28 +185,28 @@ func TestVestingAccountSend(t *testing.T) {
bacc := auth.NewBaseAccountWithAddress(addr1)
bacc.SetCoins(origCoins)
vacc := auth.NewContinuousVestingAccount(&bacc, ctx.BlockHeader().Time.Unix(), endTime.Unix())
input.ak.SetAccount(ctx, vacc)
app.AccountKeeper.SetAccount(ctx, vacc)
// require that no coins be sendable at the beginning of the vesting schedule
err := input.k.SendCoins(ctx, addr1, addr2, sendCoins)
err := app.BankKeeper.SendCoins(ctx, addr1, addr2, sendCoins)
require.Error(t, err)
// receive some coins
vacc.SetCoins(origCoins.Add(sendCoins))
input.ak.SetAccount(ctx, vacc)
app.AccountKeeper.SetAccount(ctx, vacc)
// require that all vested coins are spendable plus any received
ctx = ctx.WithBlockTime(now.Add(12 * time.Hour))
err = input.k.SendCoins(ctx, addr1, addr2, sendCoins)
vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
err = app.BankKeeper.SendCoins(ctx, addr1, addr2, sendCoins)
vacc = app.AccountKeeper.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
require.NoError(t, err)
require.Equal(t, origCoins, vacc.GetCoins())
}
func TestVestingAccountReceive(t *testing.T) {
input := setupTestInput()
app, ctx := createTestApp(false)
now := tmtime.Now()
ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
ctx = ctx.WithBlockHeader(abci.Header{Time: now})
endTime := now.Add(24 * time.Hour)
origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
@ -213,16 +218,16 @@ func TestVestingAccountReceive(t *testing.T) {
bacc := auth.NewBaseAccountWithAddress(addr1)
bacc.SetCoins(origCoins)
vacc := auth.NewContinuousVestingAccount(&bacc, ctx.BlockHeader().Time.Unix(), endTime.Unix())
acc := input.ak.NewAccountWithAddress(ctx, addr2)
input.ak.SetAccount(ctx, vacc)
input.ak.SetAccount(ctx, acc)
input.k.SetCoins(ctx, addr2, origCoins)
acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr2)
app.AccountKeeper.SetAccount(ctx, vacc)
app.AccountKeeper.SetAccount(ctx, acc)
app.BankKeeper.SetCoins(ctx, addr2, origCoins)
// send some coins to the vesting account
input.k.SendCoins(ctx, addr2, addr1, sendCoins)
app.BankKeeper.SendCoins(ctx, addr2, addr1, sendCoins)
// require the coins are spendable
vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
vacc = app.AccountKeeper.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
require.Equal(t, origCoins.Add(sendCoins), vacc.GetCoins())
require.Equal(t, vacc.SpendableCoins(now), sendCoins)
@ -231,10 +236,11 @@ func TestVestingAccountReceive(t *testing.T) {
}
func TestDelegateCoins(t *testing.T) {
input := setupTestInput()
app, ctx := createTestApp(false)
now := tmtime.Now()
ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
ctx = ctx.WithBlockHeader(abci.Header{Time: now})
endTime := now.Add(24 * time.Hour)
ak := app.AccountKeeper
origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
delCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 50))
@ -245,36 +251,37 @@ func TestDelegateCoins(t *testing.T) {
bacc := auth.NewBaseAccountWithAddress(addr1)
bacc.SetCoins(origCoins)
macc := input.ak.NewAccountWithAddress(ctx, addrModule) // we don't need to define an actual module account bc we just need the address for testing
macc := ak.NewAccountWithAddress(ctx, addrModule) // we don't need to define an actual module account bc we just need the address for testing
vacc := auth.NewContinuousVestingAccount(&bacc, ctx.BlockHeader().Time.Unix(), endTime.Unix())
acc := input.ak.NewAccountWithAddress(ctx, addr2)
input.ak.SetAccount(ctx, vacc)
input.ak.SetAccount(ctx, acc)
input.ak.SetAccount(ctx, macc)
input.k.SetCoins(ctx, addr2, origCoins)
acc := ak.NewAccountWithAddress(ctx, addr2)
ak.SetAccount(ctx, vacc)
ak.SetAccount(ctx, acc)
ak.SetAccount(ctx, macc)
app.BankKeeper.SetCoins(ctx, addr2, origCoins)
ctx = ctx.WithBlockTime(now.Add(12 * time.Hour))
// require the ability for a non-vesting account to delegate
err := input.k.DelegateCoins(ctx, addr2, addrModule, delCoins)
acc = input.ak.GetAccount(ctx, addr2)
macc = input.ak.GetAccount(ctx, addrModule)
err := app.BankKeeper.DelegateCoins(ctx, addr2, addrModule, delCoins)
acc = ak.GetAccount(ctx, addr2)
macc = ak.GetAccount(ctx, addrModule)
require.NoError(t, err)
require.Equal(t, origCoins.Sub(delCoins), acc.GetCoins())
require.Equal(t, delCoins, macc.GetCoins())
// require the ability for a vesting account to delegate
err = input.k.DelegateCoins(ctx, addr1, addrModule, delCoins)
vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
err = app.BankKeeper.DelegateCoins(ctx, addr1, addrModule, delCoins)
vacc = ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
require.NoError(t, err)
require.Equal(t, delCoins, vacc.GetCoins())
}
func TestUndelegateCoins(t *testing.T) {
input := setupTestInput()
app, ctx := createTestApp(false)
now := tmtime.Now()
ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
ctx = ctx.WithBlockHeader(abci.Header{Time: now})
endTime := now.Add(24 * time.Hour)
ak := app.AccountKeeper
origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
delCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 50))
@ -285,49 +292,49 @@ func TestUndelegateCoins(t *testing.T) {
bacc := auth.NewBaseAccountWithAddress(addr1)
bacc.SetCoins(origCoins)
macc := input.ak.NewAccountWithAddress(ctx, addrModule) // we don't need to define an actual module account bc we just need the address for testing
macc := ak.NewAccountWithAddress(ctx, addrModule) // we don't need to define an actual module account bc we just need the address for testing
vacc := auth.NewContinuousVestingAccount(&bacc, ctx.BlockHeader().Time.Unix(), endTime.Unix())
acc := input.ak.NewAccountWithAddress(ctx, addr2)
input.ak.SetAccount(ctx, vacc)
input.ak.SetAccount(ctx, acc)
input.ak.SetAccount(ctx, macc)
input.k.SetCoins(ctx, addr2, origCoins)
acc := ak.NewAccountWithAddress(ctx, addr2)
ak.SetAccount(ctx, vacc)
ak.SetAccount(ctx, acc)
ak.SetAccount(ctx, macc)
app.BankKeeper.SetCoins(ctx, addr2, origCoins)
ctx = ctx.WithBlockTime(now.Add(12 * time.Hour))
// require the ability for a non-vesting account to delegate
err := input.k.DelegateCoins(ctx, addr2, addrModule, delCoins)
err := app.BankKeeper.DelegateCoins(ctx, addr2, addrModule, delCoins)
require.NoError(t, err)
acc = input.ak.GetAccount(ctx, addr2)
macc = input.ak.GetAccount(ctx, addrModule)
acc = ak.GetAccount(ctx, addr2)
macc = ak.GetAccount(ctx, addrModule)
require.Equal(t, origCoins.Sub(delCoins), acc.GetCoins())
require.Equal(t, delCoins, macc.GetCoins())
// require the ability for a non-vesting account to undelegate
err = input.k.UndelegateCoins(ctx, addrModule, addr2, delCoins)
err = app.BankKeeper.UndelegateCoins(ctx, addrModule, addr2, delCoins)
require.NoError(t, err)
acc = input.ak.GetAccount(ctx, addr2)
macc = input.ak.GetAccount(ctx, addrModule)
acc = ak.GetAccount(ctx, addr2)
macc = ak.GetAccount(ctx, addrModule)
require.Equal(t, origCoins, acc.GetCoins())
require.True(t, macc.GetCoins().Empty())
// require the ability for a vesting account to delegate
err = input.k.DelegateCoins(ctx, addr1, addrModule, delCoins)
err = app.BankKeeper.DelegateCoins(ctx, addr1, addrModule, delCoins)
require.NoError(t, err)
vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
macc = input.ak.GetAccount(ctx, addrModule)
vacc = ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
macc = ak.GetAccount(ctx, addrModule)
require.Equal(t, origCoins.Sub(delCoins), vacc.GetCoins())
require.Equal(t, delCoins, macc.GetCoins())
// require the ability for a vesting account to undelegate
err = input.k.UndelegateCoins(ctx, addrModule, addr1, delCoins)
err = app.BankKeeper.UndelegateCoins(ctx, addrModule, addr1, delCoins)
require.NoError(t, err)
vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
macc = input.ak.GetAccount(ctx, addrModule)
vacc = ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount)
macc = ak.GetAccount(ctx, addrModule)
require.Equal(t, origCoins, vacc.GetCoins())
require.True(t, macc.GetCoins().Empty())
}

31
x/bank/internal/keeper/querier_test.go
View File

@ -1,4 +1,4 @@
package keeper
package keeper_test
import (
"fmt"
@ -10,50 +10,51 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
keep "github.com/cosmos/cosmos-sdk/x/bank/internal/keeper"
"github.com/cosmos/cosmos-sdk/x/bank/internal/types"
)
func TestBalances(t *testing.T) {
input := setupTestInput()
app, ctx := createTestApp(false)
req := abci.RequestQuery{
Path: fmt.Sprintf("custom/bank/%s", QueryBalance),
Path: fmt.Sprintf("custom/bank/%s", keep.QueryBalance),
Data: []byte{},
}
querier := NewQuerier(input.k)
querier := keep.NewQuerier(app.BankKeeper)
res, err := querier(input.ctx, []string{"balances"}, req)
res, err := querier(ctx, []string{"balances"}, req)
require.NotNil(t, err)
require.Nil(t, res)
_, _, addr := authtypes.KeyTestPubAddr()
req.Data = input.cdc.MustMarshalJSON(types.NewQueryBalanceParams(addr))
res, err = querier(input.ctx, []string{"balances"}, req)
req.Data = app.Codec().MustMarshalJSON(types.NewQueryBalanceParams(addr))
res, err = querier(ctx, []string{"balances"}, req)
require.Nil(t, err) // the account does not exist, no error returned anyway
require.NotNil(t, res)
var coins sdk.Coins
require.NoError(t, input.cdc.UnmarshalJSON(res, &coins))
require.NoError(t, app.Codec().UnmarshalJSON(res, &coins))
require.True(t, coins.IsZero())
acc := input.ak.NewAccountWithAddress(input.ctx, addr)
acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr)
acc.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("foo", 10)))
input.ak.SetAccount(input.ctx, acc)
res, err = querier(input.ctx, []string{"balances"}, req)
app.AccountKeeper.SetAccount(ctx, acc)
res, err = querier(ctx, []string{"balances"}, req)
require.Nil(t, err)
require.NotNil(t, res)
require.NoError(t, input.cdc.UnmarshalJSON(res, &coins))
require.NoError(t, app.Codec().UnmarshalJSON(res, &coins))
require.True(t, coins.AmountOf("foo").Equal(sdk.NewInt(10)))
}
func TestQuerierRouteNotFound(t *testing.T) {
input := setupTestInput()
app, ctx := createTestApp(false)
req := abci.RequestQuery{
Path: "custom/bank/notfound",
Data: []byte{},
}
querier := NewQuerier(input.k)
_, err := querier(input.ctx, []string{"notfound"}, req)
querier := keep.NewQuerier(app.BankKeeper)
_, err := querier(ctx, []string{"notfound"}, req)
require.Error(t, err)
}

19
x/mock/app.go
View File

@ -310,25 +310,6 @@ func RandomSetGenesis(r *rand.Rand, app *App, addrs []sdk.AccAddress, denoms []s
app.GenesisAccounts = accts
}
// GenSequenceOfTxs generates a set of signed transactions of messages, such
// that they differ only by having the sequence numbers incremented between
// every transaction.
func GenSequenceOfTxs(msgs []sdk.Msg, accnums []uint64, initSeqNums []uint64, numToGenerate int, priv ...crypto.PrivKey) []auth.StdTx {
txs := make([]auth.StdTx, numToGenerate)
for i := 0; i < numToGenerate; i++ {
txs[i] = GenTx(msgs, accnums, initSeqNums, priv...)
incrementAllSequenceNumbers(initSeqNums)
}
return txs
}
func incrementAllSequenceNumbers(initSeqNums []uint64) {
for i := 0; i < len(initSeqNums); i++ {
initSeqNums[i]++
}
}
func createCodec() *codec.Codec {
cdc := codec.New()
sdk.RegisterCodec(cdc)