LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

chore: enable errcheck linter (#16406)

Browse Source
This commit is contained in:
ruthishvitwit 2023-07-12 14:28:27 +05:30 committed by GitHub
parent c5df6a355a
commit fd7e549a3c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
140 changed files with 1019 additions and 617 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.golangci.yml
View File

@ -10,6 +10,7 @@ run:
linters:
disable-all: true
enable:
- errcheck
- dogsled
- exportloopref
- goconst

43
baseapp/abci_test.go
View File

@ -65,6 +65,7 @@ func TestABCI_First_block_Height(t *testing.T) {
InitialHeight: 1,
})
require.NoError(t, err)
_, err = app.Commit()
require.NoError(t, err)
@ -185,9 +186,9 @@ func TestABCI_InitChain_WithInitialHeight(t *testing.T) {
},
)
require.NoError(t, err)
_, err = app.Commit()
require.NoError(t, err)
require.Equal(t, int64(3), app.LastBlockHeight())
}
@ -210,7 +211,6 @@ func TestABCI_FinalizeBlock_WithInitialHeight(t *testing.T) {
require.NoError(t, err)
_, err = app.Commit()
require.NoError(t, err)
require.Equal(t, int64(3), app.LastBlockHeight())
}
@ -391,6 +391,7 @@ func TestABCI_GRPCQuery(t *testing.T) {
_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.baseApp.LastBlockHeight() + 1})
require.NoError(t, err)
_, err = suite.baseApp.Commit()
require.NoError(t, err)
@ -596,6 +597,7 @@ func TestABCI_FinalizeBlock_DeliverTx(t *testing.T) {
_, err = suite.baseApp.Commit()
require.NoError(t, err)
}
}
@ -646,7 +648,9 @@ func TestABCI_FinalizeBlock_MultiMsg(t *testing.T) {
msgs = append(msgs, &baseapptestutil.MsgCounter2{Counter: 0, Signer: addr.String()})
msgs = append(msgs, &baseapptestutil.MsgCounter2{Counter: 1, Signer: addr.String()})
builder.SetMsgs(msgs...)
err = builder.SetMsgs(msgs...)
require.NoError(t, err)
builder.SetMemo(tx.GetMemo())
setTxSignature(t, builder, 0)
@ -750,12 +754,10 @@ func TestABCI_InvalidTransaction(t *testing.T) {
ConsensusParams: &cmtproto.ConsensusParams{},
})
require.NoError(t, err)
_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: 1,
})
require.NoError(t, err)
// malformed transaction bytes
{
bz := []byte("example vote extension")
@ -818,7 +820,8 @@ func TestABCI_InvalidTransaction(t *testing.T) {
{
txBuilder := suite.txConfig.NewTxBuilder()
_, _, addr := testdata.KeyTestPubAddr()
txBuilder.SetMsgs(&baseapptestutil.MsgCounter2{Signer: addr.String()})
err = txBuilder.SetMsgs(&baseapptestutil.MsgCounter2{Signer: addr.String()})
require.NoError(t, err)
setTxSignature(t, txBuilder, 0)
unknownRouteTx := txBuilder.GetTx()
@ -831,10 +834,11 @@ func TestABCI_InvalidTransaction(t *testing.T) {
require.EqualValues(t, sdkerrors.ErrUnknownRequest.ABCICode(), code, err)
txBuilder = suite.txConfig.NewTxBuilder()
txBuilder.SetMsgs(
err = txBuilder.SetMsgs(
&baseapptestutil.MsgCounter{Signer: addr.String()},
&baseapptestutil.MsgCounter2{Signer: addr.String()},
)
require.NoError(t, err)
setTxSignature(t, txBuilder, 0)
unknownRouteTx = txBuilder.GetTx()
@ -850,11 +854,11 @@ func TestABCI_InvalidTransaction(t *testing.T) {
// Transaction with an unregistered message
{
txBuilder := suite.txConfig.NewTxBuilder()
txBuilder.SetMsgs(&testdata.MsgCreateDog{})
err = txBuilder.SetMsgs(&testdata.MsgCreateDog{})
require.NoError(t, err)
tx := txBuilder.GetTx()
_, _, err := suite.baseApp.SimDeliver(suite.txConfig.TxEncoder(), tx)
require.Error(t, err)
space, code, _ := errorsmod.ABCIInfo(err, false)
require.EqualValues(t, sdkerrors.ErrTxDecode.ABCICode(), code)
require.EqualValues(t, sdkerrors.ErrTxDecode.Codespace(), space)
@ -1019,7 +1023,7 @@ func TestABCI_MaxBlockGasLimits(t *testing.T) {
tx := tc.tx
// reset block gas
_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.baseApp.LastBlockHeight() + 1})
_, err := suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.baseApp.LastBlockHeight() + 1})
require.NoError(t, err)
// execute the transaction multiple times
@ -1269,7 +1273,7 @@ func TestABCI_GetBlockRetentionHeight(t *testing.T) {
tc := tc
tc.bapp.SetParamStore(&paramStore{db: dbm.NewMemDB()})
_, err = tc.bapp.InitChain(&abci.RequestInitChain{
_, err := tc.bapp.InitChain(&abci.RequestInitChain{
ConsensusParams: &cmtproto.ConsensusParams{
Evidence: &cmtproto.EvidenceParams{
MaxAgeNumBlocks: tc.maxAgeBlocks,
@ -1474,11 +1478,11 @@ func TestABCI_Proposals_WithVE(t *testing.T) {
suite := NewBaseAppSuite(t, setInitChainerOpt, prepareOpt)
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
InitialHeight: 1,
ConsensusParams: &cmtproto.ConsensusParams{},
})
require.NoError(t, err)
reqPrepareProposal := abci.RequestPrepareProposal{
MaxTxBytes: 100000,
Height: 1, // this value can't be 0
@ -1573,12 +1577,12 @@ func TestABCI_PrepareProposal_MaxGas(t *testing.T) {
baseapptestutil.RegisterCounterServer(suite.baseApp.MsgServiceRouter(), NoopCounterServerImpl{})
// set max block gas limit to 100
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
ConsensusParams: &cmtproto.ConsensusParams{
Block: &cmtproto.BlockParams{MaxGas: 100},
},
})
require.NoError(t, err)
// insert 100 txs, each with a gas limit of 10
_, _, addr := testdata.KeyTestPubAddr()
for i := int64(0); i < 100; i++ {
@ -1586,7 +1590,8 @@ func TestABCI_PrepareProposal_MaxGas(t *testing.T) {
msgs := []sdk.Msg{msg}
builder := suite.txConfig.NewTxBuilder()
builder.SetMsgs(msgs...)
err = builder.SetMsgs(msgs...)
require.NoError(t, err)
builder.SetMemo("counter=" + strconv.FormatInt(i, 10) + "&failOnAnte=false")
builder.SetGasLimit(10)
setTxSignature(t, builder, uint64(i))
@ -1884,13 +1889,13 @@ func TestABCI_HaltChain(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
suite := NewBaseAppSuite(t, baseapp.SetHaltHeight(tc.haltHeight), baseapp.SetHaltTime(tc.haltTime))
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
ConsensusParams: &cmtproto.ConsensusParams{},
InitialHeight: tc.blockHeight,
})
require.NoError(t, err)
app := suite.baseApp
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: tc.blockHeight,
Time: time.Unix(tc.blockTime, 0),
})

25
baseapp/baseapp_test.go
View File

@ -129,7 +129,8 @@ func NewBaseAppSuiteWithSnapshots(t *testing.T, cfg SnapshotsConfig, opts ...fun
}
builder := suite.txConfig.NewTxBuilder()
builder.SetMsgs(msgs...)
err := builder.SetMsgs(msgs...)
require.NoError(t, err)
setTxSignature(t, builder, 0)
txBytes, err := suite.txConfig.TxEncoder()(builder.GetTx())
@ -488,7 +489,8 @@ func TestCustomRunTxPanicHandler(t *testing.T) {
require.PanicsWithValue(t, customPanicMsg, func() {
bz, err := suite.txConfig.TxEncoder()(tx)
require.NoError(t, err)
suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: 1, Txs: [][]byte{bz}})
_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: 1, Txs: [][]byte{bz}})
require.NoError(t, err)
})
}
}
@ -530,7 +532,7 @@ func TestBaseAppAnteHandler(t *testing.T) {
// execute at tx that will pass the ante handler (the checkTx state should
// mutate) but will fail the message handler
tx = newTxCounter(t, suite.txConfig, 0, 0)
tx = setFailOnHandler(suite.txConfig, tx, true)
tx = setFailOnHandler(t, suite.txConfig, tx, true)
txBytes, err = suite.txConfig.TxEncoder()(tx)
require.NoError(t, err)
@ -562,7 +564,8 @@ func TestBaseAppAnteHandler(t *testing.T) {
require.Equal(t, int64(2), getIntFromStore(t, store, anteKey))
require.Equal(t, int64(1), getIntFromStore(t, store, deliverKey))
suite.baseApp.Commit()
_, err = suite.baseApp.Commit()
require.NoError(t, err)
}
// Test and ensure that invalid block heights always cause errors.
@ -585,7 +588,6 @@ func TestABCI_CreateQueryContext(t *testing.T) {
require.NoError(t, err)
_, err = app.Commit()
require.NoError(t, err)
testCases := []struct {
name string
height int64
@ -622,19 +624,22 @@ func TestGetMaximumBlockGas(t *testing.T) {
suite := NewBaseAppSuite(t)
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{})
require.NoError(t, err)
ctx := suite.baseApp.NewContext(true)
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 0}})
err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 0}})
require.NoError(t, err)
require.Equal(t, uint64(0), suite.baseApp.GetMaximumBlockGas(ctx))
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -1}})
err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -1}})
require.NoError(t, err)
require.Equal(t, uint64(0), suite.baseApp.GetMaximumBlockGas(ctx))
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 5000000}})
err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 5000000}})
require.NoError(t, err)
require.Equal(t, uint64(5000000), suite.baseApp.GetMaximumBlockGas(ctx))
suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -5000000}})
err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -5000000}})
require.NoError(t, err)
require.Panics(t, func() { suite.baseApp.GetMaximumBlockGas(ctx) })
}

3
baseapp/block_gas_test.go
View File

@ -117,12 +117,13 @@ func TestBaseApp_BlockGas(t *testing.T) {
genState := GenesisStateWithSingleValidator(t, cdc, appBuilder)
stateBytes, err := cmtjson.MarshalIndent(genState, "", " ")
require.NoError(t, err)
bapp.InitChain(&abci.RequestInitChain{
_, err = bapp.InitChain(&abci.RequestInitChain{
Validators: []abci.ValidatorUpdate{},
ConsensusParams: simtestutil.DefaultConsensusParams,
AppStateBytes: stateBytes,
})
require.NoError(t, err)
ctx := bapp.NewContext(false)
// tx fee

18
baseapp/streaming_test.go
View File

@ -51,12 +51,12 @@ func TestABCI_MultiListener_StateChanges(t *testing.T) {
addListenerOpt := func(bapp *baseapp.BaseApp) { bapp.CommitMultiStore().AddListeners([]storetypes.StoreKey{distKey1}) }
suite := NewBaseAppSuite(t, anteOpt, distOpt, streamingManagerOpt, addListenerOpt)
suite.baseApp.InitChain(
_, err := suite.baseApp.InitChain(
&abci.RequestInitChain{
ConsensusParams: &tmproto.ConsensusParams{},
},
)
require.NoError(t, err)
deliverKey := []byte("deliver-key")
baseapptestutil.RegisterCounterServer(suite.baseApp.MsgServiceRouter(), CounterServerImpl{t, capKey1, deliverKey})
@ -103,8 +103,8 @@ func TestABCI_MultiListener_StateChanges(t *testing.T) {
// require.Equal(t, sdk.MarkEventsToIndex(counterEvent(sdk.EventTypeMessage, counter).ToABCIEvents(), map[string]struct{}{})[0], events[2], "msg handler update counter event")
}
suite.baseApp.Commit()
_, err = suite.baseApp.Commit()
require.NoError(t, err)
require.Equal(t, expectedChangeSet, mockListener1.ChangeSet, "should contain the same changeSet")
require.Equal(t, expectedChangeSet, mockListener2.ChangeSet, "should contain the same changeSet")
}
@ -119,9 +119,10 @@ func Test_Ctx_with_StreamingManager(t *testing.T) {
addListenerOpt := func(bapp *baseapp.BaseApp) { bapp.CommitMultiStore().AddListeners([]storetypes.StoreKey{distKey1}) }
suite := NewBaseAppSuite(t, streamingManagerOpt, addListenerOpt)
suite.baseApp.InitChain(&abci.RequestInitChain{
_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
ConsensusParams: &tmproto.ConsensusParams{},
})
require.NoError(t, err)
ctx := getFinalizeBlockStateCtx(suite.baseApp)
sm := ctx.StreamingManager()
@ -133,14 +134,15 @@ func Test_Ctx_with_StreamingManager(t *testing.T) {
for blockN := 0; blockN < nBlocks; blockN++ {
suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: int64(blockN) + 1})
_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: int64(blockN) + 1})
require.NoError(t, err)
ctx := getFinalizeBlockStateCtx(suite.baseApp)
sm := ctx.StreamingManager()
require.NotNil(t, sm, fmt.Sprintf("nil StreamingManager: %v", sm))
require.Equal(t, listeners, sm.ABCIListeners, fmt.Sprintf("should contain same listeners: %v", listeners))
require.Equal(t, true, sm.StopNodeOnErr, "should contain StopNodeOnErr = true")
suite.baseApp.Commit()
_, err = suite.baseApp.Commit()
require.NoError(t, err)
}
}

13
baseapp/utils_test.go
View File

@ -339,7 +339,8 @@ func newTxCounter(t *testing.T, cfg client.TxConfig, counter int64, msgCounters
}
builder := cfg.NewTxBuilder()
builder.SetMsgs(msgs...)
err := builder.SetMsgs(msgs...)
require.NoError(t, err)
builder.SetMemo("counter=" + strconv.FormatInt(counter, 10) + "&failOnAnte=false")
setTxSignature(t, builder, uint64(counter))
@ -362,8 +363,8 @@ func getIntFromStore(t *testing.T, store storetypes.KVStore, key []byte) int64 {
func setFailOnAnte(t *testing.T, cfg client.TxConfig, tx signing.Tx, failOnAnte bool) signing.Tx {
t.Helper()
builder := cfg.NewTxBuilder()
builder.SetMsgs(tx.GetMsgs()...)
err := builder.SetMsgs(tx.GetMsgs()...)
require.NoError(t, err)
memo := tx.GetMemo()
vals, err := url.ParseQuery(memo)
require.NoError(t, err)
@ -376,7 +377,8 @@ func setFailOnAnte(t *testing.T, cfg client.TxConfig, tx signing.Tx, failOnAnte
return builder.GetTx()
}
func setFailOnHandler(cfg client.TxConfig, tx signing.Tx, fail bool) signing.Tx {
func setFailOnHandler(t *testing.T, cfg client.TxConfig, tx signing.Tx, fail bool) signing.Tx {
t.Helper()
builder := cfg.NewTxBuilder()
builder.SetMemo(tx.GetMemo())
@ -388,6 +390,7 @@ func setFailOnHandler(cfg client.TxConfig, tx signing.Tx, fail bool) signing.Tx
}
}
builder.SetMsgs(msgs...)
err := builder.SetMsgs(msgs...)
require.NoError(t, err)
return builder.GetTx()
}

6
client/grpc_query_test.go
View File

@ -83,18 +83,20 @@ func (s *IntegrationTestSuite) SetupSuite() {
s.NoError(err)
// init chain will set the validator set and initialize the genesis accounts
app.InitChain(&abci.RequestInitChain{
_, err = app.InitChain(&abci.RequestInitChain{
Validators: []abci.ValidatorUpdate{},
ConsensusParams: sims.DefaultConsensusParams,
AppStateBytes: stateBytes,
},
)
s.NoError(err)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
NextValidatorsHash: valSet.Hash(),
})
s.NoError(err)
// end of app init

3
client/rpc/rpc_test.go
View File

@ -100,7 +100,8 @@ func (s *IntegrationTestSuite) TestQueryABCIHeight() {
for _, tc := range testCases {
s.Run(tc.name, func() {
s.network.WaitForHeight(tc.expHeight)
_, err := s.network.WaitForHeight(tc.expHeight)
s.Require().NoError(err)
val := s.network.Validators[0]

8
collections/iter_test.go
View File

@ -10,11 +10,13 @@ import (
func TestIteratorBasic(t *testing.T) {
sk, ctx := deps()
// safety check to ensure that iteration does not cross prefix boundaries
sk.OpenKVStore(ctx).Set([]byte{0, 0}, []byte("before prefix"))
sk.OpenKVStore(ctx).Set([]byte{2, 1}, []byte("after prefix"))
err := sk.OpenKVStore(ctx).Set([]byte{0, 0}, []byte("before prefix"))
require.NoError(t, err)
err = sk.OpenKVStore(ctx).Set([]byte{2, 1}, []byte("after prefix"))
require.NoError(t, err)
schemaBuilder := NewSchemaBuilder(sk)
m := NewMap(schemaBuilder, NewPrefix(1), "m", StringKey, Uint64Value)
_, err := schemaBuilder.Build()
_, err = schemaBuilder.Build()
require.NoError(t, err)
for i := uint64(1); i <= 2; i++ {

10
crypto/keys/secp256k1/internal/secp256k1/secp256_test.go
View File

@ -227,7 +227,10 @@ func BenchmarkSign(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
Sign(msg, seckey)
_, err := Sign(msg, seckey)
if err != nil {
panic(err)
}
}
}
@ -238,6 +241,9 @@ func BenchmarkRecover(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
RecoverPubkey(msg, sig)
_, err := RecoverPubkey(msg, sig)
if err != nil {
panic(err)
}
}
}

2
fuzz/tests/crypto_hd_deriveprivatekeyforpath_test.go
View File

@ -30,6 +30,6 @@ func FuzzCryptoHDDerivePrivateKeyForPath(f *testing.F) {
}
seed := mnemonicToSeed(string(mnemonic))
master, ch := hd.ComputeMastersFromSeed(seed)
hd.DerivePrivateKeyForPath(master, ch, string(path))
_, _ = hd.DerivePrivateKeyForPath(master, ch, string(path))
})
}

2
fuzz/tests/crypto_hd_newparamsfrompath_test.go
View File

@ -10,6 +10,6 @@ import (
func FuzzCryptoHDNewParamsFromPath(f *testing.F) {
f.Fuzz(func(t *testing.T, data []byte) {
hd.NewParamsFromPath(string(data))
_, _ = hd.NewParamsFromPath(string(data))
})
}

2
fuzz/tests/types_parsecoin_test.go
View File

@ -10,6 +10,6 @@ import (
func FuzzTypesParseCoin(f *testing.F) {
f.Fuzz(func(t *testing.T, data []byte) {
types.ParseCoinNormalized(string(data))
_, _ = types.ParseCoinNormalized(string(data))
})
}

2
fuzz/tests/types_parsedeccoin_test.go
View File

@ -10,6 +10,6 @@ import (
func FuzzTypesParseDecCoin(f *testing.F) {
f.Fuzz(func(t *testing.T, data []byte) {
types.ParseDecCoin(string(data))
_, _ = types.ParseDecCoin(string(data))
})
}

2
fuzz/tests/types_verifyaddressformat_test.go
View File

@ -10,6 +10,6 @@ import (
func FuzzTypesVerifyAddressFormat(f *testing.F) {
f.Fuzz(func(t *testing.T, data []byte) {
types.VerifyAddressFormat(data)
_ = types.VerifyAddressFormat(data)
})
}

5
fuzz/tests/unknownproto_test.go
View File

@ -13,7 +13,8 @@ func FuzzUnknownProto(f *testing.F) {
f.Fuzz(func(t *testing.T, b []byte) {
msg := new(testdata.TestVersion2)
resolver := new(unknownproto.DefaultAnyResolver)
unknownproto.RejectUnknownFields(b, msg, true, resolver)
unknownproto.RejectUnknownFields(b, msg, false, resolver)
_, _ = unknownproto.RejectUnknownFields(b, msg, true, resolver)
_, _ = unknownproto.RejectUnknownFields(b, msg, false, resolver)
})
}

10
runtime/app.go
View File

@ -139,12 +139,18 @@ func (a *App) EndBlocker(ctx sdk.Context) (sdk.EndBlock, error) {
// Precommiter application updates every commit
func (a *App) Precommiter(ctx sdk.Context) {
a.ModuleManager.Precommit(ctx)
err := a.ModuleManager.Precommit(ctx)
if err != nil {
panic(err)
}
}
// PrepareCheckStater application updates every commit
func (a *App) PrepareCheckStater(ctx sdk.Context) {
a.ModuleManager.PrepareCheckState(ctx)
err := a.ModuleManager.PrepareCheckState(ctx)
if err != nil {
panic(err)
}
}
// InitChainer initializes the chain.

7
server/mock/app_test.go
View File

@ -42,11 +42,14 @@ func TestInitApp(t *testing.T) {
}
res, err := app.InitChain(&req)
require.NoError(t, err)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Hash: res.AppHash,
Height: 1,
})
app.Commit()
require.NoError(t, err)
_, err = app.Commit()
require.NoError(t, err)
// make sure we can query these values
query := abci.RequestQuery{

6
simapp/app_test.go
View File

@ -119,8 +119,10 @@ func TestRunMigrations(t *testing.T) {
}
// Initialize the chain
app.InitChain(&abci.RequestInitChain{})
app.Commit()
_, err := app.InitChain(&abci.RequestInitChain{})
require.NoError(t, err)
_, err = app.Commit()
require.NoError(t, err)
testCases := []struct {
name string

30
simapp/export.go
View File

@ -116,7 +116,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
ctx = ctx.WithBlockHeight(0)
// reinitialize all validators
app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) {
err = app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) {
// donate any unwithdrawn outstanding reward fraction tokens to the community pool
scraps, err := app.DistrKeeper.GetValidatorOutstandingRewardsCoins(ctx, val.GetOperator())
if err != nil {
@ -136,6 +136,9 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
}
return false
})
if err != nil {
panic(err)
}
// reinitialize all delegations
for _, del := range dels {
@ -162,7 +165,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
/* Handle staking state. */
// iterate through redelegations, reset creation height
app.StakingKeeper.IterateRedelegations(ctx, func(_ int64, red stakingtypes.Redelegation) (stop bool) {
err = app.StakingKeeper.IterateRedelegations(ctx, func(_ int64, red stakingtypes.Redelegation) (stop bool) {
for i := range red.Entries {
red.Entries[i].CreationHeight = 0
}
@ -172,9 +175,12 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
}
return false
})
if err != nil {
panic(err)
}
// iterate through unbonding delegations, reset creation height
app.StakingKeeper.IterateUnbondingDelegations(ctx, func(_ int64, ubd stakingtypes.UnbondingDelegation) (stop bool) {
err = app.StakingKeeper.IterateUnbondingDelegations(ctx, func(_ int64, ubd stakingtypes.UnbondingDelegation) (stop bool) {
for i := range ubd.Entries {
ubd.Entries[i].CreationHeight = 0
}
@ -184,7 +190,9 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
}
return false
})
if err != nil {
panic(err)
}
// Iterate through validators by power descending, reset bond heights, and
// update bond intra-tx counters.
store := ctx.KVStore(app.GetKey(stakingtypes.StoreKey))
@ -203,7 +211,9 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
validator.Jailed = true
}
app.StakingKeeper.SetValidator(ctx, validator)
if err = app.StakingKeeper.SetValidator(ctx, validator); err != nil {
panic(err)
}
counter++
}
@ -220,12 +230,18 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
/* Handle slashing state. */
// reset start height on signing infos
app.SlashingKeeper.IterateValidatorSigningInfos(
err = app.SlashingKeeper.IterateValidatorSigningInfos(
ctx,
func(addr sdk.ConsAddress, info slashingtypes.ValidatorSigningInfo) (stop bool) {
info.StartHeight = 0
app.SlashingKeeper.SetValidatorSigningInfo(ctx, addr, info)
err := app.SlashingKeeper.SetValidatorSigningInfo(ctx, addr, info)
if err != nil {
panic(err)
}
return false
},
)
if err != nil {
panic(err)
}
}

15
simapp/internal/testnet/cometrpc_test.go
View File

@ -76,7 +76,12 @@ func TestCometRPC_SingleRPCServer(t *testing.T) {
return cs
})
defer nodes.StopAndWait()
defer func() {
err := nodes.StopAndWait()
if err != nil {
panic(err)
}
}()
require.NoError(t, err)
// Once HTTP client to be shared across the following subtests.
@ -160,8 +165,12 @@ func TestCometRPC_MultipleRPCError(t *testing.T) {
rootDir,
).RPCListen() // Every node has RPCListen enabled, which will cause a failure.
})
defer nodes.StopAndWait()
defer func() {
err := nodes.StopAndWait()
if err != nil {
panic(err)
}
}()
// Returned error is convertible to CometRPCInUseError.
// We can't test the exact value because it includes a stack trace.
require.Error(t, err)

7
simapp/internal/testnet/cometstarter_test.go
View File

@ -125,7 +125,12 @@ func TestCometStarter_PortContention(t *testing.T) {
// Ensure nodes are stopped completely,
// so that we don't get t.Cleanup errors around directories not being empty.
defer nodes.StopAndWait()
defer func() {
err := nodes.StopAndWait()
if err != nil {
panic(err)
}
}()
require.NoError(t, err)
// Ensure that the height advances.

11
simapp/internal/testnet/example_basic_test.go
View File

@ -95,13 +95,18 @@ func Example_basicUsage() {
dir, // Where to put files on disk.
).Logger(logger.With("root_module", fmt.Sprintf("comet_%d", idx)))
})
// StopAndWait must be deferred before the error check,
// as the nodes value may contain some successfully started instances.
defer nodes.StopAndWait()
if err != nil {
panic(err)
}
// StopAndWait must be deferred before the error check,"os"
// as the nodes value may contain some successfully started instances.
defer func() {
err := nodes.StopAndWait()
if err != nil {
panic(err)
}
}()
// Now you can begin interacting with the nodes.
// For the sake of this example, we'll just check
// a couple simple properties of one node.

11
simapp/sim_test.go
View File

@ -180,9 +180,10 @@ func TestAppImportExport(t *testing.T) {
ctxA := app.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
ctxB := newApp.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
newApp.ModuleManager.InitGenesis(ctxB, app.AppCodec(), genesisState)
newApp.StoreConsensusParams(ctxB, exported.ConsensusParams)
_, err = newApp.ModuleManager.InitGenesis(ctxB, app.AppCodec(), genesisState)
require.NoError(t, err)
err = newApp.StoreConsensusParams(ctxB, exported.ConsensusParams)
require.NoError(t, err)
fmt.Printf("comparing stores...\n")
// skip certain prefixes
@ -288,11 +289,11 @@ func TestAppSimulationAfterImport(t *testing.T) {
newApp := NewSimApp(log.NewNopLogger(), newDB, nil, true, appOptions, fauxMerkleModeOpt, baseapp.SetChainID(SimAppChainID))
require.Equal(t, "SimApp", newApp.Name())
newApp.InitChain(&abci.RequestInitChain{
_, err = newApp.InitChain(&abci.RequestInitChain{
AppStateBytes: exported.AppState,
ChainId: SimAppChainID,
})
require.NoError(t, err)
_, _, err = simulation.SimulateFromSeed(
t,
os.Stdout,

5
store/iavl/store.go
View File

@ -216,7 +216,10 @@ func (st *Store) Has(key []byte) (exists bool) {
// Implements types.KVStore.
func (st *Store) Delete(key []byte) {
defer st.metrics.MeasureSince("store", "iavl", "delete")
st.tree.Remove(key)
_, _, err := st.tree.Remove(key)
if err != nil {
panic(err)
}
}
// DeleteVersionsTo deletes versions upto the given version from the MutableTree. An error

9
store/iavl/store_test.go
View File

@ -39,13 +39,15 @@ func newAlohaTree(t *testing.T, db dbm.DB) (*iavl.MutableTree, types.CommitID) {
tree := iavl.NewMutableTree(db, cacheSize, false, log.NewNopLogger())
for k, v := range treeData {
tree.Set([]byte(k), []byte(v))
_, err := tree.Set([]byte(k), []byte(v))
require.NoError(t, err)
}
for i := 0; i < nMoreData; i++ {
key := randBytes(12)
value := randBytes(50)
tree.Set(key, value)
_, err := tree.Set(key, value)
require.NoError(t, err)
}
hash, ver, err := tree.SaveVersion()
@ -583,7 +585,8 @@ func BenchmarkIAVLIteratorNext(b *testing.B) {
for i := 0; i < treeSize; i++ {
key := randBytes(4)
value := randBytes(50)
tree.Set(key, value)
_, err := tree.Set(key, value)
require.NoError(b, err)
}
iavlStore := UnsafeNewStore(tree)

10
store/iavl/tree_test.go
View File

@ -14,8 +14,14 @@ func TestImmutableTreePanics(t *testing.T) {
t.Parallel()
immTree := iavl.NewImmutableTree(dbm.NewMemDB(), 100, false, log.NewNopLogger())
it := &immutableTree{immTree}
require.Panics(t, func() { it.Set([]byte{}, []byte{}) })
require.Panics(t, func() { it.Remove([]byte{}) })
require.Panics(t, func() {
_, err := it.Set([]byte{}, []byte{})
require.NoError(t, err)
})
require.Panics(t, func() {
_, _, err := it.Remove([]byte{})
require.NoError(t, err)
})
require.Panics(t, func() { _, _, _ = it.SaveVersion() })
require.Panics(t, func() { _ = it.DeleteVersionsTo(int64(1)) })

15
store/rootmulti/snapshot_test.go
View File

@ -33,7 +33,10 @@ func newMultiStoreWithGeneratedData(db dbm.DB, stores uint8, storeKeys uint64) *
multiStore.MountStoreWithDB(key, types.StoreTypeIAVL, nil)
keys = append(keys, key)
}
multiStore.LoadLatestVersion()
err := multiStore.LoadLatestVersion()
if err != nil {
panic(err)
}
for _, key := range keys {
store := multiStore.GetCommitKVStore(key).(*iavl.Store)
@ -50,7 +53,10 @@ func newMultiStoreWithGeneratedData(db dbm.DB, stores uint8, storeKeys uint64) *
}
multiStore.Commit()
multiStore.LoadLatestVersion()
err = multiStore.LoadLatestVersion()
if err != nil {
panic(err)
}
return multiStore
}
@ -61,8 +67,9 @@ func newMultiStoreWithMixedMounts(db dbm.DB) *rootmulti.Store {
store.MountStoreWithDB(types.NewKVStoreKey("iavl2"), types.StoreTypeIAVL, nil)
store.MountStoreWithDB(types.NewKVStoreKey("iavl3"), types.StoreTypeIAVL, nil)
store.MountStoreWithDB(types.NewTransientStoreKey("trans1"), types.StoreTypeTransient, nil)
store.LoadLatestVersion()
if err := store.LoadLatestVersion(); err != nil {
panic(err)
}
return store
}

10
store/rootmulti/store.go
View File

@ -1205,7 +1205,10 @@ func flushCommitInfo(batch dbm.Batch, version int64, cInfo *types.CommitInfo) {
}
cInfoKey := fmt.Sprintf(commitInfoKeyFmt, version)
batch.Set([]byte(cInfoKey), bz)
err = batch.Set([]byte(cInfoKey), bz)
if err != nil {
panic(err)
}
}
func flushLatestVersion(batch dbm.Batch, version int64) {
@ -1214,5 +1217,8 @@ func flushLatestVersion(batch dbm.Batch, version int64) {
panic(err)
}
batch.Set([]byte(latestVersionKey), bz)
err = batch.Set([]byte(latestVersionKey), bz)
if err != nil {
panic(err)
}
}

14
store/rootmulti/store_test.go
View File

@ -648,7 +648,8 @@ func TestSetInitialVersion(t *testing.T) {
require.NoError(t, multi.LoadLatestVersion())
multi.SetInitialVersion(5)
err := multi.SetInitialVersion(5)
require.NoError(t, err)
require.Equal(t, int64(5), multi.initialVersion)
multi.Commit()
@ -916,13 +917,15 @@ func (stub *commitKVStoreStub) Commit() types.CommitID {
return commitID
}
func prepareStoreMap() map[types.StoreKey]types.CommitKVStore {
func prepareStoreMap() (map[types.StoreKey]types.CommitKVStore, error) {
var db dbm.DB = dbm.NewMemDB()
store := NewStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics())
store.MountStoreWithDB(types.NewKVStoreKey("iavl1"), types.StoreTypeIAVL, nil)
store.MountStoreWithDB(types.NewKVStoreKey("iavl2"), types.StoreTypeIAVL, nil)
store.MountStoreWithDB(types.NewTransientStoreKey("trans1"), types.StoreTypeTransient, nil)
store.LoadLatestVersion()
if err := store.LoadLatestVersion(); err != nil {
return nil, err
}
return map[types.StoreKey]types.CommitKVStore{
testStoreKey1: &commitKVStoreStub{
CommitKVStore: store.GetStoreByName("iavl1").(types.CommitKVStore),
@ -933,7 +936,7 @@ func prepareStoreMap() map[types.StoreKey]types.CommitKVStore {
testStoreKey3: &commitKVStoreStub{
CommitKVStore: store.GetStoreByName("trans1").(types.CommitKVStore),
},
}
}, nil
}
func TestCommitStores(t *testing.T) {
@ -960,7 +963,8 @@ func TestCommitStores(t *testing.T) {
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
storeMap := prepareStoreMap()
storeMap, err := prepareStoreMap()
require.NoError(t, err)
store := storeMap[testStoreKey1].(*commitKVStoreStub)
for i := tc.committed; i > 0; i-- {
store.Commit()

5
store/tracekv/store.go
View File

@ -195,5 +195,8 @@ func writeOperation(w io.Writer, op operation, tc types.TraceContext, key, value
panic(errors.Wrap(err, "failed to write trace operation"))
}
io.WriteString(w, "\n")
_, err = io.WriteString(w, "\n")
if err != nil {
panic(err)
}
}

3
tests/e2e/auth/suite.go
View File

@ -1340,10 +1340,11 @@ func (s *E2ETestSuite) TestSignWithMultiSignersAminoJSON() {
// because DIRECT doesn't support multi signers via the CLI.
// Since we use amino, we don't need to pre-populate signer_infos.
txBuilder := val0.ClientCtx.TxConfig.NewTxBuilder()
txBuilder.SetMsgs(
err := txBuilder.SetMsgs(
banktypes.NewMsgSend(val0.Address, addr1, sdk.NewCoins(val0Coin)),
banktypes.NewMsgSend(val1.Address, addr1, sdk.NewCoins(val1Coin)),
)
require.NoError(err)
txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(10))))
txBuilder.SetGasLimit(testdata.NewTestGasLimit() * 2)
signers, err := txBuilder.GetTx().GetSigners()

3
tests/e2e/authz/grpc.go
View File

@ -74,7 +74,8 @@ func (s *E2ETestSuite) TestQueryGrantGRPC() {
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &g)
require.NoError(err)
require.Len(g.Grants, 1)
g.Grants[0].UnpackInterfaces(val.ClientCtx.InterfaceRegistry)
err = g.Grants[0].UnpackInterfaces(val.ClientCtx.InterfaceRegistry)
require.NoError(err)
auth, err := g.Grants[0].GetAuthorization()
require.NoError(err)
require.Equal(auth.MsgTypeURL(), banktypes.SendAuthorization{}.MsgTypeURL())

2
tests/e2e/staking/suite.go
View File

@ -133,7 +133,7 @@ func (s *E2ETestSuite) TestBlockResults() {
// Loop until we find a block result with the correct validator updates.
// By experience, it happens around 2 blocks after `delHeight`.
s.network.RetryForBlocks(func() error {
_ = s.network.RetryForBlocks(func() error {
latestHeight, err := s.network.LatestHeight()
require.NoError(err)
res, err := rpcClient.BlockResults(context.Background(), &latestHeight)

3
tests/integration/auth/client/cli/suite_test.go
View File

@ -881,10 +881,11 @@ func (s *CLITestSuite) TestSignWithMultiSignersAminoJSON() {
// because DIRECT doesn't support multi signers via the CLI.
// Since we use amino, we don't need to pre-populate signer_infos.
txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
txBuilder.SetMsgs(
err := txBuilder.SetMsgs(
banktypes.NewMsgSend(val0, addr1, sdk.NewCoins(val0Coin)),
banktypes.NewMsgSend(val1, addr1, sdk.NewCoins(val1Coin)),
)
s.Require().NoError(err)
txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("stake", math.NewInt(10))))
txBuilder.SetGasLimit(testdata.NewTestGasLimit() * 2)
signers, err := txBuilder.GetTx().GetSigners()

10
tests/integration/auth/migrations/v2/store_test.go
View File

@ -74,7 +74,8 @@ func TestMigrateVestingAccounts(t *testing.T) {
require.NoError(t, v4.Migrate(ctx, storeService, legacySubspace, cdc))
ctx = app.BaseApp.NewContextLegacy(false, cmtproto.Header{Time: time.Now()})
stakingKeeper.SetParams(ctx, stakingtypes.DefaultParams())
err = stakingKeeper.SetParams(ctx, stakingtypes.DefaultParams())
require.NoError(t, err)
lastAccNum := uint64(1000)
createBaseAccount := func(addr sdk.AccAddress) *authtypes.BaseAccount {
baseAccount := authtypes.NewBaseAccountWithAddress(addr)
@ -778,14 +779,15 @@ func createValidator(t *testing.T, ctx sdk.Context, bankKeeper bankkeeper.Keeper
val1, err := stakingtypes.NewValidator(valAddrs[0], pks[0], stakingtypes.Description{})
require.NoError(t, err)
stakingKeeper.SetValidator(ctx, val1)
require.NoError(t, stakingKeeper.SetValidator(ctx, val1))
require.NoError(t, stakingKeeper.SetValidatorByConsAddr(ctx, val1))
stakingKeeper.SetNewValidatorByPowerIndex(ctx, val1)
require.NoError(t, stakingKeeper.SetNewValidatorByPowerIndex(ctx, val1))
_, err = stakingKeeper.Delegate(ctx, addrs[0], valTokens, stakingtypes.Unbonded, val1, true)
require.NoError(t, err)
stakingKeeper.EndBlocker(ctx)
_, err = stakingKeeper.EndBlocker(ctx)
require.NoError(t, err)
return addrs[0], valAddrs[0]
}

7
tests/integration/bank/keeper/deterministic_test.go
View File

@ -313,7 +313,8 @@ func TestGRPCQueryParams(t *testing.T) {
DefaultSendEnabled: rapid.Bool().Draw(rt, "send"),
}
f.bankKeeper.SetParams(f.ctx, params)
err := f.bankKeeper.SetParams(f.ctx, params)
assert.NilError(t, err)
req := &banktypes.QueryParamsRequest{}
testdata.DeterministicIterations(f.ctx, t, req, f.queryClient.Params, 0, true)
@ -329,8 +330,8 @@ func TestGRPCQueryParams(t *testing.T) {
DefaultSendEnabled: false,
}
f.bankKeeper.SetParams(f.ctx, params)
err := f.bankKeeper.SetParams(f.ctx, params)
assert.NilError(t, err)
req := &banktypes.QueryParamsRequest{}
testdata.DeterministicIterations(f.ctx, t, req, f.queryClient.Params, 1003, false)
}

3
tests/integration/distribution/keeper/msg_server_test.go
View File

@ -199,8 +199,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) {
validator, issuedShares := validator.AddTokensFromDel(delTokens)
delegation := stakingtypes.NewDelegation(delAddr, validator.GetOperator(), issuedShares)
require.NoError(t, f.stakingKeeper.SetDelegation(f.sdkCtx, delegation))
err = f.distrKeeper.DelegatorStartingInfo.Set(f.sdkCtx, collections.Join(validator.GetOperator(), delAddr), distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 20))
require.NoError(t, err)
require.NoError(t, f.distrKeeper.DelegatorStartingInfo.Set(f.sdkCtx, collections.Join(validator.GetOperator(), delAddr), distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 20)))
// setup validator rewards
decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())}
historicalRewards := distrtypes.NewValidatorHistoricalRewards(decCoins, 2)

8
tests/integration/evidence/keeper/infraction_test.go
View File

@ -196,11 +196,11 @@ func TestHandleDoubleSign(t *testing.T) {
assert.NilError(t, f.slashingKeeper.AddPubkey(f.sdkCtx, valpubkey))
info := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(valpubkey.Address()), f.sdkCtx.BlockHeight(), int64(0), time.Unix(0, 0), false, int64(0))
f.slashingKeeper.SetValidatorSigningInfo(f.sdkCtx, sdk.ConsAddress(valpubkey.Address()), info)
err = f.slashingKeeper.SetValidatorSigningInfo(f.sdkCtx, sdk.ConsAddress(valpubkey.Address()), info)
assert.NilError(t, err)
// handle a signature to set signing info
f.slashingKeeper.HandleValidatorSignature(ctx, valpubkey.Address(), selfDelegation.Int64(), comet.BlockIDFlagCommit)
err = f.slashingKeeper.HandleValidatorSignature(ctx, valpubkey.Address(), selfDelegation.Int64(), comet.BlockIDFlagCommit)
assert.NilError(t, err)
// double sign less than max age
val, err = f.stakingKeeper.Validator(ctx, operatorAddr)
assert.NilError(t, err)

22
tests/integration/gov/keeper/common_test.go
View File

@ -48,21 +48,21 @@ func createValidators(t *testing.T, f *fixture, powers []int64) ([]sdk.AccAddres
val3, err := stakingtypes.NewValidator(valAddrs[2], pks[2], stakingtypes.Description{})
assert.NilError(t, err)
f.stakingKeeper.SetValidator(f.ctx, val1)
f.stakingKeeper.SetValidator(f.ctx, val2)
f.stakingKeeper.SetValidator(f.ctx, val3)
f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val1)
f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val2)
f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val3)
f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val1)
f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val2)
f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val3)
assert.NilError(t, f.stakingKeeper.SetValidator(f.ctx, val1))
assert.NilError(t, f.stakingKeeper.SetValidator(f.ctx, val2))
assert.NilError(t, f.stakingKeeper.SetValidator(f.ctx, val3))
assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val1))
assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val2))
assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val3))
assert.NilError(t, f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val1))
assert.NilError(t, f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val2))
assert.NilError(t, f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val3))
_, _ = f.stakingKeeper.Delegate(f.ctx, addrs[0], f.stakingKeeper.TokensFromConsensusPower(f.ctx, powers[0]), stakingtypes.Unbonded, val1, true)
_, _ = f.stakingKeeper.Delegate(f.ctx, addrs[1], f.stakingKeeper.TokensFromConsensusPower(f.ctx, powers[1]), stakingtypes.Unbonded, val2, true)
_, _ = f.stakingKeeper.Delegate(f.ctx, addrs[2], f.stakingKeeper.TokensFromConsensusPower(f.ctx, powers[2]), stakingtypes.Unbonded, val3, true)
f.stakingKeeper.EndBlocker(f.ctx)
_, err = f.stakingKeeper.EndBlocker(f.ctx)
assert.NilError(t, err)
return addrs, valAddrs
}

14
tests/integration/gov/keeper/grpc_query_test.go
View File

@ -79,8 +79,8 @@ func TestGRPCQueryTally(t *testing.T) {
"request tally after few votes",
func() {
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err := f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -103,7 +103,8 @@ func TestGRPCQueryTally(t *testing.T) {
"request final tally after status changed",
func() {
proposal.Status = v1.StatusPassed
f.govKeeper.SetProposal(ctx, proposal)
err := f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
proposal, _ = f.govKeeper.Proposals.Get(ctx, proposal.Id)
req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
@ -201,8 +202,8 @@ func TestLegacyGRPCQueryTally(t *testing.T) {
"request tally after few votes",
func() {
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err := f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -225,7 +226,8 @@ func TestLegacyGRPCQueryTally(t *testing.T) {
"request final tally after status changed",
func() {
proposal.Status = v1.StatusPassed
f.govKeeper.SetProposal(ctx, proposal)
err := f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
proposal, _ = f.govKeeper.Proposals.Get(ctx, proposal.Id)
req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}

7
tests/integration/gov/keeper/keeper_test.go
View File

@ -96,8 +96,8 @@ func initFixture(tb testing.TB) *fixture {
stakingKeeper := stakingkeeper.NewKeeper(cdc, runtime.NewKVStoreService(keys[stakingtypes.StoreKey]), accountKeeper, bankKeeper, authority.String())
// set default staking params
stakingKeeper.SetParams(newCtx, stakingtypes.DefaultParams())
err := stakingKeeper.SetParams(newCtx, stakingtypes.DefaultParams())
assert.NilError(tb, err)
distrKeeper := distrkeeper.NewKeeper(
cdc, runtime.NewKVStoreService(keys[distrtypes.StoreKey]), accountKeeper, bankKeeper, stakingKeeper, distrtypes.ModuleName, authority.String(),
)
@ -118,8 +118,7 @@ func initFixture(tb testing.TB) *fixture {
types.DefaultConfig(),
authority.String(),
)
err := govKeeper.ProposalID.Set(newCtx, 1)
assert.NilError(tb, err)
assert.NilError(tb, govKeeper.ProposalID.Set(newCtx, 1))
govRouter := v1beta1.NewRouter()
govRouter.AddRoute(types.RouterKey, v1beta1.ProposalHandler)
govKeeper.SetLegacyRouter(govRouter)

82
tests/integration/gov/keeper/tally_test.go
View File

@ -26,8 +26,8 @@ func TestTallyNoOneVotes(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
proposal, ok := f.govKeeper.Proposals.Get(ctx, proposalID)
assert.Assert(t, ok)
passes, burnDeposits, tallyResults, _ := f.govKeeper.Tally(ctx, proposal)
@ -53,8 +53,8 @@ func TestTallyNoQuorum(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
err = f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), "")
assert.NilError(t, err)
@ -79,8 +79,8 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -108,8 +108,8 @@ func TestTallyOnlyValidators51No(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@ -135,8 +135,8 @@ func TestTallyOnlyValidators51Yes(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -163,8 +163,8 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[2], v1.NewNonSplitVoteOption(v1.OptionNoWithVeto), ""))
@ -192,8 +192,8 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -221,8 +221,8 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[2], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@ -251,8 +251,8 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddr1, v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddr2, v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@ -281,15 +281,15 @@ func TestTallyDelgatorOverride(t *testing.T) {
_, err := f.stakingKeeper.Delegate(ctx, addrs[4], delTokens, stakingtypes.Unbonded, val1, true)
assert.NilError(t, err)
f.stakingKeeper.EndBlocker(ctx)
_, err = f.stakingKeeper.EndBlocker(ctx)
assert.NilError(t, err)
tp := TestProposal
proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[3], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -320,15 +320,15 @@ func TestTallyDelgatorInherit(t *testing.T) {
_, err := f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true)
assert.NilError(t, err)
f.stakingKeeper.EndBlocker(ctx)
_, err = f.stakingKeeper.EndBlocker(ctx)
assert.NilError(t, err)
tp := TestProposal
proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -362,15 +362,15 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
_, err = f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val2, true)
assert.NilError(t, err)
f.stakingKeeper.EndBlocker(ctx)
_, err = f.stakingKeeper.EndBlocker(ctx)
assert.NilError(t, err)
tp := TestProposal
proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@ -407,15 +407,15 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
_, err = f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true)
assert.NilError(t, err)
f.stakingKeeper.EndBlocker(ctx)
_, err = f.stakingKeeper.EndBlocker(ctx)
assert.NilError(t, err)
tp := TestProposal
proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@ -449,19 +449,19 @@ func TestTallyJailedValidator(t *testing.T) {
_, err = f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true)
assert.NilError(t, err)
f.stakingKeeper.EndBlocker(ctx)
_, err = f.stakingKeeper.EndBlocker(ctx)
assert.NilError(t, err)
consAddr, err := val2.GetConsAddr()
assert.NilError(t, err)
f.stakingKeeper.Jail(ctx, sdk.ConsAddress(consAddr.Bytes()))
assert.NilError(t, f.stakingKeeper.Jail(ctx, sdk.ConsAddress(consAddr.Bytes())))
tp := TestProposal
proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@ -496,8 +496,8 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
assert.NilError(t, err)
proposalID := proposal.Id
proposal.Status = v1.StatusVotingPeriod
f.govKeeper.SetProposal(ctx, proposal)
err = f.govKeeper.SetProposal(ctx, proposal)
assert.NilError(t, err)
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))

39
tests/integration/slashing/keeper/keeper_test.go
View File

@ -114,19 +114,21 @@ func initFixture(tb testing.TB) *fixture {
slashingtypes.RegisterQueryServer(integrationApp.QueryHelper(), slashingkeeper.NewQuerier(slashingKeeper))
// set default staking params
stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams())
err := stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams())
assert.NilError(tb, err)
// TestParams set the SignedBlocksWindow to 1000 and MaxMissedBlocksPerWindow to 500
slashingKeeper.Params.Set(sdkCtx, testutil.TestParams())
err = slashingKeeper.Params.Set(sdkCtx, testutil.TestParams())
assert.NilError(tb, err)
addrDels := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, sdkCtx, 6, stakingKeeper.TokensFromConsensusPower(sdkCtx, 200))
valAddrs := simtestutil.ConvertAddrsToValAddrs(addrDels)
info1 := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3), time.Unix(2, 0), false, int64(10))
info2 := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[1]), int64(5), int64(4), time.Unix(2, 0), false, int64(10))
slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[0]), info1)
slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[1]), info2)
err = slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[0]), info1)
assert.NilError(tb, err)
err = slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[1]), info2)
assert.NilError(tb, err)
return &fixture{
app: integrationApp,
ctx: sdkCtx,
@ -145,8 +147,7 @@ func TestUnJailNotBonded(t *testing.T) {
p, err := f.stakingKeeper.GetParams(f.ctx)
assert.NilError(t, err)
p.MaxValidators = 5
f.stakingKeeper.SetParams(f.ctx, p)
assert.NilError(t, f.stakingKeeper.SetParams(f.ctx, p))
pks := simtestutil.CreateTestPubKeys(6)
tstaking := stakingtestutil.NewHelper(t, f.ctx, f.stakingKeeper)
@ -156,7 +157,8 @@ func TestUnJailNotBonded(t *testing.T) {
tstaking.CreateValidatorWithValPower(addr, val, 100, true)
}
f.stakingKeeper.EndBlocker(f.ctx)
_, err = f.stakingKeeper.EndBlocker(f.ctx)
assert.NilError(t, err)
f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
// create a 6th validator with less power than the cliff validator (won't be bonded)
@ -169,7 +171,8 @@ func TestUnJailNotBonded(t *testing.T) {
assert.NilError(t, err)
assert.Assert(t, res != nil)
f.stakingKeeper.EndBlocker(f.ctx)
_, err = f.stakingKeeper.EndBlocker(f.ctx)
assert.NilError(t, err)
f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
tstaking.CheckValidator(addr, stakingtypes.Unbonded, false)
@ -178,7 +181,8 @@ func TestUnJailNotBonded(t *testing.T) {
assert.Equal(t, p.BondDenom, tstaking.Denom)
tstaking.Undelegate(sdk.AccAddress(addr), addr, f.stakingKeeper.TokensFromConsensusPower(f.ctx, 1), true)
f.stakingKeeper.EndBlocker(f.ctx)
_, err = f.stakingKeeper.EndBlocker(f.ctx)
assert.NilError(t, err)
f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
// verify that validator is jailed
@ -195,12 +199,14 @@ func TestUnJailNotBonded(t *testing.T) {
)
assert.ErrorContains(t, err, "cannot be unjailed")
f.stakingKeeper.EndBlocker(f.ctx)
_, err = f.stakingKeeper.EndBlocker(f.ctx)
assert.NilError(t, err)
f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
// bond to meet minimum self-delegation
tstaking.DelegateWithPower(sdk.AccAddress(addr), addr, 1)
f.stakingKeeper.EndBlocker(f.ctx)
_, err = f.stakingKeeper.EndBlocker(f.ctx)
assert.NilError(t, err)
f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
// verify we can immediately unjail
@ -345,7 +351,8 @@ func TestValidatorDippingInAndOut(t *testing.T) {
params, err := f.stakingKeeper.GetParams(f.ctx)
require.NoError(t, err)
params.MaxValidators = 1
f.stakingKeeper.SetParams(f.ctx, params)
err = f.stakingKeeper.SetParams(f.ctx, params)
assert.NilError(t, err)
power := int64(100)
pks := simtestutil.CreateTestPubKeys(3)
@ -439,8 +446,8 @@ func TestValidatorDippingInAndOut(t *testing.T) {
assert.NilError(t, err)
// validator rejoins and starts signing again
f.stakingKeeper.Unjail(f.ctx, consAddr)
err = f.stakingKeeper.Unjail(f.ctx, consAddr)
assert.NilError(t, err)
err = f.slashingKeeper.HandleValidatorSignature(f.ctx, val.Address(), newPower, comet.BlockIDFlagCommit)
assert.NilError(t, err)

44
tests/integration/staking/keeper/validator_bench_test.go
View File

@ -27,7 +27,9 @@ func BenchmarkGetValidator(b *testing.B) {
f, _, valAddrs, vals := initValidators(b, totalPower, len(powers), powers)
for _, validator := range vals {
f.stakingKeeper.SetValidator(f.sdkCtx, validator)
if err := f.stakingKeeper.SetValidator(f.sdkCtx, validator); err != nil {
panic(err)
}
}
b.ResetTimer()
@ -50,17 +52,25 @@ func BenchmarkGetValidatorDelegations(b *testing.B) {
f, _, valAddrs, vals := initValidators(b, totalPower, len(powers), powers)
for _, validator := range vals {
f.stakingKeeper.SetValidator(f.sdkCtx, validator)
if err := f.stakingKeeper.SetValidator(f.sdkCtx, validator); err != nil {
panic(err)
}
}
delegationsNum := 1000
for _, val := range valAddrs {
for i := 0; i < delegationsNum; i++ {
delegator := sdk.AccAddress(fmt.Sprintf("address%d", i))
banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
err := banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(int64(i)))))
if err != nil {
panic(err)
}
NewDel := types.NewDelegation(delegator, val, math.LegacyNewDec(int64(i)))
f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel)
if err := f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel); err != nil {
panic(err)
}
}
}
@ -83,17 +93,24 @@ func BenchmarkGetValidatorDelegationsLegacy(b *testing.B) {
f, _, valAddrs, vals := initValidators(b, totalPower, len(powers), powers)
for _, validator := range vals {
f.stakingKeeper.SetValidator(f.sdkCtx, validator)
if err := f.stakingKeeper.SetValidator(f.sdkCtx, validator); err != nil {
panic(err)
}
}
delegationsNum := 1000
for _, val := range valAddrs {
for i := 0; i < delegationsNum; i++ {
delegator := sdk.AccAddress(fmt.Sprintf("address%d", i))
banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
err := banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(int64(i)))))
if err != nil {
panic(err)
}
NewDel := types.NewDelegation(delegator, val, math.LegacyNewDec(int64(i)))
f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel)
if err := f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel); err != nil {
panic(err)
}
}
}
@ -115,9 +132,13 @@ func updateValidatorDelegationsLegacy(f *fixture, existingValAddr, newValAddr sd
for ; iterator.Valid(); iterator.Next() {
delegation := types.MustUnmarshalDelegation(cdc, iterator.Value())
if delegation.GetValidatorAddr().Equals(existingValAddr) {
k.RemoveDelegation(f.sdkCtx, delegation)
if err := k.RemoveDelegation(f.sdkCtx, delegation); err != nil {
panic(err)
}
delegation.ValidatorAddress = newValAddr.String()
k.SetDelegation(f.sdkCtx, delegation)
if err := k.SetDelegation(f.sdkCtx, delegation); err != nil {
panic(err)
}
}
}
}
@ -148,6 +169,9 @@ func updateValidatorDelegations(f *fixture, existingValAddr, newValAddr sdk.ValA
delegation.ValidatorAddress = newValAddr.String()
// add with new operator addr
k.SetDelegation(f.sdkCtx, delegation)
if err := k.SetDelegation(f.sdkCtx, delegation); err != nil {
panic(err)
}
}
}

95
tests/integration/staking/keeper/validator_test.go
View File

@ -102,7 +102,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
// remove enough tokens to kick out the validator below the current cliff
// validator and next in line cliff validator
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, nextCliffVal)
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, nextCliffVal))
shares := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 21)
nextCliffVal, _ = nextCliffVal.RemoveDelShares(math.LegacyNewDecFromInt(shares))
_ = keeper.TestingUpdateValidator(f.stakingKeeper, f.sdkCtx, nextCliffVal, true)
@ -144,12 +144,13 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
validator, _ = validator.AddTokensFromDel(valTokens)
assert.Equal(t, types.Unbonded, validator.Status)
assert.DeepEqual(t, valTokens, validator.Tokens)
f.stakingKeeper.SetValidatorByConsAddr(f.sdkCtx, validator)
assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.sdkCtx, validator))
validator = keeper.TestingUpdateValidator(f.stakingKeeper, f.sdkCtx, validator, true)
assert.DeepEqual(t, valTokens, validator.Tokens)
// slash the validator by 100%
f.stakingKeeper.Slash(f.sdkCtx, sdk.ConsAddress(PKs[0].Address()), 0, 100, math.LegacyOneDec())
_, err = f.stakingKeeper.Slash(f.sdkCtx, sdk.ConsAddress(PKs[0].Address()), 0, 100, math.LegacyOneDec())
assert.NilError(t, err)
// apply TM updates
applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, -1)
// validator should be unbonding
@ -320,8 +321,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
assert.NilError(t, err)
nMax := uint32(2)
params.MaxValidators = nMax
f.stakingKeeper.SetParams(f.sdkCtx, params)
assert.NilError(t, f.stakingKeeper.SetParams(f.sdkCtx, params))
// initialize some validators into the state
powers := []int64{0, 100, 400, 400}
var validators [4]types.Validator
@ -346,7 +346,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
assert.Assert(ValEq(t, validators[3], resValidators[1]))
// delegate 500 tokens to validator 0
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0]))
delTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 500)
validators[0], _ = validators[0].AddTokensFromDel(delTokens)
notBondedPool := f.stakingKeeper.GetNotBondedPool(f.sdkCtx)
@ -380,7 +380,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
validators[3], err = f.stakingKeeper.GetValidator(f.sdkCtx, validators[3].GetOperator())
assert.NilError(t, err)
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3]))
validators[3], _ = validators[3].AddTokensFromDel(f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 1))
notBondedPool = f.stakingKeeper.GetNotBondedPool(f.sdkCtx)
@ -396,7 +396,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
assert.Assert(ValEq(t, validators[3], resValidators[1]))
// validator 3 kicked out temporarily
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3]))
rmTokens := validators[3].TokensFromShares(math.LegacyNewDec(201)).TruncateInt()
validators[3], _ = validators[3].RemoveDelShares(math.LegacyNewDec(201))
@ -412,7 +412,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
assert.Assert(ValEq(t, validators[2], resValidators[1]))
// validator 3 does not get spot back
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3]))
validators[3], _ = validators[3].AddTokensFromDel(math.NewInt(200))
notBondedPool = f.stakingKeeper.GetNotBondedPool(f.sdkCtx)
@ -436,8 +436,7 @@ func TestValidatorBondHeight(t *testing.T) {
params, err := f.stakingKeeper.GetParams(f.sdkCtx)
assert.NilError(t, err)
params.MaxValidators = 2
f.stakingKeeper.SetParams(f.sdkCtx, params)
assert.NilError(t, f.stakingKeeper.SetParams(f.sdkCtx, params))
// initialize some validators into the state
var validators [3]types.Validator
validators[0] = testutil.NewValidator(t, sdk.ValAddress(PKs[0].Address().Bytes()), PKs[0])
@ -465,8 +464,8 @@ func TestValidatorBondHeight(t *testing.T) {
assert.Assert(ValEq(t, validators[0], resValidators[0]))
assert.Assert(ValEq(t, validators[1], resValidators[1]))
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1])
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[2])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1]))
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[2]))
delTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 50)
validators[1], _ = validators[1].AddTokensFromDel(delTokens)
validators[2], _ = validators[2].AddTokensFromDel(delTokens)
@ -540,10 +539,10 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
// test from nothing to something
// tendermintUpdate set: {} -> {c1, c3}
applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 0)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[0])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0])
f.stakingKeeper.SetValidator(f.sdkCtx, validators[1])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[0]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0]))
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[1]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1]))
updates := applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 2)
validators[0], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[0].GetOperator())
@ -634,24 +633,24 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
// test validtor added at the beginning
// tendermintUpdate set: {} -> {c0}
f.stakingKeeper.SetValidator(f.sdkCtx, validators[2])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[2]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2]))
updates := applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)
validators[2], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[2].GetOperator())
assert.DeepEqual(t, validators[2].ABCIValidatorUpdate(f.stakingKeeper.PowerReduction(f.sdkCtx)), updates[0])
// test validtor added at the beginning
// tendermintUpdate set: {} -> {c0}
f.stakingKeeper.SetValidator(f.sdkCtx, validators[3])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[3])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[3]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[3]))
updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)
validators[3], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[3].GetOperator())
assert.DeepEqual(t, validators[3].ABCIValidatorUpdate(f.stakingKeeper.PowerReduction(f.sdkCtx)), updates[0])
// test validtor added at the end
// tendermintUpdate set: {} -> {c0}
f.stakingKeeper.SetValidator(f.sdkCtx, validators[4])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[4])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[4]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[4]))
updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)
validators[4], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[4].GetOperator())
assert.DeepEqual(t, validators[4].ABCIValidatorUpdate(f.stakingKeeper.PowerReduction(f.sdkCtx)), updates[0])
@ -661,8 +660,8 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
f, addrs, _ := bootstrapValidatorTest(t, 1000, 20)
params := types.DefaultParams()
params.MaxValidators = 2
f.stakingKeeper.SetParams(f.sdkCtx, params)
err := f.stakingKeeper.SetParams(f.sdkCtx, params)
assert.NilError(t, err)
powers := []int64{10, 20, 5}
var validators [5]types.Validator
for i, power := range powers {
@ -685,8 +684,8 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 10)
validators[2], _ = validators[2].AddTokensFromDel(tokens)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[2])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[2]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2]))
updates := applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 2)
validators[2], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[2].GetOperator())
assert.DeepEqual(t, validators[0].ABCIValidatorUpdateZero(), updates[1])
@ -713,8 +712,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[i])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[i]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i]))
}
// verify initial CometBFT updates are correct
@ -729,12 +728,12 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
// update initial validator set
for i, power := range powers {
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[i])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[i]))
tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[i])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[i]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i]))
}
// add a new validator that goes from zero power, to non-zero power, back to
@ -746,11 +745,11 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
validator := testutil.NewValidator(t, valAddr, valPubKey)
validator, _ = validator.AddTokensFromDel(amt)
f.stakingKeeper.SetValidator(f.sdkCtx, validator)
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validator))
validator, _ = validator.RemoveDelShares(math.LegacyNewDecFromInt(amt))
f.stakingKeeper.SetValidator(f.sdkCtx, validator)
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator)
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validator))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator))
// add a new validator that increases in power
valPubKey = PKs[len(validators)+2]
@ -759,8 +758,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
validator = testutil.NewValidator(t, valAddr, valPubKey)
tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 500)
validator, _ = validator.AddTokensFromDel(tokens)
f.stakingKeeper.SetValidator(f.sdkCtx, validator)
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator)
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validator))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator))
// verify initial CometBFT updates are correct
updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, len(validators)+1)
@ -792,8 +791,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker)
tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[i])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[i]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i]))
}
// verify initial CometBFT updates are correct
@ -811,11 +810,11 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
validators[0], err = f.stakingKeeper.GetValidator(f.sdkCtx, validators[0].GetOperator())
assert.NilError(t, err)
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0]))
tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 1)
validators[0], _ = validators[0].AddTokensFromDel(tokens)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[0])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[0]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0]))
// verify initial CometBFT updates are correct
applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 0)
@ -827,17 +826,17 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
validators[1], err = f.stakingKeeper.GetValidator(f.sdkCtx, validators[1].GetOperator())
assert.NilError(t, err)
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0]))
validators[0], _ = validators[0].RemoveDelShares(validators[0].DelegatorShares)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[0])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[0]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0]))
applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 0)
f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1])
assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1]))
tokens = f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 250)
validators[1], _ = validators[1].AddTokensFromDel(tokens)
f.stakingKeeper.SetValidator(f.sdkCtx, validators[1])
f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1])
assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[1]))
assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1]))
// verify initial CometBFT updates are correct
updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)

4
tests/integration/staking/simulation/operations_test.go
View File

@ -165,7 +165,6 @@ func (s *SimTestSuite) TestSimulateMsgCreateValidator() {
require := s.Require()
_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash})
require.NoError(err)
// execute operation
op := simulation.SimulateMsgCreateValidator(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
operationMsg, futureOperations, err := op(s.r, s.app.BaseApp, s.ctx, s.accounts[1:], "")
@ -210,7 +209,6 @@ func (s *SimTestSuite) TestSimulateMsgCancelUnbondingDelegation() {
_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash, Time: blockTime})
require.NoError(err)
// execute operation
op := simulation.SimulateMsgCancelUnbondingDelegate(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
accounts := []simtypes.Account{delegator}
@ -239,7 +237,6 @@ func (s *SimTestSuite) TestSimulateMsgEditValidator() {
_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash, Time: blockTime})
require.NoError(err)
// execute operation
op := simulation.SimulateMsgEditValidator(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
operationMsg, futureOperations, err := op(s.r, s.app.BaseApp, ctx, s.accounts, "")
@ -299,7 +296,6 @@ func (s *SimTestSuite) TestSimulateMsgUndelegate() {
_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash, Time: blockTime})
require.NoError(err)
// execute operation
op := simulation.SimulateMsgUndelegate(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
operationMsg, futureOperations, err := op(s.r, s.app.BaseApp, ctx, s.accounts, "")

18
tests/integration/store/rootmulti/rollback_test.go
View File

@ -31,16 +31,19 @@ func TestRollback(t *testing.T) {
AppHash: app.LastCommitID().Hash,
}
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: header.Height,
})
assert.NilError(t, err)
ctx := app.NewContextLegacy(false, header)
store := ctx.KVStore(app.GetKey("bank"))
store.Set([]byte("key"), []byte(fmt.Sprintf("value%d", i)))
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: header.Height,
})
app.Commit()
assert.NilError(t, err)
_, err = app.Commit()
assert.NilError(t, err)
}
assert.Equal(t, ver0+10, app.LastBlockHeight())
@ -63,14 +66,17 @@ func TestRollback(t *testing.T) {
Height: ver0 + i,
AppHash: app.LastCommitID().Hash,
}
app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: header.Height})
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: header.Height})
assert.NilError(t, err)
ctx := app.NewContextLegacy(false, header)
store := ctx.KVStore(app.GetKey("bank"))
store.Set([]byte("key"), []byte(fmt.Sprintf("VALUE%d", i)))
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: header.Height,
})
app.Commit()
assert.NilError(t, err)
_, err = app.Commit()
assert.NilError(t, err)
}
assert.Equal(t, ver0+10, app.LastBlockHeight())

12
testutil/integration/router.go
View File

@ -102,7 +102,10 @@ func NewIntegrationApp(
}
}
bApp.Commit()
_, err := bApp.Commit()
if err != nil {
panic(err)
}
ctx := sdkCtx.WithBlockHeader(cmtproto.Header{ChainID: appName}).WithIsCheckTx(true)
@ -129,7 +132,12 @@ func (app *App) RunMsg(msg sdk.Msg, option ...Option) (*codectypes.Any, error) {
}
if cfg.AutomaticCommit {
defer app.Commit()
defer func() {
_, err := app.Commit()
if err != nil {
panic(err)
}
}()
}
if cfg.AutomaticFinalizeBlock {

2
testutil/network/network.go
View File

@ -744,7 +744,7 @@ func (n *Network) WaitForHeightWithTimeout(h int64, t time.Duration) (int64, err
// blocks has been reached.
func (n *Network) RetryForBlocks(retryFunc func() error, blocks int) error {
for i := 0; i < blocks; i++ {
n.WaitForNextBlock()
_ = n.WaitForNextBlock()
err := retryFunc()
if err == nil {
return nil

4
testutil/sims/simulation_helpers_test.go
View File

@ -118,6 +118,8 @@ func initTestStores(t *testing.T) (storetypes.KVStore, storetypes.KVStore) {
key2 := storetypes.NewKVStoreKey("store2")
require.NotPanics(t, func() { ms.MountStoreWithDB(key1, storetypes.StoreTypeIAVL, db) })
require.NotPanics(t, func() { ms.MountStoreWithDB(key2, storetypes.StoreTypeIAVL, db) })
require.NotPanics(t, func() { ms.LoadLatestVersion() })
require.NotPanics(t, func() {
_ = ms.LoadLatestVersion()
})
return ms.GetKVStore(key1), ms.GetKVStore(key2)
}

4
testutil/sims/tx_helpers.go
View File

@ -141,8 +141,8 @@ func SignCheckDeliver(
require.False(t, finalizeSuccess)
}
app.Commit()
_, err = app.Commit()
require.NoError(t, err)
gInfo := sdk.GasInfo{GasWanted: uint64(txResult.GasWanted), GasUsed: uint64(txResult.GasUsed)}
txRes := sdk.Result{Data: txResult.Data, Log: txResult.Log, Events: txResult.Events}
if finalizeSuccess {

2
tools/rosetta/lib/errors/errors_test.go
View File

@ -20,7 +20,7 @@ func TestRegisterError(t *testing.T) {
registeredErrorsCount++
assert.Equal(t, len(ListErrors()), registeredErrorsCount)
// re-register an error should not change anything
RegisterError(69, "nice!", false, "nice!")
_ = RegisterError(69, "nice!", false, "nice!")
assert.Equal(t, len(ListErrors()), registeredErrorsCount)
// test sealing

33
types/address_test.go
View File

@ -92,8 +92,8 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
pub := &ed25519.PubKey{Key: pubBz}
for i := 0; i < 1000; i++ {
rand.Read(pub.Key)
_, err := rand.Read(pub.Key)
s.Require().NoError(err)
acc := types.AccAddress(pub.Address())
res := types.AccAddress{}
@ -101,7 +101,7 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal)
str := acc.String()
res, err := types.AccAddressFromBech32(str)
res, err = types.AccAddressFromBech32(str)
s.Require().Nil(err)
s.Require().Equal(acc, res)
@ -133,8 +133,8 @@ func (s *addressTestSuite) TestAddrCache() {
// Use a random key
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
rand.Read(pub.Key)
_, err := rand.Read(pub.Key)
s.Require().NoError(err)
// Set SDK bech32 prefixes to 'osmo'
prefix := "osmo"
conf := types.GetConfig()
@ -170,8 +170,8 @@ func (s *addressTestSuite) TestAddrCacheDisabled() {
// Use a random key
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
rand.Read(pub.Key)
_, err := rand.Read(pub.Key)
s.Require().NoError(err)
// Set SDK bech32 prefixes to 'osmo'
prefix := "osmo"
conf := types.GetConfig()
@ -202,8 +202,8 @@ func (s *addressTestSuite) TestValAddr() {
pub := &ed25519.PubKey{Key: pubBz}
for i := 0; i < 20; i++ {
rand.Read(pub.Key)
_, err := rand.Read(pub.Key)
s.Require().NoError(err)
acc := types.ValAddress(pub.Address())
res := types.ValAddress{}
@ -211,7 +211,7 @@ func (s *addressTestSuite) TestValAddr() {
s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal)
str := acc.String()
res, err := types.ValAddressFromBech32(str)
res, err = types.ValAddressFromBech32(str)
s.Require().Nil(err)
s.Require().Equal(acc, res)
@ -243,8 +243,8 @@ func (s *addressTestSuite) TestConsAddress() {
pub := &ed25519.PubKey{Key: pubBz}
for i := 0; i < 20; i++ {
rand.Read(pub.Key[:])
_, err := rand.Read(pub.Key[:])
s.Require().NoError(err)
acc := types.ConsAddress(pub.Address())
res := types.ConsAddress{}
@ -252,7 +252,7 @@ func (s *addressTestSuite) TestConsAddress() {
s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal)
str := acc.String()
res, err := types.ConsAddressFromBech32(str)
res, err = types.ConsAddressFromBech32(str)
s.Require().Nil(err)
s.Require().Equal(acc, res)
@ -293,7 +293,8 @@ func (s *addressTestSuite) TestConfiguredPrefix() {
pub := &ed25519.PubKey{Key: pubBz}
for length := 1; length < 10; length++ {
for times := 1; times < 20; times++ {
rand.Read(pub.Key[:])
_, err := rand.Read(pub.Key[:])
s.Require().NoError(err)
// Test if randomly generated prefix of a given length works
prefix := RandString(length)
@ -347,8 +348,8 @@ func (s *addressTestSuite) TestConfiguredPrefix() {
func (s *addressTestSuite) TestAddressInterface() {
pubBz := make([]byte, ed25519.PubKeySize)
pub := &ed25519.PubKey{Key: pubBz}
rand.Read(pub.Key)
_, err := rand.Read(pub.Key)
s.Require().NoError(err)
addrs := []types.Address{
types.ConsAddress(pub.Address()),
types.ValAddress(pub.Address()),

17
types/module/module_test.go
View File

@ -219,7 +219,12 @@ func TestManager_RegisterQueryServices(t *testing.T) {
mockAppModule1.EXPECT().RegisterServices(cfg).Times(1)
mockAppModule2.EXPECT().RegisterServices(cfg).Times(1)
require.NotPanics(t, func() { mm.RegisterServices(cfg) })
require.NotPanics(t, func() {
err := mm.RegisterServices(cfg)
if err != nil {
panic(err)
}
})
}
func TestManager_InitGenesis(t *testing.T) {
@ -575,7 +580,10 @@ func (MockCoreAppModule) DefaultGenesis(target appmodule.GenesisTarget) error {
if err != nil {
return err
}
someFieldWriter.Write([]byte(`"someKey"`))
_, err = someFieldWriter.Write([]byte(`"someKey"`))
if err != nil {
return err
}
return someFieldWriter.Close()
}
@ -602,7 +610,10 @@ func (MockCoreAppModule) ExportGenesis(ctx context.Context, target appmodule.Gen
if err != nil {
return err
}
wrt.Write([]byte(`"someKey"`))
_, err = wrt.Write([]byte(`"someKey"`))
if err != nil {
return err
}
return wrt.Close()
}

6
x/auth/ante/ante_test.go
View File

@ -1086,7 +1086,8 @@ func TestAnteHandlerSetPubKey(t *testing.T) {
privs, accNums, accSeqs := []cryptotypes.PrivKey{accs[1].priv}, []uint64{accs[1].acc.GetAccountNumber()}, []uint64{accs[1].acc.GetSequence()}
msgs := []sdk.Msg{testdata.NewTestMsg(accs[1].acc.GetAddress())}
suite.txBuilder.SetMsgs(msgs...)
err := suite.txBuilder.SetMsgs(msgs...)
require.NoError(t, err)
suite.txBuilder.SetFeeAmount(feeAmount)
suite.txBuilder.SetGasLimit(gasLimit)
@ -1132,7 +1133,8 @@ func TestAnteHandlerSetPubKey(t *testing.T) {
privs, accNums, accSeqs := []cryptotypes.PrivKey{accs[1].priv}, []uint64{accs[1].acc.GetAccountNumber()}, []uint64{accs[1].acc.GetSequence()}
msgs := []sdk.Msg{testdata.NewTestMsg(accs[1].acc.GetAddress())}
suite.txBuilder.SetMsgs(msgs...)
err := suite.txBuilder.SetMsgs(msgs...)
require.NoError(t, err)
suite.txBuilder.SetFeeAmount(feeAmount)
suite.txBuilder.SetGasLimit(gasLimit)

2
x/auth/ante/setup_test.go
View File

@ -118,7 +118,7 @@ func TestRecoverPanic(t *testing.T) {
require.Equal(t, gasLimit, newCtx.GasMeter().Limit())
antehandler = sdk.ChainAnteDecorators(sud, PanicDecorator{})
require.Panics(t, func() { antehandler(suite.ctx, tx, false) }, "Recovered from non-Out-of-Gas panic")
require.Panics(t, func() { _, _ = antehandler(suite.ctx, tx, false) }, "Recovered from non-Out-of-Gas panic")
}
type OutOfGasDecorator struct{}

4
x/auth/ante/sigverify_test.go
View File

@ -226,7 +226,9 @@ func TestSigVerification(t *testing.T) {
},
Sequence: tc.accSeqs[0],
}
suite.txBuilder.SetSignatures(txSigs...)
err := suite.txBuilder.SetSignatures(txSigs...)
require.NoError(t, err)
tx = suite.txBuilder.GetTx()
}

5
x/auth/ante/testutil_test.go
View File

@ -117,7 +117,10 @@ func (suite *AnteTestSuite) CreateTestAccounts(numAccs int) []TestAccount {
for i := 0; i < numAccs; i++ {
priv, _, addr := testdata.KeyTestPubAddr()
acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, addr)
acc.SetAccountNumber(uint64(i + 1000))
err := acc.SetAccountNumber(uint64(i + 1000))
if err != nil {
panic(err)
}
suite.accountKeeper.SetAccount(suite.ctx, acc)
accounts = append(accounts, TestAccount{acc, priv})
}

25
x/auth/client/cli/tx_sign.go
View File

@ -58,7 +58,10 @@ account key. It implies --signature-only.
flags.AddTxFlagsToCmd(cmd)
cmd.MarkFlagRequired(flags.FlagFrom)
err := cmd.MarkFlagRequired(flags.FlagFrom)
if err != nil {
panic(err)
}
return cmd
}
@ -137,7 +140,10 @@ func makeSignBatchCmd() func(cmd *cobra.Command, args []string) error {
msgs = append(msgs, unsignedStdTx.GetMsgs()...)
}
// set the new appened msgs into builder
txBuilder.SetMsgs(msgs...)
err = txBuilder.SetMsgs(msgs...)
if err != nil {
return err
}
// set the memo,fees,feeGranter,feePayer from cmd flags
txBuilder.SetMemo(txFactory.Memo())
@ -284,7 +290,10 @@ be generated via the 'multisign' command.
cmd.Flags().String(flags.FlagOutputDocument, "", "The document will be written to the given file instead of STDOUT")
flags.AddTxFlagsToCmd(cmd)
cmd.MarkFlagRequired(flags.FlagFrom)
err := cmd.MarkFlagRequired(flags.FlagFrom)
if err != nil {
panic(err)
}
return cmd
}
@ -293,8 +302,14 @@ func preSignCmd(cmd *cobra.Command, _ []string) {
// Conditionally mark the account and sequence numbers required as no RPC
// query will be done.
if offline, _ := cmd.Flags().GetBool(flags.FlagOffline); offline {
cmd.MarkFlagRequired(flags.FlagAccountNumber)
cmd.MarkFlagRequired(flags.FlagSequence)
err := cmd.MarkFlagRequired(flags.FlagAccountNumber)
if err != nil {
panic(err)
}
err = cmd.MarkFlagRequired(flags.FlagSequence)
if err != nil {
panic(err)
}
}
}

5
x/auth/migrations/v3/store.go
View File

@ -22,7 +22,10 @@ func mapAccountAddressToAccountID(ctx sdk.Context, storeService corestore.KVStor
if err := cdc.UnmarshalInterface(iterator.Value(), &acc); err != nil {
return err
}
store.Set(accountNumberStoreKey(acc.GetAccountNumber()), acc.GetAddress().Bytes())
err = store.Set(accountNumberStoreKey(acc.GetAccountNumber()), acc.GetAddress().Bytes())
if err != nil {
return err
}
}
return nil

4
x/auth/migrations/v4/migrate.go
View File

@ -25,7 +25,5 @@ func Migrate(ctx sdk.Context, storeService storetypes.KVStoreService, legacySubs
}
bz := cdc.MustMarshal(&currParams)
store.Set(ParamsKey, bz)
return nil
return store.Set(ParamsKey, bz)
}

19
x/auth/tx/aux_test.go
View File

@ -59,8 +59,10 @@ func TestBuilderWithAux(t *testing.T) {
aux2Builder.SetTimeoutHeight(3)
aux2Builder.SetMemo(memo)
aux2Builder.SetChainID(chainID)
aux2Builder.SetMsgs(msg)
aux2Builder.SetPubKey(aux2Pk)
err = aux2Builder.SetMsgs(msg)
require.NoError(t, err)
err = aux2Builder.SetPubKey(aux2Pk)
require.NoError(t, err)
aux2Builder.SetTip(tip)
extOptAny, err := codectypes.NewAnyWithValue(extOpt)
require.NoError(t, err)
@ -130,10 +132,12 @@ func TestBuilderWithAux(t *testing.T) {
tipperSigV2 := sigs[0]
aux2SigV2 := sigs[1]
// Set all signer infos.
w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
err = w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
PubKey: feepayerPk,
Sequence: 15,
})
require.NoError(t, err)
signerData := authsigning.SignerData{
Address: feepayerAddr.String(),
ChainID: chainID,
@ -150,7 +154,7 @@ func TestBuilderWithAux(t *testing.T) {
feepayerSig, err := feepayerPriv.Sign(signBz)
require.NoError(t, err)
// Set all signatures.
w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
err = w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
PubKey: feepayerPk,
Data: &signing.SingleSignatureData{
SignMode: signing.SignMode_SIGN_MODE_DIRECT,
@ -158,6 +162,7 @@ func TestBuilderWithAux(t *testing.T) {
},
Sequence: 22,
})
require.NoError(t, err)
// Make sure tx is correct.
txBz, err := txConfig.TxEncoder()(w.GetTx())
@ -200,8 +205,10 @@ func makeTipperTxBuilder(t *testing.T) (clienttx.AuxTxBuilder, []byte) {
tipperBuilder.SetTimeoutHeight(3)
tipperBuilder.SetMemo(memo)
tipperBuilder.SetChainID(chainID)
tipperBuilder.SetMsgs(msg)
tipperBuilder.SetPubKey(tipperPk)
err := tipperBuilder.SetMsgs(msg)
require.NoError(t, err)
err = tipperBuilder.SetPubKey(tipperPk)
require.NoError(t, err)
tipperBuilder.SetTip(tip)
extOptAny, err := codectypes.NewAnyWithValue(extOpt)
require.NoError(t, err)

5
x/auth/tx/service.go
View File

@ -320,7 +320,10 @@ func RegisterTxService(
// RegisterGRPCGatewayRoutes mounts the tx service's GRPC-gateway routes on the
// given Mux.
func RegisterGRPCGatewayRoutes(clientConn gogogrpc.ClientConn, mux *runtime.ServeMux) {
txtypes.RegisterServiceHandlerClient(context.Background(), mux, txtypes.NewServiceClient(clientConn))
err := txtypes.RegisterServiceHandlerClient(context.Background(), mux, txtypes.NewServiceClient(clientConn))
if err != nil {
panic(err)
}
}
func parseOrderBy(orderBy txtypes.OrderBy) string {

3
x/auth/types/account_test.go
View File

@ -97,7 +97,8 @@ func TestModuleAccountString(t *testing.T) {
moduleAcc := types.NewEmptyModuleAccount(name, types.Minter, types.Burner, types.Staking)
want := `base_account:<address:"cosmos1n7rdpqvgf37ktx30a2sv2kkszk3m7ncmg5drhe" > name:"test" permissions:"minter" permissions:"burner" permissions:"staking" `
require.Equal(t, want, moduleAcc.String())
moduleAcc.SetSequence(10)
err := moduleAcc.SetSequence(10)
require.NoError(t, err)
want = `base_account:<address:"cosmos1n7rdpqvgf37ktx30a2sv2kkszk3m7ncmg5drhe" sequence:10 > name:"test" permissions:"minter" permissions:"burner" permissions:"staking" `
require.Equal(t, want, moduleAcc.String())
}

4
x/authz/client/cli/tx_test.go
View File

@ -174,7 +174,9 @@ func (s *CLITestSuite) createAccount(uid string) sdk.AccAddress {
func (s *CLITestSuite) msgSendExec(grantee sdk.AccAddress) {
val := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
// Send some funds to the new account.
s.ac.StringToBytes("cosmos16zex22087zs656t0vedytv5wqhm6axxd5679ry")
_, err := s.ac.StringToBytes("cosmos16zex22087zs656t0vedytv5wqhm6axxd5679ry")
s.Require().NoError(err)
out, err := clitestutil.MsgSendExec(
s.clientCtx,
val[0].Address,

3
x/authz/keeper/genesis_test.go
View File

@ -82,7 +82,8 @@ func (suite *GenesisTestSuite) TestImportExportGenesis() {
// TODO, recheck!
// Clear keeper
suite.keeper.DeleteGrant(suite.ctx, granteeAddr, granterAddr, grant.MsgTypeURL())
err = suite.keeper.DeleteGrant(suite.ctx, granteeAddr, granterAddr, grant.MsgTypeURL())
suite.Require().NoError(err)
newGenesis := suite.keeper.ExportGenesis(suite.ctx)
suite.Require().NotEqual(genesis, newGenesis)
suite.Require().Empty(newGenesis)

4
x/authz/keeper/keeper.go
View File

@ -87,9 +87,7 @@ func (k Keeper) update(ctx context.Context, grantee, granter sdk.AccAddress, upd
grant.Authorization = any
store := k.storeService.OpenKVStore(ctx)
store.Set(skey, k.cdc.MustMarshal(&grant))
return nil
return store.Set(skey, k.cdc.MustMarshal(&grant))
}
// DispatchActions attempts to execute the provided messages via authorization

10
x/authz/keeper/keeper_test.go
View File

@ -148,8 +148,11 @@ func (s *TestSuite) TestKeeperIter() {
e := ctx.BlockTime().AddDate(1, 0, 0)
sendAuthz := banktypes.NewSendAuthorization(coins100, nil)
s.authzKeeper.SaveGrant(ctx, granteeAddr, granterAddr, sendAuthz, &e)
s.authzKeeper.SaveGrant(ctx, granteeAddr, granter2Addr, sendAuthz, &e)
err := s.authzKeeper.SaveGrant(ctx, granteeAddr, granterAddr, sendAuthz, &e)
s.Require().NoError(err)
err = s.authzKeeper.SaveGrant(ctx, granteeAddr, granter2Addr, sendAuthz, &e)
s.Require().NoError(err)
s.authzKeeper.IterateGrants(ctx, func(granter, grantee sdk.AccAddress, grant authz.Grant) bool {
s.Require().Equal(granteeAddr, grantee)
@ -189,7 +192,8 @@ func (s *TestSuite) TestDispatchAction() {
"authorization not found",
func() sdk.Context {
// remove any existing authorizations
s.authzKeeper.DeleteGrant(s.ctx, granteeAddr, granterAddr, bankSendAuthMsgType)
err := s.authzKeeper.DeleteGrant(s.ctx, granteeAddr, granterAddr, bankSendAuthMsgType)
require.Error(err)
return s.ctx
},
func() {},

3
x/authz/migrations/v2/store_test.go
View File

@ -106,7 +106,8 @@ func TestMigration(t *testing.T) {
for _, g := range grants {
grant := g.authorization()
store.Set(v2.GrantStoreKey(g.grantee, g.granter, g.msgType), cdc.MustMarshal(&grant))
err := store.Set(v2.GrantStoreKey(g.grantee, g.granter, g.msgType), cdc.MustMarshal(&grant))
require.NoError(t, err)
}
ctx = ctx.WithBlockTime(ctx.BlockTime().Add(1 * time.Hour))

3
x/authz/module/abci_test.go
View File

@ -81,7 +81,8 @@ func TestExpiredGrantsQueue(t *testing.T) {
queryClient := authz.NewQueryClient(queryHelper)
checkGrants := func(ctx sdk.Context, expectedNum int) {
authzmodule.BeginBlocker(ctx, authzKeeper)
err := authzmodule.BeginBlocker(ctx, authzKeeper)
require.NoError(t, err)
res, err := queryClient.GranterGrants(ctx.Context(), &authz.QueryGranterGrantsRequest{
Granter: granter.String(),

4
x/authz/msgs_test.go
View File

@ -40,7 +40,9 @@ func TestMsgGrantGetAuthorization(t *testing.T) {
require.Equal(a, &g)
g = authz.GenericAuthorization{Msg: "some_type2"}
m.SetAuthorization(&g)
err = m.SetAuthorization(&g)
require.NoError(err)
a, err = m.GetAuthorization()
require.NoError(err)
require.Equal(a, &g)

16
x/authz/simulation/operations_test.go
View File

@ -122,11 +122,11 @@ func (suite *SimTestSuite) TestSimulateGrant() {
blockTime := time.Now().UTC()
ctx := suite.ctx.WithBlockTime(blockTime)
suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: suite.app.LastBlockHeight() + 1,
Hash: suite.app.LastCommitID().Hash,
})
suite.Require().NoError(err)
granter := accounts[0]
grantee := accounts[1]
@ -150,11 +150,11 @@ func (suite *SimTestSuite) TestSimulateRevoke() {
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 3)
suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: suite.app.LastBlockHeight() + 1,
Hash: suite.app.LastCommitID().Hash,
})
suite.Require().NoError(err)
initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
@ -163,7 +163,7 @@ func (suite *SimTestSuite) TestSimulateRevoke() {
a := banktypes.NewSendAuthorization(initCoins, nil)
expire := time.Now().Add(30 * time.Hour)
err := suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
err = suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
suite.Require().NoError(err)
// execute operation
@ -187,8 +187,8 @@ func (suite *SimTestSuite) TestSimulateExec() {
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 3)
suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
suite.Require().NoError(err)
initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
@ -197,7 +197,7 @@ func (suite *SimTestSuite) TestSimulateExec() {
a := banktypes.NewSendAuthorization(initCoins, nil)
expire := suite.ctx.BlockTime().Add(1 * time.Hour)
err := suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
err = suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
suite.Require().NoError(err)
// execute operation

10
x/bank/client/cli/tx.go
View File

@ -46,7 +46,10 @@ When using '--dry-run' a key name cannot be used, only a bech32 address.
`,
Args: cobra.ExactArgs(3),
RunE: func(cmd *cobra.Command, args []string) error {
cmd.Flags().Set(flags.FlagFrom, args[0])
err := cmd.Flags().Set(flags.FlagFrom, args[0])
if err != nil {
return err
}
clientCtx, err := client.GetClientTxContext(cmd)
if err != nil {
return err
@ -90,7 +93,10 @@ When using '--dry-run' a key name cannot be used, only a bech32 address.
`,
Args: cobra.MinimumNArgs(4),
RunE: func(cmd *cobra.Command, args []string) error {
cmd.Flags().Set(flags.FlagFrom, args[0])
err := cmd.Flags().Set(flags.FlagFrom, args[0])
if err != nil {
return err
}
clientCtx, err := client.GetClientTxContext(cmd)
if err != nil {
return err

24
x/bank/keeper/keeper_test.go
View File

@ -338,18 +338,18 @@ func (suite *KeeperTestSuite) TestSupply_DelegateUndelegateCoins() {
authKeeper.EXPECT().GetModuleAddress("").Return(nil)
require.Panics(func() {
_ = keeper.SendCoinsFromModuleToAccount(ctx, "", holderAcc.GetAddress(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
_ = keeper.SendCoinsFromModuleToAccount(ctx, "", holderAcc.GetAddress(), initCoins)
})
authKeeper.EXPECT().GetModuleAddress(burnerAcc.Name).Return(burnerAcc.GetAddress())
authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
require.Panics(func() {
_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins) //nolint:errcheck // we're testing for a panic, not an error
_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins)
})
authKeeper.EXPECT().GetModuleAddress("").Return(nil)
require.Panics(func() {
_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins)
})
authKeeper.EXPECT().GetModuleAddress(holderAcc.Name).Return(holderAcc.GetAddress())
@ -399,18 +399,18 @@ func (suite *KeeperTestSuite) TestSupply_SendCoins() {
authKeeper.EXPECT().GetModuleAddress("").Return(nil)
require.Panics(func() {
_ = keeper.SendCoinsFromModuleToModule(ctx, "", holderAcc.GetName(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
_ = keeper.SendCoinsFromModuleToModule(ctx, "", holderAcc.GetName(), initCoins)
})
authKeeper.EXPECT().GetModuleAddress(burnerAcc.Name).Return(burnerAcc.GetAddress())
authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
require.Panics(func() {
_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins) //nolint:errcheck // we're testing for a panic, not an error
_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins)
})
authKeeper.EXPECT().GetModuleAddress("").Return(nil)
require.Panics(func() {
_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins)
})
authKeeper.EXPECT().GetModuleAddress(holderAcc.Name).Return(holderAcc.GetAddress())
@ -451,16 +451,16 @@ func (suite *KeeperTestSuite) TestSupply_MintCoins() {
require.NoError(err)
authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
require.Panics(func() { _ = keeper.MintCoins(ctx, "", initCoins) }, "no module account") //nolint:errcheck // we're testing for a panic, not an error
require.Panics(func() { _ = keeper.MintCoins(ctx, "", initCoins) }, "no module account")
suite.mockMintCoins(burnerAcc)
require.Panics(func() { _ = keeper.MintCoins(ctx, authtypes.Burner, initCoins) }, "invalid permission") //nolint:errcheck // we're testing for a panic, not an error
require.Panics(func() { _ = keeper.MintCoins(ctx, authtypes.Burner, initCoins) }, "invalid permission")
suite.mockMintCoins(minterAcc)
require.Error(keeper.MintCoins(ctx, authtypes.Minter, sdk.Coins{sdk.Coin{Denom: "denom", Amount: math.NewInt(-10)}}), "insufficient coins")
authKeeper.EXPECT().GetModuleAccount(ctx, randomPerm).Return(nil)
require.Panics(func() { _ = keeper.MintCoins(ctx, randomPerm, initCoins) }) //nolint:errcheck // we're testing for a panic, not an error
require.Panics(func() { _ = keeper.MintCoins(ctx, randomPerm, initCoins) })
suite.mockMintCoins(minterAcc)
require.NoError(keeper.MintCoins(ctx, authtypes.Minter, initCoins))
@ -504,13 +504,13 @@ func (suite *KeeperTestSuite) TestSupply_BurnCoins() {
require.NoError(err)
authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
require.Panics(func() { _ = keeper.BurnCoins(ctx, "", initCoins) }, "no module account") //nolint:errcheck // we're testing for a panic, not an error
require.Panics(func() { _ = keeper.BurnCoins(ctx, "", initCoins) }, "no module account")
authKeeper.EXPECT().GetModuleAccount(ctx, minterAcc.Name).Return(nil)
require.Panics(func() { _ = keeper.BurnCoins(ctx, authtypes.Minter, initCoins) }, "invalid permission") //nolint:errcheck // we're testing for a panic, not an error
require.Panics(func() { _ = keeper.BurnCoins(ctx, authtypes.Minter, initCoins) }, "invalid permission")
authKeeper.EXPECT().GetModuleAccount(ctx, randomPerm).Return(nil)
require.Panics(func() { _ = keeper.BurnCoins(ctx, randomPerm, supplyAfterInflation) }, "random permission") //nolint:errcheck // we're testing for a panic, not an error
require.Panics(func() { _ = keeper.BurnCoins(ctx, randomPerm, supplyAfterInflation) }, "random permission")
suite.mockBurnCoins(burnerAcc)
require.Error(keeper.BurnCoins(ctx, authtypes.Burner, supplyAfterInflation), "insufficient coins")

10
x/bank/keeper/msg_server_test.go
View File

@ -142,11 +142,12 @@ func (suite *KeeperTestSuite) TestMsgSend() {
tc := tc
suite.Run(tc.name, func() {
suite.mockMintCoins(minterAcc)
suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
err := suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
suite.Require().NoError(err)
if !tc.expErr {
suite.mockSendCoins(suite.ctx, minterAcc, baseAcc.GetAddress())
}
_, err := suite.msgServer.Send(suite.ctx, tc.input)
_, err = suite.msgServer.Send(suite.ctx, tc.input)
if tc.expErr {
suite.Require().Error(err)
suite.Require().Contains(err.Error(), tc.expErrMsg)
@ -239,11 +240,12 @@ func (suite *KeeperTestSuite) TestMsgMultiSend() {
tc := tc
suite.Run(tc.name, func() {
suite.mockMintCoins(minterAcc)
suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
err := suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
suite.Require().NoError(err)
if !tc.expErr {
suite.mockInputOutputCoins([]sdk.AccountI{minterAcc}, accAddrs[:2])
}
_, err := suite.msgServer.MultiSend(suite.ctx, tc.input)
_, err = suite.msgServer.MultiSend(suite.ctx, tc.input)
if tc.expErr {
suite.Require().Error(err)
suite.Require().Contains(err.Error(), tc.expErrMsg)

12
x/bank/simulation/operations_test.go
View File

@ -106,10 +106,11 @@ func (suite *SimTestSuite) TestSimulateMsgSend() {
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 3)
suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: suite.app.LastBlockHeight() + 1,
Hash: suite.app.LastCommitID().Hash,
})
suite.Require().NoError(err)
// execute operation
op := simulation.SimulateMsgSend(suite.txConfig, suite.accountKeeper, suite.bankKeeper)
@ -135,10 +136,11 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSend() {
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 3)
suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: suite.app.LastBlockHeight() + 1,
Hash: suite.app.LastCommitID().Hash,
})
suite.Require().NoError(err)
// execute operation
op := simulation.SimulateMsgMultiSend(suite.txConfig, suite.accountKeeper, suite.bankKeeper)
@ -170,11 +172,12 @@ func (suite *SimTestSuite) TestSimulateModuleAccountMsgSend() {
r := rand.New(s)
accounts := suite.getTestingAccounts(r, accCount)
suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: suite.app.LastBlockHeight() + 1,
Hash: suite.app.LastCommitID().Hash,
},
)
suite.Require().NoError(err)
// execute operation
op := simulation.SimulateMsgSendToModuleAccount(suite.txConfig, suite.accountKeeper, suite.bankKeeper, moduleAccCount)
@ -204,10 +207,11 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSendToModuleAccount() {
r := rand.New(s)
accounts := suite.getTestingAccounts(r, accCount)
suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: suite.app.LastBlockHeight() + 1,
Hash: suite.app.LastCommitID().Hash,
})
suite.Require().NoError(err)
// execute operation
op := simulation.SimulateMsgMultiSendToModuleAccount(suite.txConfig, suite.accountKeeper, suite.bankKeeper, mAccCount)

6
x/circuit/ante/circuit_test.go
View File

@ -78,11 +78,13 @@ func TestCircuitBreakerDecorator(t *testing.T) {
// CircuitBreakerDecorator AnteHandler should always return success
decorator := ante.NewCircuitBreakerDecorator(circuitBreaker)
f.txBuilder.SetMsgs(tc.msg)
err := f.txBuilder.SetMsgs(tc.msg)
require.NoError(t, err)
tx := f.txBuilder.GetTx()
sdkCtx := sdk.UnwrapSDKContext(f.ctx)
_, err := decorator.AnteHandle(sdkCtx, tx, false, func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error) {
_, err = decorator.AnteHandle(sdkCtx, tx, false, func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error) {
return ctx, nil
})

3
x/circuit/keeper/keeper_test.go
View File

@ -102,7 +102,8 @@ func TestIteratePermissions(t *testing.T) {
[]byte("mock_address_3"),
}
for i, addr := range mockAddrs {
f.keeper.Permissions.Set(f.ctx, addr, mockPerms[i])
err := f.keeper.Permissions.Set(f.ctx, addr, mockPerms[i])
require.NoError(t, err)
}
// Define a variable to store the returned permissions

6
x/consensus/keeper/keeper_test.go
View File

@ -69,7 +69,8 @@ func (s *KeeperTestSuite) TestGRPCQueryConsensusParams() {
Validator: defaultConsensusParams.Validator,
Evidence: defaultConsensusParams.Evidence,
}
s.consensusParamsKeeper.UpdateParams(s.ctx, input)
_, err := s.consensusParamsKeeper.UpdateParams(s.ctx, input)
s.Require().NoError(err)
},
types.QueryParamsResponse{
Params: &cmtproto.ConsensusParams{
@ -94,7 +95,8 @@ func (s *KeeperTestSuite) TestGRPCQueryConsensusParams() {
VoteExtensionsEnableHeight: 1234,
},
}
s.consensusParamsKeeper.UpdateParams(s.ctx, input)
_, err := s.consensusParamsKeeper.UpdateParams(s.ctx, input)
s.Require().NoError(err)
},
types.QueryParamsResponse{
Params: &cmtproto.ConsensusParams{

2
x/distribution/simulation/operations_test.go
View File

@ -79,7 +79,6 @@ func (suite *SimTestSuite) TestSimulateMsgSetWithdrawAddress() {
Hash: suite.app.LastCommitID().Hash,
})
suite.Require().NoError(err)
// execute operation
op := simulation.SimulateMsgSetWithdrawAddress(suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.distrKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
@ -182,7 +181,6 @@ func (suite *SimTestSuite) testSimulateMsgWithdrawValidatorCommission(tokenName
Hash: suite.app.LastCommitID().Hash,
})
suite.Require().NoError(err)
// execute operation
op := simulation.SimulateMsgWithdrawValidatorCommission(suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.distrKeeper, suite.stakingKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")

5
x/distribution/testutil/staking_helper.go
View File

@ -83,7 +83,10 @@ func SlashValidator(
effectiveFraction = math.LegacyOneDec()
}
// call the before-slashed hook
distrKeeper.Hooks().BeforeValidatorSlashed(ctx, validator.GetOperator(), effectiveFraction)
err := distrKeeper.Hooks().BeforeValidatorSlashed(ctx, validator.GetOperator(), effectiveFraction)
if err != nil {
panic(err)
}
}
// Deduct from validator's bonded tokens and update the validator.
// Burn the slashed tokens from the pool account and decrease the total supply.

4
x/feegrant/client/cli/tx.go
View File

@ -201,7 +201,9 @@ Example:
),
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
cmd.Flags().Set(flags.FlagFrom, args[0])
if err := cmd.Flags().Set(flags.FlagFrom, args[0]); err != nil {
return err
}
clientCtx, err := client.GetClientTxContext(cmd)
if err != nil {
return err

6
x/feegrant/keeper/keeper.go
View File

@ -244,23 +244,19 @@ func (k Keeper) UseGrantedFees(ctx context.Context, granter, grantee sdk.AccAddr
}
remove, err := grant.Accept(ctx, fee, msgs)
if remove {
// Ignoring the `revokeFeeAllowance` error, because the user has enough grants to perform this transaction.
k.revokeAllowance(ctx, granter, grantee)
_ = k.revokeAllowance(ctx, granter, grantee)
if err != nil {
return err
}
emitUseGrantEvent(ctx, granter.String(), grantee.String())
return nil
}
if err != nil {
return err
}
emitUseGrantEvent(ctx, granter.String(), grantee.String())
// if fee allowance is accepted, store the updated state of the allowance

13
x/feegrant/keeper/keeper_test.go
View File

@ -308,14 +308,16 @@ func (suite *KeeperTestSuite) TestIterateGrants() {
Expiration: &exp,
}
suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[0], suite.addrs[1], allowance)
suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[2], suite.addrs[1], allowance1)
suite.feegrantKeeper.IterateAllFeeAllowances(suite.ctx, func(grant feegrant.Grant) bool {
err := suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[0], suite.addrs[1], allowance)
suite.Require().NoError(err)
err = suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[2], suite.addrs[1], allowance1)
suite.Require().NoError(err)
err = suite.feegrantKeeper.IterateAllFeeAllowances(suite.ctx, func(grant feegrant.Grant) bool {
suite.Require().Equal(suite.addrs[1].String(), grant.Grantee)
suite.Require().Contains([]string{suite.addrs[0].String(), suite.addrs[2].String()}, grant.Granter)
return true
})
suite.Require().NoError(err)
}
func (suite *KeeperTestSuite) TestPruneGrants() {
@ -395,7 +397,8 @@ func (suite *KeeperTestSuite) TestPruneGrants() {
}
err := suite.feegrantKeeper.GrantAllowance(suite.ctx, tc.granter, tc.grantee, tc.allowance)
suite.NoError(err)
suite.feegrantKeeper.RemoveExpiredAllowances(tc.ctx)
err = suite.feegrantKeeper.RemoveExpiredAllowances(tc.ctx)
suite.NoError(err)
grant, err := suite.feegrantKeeper.GetAllowance(tc.ctx, tc.granter, tc.grantee)
if tc.expErrMsg != "" {
suite.Error(err)

4
x/feegrant/keeper/msg_server_test.go
View File

@ -237,11 +237,11 @@ func (suite *KeeperTestSuite) TestRevokeAllowance() {
},
func() {
// removing fee allowance from previous tests if exists
suite.msgSrvr.RevokeAllowance(suite.ctx, &feegrant.MsgRevokeAllowance{
_, err := suite.msgSrvr.RevokeAllowance(suite.ctx, &feegrant.MsgRevokeAllowance{
Granter: suite.addrs[0].String(),
Grantee: suite.addrs[1].String(),
})
suite.Require().Error(err)
any, err := codectypes.NewAnyWithValue(&feegrant.PeriodicAllowance{
Basic: feegrant.BasicAllowance{
SpendLimit: suite.atom,

5
x/feegrant/migrations/v2/store.go
View File

@ -41,7 +41,10 @@ func addAllowancesByExpTimeQueue(ctx context.Context, store store.KVStore, cdc c
prefixStore.Delete(key)
} else {
grantByExpTimeQueueKey := FeeAllowancePrefixQueue(exp, key)
store.Set(grantByExpTimeQueueKey, []byte{})
err = store.Set(grantByExpTimeQueueKey, []byte{})
if err != nil {
return err
}
}
}
}

11
x/feegrant/module/abci_test.go
View File

@ -48,7 +48,7 @@ func TestFeegrantPruning(t *testing.T) {
feegrantKeeper := keeper.NewKeeper(encCfg.Codec, runtime.NewKVStoreService(key), accountKeeper)
feegrantKeeper.GrantAllowance(
err := feegrantKeeper.GrantAllowance(
testCtx.Ctx,
granter1,
grantee,
@ -56,7 +56,9 @@ func TestFeegrantPruning(t *testing.T) {
Expiration: &now,
},
)
feegrantKeeper.GrantAllowance(
require.NoError(t, err)
err = feegrantKeeper.GrantAllowance(
testCtx.Ctx,
granter2,
grantee,
@ -64,7 +66,9 @@ func TestFeegrantPruning(t *testing.T) {
SpendLimit: spendLimit,
},
)
feegrantKeeper.GrantAllowance(
require.NoError(t, err)
err = feegrantKeeper.GrantAllowance(
testCtx.Ctx,
granter3,
grantee,
@ -72,6 +76,7 @@ func TestFeegrantPruning(t *testing.T) {
Expiration: &oneDay,
},
)
require.NoError(t, err)
queryHelper := baseapp.NewQueryServerTestHelper(testCtx.Ctx, encCfg.InterfaceRegistry)
feegrant.RegisterQueryServer(queryHelper, feegrantKeeper)

6
x/feegrant/simulation/operations.go
View File

@ -138,9 +138,10 @@ func SimulateMsgRevokeAllowance(
r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
hasGrant := false
var granterAddr sdk.AccAddress
var granteeAddr sdk.AccAddress
k.IterateAllFeeAllowances(ctx, func(grant feegrant.Grant) bool {
err := k.IterateAllFeeAllowances(ctx, func(grant feegrant.Grant) bool {
granter, err := ac.StringToBytes(grant.Granter)
if err != nil {
panic(err)
@ -154,6 +155,9 @@ func SimulateMsgRevokeAllowance(
hasGrant = true
return true
})
if err != nil {
return simtypes.OperationMsg{}, nil, err
}
if !hasGrant {
return simtypes.NoOpMsg(feegrant.ModuleName, TypeMsgRevokeAllowance, "no grants"), nil, nil

6
x/feegrant/simulation/operations_test.go
View File

@ -178,15 +178,15 @@ func (suite *SimTestSuite) TestSimulateMsgRevokeAllowance() {
accounts := suite.getTestingAccounts(r, 3)
// begin a new block
app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
require.NoError(err)
feeAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
feeCoins := sdk.NewCoins(sdk.NewCoin("foo", feeAmt))
granter, grantee := accounts[0], accounts[1]
oneYear := ctx.BlockTime().AddDate(1, 0, 0)
err := suite.feegrantKeeper.GrantAllowance(
err = suite.feegrantKeeper.GrantAllowance(
ctx,
granter.Address,
grantee.Address,

7
x/genutil/client/cli/init_test.go
View File

@ -186,7 +186,9 @@ func TestEmptyState(t *testing.T) {
outC := make(chan string)
go func() {
var buf bytes.Buffer
io.Copy(&buf, r)
_, err := io.Copy(&buf, r)
require.NoError(t, err)
outC <- buf.String()
}()
@ -278,7 +280,8 @@ func TestInitConfig(t *testing.T) {
outC := make(chan string)
go func() {
var buf bytes.Buffer
io.Copy(&buf, r)
_, err := io.Copy(&buf, r)
require.NoError(t, err)
outC <- buf.String()
}()

3
x/genutil/gentx_test.go
View File

@ -296,10 +296,11 @@ func (suite *GenTxTestSuite) TestDeliverGenTxs() {
if tc.expPass {
suite.stakingKeeper.EXPECT().ApplyAndReturnValidatorSetUpdates(gomock.Any()).Return(nil, nil).AnyTimes()
suite.Require().NotPanics(func() {
genutil.DeliverGenTxs(
_, err := genutil.DeliverGenTxs(
suite.ctx, genTxs, suite.stakingKeeper, tc.deliverTxFn,
suite.encodingConfig.TxConfig,
)
suite.Require().NoError(err)
})
} else {
_, err := genutil.DeliverGenTxs(

53
x/gov/abci_test.go
View File

@ -28,11 +28,11 @@ func TestTickExpiredDepositPeriod(t *testing.T) {
ctx := app.BaseApp.NewContext(false)
addrs := simtestutil.AddTestAddrs(suite.BankKeeper, suite.StakingKeeper, ctx, 10, valTokens)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
})
require.NoError(t, err)
govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@ -79,11 +79,11 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
ctx := app.BaseApp.NewContext(false)
addrs := simtestutil.AddTestAddrs(suite.BankKeeper, suite.StakingKeeper, ctx, 10, valTokens)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
})
require.NoError(t, err)
govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@ -150,11 +150,11 @@ func TestTickPassedDepositPeriod(t *testing.T) {
ctx := app.BaseApp.NewContext(false)
addrs := simtestutil.AddTestAddrs(suite.BankKeeper, suite.StakingKeeper, ctx, 10, valTokens)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
})
require.NoError(t, err)
govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
newProposalMsg, err := v1.NewMsgSubmitProposal(
@ -215,11 +215,11 @@ func TestTickPassedVotingPeriod(t *testing.T) {
SortAddresses(addrs)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
})
require.NoError(t, err)
govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@ -309,17 +309,18 @@ func TestProposalPassedEndblocker(t *testing.T) {
govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
stakingMsgSvr := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
})
require.NoError(t, err)
valAddr := sdk.ValAddress(addrs[0])
proposer := addrs[0]
createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10})
suite.StakingKeeper.EndBlocker(ctx)
_, err = suite.StakingKeeper.EndBlocker(ctx)
require.NoError(t, err)
macc := suite.GovKeeper.GetGovernanceAccount(ctx)
require.NotNil(t, macc)
initialModuleAccCoins := suite.BankKeeper.GetAllBalances(ctx, macc.GetAddress())
@ -349,8 +350,8 @@ func TestProposalPassedEndblocker(t *testing.T) {
newHeader.Time = ctx.BlockHeader().Time.Add(*params.MaxDepositPeriod).Add(*params.VotingPeriod)
ctx = ctx.WithBlockHeader(newHeader)
gov.EndBlocker(ctx, suite.GovKeeper)
err = gov.EndBlocker(ctx, suite.GovKeeper)
require.NoError(t, err)
macc = suite.GovKeeper.GetGovernanceAccount(ctx)
require.NotNil(t, macc)
require.True(t, suite.BankKeeper.GetAllBalances(ctx, macc.GetAddress()).Equal(initialModuleAccCoins))
@ -368,17 +369,18 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) {
stakingMsgSvr := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
})
require.NoError(t, err)
valAddr := sdk.ValAddress(addrs[0])
proposer := addrs[0]
createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10})
suite.StakingKeeper.EndBlocker(ctx)
_, err = suite.StakingKeeper.EndBlocker(ctx)
require.NoError(t, err)
msg := banktypes.NewMsgSend(authtypes.NewModuleAddress(types.ModuleName), addrs[0], sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(100000))))
proposal, err := suite.GovKeeper.SubmitProposal(ctx, []sdk.Msg{msg}, "", "title", "summary", proposer, false)
require.NoError(t, err)
@ -400,8 +402,8 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) {
ctx = ctx.WithBlockHeader(newHeader)
// validate that the proposal fails/has been rejected
gov.EndBlocker(ctx, suite.GovKeeper)
err = gov.EndBlocker(ctx, suite.GovKeeper)
require.NoError(t, err)
// check proposal events
events := ctx.EventManager().Events()
attr, eventOk := events.GetAttributes(types.AttributeKeyProposalLog)
@ -452,18 +454,19 @@ func TestExpeditedProposal_PassAndConversionToRegular(t *testing.T) {
govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
stakingMsgSvr := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
app.FinalizeBlock(&abci.RequestFinalizeBlock{
_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
Height: app.LastBlockHeight() + 1,
Hash: app.LastCommitID().Hash,
})
require.NoError(t, err)
valAddr := sdk.ValAddress(addrs[0])
proposer := addrs[0]
// Create a validator so that able to vote on proposal.
createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10})
suite.StakingKeeper.EndBlocker(ctx)
_, err = suite.StakingKeeper.EndBlocker(ctx)
require.NoError(t, err)
checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
checkActiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@ -512,8 +515,8 @@ func TestExpeditedProposal_PassAndConversionToRegular(t *testing.T) {
}
// Here the expedited proposal is converted to regular after expiry.
gov.EndBlocker(ctx, suite.GovKeeper)
err = gov.EndBlocker(ctx, suite.GovKeeper)
require.NoError(t, err)
if tc.expeditedPasses {
checkActiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@ -567,8 +570,8 @@ func TestExpeditedProposal_PassAndConversionToRegular(t *testing.T) {
}
// Here we validate the converted regular proposal
gov.EndBlocker(ctx, suite.GovKeeper)
err = gov.EndBlocker(ctx, suite.GovKeeper)
require.NoError(t, err)
macc = suite.GovKeeper.GetGovernanceAccount(ctx)
require.NotNil(t, macc)
eventualModuleAccCoins := suite.BankKeeper.GetAllBalances(ctx, macc.GetAddress())

7
x/gov/client/cli/prompt_test.go
View File

@ -47,7 +47,8 @@ func TestPromptIntegerOverflow(t *testing.T) {
fin, fw := readline.NewFillableStdin(os.Stdin)
readline.Stdin = fin
fw.Write([]byte(overflowStr + "\n"))
_, err := fw.Write([]byte(overflowStr + "\n"))
assert.NoError(t, err)
v, err := cli.Prompt(st{}, "")
assert.Equal(t, st{}, v, "expected a value of zero")
@ -78,8 +79,8 @@ func TestPromptParseInteger(t *testing.T) {
fin, fw := readline.NewFillableStdin(os.Stdin)
readline.Stdin = fin
fw.Write([]byte(tc.in + "\n"))
_, err := fw.Write([]byte(tc.in + "\n"))
assert.NoError(t, err)
v, err := cli.Prompt(st{}, "")
assert.Nil(t, err, "expected a nil error")
assert.Equal(t, tc.want, v.I, "expected %d = %d", tc.want, v.I)

33
x/gov/client/cli/util_test.go
View File

@ -41,17 +41,21 @@ func TestParseSubmitLegacyProposal(t *testing.T) {
fs := NewCmdSubmitLegacyProposal().Flags()
// nonexistent json
fs.Set(FlagProposal, "fileDoesNotExist")
_, err := parseSubmitLegacyProposal(fs)
err := fs.Set(FlagProposal, "fileDoesNotExist")
require.NoError(t, err)
_, err = parseSubmitLegacyProposal(fs)
require.Error(t, err)
// invalid json
fs.Set(FlagProposal, badJSON.Name())
err = fs.Set(FlagProposal, badJSON.Name())
require.NoError(t, err)
_, err = parseSubmitLegacyProposal(fs)
require.Error(t, err)
// ok json
fs.Set(FlagProposal, okJSON.Name())
err = fs.Set(FlagProposal, okJSON.Name())
require.NoError(t, err)
proposal1, err := parseSubmitLegacyProposal(fs)
require.Nil(t, err, "unexpected error")
require.Equal(t, "Test Proposal", proposal1.Title)
@ -61,14 +65,17 @@ func TestParseSubmitLegacyProposal(t *testing.T) {
// flags that can't be used with --proposal
for _, incompatibleFlag := range ProposalFlags {
fs.Set(incompatibleFlag, "some value")
err = fs.Set(incompatibleFlag, "some value")
require.NoError(t, err)
_, err := parseSubmitLegacyProposal(fs)
require.Error(t, err)
fs.Set(incompatibleFlag, "")
err = fs.Set(incompatibleFlag, "")
require.NoError(t, err)
}
// no --proposal, only flags
fs.Set(FlagProposal, "")
err = fs.Set(FlagProposal, "")
require.NoError(t, err)
flagTestCases := map[string]struct {
pTitle string
pDescription string
@ -102,10 +109,14 @@ func TestParseSubmitLegacyProposal(t *testing.T) {
}
for name, tc := range flagTestCases {
t.Run(name, func(t *testing.T) {
fs.Set(FlagTitle, tc.pTitle)
fs.Set(FlagDescription, tc.pDescription)
fs.Set(FlagProposalType, tc.pType)
fs.Set(FlagDeposit, proposal1.Deposit)
err = fs.Set(FlagTitle, tc.pTitle)
require.NoError(t, err)
err = fs.Set(FlagDescription, tc.pDescription)
require.NoError(t, err)
err = fs.Set(FlagProposalType, tc.pType)
require.NoError(t, err)
err = fs.Set(FlagDeposit, proposal1.Deposit)
require.NoError(t, err)
proposal2, err := parseSubmitLegacyProposal(fs)
if tc.expErr {

6
x/gov/client/testutil/helpers.go
View File

@ -20,13 +20,11 @@ var commonArgs = []string{
}
// MsgSubmitLegacyProposal creates a tx for submit legacy proposal
//
//nolint:staticcheck // we are intentionally using a deprecated flag here.
func MsgSubmitLegacyProposal(clientCtx client.Context, from, title, description, proposalType string, extraArgs ...string) (testutil.BufferWriter, error) {
args := append([]string{
fmt.Sprintf("--%s=%s", govcli.FlagTitle, title),
fmt.Sprintf("--%s=%s", govcli.FlagDescription, description),
fmt.Sprintf("--%s=%s", govcli.FlagProposalType, proposalType),
fmt.Sprintf("--%s=%s", govcli.FlagDescription, description), //nolint:staticcheck // we are intentionally using a deprecated flag here.
fmt.Sprintf("--%s=%s", govcli.FlagProposalType, proposalType), //nolint:staticcheck // we are intentionally using a deprecated flag here.
fmt.Sprintf("--%s=%s", flags.FlagFrom, from),
}, commonArgs...)

13
x/gov/keeper/deposit_test.go
View File

@ -136,7 +136,9 @@ func TestDeposits(t *testing.T) {
deposit, err = govKeeper.Deposits.Get(ctx, collections.Join(proposalID, TestAddrs[1]))
require.Nil(t, err)
require.Equal(t, fourStake, sdk.NewCoins(deposit.Amount...))
govKeeper.RefundAndDeleteDeposits(ctx, proposalID)
err = govKeeper.RefundAndDeleteDeposits(ctx, proposalID)
require.NoError(t, err)
deposit, err = govKeeper.Deposits.Get(ctx, collections.Join(proposalID, TestAddrs[1]))
require.ErrorIs(t, err, collections.ErrNotFound)
require.Equal(t, addr0Initial, bankKeeper.GetAllBalances(ctx, TestAddrs[0]))
@ -148,7 +150,9 @@ func TestDeposits(t *testing.T) {
proposalID = proposal.Id
_, err = govKeeper.AddDeposit(ctx, proposalID, TestAddrs[0], fourStake)
require.NoError(t, err)
govKeeper.DeleteAndBurnDeposits(ctx, proposalID)
err = govKeeper.DeleteAndBurnDeposits(ctx, proposalID)
require.NoError(t, err)
deposits, _ = govKeeper.GetDeposits(ctx, proposalID)
require.Len(t, deposits, 0)
require.Equal(t, addr0Initial.Sub(fourStake...), bankKeeper.GetAllBalances(ctx, TestAddrs[0]))
@ -255,9 +259,10 @@ func TestValidateInitialDeposit(t *testing.T) {
}
params.MinInitialDepositRatio = sdkmath.LegacyNewDec(tc.minInitialDepositPercent).Quo(sdkmath.LegacyNewDec(100)).String()
govKeeper.Params.Set(ctx, params)
err := govKeeper.Params.Set(ctx, params)
require.NoError(t, err)
err := govKeeper.ValidateInitialDeposit(ctx, tc.initialDeposit, tc.expedited)
err = govKeeper.ValidateInitialDeposit(ctx, tc.initialDeposit, tc.expedited)
if tc.expectError {
require.Error(t, err)

56
x/gov/keeper/grpc_query_test.go
View File

@ -276,7 +276,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() {
func() {
depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit := v1.NewDeposit(testProposals[0].Id, addrs[0], depositCoins)
suite.govKeeper.SetDeposit(ctx, deposit)
err := suite.govKeeper.SetDeposit(ctx, deposit)
suite.Require().NoError(err)
req = &v1.QueryProposalsRequest{
Depositor: addrs[0].String(),
@ -292,7 +293,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() {
"request with filter of deposit address",
func() {
testProposals[1].Status = v1.StatusVotingPeriod
suite.govKeeper.SetProposal(ctx, *testProposals[1])
err := suite.govKeeper.SetProposal(ctx, *testProposals[1])
suite.Require().NoError(err)
suite.Require().NoError(suite.govKeeper.AddVote(ctx, testProposals[1].Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
req = &v1.QueryProposalsRequest{
@ -446,7 +448,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryVote() {
"valid request",
func() {
proposal.Status = v1.StatusVotingPeriod
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
suite.Require().NoError(suite.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
req = &v1.QueryVoteRequest{
@ -560,7 +563,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVote() {
"valid request",
func() {
proposal.Status = v1.StatusVotingPeriod
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
suite.Require().NoError(suite.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
req = &v1beta1.QueryVoteRequest{
@ -663,8 +667,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryVotes() {
"request after adding 2 votes",
func() {
proposal.Status = v1.StatusVotingPeriod
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
votes = []*v1.Vote{
{ProposalId: proposal.Id, Voter: addrs[0].String(), Options: v1.NewNonSplitVoteOption(v1.OptionAbstain)},
{ProposalId: proposal.Id, Voter: addrs[1].String(), Options: v1.NewNonSplitVoteOption(v1.OptionYes)},
@ -767,7 +771,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVotes() {
"request after adding 2 votes",
func() {
proposal.Status = v1.StatusVotingPeriod
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
votes = []v1beta1.Vote{
{ProposalId: proposal.Id, Voter: addrs[0].String(), Options: v1beta1.NewNonSplitVoteOption(v1beta1.OptionAbstain)},
@ -1057,7 +1062,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposit() {
func() {
depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit := v1.NewDeposit(proposal.Id, addrs[0], depositCoins)
suite.govKeeper.SetDeposit(ctx, deposit)
err := suite.govKeeper.SetDeposit(ctx, deposit)
suite.Require().NoError(err)
req = &v1.QueryDepositRequest{
ProposalId: proposal.Id,
@ -1159,7 +1165,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryDeposit() {
depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit := v1beta1.NewDeposit(proposal.Id, addrs[0], depositCoins)
v1deposit := v1.NewDeposit(proposal.Id, addrs[0], depositCoins)
suite.govKeeper.SetDeposit(ctx, v1deposit)
err := suite.govKeeper.SetDeposit(ctx, v1deposit)
suite.Require().NoError(err)
req = &v1beta1.QueryDepositRequest{
ProposalId: proposal.Id,
@ -1246,11 +1253,13 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposits() {
func() {
depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit1 := v1.NewDeposit(proposal.Id, addrs[0], depositAmount1)
suite.govKeeper.SetDeposit(ctx, deposit1)
err := suite.govKeeper.SetDeposit(ctx, deposit1)
suite.Require().NoError(err)
depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 30)))
deposit2 := v1.NewDeposit(proposal.Id, addrs[1], depositAmount2)
suite.govKeeper.SetDeposit(ctx, deposit2)
err = suite.govKeeper.SetDeposit(ctx, deposit2)
suite.Require().NoError(err)
deposits := v1.Deposits{&deposit1, &deposit2}
@ -1342,12 +1351,14 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryDeposits() {
depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit1 := v1beta1.NewDeposit(proposal.Id, addrs[0], depositAmount1)
v1deposit1 := v1.NewDeposit(proposal.Id, addrs[0], depositAmount1)
suite.govKeeper.SetDeposit(ctx, v1deposit1)
err := suite.govKeeper.SetDeposit(ctx, v1deposit1)
suite.Require().NoError(err)
depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 30)))
deposit2 := v1beta1.NewDeposit(proposal.Id, addrs[1], depositAmount2)
v1deposit2 := v1.NewDeposit(proposal.Id, addrs[1], depositAmount2)
suite.govKeeper.SetDeposit(ctx, v1deposit2)
err = suite.govKeeper.SetDeposit(ctx, v1deposit2)
suite.Require().NoError(err)
deposits := v1beta1.Deposits{deposit1, deposit2}
@ -1433,7 +1444,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryTallyResult() {
VotingEndTime: &propTime,
Metadata: "proposal metadata",
}
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
@ -1458,7 +1470,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryTallyResult() {
VotingEndTime: &propTime,
Metadata: "proposal metadata",
}
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
@ -1483,7 +1496,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryTallyResult() {
VotingEndTime: &propTime,
Metadata: "proposal metadata",
}
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
@ -1569,7 +1583,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryTallyResult() {
VotingEndTime: &propTime,
Metadata: "proposal metadata",
}
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}
@ -1594,7 +1609,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryTallyResult() {
VotingEndTime: &propTime,
Metadata: "proposal metadata",
}
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}
@ -1619,8 +1635,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryTallyResult() {
VotingEndTime: &propTime,
Metadata: "proposal metadata",
}
suite.govKeeper.SetProposal(ctx, proposal)
err := suite.govKeeper.SetProposal(ctx, proposal)
suite.Require().NoError(err)
req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}
expTally = &v1beta1.TallyResult{

6
x/gov/keeper/hooks_test.go
View File

@ -75,7 +75,8 @@ func TestHooks(t *testing.T) {
newHeader := ctx.BlockHeader()
newHeader.Time = ctx.BlockHeader().Time.Add(*params.MaxDepositPeriod).Add(time.Duration(1) * time.Second)
ctx = ctx.WithBlockHeader(newHeader)
gov.EndBlocker(ctx, govKeeper)
err = gov.EndBlocker(ctx, govKeeper)
require.NoError(t, err)
require.True(t, govHooksReceiver.AfterProposalFailedMinDepositValid)
@ -94,6 +95,7 @@ func TestHooks(t *testing.T) {
newHeader = ctx.BlockHeader()
newHeader.Time = ctx.BlockHeader().Time.Add(*params.VotingPeriod).Add(time.Duration(1) * time.Second)
ctx = ctx.WithBlockHeader(newHeader)
gov.EndBlocker(ctx, govKeeper)
err = gov.EndBlocker(ctx, govKeeper)
require.NoError(t, err)
require.True(t, govHooksReceiver.AfterProposalVotingPeriodEndedValid)
}

3
x/gov/keeper/msg_server_test.go
View File

@ -1699,7 +1699,8 @@ func (suite *KeeperTestSuite) TestSubmitProposal_InitialDeposit() {
params := v1.DefaultParams()
params.MinDeposit = tc.minDeposit
params.MinInitialDepositRatio = tc.minInitialDepositRatio.String()
govKeeper.Params.Set(ctx, params)
err := govKeeper.Params.Set(ctx, params)
suite.Require().NoError(err)
msg, err := v1.NewMsgSubmitProposal(TestProposal, tc.initialDeposit, address.String(), "test", "Proposal", "description of proposal", false)
suite.Require().NoError(err)

Some files were not shown because too many files have changed in this diff Show More