From e035957a047da8a31e655e74de7b303fc0f210ea Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 28 Mar 2023 16:12:35 +0530 Subject: [PATCH 01/30] wip: add tests for distr CommunityPoolSpend --- .../distribution/keeper/integration_test.go | 135 ++++++++++++++++++ testutil/integration/integration_setup.go | 115 +++++++++++++++ 2 files changed, 250 insertions(+) create mode 100644 tests/integration/distribution/keeper/integration_test.go create mode 100644 testutil/integration/integration_setup.go diff --git a/tests/integration/distribution/keeper/integration_test.go b/tests/integration/distribution/keeper/integration_test.go new file mode 100644 index 000000000000..effcf997cb7e --- /dev/null +++ b/tests/integration/distribution/keeper/integration_test.go @@ -0,0 +1,135 @@ +package keeper_test + +import ( + "testing" + + "cosmossdk.io/math" + storetypes "cosmossdk.io/store/types" + "gotest.tools/v3/assert" + + "github.com/cosmos/cosmos-sdk/testutil/integration" + sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/auth" + authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" + authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + "github.com/cosmos/cosmos-sdk/x/bank" + bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/cosmos/cosmos-sdk/x/distribution" + distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" + "github.com/cosmos/cosmos-sdk/x/distribution/types" + distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types" + "github.com/cosmos/cosmos-sdk/x/staking" + stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +func TestIntegrationCommunityPoolSpend(t *testing.T) { + keys := storetypes.NewKVStoreKeys( + authtypes.StoreKey, banktypes.StoreKey, distrtypes.StoreKey, stakingtypes.StoreKey, + ) + cdc := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}, distribution.AppModuleBasic{}).Codec + + authority := authtypes.NewModuleAddress("gov") + + maccPerms := map[string][]string{ + distrtypes.ModuleName: {authtypes.Minter}, + stakingtypes.BondedPoolName: nil, + stakingtypes.NotBondedPoolName: nil, + } + + accountKeeper := authkeeper.NewAccountKeeper( + cdc, + keys[authtypes.StoreKey], + authtypes.ProtoBaseAccount, + maccPerms, + sdk.Bech32MainPrefix, + authority.String(), + ) + authModule := auth.NewAppModule(cdc, accountKeeper, authsims.RandomGenesisAccounts, nil) + + blockedAddresses := map[string]bool{ + accountKeeper.GetAuthority(): false, + } + bankKeeper := bankkeeper.NewBaseKeeper( + cdc, + keys[banktypes.StoreKey], + accountKeeper, + blockedAddresses, + authority.String(), + ) + bankModule := bank.NewAppModule(cdc, bankKeeper, accountKeeper, nil) + + stakingKeeper := stakingkeeper.NewKeeper(cdc, keys[stakingtypes.StoreKey], accountKeeper, bankKeeper, authority.String()) + stakingModule := staking.NewAppModule(cdc, stakingKeeper, accountKeeper, bankKeeper, nil) + + distrKeeper := distrkeeper.NewKeeper( + cdc, keys[distrtypes.StoreKey], accountKeeper, bankKeeper, stakingKeeper, authtypes.FeeCollectorName, authority.String(), + ) + distrModule := distribution.NewAppModule(cdc, distrKeeper, accountKeeper, bankKeeper, stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, keys, authModule, bankModule, stakingModule, distrModule) + + distrKeeper.SetParams(integrationApp.Ctx, distrtypes.DefaultParams()) + distrKeeper.SetFeePool(integrationApp.Ctx, distrtypes.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), + }) + initTokens := stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(100)) + bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(distrKeeper)) + + recipient := sdk.AccAddress([]byte("addr1")) + + testCases := []struct { + name string + msg *distrtypes.MsgCommunityPoolSpend + expErr bool + expErrMsg string + }{ + { + name: "invalid authority", + msg: &distrtypes.MsgCommunityPoolSpend{ + Authority: "invalid", + Recipient: recipient.String(), + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + }, + expErr: true, + expErrMsg: "invalid authority", + }, + { + name: "invalid recipient", + msg: &types.MsgCommunityPoolSpend{ + Authority: distrKeeper.GetAuthority(), + Recipient: "invalid", + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + }, + expErr: true, + expErrMsg: "decoding bech32 failed", + }, + { + name: "valid message", + msg: &types.MsgCommunityPoolSpend{ + Authority: distrKeeper.GetAuthority(), + Recipient: recipient.String(), + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + }, + expErr: false, + }, + } + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + } + }) + } +} diff --git a/testutil/integration/integration_setup.go b/testutil/integration/integration_setup.go new file mode 100644 index 000000000000..d284434163c4 --- /dev/null +++ b/testutil/integration/integration_setup.go @@ -0,0 +1,115 @@ +package integration + +import ( + "fmt" + "testing" + + errorsmod "cosmossdk.io/errors" + "cosmossdk.io/log" + storetypes "cosmossdk.io/store/types" + cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" + dbm "github.com/cosmos/cosmos-db" + "gotest.tools/v3/assert" + + abcitypes "github.com/cometbft/cometbft/abci/types" + + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + authtx "github.com/cosmos/cosmos-sdk/x/auth/tx" +) + +type IntegrationTestApp struct { + *baseapp.BaseApp + t *testing.T + InterfaceRegistry codectypes.InterfaceRegistry + Ctx sdk.Context + QueryServiceHelper *baseapp.QueryServiceTestHelper +} + +// func createIntegrationTestRegistry(msgs ...proto.Message) codectypes.InterfaceRegistry { +// interfaceRegistry := codectypes.NewInterfaceRegistry() +// interfaceRegistry.RegisterInterface("sdk.Msg", +// (*sdk.Msg)(nil), +// msgs..., +// ) +// interfaceRegistry.RegisterImplementations((*sdk.Msg)(nil), msgs...) +// fmt.Println("msgs: ", msgs) +// fmt.Println("interface registry: ", interfaceRegistry.ListAllInterfaces()) + +// return interfaceRegistry +// } + +func SetupTestApp(t *testing.T, keys map[string]*storetypes.KVStoreKey, modules ...module.AppModuleBasic) *IntegrationTestApp { + logger := log.NewTestLogger(t) + db := dbm.NewMemDB() + + interfaceRegistry := codectypes.NewInterfaceRegistry() + for _, module := range modules { + module.RegisterInterfaces(interfaceRegistry) + } + + txConfig := authtx.NewTxConfig(codec.NewProtoCodec(interfaceRegistry), authtx.DefaultSignModes) + // testStore := storetypes.NewKVStoreKey("test") + + var initChainer sdk.InitChainer = func(ctx sdk.Context, req abcitypes.RequestInitChain) (abcitypes.ResponseInitChain, error) { + return abcitypes.ResponseInitChain{}, nil + } + + bApp := baseapp.NewBaseApp(t.Name(), logger, db, txConfig.TxDecoder()) + bApp.MountKVStores(keys) + bApp.SetInitChainer(initChainer) + + router := baseapp.NewMsgServiceRouter() + router.SetInterfaceRegistry(interfaceRegistry) + bApp.SetMsgServiceRouter(router) + + assert.NilError(t, bApp.LoadLatestVersion()) + // testdata.RegisterMsgServer(bApp.MsgServiceRouter(), ) + + ctx := bApp.NewContext(true, cmtproto.Header{}) + + queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry) + + return &IntegrationTestApp{ + BaseApp: bApp, + t: t, + InterfaceRegistry: interfaceRegistry, + Ctx: ctx, + QueryServiceHelper: queryHelper, + } +} + +func (app *IntegrationTestApp) ExecMsgs(msgs ...sdk.Msg) ([]*codectypes.Any, error) { + results := make([]*codectypes.Any, len(msgs)) + + for i, msg := range msgs { + handler := app.MsgServiceRouter().Handler(msg) + if handler == nil { + return nil, fmt.Errorf("no message handler found for %q", sdk.MsgTypeURL(msg)) + } + r, err := handler(app.Ctx, msg) + if err != nil { + return nil, errorsmod.Wrapf(err, "message %s at position %d", sdk.MsgTypeURL(msg), i) + } + // Handler should always return non-nil sdk.Result. + if r == nil { + return nil, fmt.Errorf("got nil sdk.Result for message %q at position %d", msg, i) + } + + var result *codectypes.Any + if len(r.MsgResponses) != 0 { + fmt.Printf("r.MsgResponses[0].Value: %v\n", r.MsgResponses[0].Value) + msgResponse := r.MsgResponses[0] + if msgResponse == nil { + return nil, fmt.Errorf("got nil Msg response for msg %s", msg) + } + result = msgResponse + } + results[i] = result + } + + return results, nil +} From 2fb5633e207bf25b1432110baa8df5ec652d25d1 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 28 Mar 2023 18:06:00 +0530 Subject: [PATCH 02/30] wip: add tests in x/distr module --- .../distribution/keeper/integration_test.go | 8 +- testutil/integration/integration_setup.go | 1 - x/distribution/keeper/integration_test.go | 293 ++++++++++++++++++ 3 files changed, 298 insertions(+), 4 deletions(-) create mode 100644 x/distribution/keeper/integration_test.go diff --git a/tests/integration/distribution/keeper/integration_test.go b/tests/integration/distribution/keeper/integration_test.go index effcf997cb7e..e522e688563d 100644 --- a/tests/integration/distribution/keeper/integration_test.go +++ b/tests/integration/distribution/keeper/integration_test.go @@ -19,7 +19,6 @@ import ( banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" "github.com/cosmos/cosmos-sdk/x/distribution" distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - "github.com/cosmos/cosmos-sdk/x/distribution/types" distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/staking" stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" @@ -102,7 +101,7 @@ func TestIntegrationCommunityPoolSpend(t *testing.T) { }, { name: "invalid recipient", - msg: &types.MsgCommunityPoolSpend{ + msg: &distrtypes.MsgCommunityPoolSpend{ Authority: distrKeeper.GetAuthority(), Recipient: "invalid", Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), @@ -112,7 +111,7 @@ func TestIntegrationCommunityPoolSpend(t *testing.T) { }, { name: "valid message", - msg: &types.MsgCommunityPoolSpend{ + msg: &distrtypes.MsgCommunityPoolSpend{ Authority: distrKeeper.GetAuthority(), Recipient: recipient.String(), Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), @@ -129,6 +128,9 @@ func TestIntegrationCommunityPoolSpend(t *testing.T) { } else { assert.NilError(t, err) assert.Assert(t, res != nil) + result := distrtypes.MsgCommunityPoolSpend{} + err = cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) } }) } diff --git a/testutil/integration/integration_setup.go b/testutil/integration/integration_setup.go index d284434163c4..d5ebe4e6fe6a 100644 --- a/testutil/integration/integration_setup.go +++ b/testutil/integration/integration_setup.go @@ -101,7 +101,6 @@ func (app *IntegrationTestApp) ExecMsgs(msgs ...sdk.Msg) ([]*codectypes.Any, err var result *codectypes.Any if len(r.MsgResponses) != 0 { - fmt.Printf("r.MsgResponses[0].Value: %v\n", r.MsgResponses[0].Value) msgResponse := r.MsgResponses[0] if msgResponse == nil { return nil, fmt.Errorf("got nil Msg response for msg %s", msg) diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go new file mode 100644 index 000000000000..3f8f2b2d04e3 --- /dev/null +++ b/x/distribution/keeper/integration_test.go @@ -0,0 +1,293 @@ +package keeper_test + +import ( + "testing" + + "cosmossdk.io/math" + storetypes "cosmossdk.io/store/types" + "gotest.tools/v3/assert" + + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/testutil/integration" + sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/auth" + authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" + authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + "github.com/cosmos/cosmos-sdk/x/bank" + bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/cosmos/cosmos-sdk/x/distribution" + distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" + distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types" + "github.com/cosmos/cosmos-sdk/x/staking" + stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +type fixture struct { + cdc codec.Codec + keys map[string]*storetypes.KVStoreKey + + accountKeeper authkeeper.AccountKeeper + bankKeeper bankkeeper.Keeper + distrKeeper distrkeeper.Keeper + stakingKeeper *stakingkeeper.Keeper +} + +func initFixture(t assert.TestingT) *fixture { + f := &fixture{} + + keys := storetypes.NewKVStoreKeys( + authtypes.StoreKey, banktypes.StoreKey, distrtypes.StoreKey, stakingtypes.StoreKey, + ) + cdc := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}, distribution.AppModuleBasic{}).Codec + + authority := authtypes.NewModuleAddress("gov") + + maccPerms := map[string][]string{ + distrtypes.ModuleName: {authtypes.Minter}, + stakingtypes.BondedPoolName: nil, + stakingtypes.NotBondedPoolName: nil, + } + + accountKeeper := authkeeper.NewAccountKeeper( + cdc, + keys[authtypes.StoreKey], + authtypes.ProtoBaseAccount, + maccPerms, + sdk.Bech32MainPrefix, + authority.String(), + ) + + blockedAddresses := map[string]bool{ + accountKeeper.GetAuthority(): false, + } + bankKeeper := bankkeeper.NewBaseKeeper( + cdc, + keys[banktypes.StoreKey], + accountKeeper, + blockedAddresses, + authority.String(), + ) + + stakingKeeper := stakingkeeper.NewKeeper(cdc, keys[stakingtypes.StoreKey], accountKeeper, bankKeeper, authority.String()) + + distrKeeper := distrkeeper.NewKeeper( + cdc, keys[distrtypes.StoreKey], accountKeeper, bankKeeper, stakingKeeper, authtypes.FeeCollectorName, authority.String(), + ) + + f.cdc = cdc + f.keys = keys + f.accountKeeper = accountKeeper + f.bankKeeper = bankKeeper + f.stakingKeeper = stakingKeeper + f.distrKeeper = distrKeeper + + return f +} + +func TestMsgUpdateParams(t *testing.T) { + t.Parallel() + f := initFixture(t) + + // default params + communityTax := sdk.NewDecWithPrec(2, 2) // 2% + withdrawAddrEnabled := true + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + + // Register MsgServer and QueryServer + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(f.distrKeeper)) + + testCases := []struct { + name string + msg *distrtypes.MsgUpdateParams + expErr bool + expErrMsg string + }{ + { + name: "invalid authority", + msg: &distrtypes.MsgUpdateParams{ + Authority: "invalid", + Params: distrtypes.Params{ + CommunityTax: sdk.NewDecWithPrec(2, 0), + WithdrawAddrEnabled: withdrawAddrEnabled, + BaseProposerReward: sdk.ZeroDec(), + BonusProposerReward: sdk.ZeroDec(), + }, + }, + expErr: true, + expErrMsg: "invalid authority", + }, + { + name: "community tax > 1", + msg: &distrtypes.MsgUpdateParams{ + Authority: f.distrKeeper.GetAuthority(), + Params: distrtypes.Params{ + CommunityTax: sdk.NewDecWithPrec(2, 0), + WithdrawAddrEnabled: withdrawAddrEnabled, + BaseProposerReward: sdk.ZeroDec(), + BonusProposerReward: sdk.ZeroDec(), + }, + }, + expErr: true, + expErrMsg: "community tax should be non-negative and less than one", + }, + { + name: "negative community tax", + msg: &distrtypes.MsgUpdateParams{ + Authority: f.distrKeeper.GetAuthority(), + Params: distrtypes.Params{ + CommunityTax: sdk.NewDecWithPrec(-2, 1), + WithdrawAddrEnabled: withdrawAddrEnabled, + BaseProposerReward: sdk.ZeroDec(), + BonusProposerReward: sdk.ZeroDec(), + }, + }, + expErr: true, + expErrMsg: "community tax should be non-negative and less than one", + }, + { + name: "base proposer reward set", + msg: &distrtypes.MsgUpdateParams{ + Authority: f.distrKeeper.GetAuthority(), + Params: distrtypes.Params{ + CommunityTax: communityTax, + BaseProposerReward: sdk.NewDecWithPrec(1, 2), + BonusProposerReward: sdk.ZeroDec(), + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "base and bonus proposer reward are deprecated fields and should not be used", + }, + { + name: "bonus proposer reward set", + msg: &distrtypes.MsgUpdateParams{ + Authority: f.distrKeeper.GetAuthority(), + Params: distrtypes.Params{ + CommunityTax: communityTax, + BaseProposerReward: sdk.ZeroDec(), + BonusProposerReward: sdk.NewDecWithPrec(1, 2), + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "base and bonus proposer reward are deprecated fields and should not be used", + }, + { + name: "all good", + msg: &distrtypes.MsgUpdateParams{ + Authority: f.distrKeeper.GetAuthority(), + Params: distrtypes.Params{ + CommunityTax: communityTax, + BaseProposerReward: sdk.ZeroDec(), + BonusProposerReward: sdk.ZeroDec(), + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + result := distrtypes.MsgUpdateParams{} + err = f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) + } + }) + } +} + +func TestCommunityPoolSpend(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + + f.distrKeeper.SetParams(integrationApp.Ctx, distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(integrationApp.Ctx, distrtypes.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), + }) + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(100)) + f.bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + // Register MsgServer and QueryServer + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(f.distrKeeper)) + + recipient := sdk.AccAddress([]byte("addr1")) + + testCases := []struct { + name string + msg *distrtypes.MsgCommunityPoolSpend + expErr bool + expErrMsg string + }{ + { + name: "invalid authority", + msg: &distrtypes.MsgCommunityPoolSpend{ + Authority: "invalid", + Recipient: recipient.String(), + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + }, + expErr: true, + expErrMsg: "invalid authority", + }, + { + name: "invalid recipient", + msg: &distrtypes.MsgCommunityPoolSpend{ + Authority: f.distrKeeper.GetAuthority(), + Recipient: "invalid", + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + }, + expErr: true, + expErrMsg: "decoding bech32 failed", + }, + { + name: "valid message", + msg: &distrtypes.MsgCommunityPoolSpend{ + Authority: f.distrKeeper.GetAuthority(), + Recipient: recipient.String(), + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + }, + expErr: false, + }, + } + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + result := distrtypes.MsgCommunityPoolSpend{} + err = f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) + } + }) + } +} From edb8228b53fc91b1338277be4eb32c1cfbdebe7d Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 28 Mar 2023 18:12:27 +0530 Subject: [PATCH 03/30] cleanup setup and tests --- .../distribution/keeper/integration_test.go | 137 ------------------ testutil/integration/integration_setup.go | 17 --- 2 files changed, 154 deletions(-) delete mode 100644 tests/integration/distribution/keeper/integration_test.go diff --git a/tests/integration/distribution/keeper/integration_test.go b/tests/integration/distribution/keeper/integration_test.go deleted file mode 100644 index e522e688563d..000000000000 --- a/tests/integration/distribution/keeper/integration_test.go +++ /dev/null @@ -1,137 +0,0 @@ -package keeper_test - -import ( - "testing" - - "cosmossdk.io/math" - storetypes "cosmossdk.io/store/types" - "gotest.tools/v3/assert" - - "github.com/cosmos/cosmos-sdk/testutil/integration" - sdk "github.com/cosmos/cosmos-sdk/types" - moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" - "github.com/cosmos/cosmos-sdk/x/auth" - authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" - authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" - authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - "github.com/cosmos/cosmos-sdk/x/bank" - bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" - banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" - "github.com/cosmos/cosmos-sdk/x/distribution" - distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" - stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" -) - -func TestIntegrationCommunityPoolSpend(t *testing.T) { - keys := storetypes.NewKVStoreKeys( - authtypes.StoreKey, banktypes.StoreKey, distrtypes.StoreKey, stakingtypes.StoreKey, - ) - cdc := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}, distribution.AppModuleBasic{}).Codec - - authority := authtypes.NewModuleAddress("gov") - - maccPerms := map[string][]string{ - distrtypes.ModuleName: {authtypes.Minter}, - stakingtypes.BondedPoolName: nil, - stakingtypes.NotBondedPoolName: nil, - } - - accountKeeper := authkeeper.NewAccountKeeper( - cdc, - keys[authtypes.StoreKey], - authtypes.ProtoBaseAccount, - maccPerms, - sdk.Bech32MainPrefix, - authority.String(), - ) - authModule := auth.NewAppModule(cdc, accountKeeper, authsims.RandomGenesisAccounts, nil) - - blockedAddresses := map[string]bool{ - accountKeeper.GetAuthority(): false, - } - bankKeeper := bankkeeper.NewBaseKeeper( - cdc, - keys[banktypes.StoreKey], - accountKeeper, - blockedAddresses, - authority.String(), - ) - bankModule := bank.NewAppModule(cdc, bankKeeper, accountKeeper, nil) - - stakingKeeper := stakingkeeper.NewKeeper(cdc, keys[stakingtypes.StoreKey], accountKeeper, bankKeeper, authority.String()) - stakingModule := staking.NewAppModule(cdc, stakingKeeper, accountKeeper, bankKeeper, nil) - - distrKeeper := distrkeeper.NewKeeper( - cdc, keys[distrtypes.StoreKey], accountKeeper, bankKeeper, stakingKeeper, authtypes.FeeCollectorName, authority.String(), - ) - distrModule := distribution.NewAppModule(cdc, distrKeeper, accountKeeper, bankKeeper, stakingKeeper, nil) - - integrationApp := integration.SetupTestApp(t, keys, authModule, bankModule, stakingModule, distrModule) - - distrKeeper.SetParams(integrationApp.Ctx, distrtypes.DefaultParams()) - distrKeeper.SetFeePool(integrationApp.Ctx, distrtypes.FeePool{ - CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), - }) - initTokens := stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(100)) - bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(distrKeeper)) - - recipient := sdk.AccAddress([]byte("addr1")) - - testCases := []struct { - name string - msg *distrtypes.MsgCommunityPoolSpend - expErr bool - expErrMsg string - }{ - { - name: "invalid authority", - msg: &distrtypes.MsgCommunityPoolSpend{ - Authority: "invalid", - Recipient: recipient.String(), - Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), - }, - expErr: true, - expErrMsg: "invalid authority", - }, - { - name: "invalid recipient", - msg: &distrtypes.MsgCommunityPoolSpend{ - Authority: distrKeeper.GetAuthority(), - Recipient: "invalid", - Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), - }, - expErr: true, - expErrMsg: "decoding bech32 failed", - }, - { - name: "valid message", - msg: &distrtypes.MsgCommunityPoolSpend{ - Authority: distrKeeper.GetAuthority(), - Recipient: recipient.String(), - Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), - }, - expErr: false, - }, - } - for _, tc := range testCases { - tc := tc - t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.ExecMsgs(tc.msg) - if tc.expErr { - assert.ErrorContains(t, err, tc.expErrMsg) - } else { - assert.NilError(t, err) - assert.Assert(t, res != nil) - result := distrtypes.MsgCommunityPoolSpend{} - err = cdc.Unmarshal(res[0].Value, &result) - assert.NilError(t, err) - } - }) - } -} diff --git a/testutil/integration/integration_setup.go b/testutil/integration/integration_setup.go index d5ebe4e6fe6a..7498abaca566 100644 --- a/testutil/integration/integration_setup.go +++ b/testutil/integration/integration_setup.go @@ -29,19 +29,6 @@ type IntegrationTestApp struct { QueryServiceHelper *baseapp.QueryServiceTestHelper } -// func createIntegrationTestRegistry(msgs ...proto.Message) codectypes.InterfaceRegistry { -// interfaceRegistry := codectypes.NewInterfaceRegistry() -// interfaceRegistry.RegisterInterface("sdk.Msg", -// (*sdk.Msg)(nil), -// msgs..., -// ) -// interfaceRegistry.RegisterImplementations((*sdk.Msg)(nil), msgs...) -// fmt.Println("msgs: ", msgs) -// fmt.Println("interface registry: ", interfaceRegistry.ListAllInterfaces()) - -// return interfaceRegistry -// } - func SetupTestApp(t *testing.T, keys map[string]*storetypes.KVStoreKey, modules ...module.AppModuleBasic) *IntegrationTestApp { logger := log.NewTestLogger(t) db := dbm.NewMemDB() @@ -52,8 +39,6 @@ func SetupTestApp(t *testing.T, keys map[string]*storetypes.KVStoreKey, modules } txConfig := authtx.NewTxConfig(codec.NewProtoCodec(interfaceRegistry), authtx.DefaultSignModes) - // testStore := storetypes.NewKVStoreKey("test") - var initChainer sdk.InitChainer = func(ctx sdk.Context, req abcitypes.RequestInitChain) (abcitypes.ResponseInitChain, error) { return abcitypes.ResponseInitChain{}, nil } @@ -65,9 +50,7 @@ func SetupTestApp(t *testing.T, keys map[string]*storetypes.KVStoreKey, modules router := baseapp.NewMsgServiceRouter() router.SetInterfaceRegistry(interfaceRegistry) bApp.SetMsgServiceRouter(router) - assert.NilError(t, bApp.LoadLatestVersion()) - // testdata.RegisterMsgServer(bApp.MsgServiceRouter(), ) ctx := bApp.NewContext(true, cmtproto.Header{}) From 466e4110c28cf9ae70fd75e702d2631451524323 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Thu, 30 Mar 2023 12:00:59 +0530 Subject: [PATCH 04/30] add more tests --- x/distribution/keeper/integration_test.go | 108 +++++++++++++++++++++- 1 file changed, 106 insertions(+), 2 deletions(-) diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index 3f8f2b2d04e3..b665f504363f 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -23,6 +23,7 @@ import ( distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/staking" stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -48,8 +49,8 @@ func initFixture(t assert.TestingT) *fixture { maccPerms := map[string][]string{ distrtypes.ModuleName: {authtypes.Minter}, - stakingtypes.BondedPoolName: nil, - stakingtypes.NotBondedPoolName: nil, + stakingtypes.BondedPoolName: {authtypes.Burner, authtypes.Staking}, + stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking}, } accountKeeper := authkeeper.NewAccountKeeper( @@ -291,3 +292,106 @@ func TestCommunityPoolSpend(t *testing.T) { }) } } + +func TestMsgDepositValidatorRewardsPool(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + + f.distrKeeper.SetParams(integrationApp.Ctx, distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(integrationApp.Ctx, distrtypes.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), + }) + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(10000)) + f.bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + // Set default staking params + f.stakingKeeper.SetParams(integrationApp.Ctx, stakingtypes.DefaultParams()) + + // Register MsgServer and QueryServer + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(f.distrKeeper)) + + addr := sdk.AccAddress([]byte("addr")) + addr1 := sdk.AccAddress(PKS[0].Address()) + valAddr1 := sdk.ValAddress(addr1) + + // send funds to val addr + tokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.Ctx, distrtypes.ModuleName, sdk.AccAddress(valAddr1), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + + // send funds from module to addr to perform DepositValidatorRewardsPool + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.Ctx, distrtypes.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + + tstaking := stakingtestutil.NewHelper(t, integrationApp.Ctx, f.stakingKeeper) + tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) + tstaking.CreateValidator(valAddr1, valConsPk0, sdk.NewInt(100), true) + + // mint a non-staking token and send to an account + amt := sdk.NewCoins(sdk.NewInt64Coin("foo", 500)) + f.bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, amt) + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.Ctx, distrtypes.ModuleName, addr, amt) + + testCases := []struct { + name string + msg *distrtypes.MsgDepositValidatorRewardsPool + expErr bool + expErrMsg string + }{ + { + name: "happy path (staking token)", + msg: &distrtypes.MsgDepositValidatorRewardsPool{ + Authority: addr.String(), + ValidatorAddress: valAddr1.String(), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.Ctx), sdk.NewInt(100))), + }, + }, + { + name: "happy path (non-staking token)", + msg: &distrtypes.MsgDepositValidatorRewardsPool{ + Authority: addr.String(), + ValidatorAddress: valAddr1.String(), + Amount: amt, + }, + }, + { + name: "invalid validator", + msg: &distrtypes.MsgDepositValidatorRewardsPool{ + Authority: addr.String(), + ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String(), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.Ctx), sdk.NewInt(100))), + }, + expErr: true, + expErrMsg: "validator does not exist", + }, + } + + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + + valAddr, err := sdk.ValAddressFromBech32(tc.msg.ValidatorAddress) + assert.NilError(t, err) + + // check validator outstanding rewards + outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.Ctx, valAddr) + for _, c := range tc.msg.Amount { + x := outstandingRewards.Rewards.AmountOf(c.Denom) + assert.DeepEqual(t, x, sdk.NewDecFromInt(c.Amount)) + } + } + }) + } +} From bbe5e895f349d7f03ddbceb7f99c5c312db13a91 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Thu, 30 Mar 2023 16:51:28 +0530 Subject: [PATCH 05/30] fix failing test --- x/distribution/keeper/integration_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index b665f504363f..75ea58dad646 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -8,6 +8,7 @@ import ( "gotest.tools/v3/assert" "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/testutil/integration" sdk "github.com/cosmos/cosmos-sdk/types" moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" @@ -55,7 +56,7 @@ func initFixture(t assert.TestingT) *fixture { accountKeeper := authkeeper.NewAccountKeeper( cdc, - keys[authtypes.StoreKey], + runtime.NewKVStoreService(keys[authtypes.StoreKey]), authtypes.ProtoBaseAccount, maccPerms, sdk.Bech32MainPrefix, From 415357a9a739da8befbef8d83305e2418f69ab85 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Thu, 30 Mar 2023 17:09:50 +0530 Subject: [PATCH 06/30] address comments --- testutil/integration/integration_setup.go | 20 +++++---- x/distribution/keeper/integration_test.go | 51 +++++++++++++---------- 2 files changed, 43 insertions(+), 28 deletions(-) diff --git a/testutil/integration/integration_setup.go b/testutil/integration/integration_setup.go index 7498abaca566..4da13c6622d8 100644 --- a/testutil/integration/integration_setup.go +++ b/testutil/integration/integration_setup.go @@ -24,9 +24,8 @@ import ( type IntegrationTestApp struct { *baseapp.BaseApp t *testing.T - InterfaceRegistry codectypes.InterfaceRegistry - Ctx sdk.Context - QueryServiceHelper *baseapp.QueryServiceTestHelper + ctx sdk.Context + queryServiceHelper *baseapp.QueryServiceTestHelper } func SetupTestApp(t *testing.T, keys map[string]*storetypes.KVStoreKey, modules ...module.AppModuleBasic) *IntegrationTestApp { @@ -59,12 +58,19 @@ func SetupTestApp(t *testing.T, keys map[string]*storetypes.KVStoreKey, modules return &IntegrationTestApp{ BaseApp: bApp, t: t, - InterfaceRegistry: interfaceRegistry, - Ctx: ctx, - QueryServiceHelper: queryHelper, + ctx: ctx, + queryServiceHelper: queryHelper, } } +func (app *IntegrationTestApp) SDKContext() sdk.Context { + return app.ctx +} + +func (app *IntegrationTestApp) QueryServiceHelper() *baseapp.QueryServiceTestHelper { + return app.queryServiceHelper +} + func (app *IntegrationTestApp) ExecMsgs(msgs ...sdk.Msg) ([]*codectypes.Any, error) { results := make([]*codectypes.Any, len(msgs)) @@ -73,7 +79,7 @@ func (app *IntegrationTestApp) ExecMsgs(msgs ...sdk.Msg) ([]*codectypes.Any, err if handler == nil { return nil, fmt.Errorf("no message handler found for %q", sdk.MsgTypeURL(msg)) } - r, err := handler(app.Ctx, msg) + r, err := handler(app.ctx, msg) if err != nil { return nil, errorsmod.Wrapf(err, "message %s at position %d", sdk.MsgTypeURL(msg), i) } diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index 75ea58dad646..7b1efc695fe8 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -107,7 +107,7 @@ func TestMsgUpdateParams(t *testing.T) { // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) testCases := []struct { name string @@ -209,6 +209,8 @@ func TestMsgUpdateParams(t *testing.T) { } else { assert.NilError(t, err) assert.Assert(t, res != nil) + + // check the result result := distrtypes.MsgUpdateParams{} err = f.cdc.Unmarshal(res[0].Value, &result) assert.NilError(t, err) @@ -228,16 +230,16 @@ func TestCommunityPoolSpend(t *testing.T) { integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) - f.distrKeeper.SetParams(integrationApp.Ctx, distrtypes.DefaultParams()) - f.distrKeeper.SetFeePool(integrationApp.Ctx, distrtypes.FeePool{ + f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), }) - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(100)) - f.bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(100)) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) recipient := sdk.AccAddress([]byte("addr1")) @@ -286,6 +288,8 @@ func TestCommunityPoolSpend(t *testing.T) { } else { assert.NilError(t, err) assert.Assert(t, res != nil) + + // check the result result := distrtypes.MsgCommunityPoolSpend{} err = f.cdc.Unmarshal(res[0].Value, &result) assert.NilError(t, err) @@ -305,39 +309,39 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) - f.distrKeeper.SetParams(integrationApp.Ctx, distrtypes.DefaultParams()) - f.distrKeeper.SetFeePool(integrationApp.Ctx, distrtypes.FeePool{ + f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), }) - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(10000)) - f.bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(10000)) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Set default staking params - f.stakingKeeper.SetParams(integrationApp.Ctx, stakingtypes.DefaultParams()) + f.stakingKeeper.SetParams(integrationApp.SDKContext(), stakingtypes.DefaultParams()) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper, distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) addr := sdk.AccAddress([]byte("addr")) addr1 := sdk.AccAddress(PKS[0].Address()) valAddr1 := sdk.ValAddress(addr1) // send funds to val addr - tokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.Ctx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.Ctx, distrtypes.ModuleName, sdk.AccAddress(valAddr1), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + tokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.AccAddress(valAddr1), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) // send funds from module to addr to perform DepositValidatorRewardsPool - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.Ctx, distrtypes.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) - tstaking := stakingtestutil.NewHelper(t, integrationApp.Ctx, f.stakingKeeper) + tstaking := stakingtestutil.NewHelper(t, integrationApp.SDKContext(), f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) tstaking.CreateValidator(valAddr1, valConsPk0, sdk.NewInt(100), true) // mint a non-staking token and send to an account amt := sdk.NewCoins(sdk.NewInt64Coin("foo", 500)) - f.bankKeeper.MintCoins(integrationApp.Ctx, distrtypes.ModuleName, amt) - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.Ctx, distrtypes.ModuleName, addr, amt) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, amt) + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, addr, amt) testCases := []struct { name string @@ -350,7 +354,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { msg: &distrtypes.MsgDepositValidatorRewardsPool{ Authority: addr.String(), ValidatorAddress: valAddr1.String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.Ctx), sdk.NewInt(100))), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.SDKContext()), sdk.NewInt(100))), }, }, { @@ -366,7 +370,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { msg: &distrtypes.MsgDepositValidatorRewardsPool{ Authority: addr.String(), ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.Ctx), sdk.NewInt(100))), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.SDKContext()), sdk.NewInt(100))), }, expErr: true, expErrMsg: "validator does not exist", @@ -387,11 +391,16 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { assert.NilError(t, err) // check validator outstanding rewards - outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.Ctx, valAddr) + outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr) for _, c := range tc.msg.Amount { x := outstandingRewards.Rewards.AmountOf(c.Denom) assert.DeepEqual(t, x, sdk.NewDecFromInt(c.Amount)) } + + // check the result + result := distrtypes.MsgDepositValidatorRewardsPoolResponse{} + err = f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) } }) } From da0d3280c61d05c0c13db01bf2cb45491731789a Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Fri, 31 Mar 2023 18:09:49 +0530 Subject: [PATCH 07/30] wip: verify state updation --- x/distribution/keeper/integration_test.go | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index 7b1efc695fe8..574de36e5e00 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -214,6 +214,10 @@ func TestMsgUpdateParams(t *testing.T) { result := distrtypes.MsgUpdateParams{} err = f.cdc.Unmarshal(res[0].Value, &result) assert.NilError(t, err) + + // query the params and verify it has been updated + params := f.distrKeeper.GetParams(integrationApp.SDKContext()) + assert.DeepEqual(t, distrtypes.DefaultParams(), params) } }) } @@ -232,8 +236,10 @@ func TestCommunityPoolSpend(t *testing.T) { f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ - CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), }) + initialFeePool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(100)) f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) @@ -293,6 +299,12 @@ func TestCommunityPoolSpend(t *testing.T) { result := distrtypes.MsgCommunityPoolSpend{} err = f.cdc.Unmarshal(res[0].Value, &result) assert.NilError(t, err) + + // query the community pool to verify it has been updated + communityPool := f.distrKeeper.GetFeePoolCommunityCoins(integrationApp.SDKContext()) + newPool, negative := initialFeePool.CommunityPool.SafeSub(sdk.NewDecCoinsFromCoins(tc.msg.Amount...)) + assert.Assert(t, negative == false) + assert.DeepEqual(t, communityPool, newPool) } }) } @@ -387,6 +399,11 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { assert.NilError(t, err) assert.Assert(t, res != nil) + // check the result + result := distrtypes.MsgDepositValidatorRewardsPoolResponse{} + err = f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) + valAddr, err := sdk.ValAddressFromBech32(tc.msg.ValidatorAddress) assert.NilError(t, err) @@ -397,10 +414,6 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { assert.DeepEqual(t, x, sdk.NewDecFromInt(c.Amount)) } - // check the result - result := distrtypes.MsgDepositValidatorRewardsPoolResponse{} - err = f.cdc.Unmarshal(res[0].Value, &result) - assert.NilError(t, err) } }) } From 44518675bef3b046ec83f85808ab32d6d9333f56 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Fri, 31 Mar 2023 23:02:00 +0530 Subject: [PATCH 08/30] wip: add more tests --- x/distribution/keeper/integration_test.go | 82 ++++++++++++++++++++++- 1 file changed, 81 insertions(+), 1 deletion(-) diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index 574de36e5e00..25d4d7ae1d9e 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -90,6 +90,86 @@ func initFixture(t assert.TestingT) *fixture { return f } +func TestMsgFundCommunityPool(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + + // reset fee pool + f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.InitialFeePool()) + initPool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + assert.Assert(t, initPool.CommunityPool.Empty()) + + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(100)) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + // Register MsgServer and QueryServer + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + addr := sdk.AccAddress(PKS[0].Address()) + addr2 := sdk.AccAddress(PKS[1].Address()) + amount := sdk.NewCoins(sdk.NewInt64Coin("stake", 100)) + + // fund the account by minting and sending amount from distribution module to addr + err := f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, amount) + assert.NilError(t, err) + err = f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, addr, amount) + assert.NilError(t, err) + + testCases := []struct { + name string + msg *distrtypes.MsgFundCommunityPool + expErr bool + expErrMsg string + }{ + { + name: "depositor address with no funds", + msg: &distrtypes.MsgFundCommunityPool{ + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + Depositor: addr2.String(), + }, + expErr: true, + expErrMsg: "insufficient funds", + }, + { + name: "valid message", + msg: &distrtypes.MsgFundCommunityPool{ + Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), + Depositor: addr.String(), + }, + expErr: false, + }, + } + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + + // check the result + result := distrtypes.MsgFundCommunityPool{} + err = f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) + + // query the community pool funds + assert.DeepEqual(t, initPool.CommunityPool.Add(sdk.NewDecCoinsFromCoins(amount...)...), f.distrKeeper.GetFeePool(integrationApp.SDKContext()).CommunityPool) + assert.Assert(t, f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), addr).Empty()) + } + }) + } +} + func TestMsgUpdateParams(t *testing.T) { t.Parallel() f := initFixture(t) @@ -223,7 +303,7 @@ func TestMsgUpdateParams(t *testing.T) { } } -func TestCommunityPoolSpend(t *testing.T) { +func TestMsgCommunityPoolSpend(t *testing.T) { t.Parallel() f := initFixture(t) From c929740ef9aa0d1f0c6fe2d962165d72ffc5401e Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Fri, 31 Mar 2023 23:12:01 +0530 Subject: [PATCH 09/30] wip: add one more test --- x/distribution/keeper/integration_test.go | 102 ++++++++++++++++++++++ 1 file changed, 102 insertions(+) diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index 25d4d7ae1d9e..f9d3437c565b 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -90,6 +90,108 @@ func initFixture(t assert.TestingT) *fixture { return f } +func TestMsgWithdrawValidatorCommission(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + + // Register MsgServer and QueryServer + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + valCommission := sdk.DecCoins{ + sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5).Quo(math.LegacyNewDec(4))), + sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(3).Quo(math.LegacyNewDec(2))), + } + + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + + // set module account coins + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + // send funds to val addr + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + coins := sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(2)), sdk.NewCoin("stake", sdk.NewInt(2))) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, coins) + + // check initial balance + balance := f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), sdk.AccAddress(valAddr)) + expTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), 1000) + expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) + assert.DeepEqual(t, expCoins, balance) + + // set outstanding rewards + f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + + // set commission + f.distrKeeper.SetValidatorAccumulatedCommission(integrationApp.SDKContext(), valAddr, distrtypes.ValidatorAccumulatedCommission{Commission: valCommission}) + + testCases := []struct { + name string + msg *distrtypes.MsgWithdrawValidatorCommission + expErr bool + expErrMsg string + }{ + { + name: "validator with no commission", + msg: &distrtypes.MsgWithdrawValidatorCommission{ + ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String(), + }, + expErr: true, + expErrMsg: "no validator commission to withdraw", + }, + { + name: "valid msg", + msg: &distrtypes.MsgWithdrawValidatorCommission{ + ValidatorAddress: valAddr.String(), + }, + expErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + + // check the result + result := distrtypes.MsgWithdrawValidatorCommissionResponse{} + err = f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) + + // check balance increase + balance = f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), sdk.AccAddress(valAddr)) + assert.DeepEqual(t, sdk.NewCoins( + sdk.NewCoin("mytoken", sdk.NewInt(1)), + sdk.NewCoin("stake", expTokens.AddRaw(1)), + ), balance) + + // check remainder + remainder := f.distrKeeper.GetValidatorAccumulatedCommission(integrationApp.SDKContext(), valAddr).Commission + assert.DeepEqual(t, sdk.DecCoins{ + sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(1).Quo(math.LegacyNewDec(4))), + sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(1).Quo(math.LegacyNewDec(2))), + }, remainder) + } + }) + + } +} + func TestMsgFundCommunityPool(t *testing.T) { t.Parallel() f := initFixture(t) From d44336cfbf6efe449cd937884caa2865df6a956c Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 3 Apr 2023 13:56:39 +0530 Subject: [PATCH 10/30] wip: add more msg server tests --- x/distribution/keeper/integration_test.go | 211 ++++++++++++++++++++++ 1 file changed, 211 insertions(+) diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index f9d3437c565b..0dfdab1d47ab 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -90,6 +90,217 @@ func initFixture(t assert.TestingT) *fixture { return f } +func TestWithdrawDelegatorReward(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + + f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), + }) + initFeePool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + + // Register MsgServer and QueryServer + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + addr := sdk.AccAddress(PKS[0].Address()) + delAddr := sdk.AccAddress(PKS[1].Address()) + + valCommission := sdk.DecCoins{ + sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5).Quo(math.LegacyNewDec(4))), + sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(3).Quo(math.LegacyNewDec(2))), + } + + // setup staking validator + valAddr := sdk.ValAddress(addr) + validator, err := stakingtypes.NewValidator(valAddr, PKS[0], stakingtypes.Description{}) + assert.NilError(t, err) + commission := stakingtypes.NewCommission(math.LegacyZeroDec(), math.LegacyOneDec(), math.LegacyOneDec()) + validator, err = validator.SetInitialCommission(commission) + assert.NilError(t, err) + validator.DelegatorShares = math.LegacyNewDec(100) + validator.Tokens = sdk.NewInt(1000000) + f.stakingKeeper.SetValidator(integrationApp.SDKContext(), validator) + + // set module account coins + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + // send funds to val addr + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + initBalance := f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), delAddr) + + // setup delegation + delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) + validator, issuedShares := validator.AddTokensFromDel(delTokens) + delegation := stakingtypes.NewDelegation(delAddr, validator.GetOperator(), issuedShares) + f.stakingKeeper.SetDelegation(integrationApp.SDKContext(), delegation) + f.distrKeeper.SetDelegatorStartingInfo(integrationApp.SDKContext(), 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) + f.distrKeeper.SetValidatorHistoricalRewards(integrationApp.SDKContext(), validator.GetOperator(), 2, historicalRewards) + // setup current rewards and outstanding rewards + currentRewards := distrtypes.NewValidatorCurrentRewards(decCoins, 3) + f.distrKeeper.SetValidatorCurrentRewards(integrationApp.SDKContext(), valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + initOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewardsCoins(integrationApp.SDKContext(), valAddr) + + testCases := []struct { + name string + msg *distrtypes.MsgWithdrawDelegatorReward + expErr bool + expErrMsg string + }{ + { + name: "delegator with no delegations", + msg: &distrtypes.MsgWithdrawDelegatorReward{ + DelegatorAddress: sdk.AccAddress([]byte("invalid")).String(), + ValidatorAddress: valAddr.String(), + }, + expErr: true, + expErrMsg: "no delegation distribution info", + }, + { + name: "validator with no delegations", + msg: &distrtypes.MsgWithdrawDelegatorReward{ + DelegatorAddress: delAddr.String(), + ValidatorAddress: sdk.ValAddress(sdk.AccAddress(PKS[2].Address())).String(), + }, + expErr: true, + expErrMsg: "no validator distribution info", + }, + { + name: "valid msg", + msg: &distrtypes.MsgWithdrawDelegatorReward{ + DelegatorAddress: delAddr.String(), + ValidatorAddress: valAddr.String(), + }, + expErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + + // check the result + result := distrtypes.MsgWithdrawDelegatorRewardResponse{} + err := f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) + + // check current balance is greater than initial balance + curBalance := f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), sdk.AccAddress(valAddr)) + assert.Assert(t, initBalance.IsAllLTE(curBalance)) + + // check rewards + curFeePool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + rewards := curFeePool.GetCommunityPool().Sub(initFeePool.CommunityPool) + curOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr) + assert.DeepEqual(t, rewards, initOutstandingRewards.Sub(curOutstandingRewards.Rewards)) + } + }) + } +} + +func TestMsgSetWithdrawAddress(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + + // Register MsgServer and QueryServer + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) + + delAddr := sdk.AccAddress(PKS[0].Address()) + withdrawAddr := sdk.AccAddress(PKS[1].Address()) + + testCases := []struct { + name string + preRun func() + msg *distrtypes.MsgSetWithdrawAddress + expErr bool + expErrMsg string + }{ + { + name: "withdraw address disabled", + preRun: func() { + params := f.distrKeeper.GetParams(integrationApp.SDKContext()) + params.WithdrawAddrEnabled = false + assert.NilError(t, f.distrKeeper.SetParams(integrationApp.SDKContext(), params)) + }, + msg: &distrtypes.MsgSetWithdrawAddress{ + DelegatorAddress: delAddr.String(), + WithdrawAddress: withdrawAddr.String(), + }, + expErr: true, + expErrMsg: "set withdraw address disabled", + }, + { + name: "valid msg", + preRun: func() { + params := f.distrKeeper.GetParams(integrationApp.SDKContext()) + params.WithdrawAddrEnabled = true + assert.NilError(t, f.distrKeeper.SetParams(integrationApp.SDKContext(), params)) + }, + msg: &distrtypes.MsgSetWithdrawAddress{ + DelegatorAddress: delAddr.String(), + WithdrawAddress: withdrawAddr.String(), + }, + expErr: false, + }, + } + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + tc.preRun() + res, err := integrationApp.ExecMsgs(tc.msg) + if tc.expErr { + assert.ErrorContains(t, err, tc.expErrMsg) + + // query the delegator withdraw address + addr := f.distrKeeper.GetDelegatorWithdrawAddr(integrationApp.SDKContext(), delAddr) + assert.DeepEqual(t, addr, delAddr) + } else { + assert.NilError(t, err) + assert.Assert(t, res != nil) + + // check the result + result := distrtypes.MsgSetWithdrawAddressResponse{} + err = f.cdc.Unmarshal(res[0].Value, &result) + assert.NilError(t, err) + + // query the delegator withdraw address + addr := f.distrKeeper.GetDelegatorWithdrawAddr(integrationApp.SDKContext(), delAddr) + assert.DeepEqual(t, addr, withdrawAddr) + } + }) + } +} + func TestMsgWithdrawValidatorCommission(t *testing.T) { t.Parallel() f := initFixture(t) From a9453a4318f4b6a0326960d7307d0a293364de4a Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 3 Apr 2023 15:46:53 +0530 Subject: [PATCH 11/30] remove setup files and use router setup --- testutil/integration/integration_setup.go | 103 ---------------------- x/distribution/keeper/integration_test.go | 57 ++++++------ 2 files changed, 29 insertions(+), 131 deletions(-) delete mode 100644 testutil/integration/integration_setup.go diff --git a/testutil/integration/integration_setup.go b/testutil/integration/integration_setup.go deleted file mode 100644 index 4da13c6622d8..000000000000 --- a/testutil/integration/integration_setup.go +++ /dev/null @@ -1,103 +0,0 @@ -package integration - -import ( - "fmt" - "testing" - - errorsmod "cosmossdk.io/errors" - "cosmossdk.io/log" - storetypes "cosmossdk.io/store/types" - cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" - dbm "github.com/cosmos/cosmos-db" - "gotest.tools/v3/assert" - - abcitypes "github.com/cometbft/cometbft/abci/types" - - "github.com/cosmos/cosmos-sdk/baseapp" - "github.com/cosmos/cosmos-sdk/codec" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/module" - authtx "github.com/cosmos/cosmos-sdk/x/auth/tx" -) - -type IntegrationTestApp struct { - *baseapp.BaseApp - t *testing.T - ctx sdk.Context - queryServiceHelper *baseapp.QueryServiceTestHelper -} - -func SetupTestApp(t *testing.T, keys map[string]*storetypes.KVStoreKey, modules ...module.AppModuleBasic) *IntegrationTestApp { - logger := log.NewTestLogger(t) - db := dbm.NewMemDB() - - interfaceRegistry := codectypes.NewInterfaceRegistry() - for _, module := range modules { - module.RegisterInterfaces(interfaceRegistry) - } - - txConfig := authtx.NewTxConfig(codec.NewProtoCodec(interfaceRegistry), authtx.DefaultSignModes) - var initChainer sdk.InitChainer = func(ctx sdk.Context, req abcitypes.RequestInitChain) (abcitypes.ResponseInitChain, error) { - return abcitypes.ResponseInitChain{}, nil - } - - bApp := baseapp.NewBaseApp(t.Name(), logger, db, txConfig.TxDecoder()) - bApp.MountKVStores(keys) - bApp.SetInitChainer(initChainer) - - router := baseapp.NewMsgServiceRouter() - router.SetInterfaceRegistry(interfaceRegistry) - bApp.SetMsgServiceRouter(router) - assert.NilError(t, bApp.LoadLatestVersion()) - - ctx := bApp.NewContext(true, cmtproto.Header{}) - - queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry) - - return &IntegrationTestApp{ - BaseApp: bApp, - t: t, - ctx: ctx, - queryServiceHelper: queryHelper, - } -} - -func (app *IntegrationTestApp) SDKContext() sdk.Context { - return app.ctx -} - -func (app *IntegrationTestApp) QueryServiceHelper() *baseapp.QueryServiceTestHelper { - return app.queryServiceHelper -} - -func (app *IntegrationTestApp) ExecMsgs(msgs ...sdk.Msg) ([]*codectypes.Any, error) { - results := make([]*codectypes.Any, len(msgs)) - - for i, msg := range msgs { - handler := app.MsgServiceRouter().Handler(msg) - if handler == nil { - return nil, fmt.Errorf("no message handler found for %q", sdk.MsgTypeURL(msg)) - } - r, err := handler(app.ctx, msg) - if err != nil { - return nil, errorsmod.Wrapf(err, "message %s at position %d", sdk.MsgTypeURL(msg), i) - } - // Handler should always return non-nil sdk.Result. - if r == nil { - return nil, fmt.Errorf("got nil sdk.Result for message %q at position %d", msg, i) - } - - var result *codectypes.Any - if len(r.MsgResponses) != 0 { - msgResponse := r.MsgResponses[0] - if msgResponse == nil { - return nil, fmt.Errorf("got nil Msg response for msg %s", msg) - } - result = msgResponse - } - results[i] = result - } - - return results, nil -} diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/integration_test.go index 0dfdab1d47ab..e55862e9312a 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/integration_test.go @@ -3,6 +3,7 @@ package keeper_test import ( "testing" + "cosmossdk.io/log" "cosmossdk.io/math" storetypes "cosmossdk.io/store/types" "gotest.tools/v3/assert" @@ -99,7 +100,7 @@ func TestWithdrawDelegatorReward(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), @@ -108,7 +109,7 @@ func TestWithdrawDelegatorReward(t *testing.T) { // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) addr := sdk.AccAddress(PKS[0].Address()) delAddr := sdk.AccAddress(PKS[1].Address()) @@ -192,7 +193,7 @@ func TestWithdrawDelegatorReward(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.ExecMsgs(tc.msg) + res, err := integrationApp.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -201,7 +202,7 @@ func TestWithdrawDelegatorReward(t *testing.T) { // check the result result := distrtypes.MsgWithdrawDelegatorRewardResponse{} - err := f.cdc.Unmarshal(res[0].Value, &result) + err := f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) // check current balance is greater than initial balance @@ -227,11 +228,11 @@ func TestMsgSetWithdrawAddress(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) @@ -277,7 +278,7 @@ func TestMsgSetWithdrawAddress(t *testing.T) { tc := tc t.Run(tc.name, func(t *testing.T) { tc.preRun() - res, err := integrationApp.ExecMsgs(tc.msg) + res, err := integrationApp.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) @@ -290,7 +291,7 @@ func TestMsgSetWithdrawAddress(t *testing.T) { // check the result result := distrtypes.MsgSetWithdrawAddressResponse{} - err = f.cdc.Unmarshal(res[0].Value, &result) + err = f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) // query the delegator withdraw address @@ -310,11 +311,11 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) valCommission := sdk.DecCoins{ sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5).Quo(math.LegacyNewDec(4))), @@ -372,7 +373,7 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.ExecMsgs(tc.msg) + res, err := integrationApp.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -381,7 +382,7 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { // check the result result := distrtypes.MsgWithdrawValidatorCommissionResponse{} - err = f.cdc.Unmarshal(res[0].Value, &result) + err = f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) // check balance increase @@ -412,7 +413,7 @@ func TestMsgFundCommunityPool(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) // reset fee pool f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.InitialFeePool()) @@ -424,7 +425,7 @@ func TestMsgFundCommunityPool(t *testing.T) { // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) addr := sdk.AccAddress(PKS[0].Address()) addr2 := sdk.AccAddress(PKS[1].Address()) @@ -463,7 +464,7 @@ func TestMsgFundCommunityPool(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.ExecMsgs(tc.msg) + res, err := integrationApp.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -472,7 +473,7 @@ func TestMsgFundCommunityPool(t *testing.T) { // check the result result := distrtypes.MsgFundCommunityPool{} - err = f.cdc.Unmarshal(res[0].Value, &result) + err = f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) // query the community pool funds @@ -496,11 +497,11 @@ func TestMsgUpdateParams(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) testCases := []struct { name string @@ -596,7 +597,7 @@ func TestMsgUpdateParams(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.ExecMsgs(tc.msg) + res, err := integrationApp.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -605,7 +606,7 @@ func TestMsgUpdateParams(t *testing.T) { // check the result result := distrtypes.MsgUpdateParams{} - err = f.cdc.Unmarshal(res[0].Value, &result) + err = f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) // query the params and verify it has been updated @@ -625,7 +626,7 @@ func TestMsgCommunityPoolSpend(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ @@ -638,7 +639,7 @@ func TestMsgCommunityPoolSpend(t *testing.T) { // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) recipient := sdk.AccAddress([]byte("addr1")) @@ -681,7 +682,7 @@ func TestMsgCommunityPoolSpend(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.ExecMsgs(tc.msg) + res, err := integrationApp.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -690,7 +691,7 @@ func TestMsgCommunityPoolSpend(t *testing.T) { // check the result result := distrtypes.MsgCommunityPoolSpend{} - err = f.cdc.Unmarshal(res[0].Value, &result) + err = f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) // query the community pool to verify it has been updated @@ -712,7 +713,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.SetupTestApp(t, f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ @@ -726,7 +727,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryServiceHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) addr := sdk.AccAddress([]byte("addr")) addr1 := sdk.AccAddress(PKS[0].Address()) @@ -785,7 +786,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.ExecMsgs(tc.msg) + res, err := integrationApp.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -794,7 +795,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { // check the result result := distrtypes.MsgDepositValidatorRewardsPoolResponse{} - err = f.cdc.Unmarshal(res[0].Value, &result) + err = f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) valAddr, err := sdk.ValAddressFromBech32(tc.msg.ValidatorAddress) From b1e1a499ee88665754955a38f437a82ace547e1d Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 4 Apr 2023 09:04:05 +0530 Subject: [PATCH 12/30] delete duplicate tests from tests/integration/distr --- .../distribution/keeper/allocation_test.go | 248 ------ .../distribution/keeper/delegation_test.go | 820 ------------------ .../distribution/keeper/keeper_test.go | 185 ---- .../distribution/keeper/msg_server_test.go | 261 ------ ...integration_test.go => msg_server_test.go} | 2 +- 5 files changed, 1 insertion(+), 1515 deletions(-) delete mode 100644 tests/integration/distribution/keeper/allocation_test.go delete mode 100644 tests/integration/distribution/keeper/delegation_test.go delete mode 100644 tests/integration/distribution/keeper/keeper_test.go delete mode 100644 tests/integration/distribution/keeper/msg_server_test.go rename x/distribution/keeper/{integration_test.go => msg_server_test.go} (99%) diff --git a/tests/integration/distribution/keeper/allocation_test.go b/tests/integration/distribution/keeper/allocation_test.go deleted file mode 100644 index 7ad05a0ffd6e..000000000000 --- a/tests/integration/distribution/keeper/allocation_test.go +++ /dev/null @@ -1,248 +0,0 @@ -package keeper_test - -import ( - "testing" - - "cosmossdk.io/math" - abci "github.com/cometbft/cometbft/abci/types" - cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" - "gotest.tools/v3/assert" - - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" - sdk "github.com/cosmos/cosmos-sdk/types" - authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" - "github.com/cosmos/cosmos-sdk/x/auth/types" - bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" - banktestutil "github.com/cosmos/cosmos-sdk/x/bank/testutil" - "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - "github.com/cosmos/cosmos-sdk/x/distribution/testutil" - disttypes "github.com/cosmos/cosmos-sdk/x/distribution/types" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" - stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" - stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" -) - -func TestAllocateTokensToValidatorWithCommission(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - addrs := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 3, sdk.NewInt(1234)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addrs) - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - - // create validator with 50% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(sdk.ValAddress(addrs[0]), valConsPk0, sdk.NewInt(100), true) - val := stakingKeeper.Validator(ctx, valAddrs[0]) - - // allocate tokens - tokens := sdk.DecCoins{ - {Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(10)}, - } - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // check commission - expected := sdk.DecCoins{ - {Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(5)}, - } - assert.DeepEqual(t, expected, distrKeeper.GetValidatorAccumulatedCommission(ctx, val.GetOperator()).Commission) - - // check current rewards - assert.DeepEqual(t, expected, distrKeeper.GetValidatorCurrentRewards(ctx, val.GetOperator()).Rewards) -} - -func TestAllocateTokensToManyValidators(t *testing.T) { - var ( - accountKeeper authkeeper.AccountKeeper - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &accountKeeper, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - // reset fee pool - distrKeeper.SetFeePool(ctx, disttypes.InitialFeePool()) - - addrs := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(1234)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addrs) - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - - // create validator with 50% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[0], valConsPk0, sdk.NewInt(100), true) - - // create second validator with 0% commission - tstaking.Commission = stakingtypes.NewCommissionRates(math.LegacyNewDec(0), math.LegacyNewDec(0), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[1], valConsPk1, sdk.NewInt(100), true) - - abciValA := abci.Validator{ - Address: valConsPk0.Address(), - Power: 100, - } - abciValB := abci.Validator{ - Address: valConsPk1.Address(), - Power: 100, - } - - // assert initial state: zero outstanding rewards, zero community pool, zero commission, zero current rewards - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[0]).Rewards.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[1]).Rewards.IsZero()) - assert.Assert(t, distrKeeper.GetFeePool(ctx).CommunityPool.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[1]).Commission.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorCurrentRewards(ctx, valAddrs[0]).Rewards.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorCurrentRewards(ctx, valAddrs[1]).Rewards.IsZero()) - - // allocate tokens as if both had voted and second was proposer - fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100))) - feeCollector := accountKeeper.GetModuleAccount(ctx, types.FeeCollectorName) - assert.Assert(t, feeCollector != nil) - - // fund fee collector - assert.NilError(t, banktestutil.FundModuleAccount(bankKeeper, ctx, feeCollector.GetName(), fees)) - - accountKeeper.SetAccount(ctx, feeCollector) - - votes := []abci.VoteInfo{ - { - Validator: abciValA, - SignedLastBlock: true, - }, - { - Validator: abciValB, - SignedLastBlock: true, - }, - } - distrKeeper.AllocateTokens(ctx, 200, votes) - - // 98 outstanding rewards (100 less 2 to community pool) - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[0]).Rewards) - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[1]).Rewards) - - // 2 community pool coins - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(2)}}, distrKeeper.GetFeePool(ctx).CommunityPool) - - // 50% commission for first proposer, (0.5 * 98%) * 100 / 2 = 23.25 - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(2450, 2)}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) - - // zero commission for second proposer - assert.Assert(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[1]).Commission.IsZero()) - - // just staking.proportional for first proposer less commission = (0.5 * 98%) * 100 / 2 = 24.50 - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(2450, 2)}}, distrKeeper.GetValidatorCurrentRewards(ctx, valAddrs[0]).Rewards) - - // proposer reward + staking.proportional for second proposer = (0.5 * (98%)) * 100 = 49 - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorCurrentRewards(ctx, valAddrs[1]).Rewards) -} - -func TestAllocateTokensTruncation(t *testing.T) { - var ( - accountKeeper authkeeper.AccountKeeper - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &accountKeeper, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - // reset fee pool - distrKeeper.SetFeePool(ctx, disttypes.InitialFeePool()) - - addrs := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 3, sdk.NewInt(1234)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addrs) - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - - // create validator with 10% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(1, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[0], valConsPk0, sdk.NewInt(110), true) - - // create second validator with 10% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(1, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[1], valConsPk1, sdk.NewInt(100), true) - - // create third validator with 10% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(1, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[2], valConsPk2, sdk.NewInt(100), true) - - abciValA := abci.Validator{ - Address: valConsPk0.Address(), - Power: 11, - } - abciValB := abci.Validator{ - Address: valConsPk1.Address(), - Power: 10, - } - abciValC := abci.Validator{ - Address: valConsPk2.Address(), - Power: 10, - } - - // assert initial state: zero outstanding rewards, zero community pool, zero commission, zero current rewards - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[0]).Rewards.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[1]).Rewards.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[1]).Rewards.IsZero()) - assert.Assert(t, distrKeeper.GetFeePool(ctx).CommunityPool.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[1]).Commission.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorCurrentRewards(ctx, valAddrs[0]).Rewards.IsZero()) - assert.Assert(t, distrKeeper.GetValidatorCurrentRewards(ctx, valAddrs[1]).Rewards.IsZero()) - - // allocate tokens as if both had voted and second was proposer - fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(634195840))) - - feeCollector := accountKeeper.GetModuleAccount(ctx, types.FeeCollectorName) - assert.Assert(t, feeCollector != nil) - - assert.NilError(t, banktestutil.FundModuleAccount(bankKeeper, ctx, feeCollector.GetName(), fees)) - - accountKeeper.SetAccount(ctx, feeCollector) - - votes := []abci.VoteInfo{ - { - Validator: abciValA, - SignedLastBlock: true, - }, - { - Validator: abciValB, - SignedLastBlock: true, - }, - { - Validator: abciValC, - SignedLastBlock: true, - }, - } - distrKeeper.AllocateTokens(ctx, 31, votes) - - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[0]).Rewards.IsValid()) - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[1]).Rewards.IsValid()) - assert.Assert(t, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[2]).Rewards.IsValid()) -} diff --git a/tests/integration/distribution/keeper/delegation_test.go b/tests/integration/distribution/keeper/delegation_test.go deleted file mode 100644 index dcb25cbf3fd8..000000000000 --- a/tests/integration/distribution/keeper/delegation_test.go +++ /dev/null @@ -1,820 +0,0 @@ -package keeper_test - -import ( - "testing" - - "cosmossdk.io/math" - cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" - "gotest.tools/v3/assert" - - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" - sdk "github.com/cosmos/cosmos-sdk/types" - authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" - bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" - banktestutil "github.com/cosmos/cosmos-sdk/x/bank/testutil" - "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - "github.com/cosmos/cosmos-sdk/x/distribution/testutil" - "github.com/cosmos/cosmos-sdk/x/staking" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" - stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" - stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" -) - -func TestCalculateRewardsBasic(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - distrKeeper.DeleteAllValidatorHistoricalRewards(ctx) - - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(1000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - - // create validator with 50% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[0], valConsPk0, sdk.NewInt(100), true) - - // end block to bond validator and start new block - staking.EndBlocker(ctx, stakingKeeper) - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - tstaking.Ctx = ctx - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - del := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // historical count should be 2 (once for validator init, once for delegation init) - assert.Equal(t, uint64(2), distrKeeper.GetValidatorHistoricalReferenceCount(ctx)) - - // end period - endingPeriod := distrKeeper.IncrementValidatorPeriod(ctx, val) - - // historical count should be 2 still - assert.Equal(t, uint64(2), distrKeeper.GetValidatorHistoricalReferenceCount(ctx)) - - // calculate delegation rewards - rewards := distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be zero - assert.Assert(t, rewards.IsZero()) - - // allocate some rewards - initial := int64(10) - tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial)}} - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // end period - endingPeriod = distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be half the tokens - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial / 2)}}, rewards) - - // commission should be the other half - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial / 2)}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) -} - -func TestCalculateRewardsAfterSlash(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(100000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - - // create validator with 50% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - valPower := int64(100) - tstaking.CreateValidatorWithValPower(valAddrs[0], valConsPk0, valPower, true) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - del := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // end period - endingPeriod := distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards - rewards := distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be zero - assert.Assert(t, rewards.IsZero()) - - // start out block height - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // slash the validator by 50% - stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1)) - - // retrieve validator - val = stakingKeeper.Validator(ctx, valAddrs[0]) - - // increase block height - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // allocate some rewards - initial := stakingKeeper.TokensFromConsensusPower(ctx, 10) - tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}} - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // end period - endingPeriod = distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be half the tokens - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial.QuoRaw(2))}}, rewards) - - // commission should be the other half - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial.QuoRaw(2))}}, - distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) -} - -func TestCalculateRewardsAfterManySlashes(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(100000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - - // create validator with 50% commission - valPower := int64(100) - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidatorWithValPower(valAddrs[0], valConsPk0, valPower, true) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - del := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // end period - endingPeriod := distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards - rewards := distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be zero - assert.Assert(t, rewards.IsZero()) - - // start out block height - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // slash the validator by 50% - stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1)) - - // fetch the validator again - val = stakingKeeper.Validator(ctx, valAddrs[0]) - - // increase block height - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // allocate some rewards - initial := stakingKeeper.TokensFromConsensusPower(ctx, 10) - tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}} - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // slash the validator by 50% again - stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower/2, sdk.NewDecWithPrec(5, 1)) - - // fetch the validator again - val = stakingKeeper.Validator(ctx, valAddrs[0]) - - // increase block height - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // end period - endingPeriod = distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be half the tokens - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}}, rewards) - - // commission should be the other half - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}}, - distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) -} - -func TestCalculateRewardsMultiDelegator(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(100000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - - // create validator with 50% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[0], valConsPk0, sdk.NewInt(100), true) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - del1 := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // allocate some rewards - initial := int64(20) - tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial)}} - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // second delegation - tstaking.Ctx = ctx - tstaking.Delegate(sdk.AccAddress(valAddrs[1]), valAddrs[0], sdk.NewInt(100)) - del2 := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[1]), valAddrs[0]) - - // fetch updated validator - val = stakingKeeper.Validator(ctx, valAddrs[0]) - - // end block - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // end period - endingPeriod := distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards for del1 - rewards := distrKeeper.CalculateDelegationRewards(ctx, val, del1, endingPeriod) - - // rewards for del1 should be 3/4 initial - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial * 3 / 4)}}, rewards) - - // calculate delegation rewards for del2 - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del2, endingPeriod) - - // rewards for del2 should be 1/4 initial - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial * 1 / 4)}}, rewards) - - // commission should be equal to initial (50% twice) - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial)}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) -} - -func TestWithdrawDelegationRewardsBasic(t *testing.T) { - var ( - accountKeeper authkeeper.AccountKeeper - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &accountKeeper, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - distrKeeper.DeleteAllValidatorHistoricalRewards(ctx) - - balancePower := int64(1000) - balanceTokens := stakingKeeper.TokensFromConsensusPower(ctx, balancePower) - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 1, sdk.NewInt(1000000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - - // set module account coins - distrAcc := distrKeeper.GetDistributionAccount(ctx) - assert.NilError(t, banktestutil.FundModuleAccount(bankKeeper, ctx, distrAcc.GetName(), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, balanceTokens)))) - accountKeeper.SetModuleAccount(ctx, distrAcc) - - // create validator with 50% commission - power := int64(100) - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - valTokens := tstaking.CreateValidatorWithValPower(valAddrs[0], valConsPk0, power, true) - - // assert correct initial balance - expTokens := balanceTokens.Sub(valTokens) - assert.DeepEqual(t, - sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, expTokens)}, - bankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0])), - ) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - - // allocate some rewards - initial := stakingKeeper.TokensFromConsensusPower(ctx, 10) - tokens := sdk.DecCoins{sdk.NewDecCoin(sdk.DefaultBondDenom, initial)} - - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // historical count should be 2 (initial + latest for delegation) - assert.Equal(t, uint64(2), distrKeeper.GetValidatorHistoricalReferenceCount(ctx)) - - // withdraw rewards - _, err = distrKeeper.WithdrawDelegationRewards(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - assert.Assert(t, err == nil) - - // historical count should still be 2 (added one record, cleared one) - assert.Equal(t, uint64(2), distrKeeper.GetValidatorHistoricalReferenceCount(ctx)) - - // assert correct balance - exp := balanceTokens.Sub(valTokens).Add(initial.QuoRaw(2)) - assert.DeepEqual(t, - sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, exp)}, - bankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0])), - ) - - // withdraw commission - _, err = distrKeeper.WithdrawValidatorCommission(ctx, valAddrs[0]) - assert.Assert(t, err == nil) - - // assert correct balance - exp = balanceTokens.Sub(valTokens).Add(initial) - assert.DeepEqual(t, - sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, exp)}, - bankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0])), - ) -} - -func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 1, sdk.NewInt(1000000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - - // create validator with 50% commission - valPower := int64(100) - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidatorWithValPower(valAddrs[0], valConsPk0, valPower, true) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - del := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // end period - endingPeriod := distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards - rewards := distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be zero - assert.Assert(t, rewards.IsZero()) - - // start out block height - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // allocate some rewards - initial := sdk.NewDecFromInt(stakingKeeper.TokensFromConsensusPower(ctx, 10)) - tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}} - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // slash the validator by 50% - stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1)) - - // slash the validator by 50% again - stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower/2, sdk.NewDecWithPrec(5, 1)) - - // fetch the validator again - val = stakingKeeper.Validator(ctx, valAddrs[0]) - - // increase block height - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // end period - endingPeriod = distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) - - // rewards should be half the tokens - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}, rewards) - - // commission should be the other half - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) -} - -func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(1000000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - - // create validator with 50% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - valPower := int64(100) - tstaking.CreateValidatorWithValPower(valAddrs[0], valConsPk0, valPower, true) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - del1 := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // allocate some rewards - initial := sdk.NewDecFromInt(stakingKeeper.TokensFromConsensusPower(ctx, 30)) - tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}} - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // slash the validator - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1)) - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // second delegation - tstaking.DelegateWithPower(sdk.AccAddress(valAddrs[1]), valAddrs[0], 100) - - del2 := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[1]), valAddrs[0]) - - // end block - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // slash the validator again - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1)) - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) - - // fetch updated validator - val = stakingKeeper.Validator(ctx, valAddrs[0]) - - // end period - endingPeriod := distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards for del1 - rewards := distrKeeper.CalculateDelegationRewards(ctx, val, del1, endingPeriod) - - // rewards for del1 should be 2/3 initial (half initial first period, 1/6 initial second period) - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.QuoInt64(2).Add(initial.QuoInt64(6))}}, rewards) - - // calculate delegation rewards for del2 - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del2, endingPeriod) - - // rewards for del2 should be initial / 3 - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.QuoInt64(3)}}, rewards) - - // commission should be equal to initial (twice 50% commission, unaffected by slashing) - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) -} - -func TestCalculateRewardsMultiDelegatorMultWithdraw(t *testing.T) { - var ( - accountKeeper authkeeper.AccountKeeper - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &accountKeeper, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - distrKeeper.DeleteAllValidatorHistoricalRewards(ctx) - - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(1000000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - initial := int64(20) - - // set module account coins - distrAcc := distrKeeper.GetDistributionAccount(ctx) - assert.NilError(t, banktestutil.FundModuleAccount(bankKeeper, ctx, distrAcc.GetName(), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000))))) - accountKeeper.SetModuleAccount(ctx, distrAcc) - - tokens := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyNewDec(initial))} - - // create validator with 50% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[0], valConsPk0, sdk.NewInt(100), true) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator and delegation - val := stakingKeeper.Validator(ctx, valAddrs[0]) - del1 := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // allocate some rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // historical count should be 2 (validator init, delegation init) - assert.Equal(t, uint64(2), distrKeeper.GetValidatorHistoricalReferenceCount(ctx)) - - // second delegation - tstaking.Delegate(sdk.AccAddress(valAddrs[1]), valAddrs[0], sdk.NewInt(100)) - - // historical count should be 3 (second delegation init) - assert.Equal(t, uint64(3), distrKeeper.GetValidatorHistoricalReferenceCount(ctx)) - - // fetch updated validator - val = stakingKeeper.Validator(ctx, valAddrs[0]) - del2 := stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[1]), valAddrs[0]) - - // end block - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // first delegator withdraws - _, err = distrKeeper.WithdrawDelegationRewards(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - assert.NilError(t, err) - - // second delegator withdraws - _, err = distrKeeper.WithdrawDelegationRewards(ctx, sdk.AccAddress(valAddrs[1]), valAddrs[0]) - assert.NilError(t, err) - - // historical count should be 3 (validator init + two delegations) - assert.Equal(t, uint64(3), distrKeeper.GetValidatorHistoricalReferenceCount(ctx)) - - // validator withdraws commission - _, err = distrKeeper.WithdrawValidatorCommission(ctx, valAddrs[0]) - assert.NilError(t, err) - - // end period - endingPeriod := distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards for del1 - rewards := distrKeeper.CalculateDelegationRewards(ctx, val, del1, endingPeriod) - - // rewards for del1 should be zero - assert.Assert(t, rewards.IsZero()) - - // calculate delegation rewards for del2 - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del2, endingPeriod) - - // rewards for del2 should be zero - assert.Assert(t, rewards.IsZero()) - - // commission should be zero - assert.Assert(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission.IsZero()) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // first delegator withdraws again - _, err = distrKeeper.WithdrawDelegationRewards(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - assert.NilError(t, err) - - // end period - endingPeriod = distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards for del1 - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del1, endingPeriod) - - // rewards for del1 should be zero - assert.Assert(t, rewards.IsZero()) - - // calculate delegation rewards for del2 - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del2, endingPeriod) - - // rewards for del2 should be 1/4 initial - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial / 4)}}, rewards) - - // commission should be half initial - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial / 2)}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // withdraw commission - _, err = distrKeeper.WithdrawValidatorCommission(ctx, valAddrs[0]) - assert.NilError(t, err) - - // end period - endingPeriod = distrKeeper.IncrementValidatorPeriod(ctx, val) - - // calculate delegation rewards for del1 - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del1, endingPeriod) - - // rewards for del1 should be 1/4 initial - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial / 4)}}, rewards) - - // calculate delegation rewards for del2 - rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del2, endingPeriod) - - // rewards for del2 should be 1/2 initial - assert.DeepEqual(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial / 2)}}, rewards) - - // commission should be zero - assert.Assert(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission.IsZero()) -} - -func Test100PercentCommissionReward(t *testing.T) { - var ( - accountKeeper authkeeper.AccountKeeper - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &accountKeeper, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - tstaking := stakingtestutil.NewHelper(t, ctx, stakingKeeper) - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(1000000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - initial := int64(20) - - // set module account coins - distrAcc := distrKeeper.GetDistributionAccount(ctx) - assert.NilError(t, banktestutil.FundModuleAccount(bankKeeper, ctx, distrAcc.GetName(), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000))))) - accountKeeper.SetModuleAccount(ctx, distrAcc) - - tokens := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyNewDec(initial))} - - // create validator with 100% commission - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(10, 1), sdk.NewDecWithPrec(10, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[0], valConsPk0, sdk.NewInt(100), true) - stakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - - // end block to bond validator - staking.EndBlocker(ctx, stakingKeeper) - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // fetch validator - val := stakingKeeper.Validator(ctx, valAddrs[0]) - - // allocate some rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // end block - staking.EndBlocker(ctx, stakingKeeper) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - // next block - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) - - // allocate some more rewards - distrKeeper.AllocateTokensToValidator(ctx, val, tokens) - - rewards, err := distrKeeper.WithdrawDelegationRewards(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) - assert.NilError(t, err) - - zeroRewards := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, math.ZeroInt())} - assert.Assert(t, rewards.Equal(zeroRewards)) - - events := ctx.EventManager().Events() - lastEvent := events[len(events)-1] - - var hasValue bool - for _, attr := range lastEvent.Attributes { - if attr.Key == "amount" && attr.Value == "0stake" { - hasValue = true - } - } - assert.Assert(t, hasValue) -} diff --git a/tests/integration/distribution/keeper/keeper_test.go b/tests/integration/distribution/keeper/keeper_test.go deleted file mode 100644 index 3db593890a30..000000000000 --- a/tests/integration/distribution/keeper/keeper_test.go +++ /dev/null @@ -1,185 +0,0 @@ -package keeper_test - -import ( - "fmt" - "testing" - - "cosmossdk.io/math" - cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" - "gotest.tools/v3/assert" - - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" - sdk "github.com/cosmos/cosmos-sdk/types" - authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" - bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" - banktestutil "github.com/cosmos/cosmos-sdk/x/bank/testutil" - "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - "github.com/cosmos/cosmos-sdk/x/distribution/testutil" - "github.com/cosmos/cosmos-sdk/x/distribution/types" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" -) - -func TestSetWithdrawAddr(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(1000000000)) - - params := distrKeeper.GetParams(ctx) - params.WithdrawAddrEnabled = false - assert.NilError(t, distrKeeper.SetParams(ctx, params)) - - err = distrKeeper.SetWithdrawAddr(ctx, addr[0], addr[1]) - assert.Assert(t, err != nil) - - params.WithdrawAddrEnabled = true - assert.NilError(t, distrKeeper.SetParams(ctx, params)) - - err = distrKeeper.SetWithdrawAddr(ctx, addr[0], addr[1]) - assert.NilError(t, err) - - assert.ErrorContains(t, distrKeeper.SetWithdrawAddr(ctx, addr[0], distrAcc.GetAddress()), fmt.Sprintf("%s is not allowed to receive external funds: unauthorized", distrAcc.GetAddress())) -} - -func TestWithdrawValidatorCommission(t *testing.T) { - var ( - accountKeeper authkeeper.AccountKeeper - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &accountKeeper, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - valCommission := sdk.DecCoins{ - sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5).Quo(math.LegacyNewDec(4))), - sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(3).Quo(math.LegacyNewDec(2))), - } - - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 1, sdk.NewInt(1000000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - - // set module account coins - distrAcc := distrKeeper.GetDistributionAccount(ctx) - coins := sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(2)), sdk.NewCoin("stake", sdk.NewInt(2))) - assert.NilError(t, banktestutil.FundModuleAccount(bankKeeper, ctx, distrAcc.GetName(), coins)) - - accountKeeper.SetModuleAccount(ctx, distrAcc) - - // check initial balance - balance := bankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0])) - expTokens := stakingKeeper.TokensFromConsensusPower(ctx, 1000) - expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) - assert.DeepEqual(t, expCoins, balance) - - // set outstanding rewards - distrKeeper.SetValidatorOutstandingRewards(ctx, valAddrs[0], types.ValidatorOutstandingRewards{Rewards: valCommission}) - - // set commission - distrKeeper.SetValidatorAccumulatedCommission(ctx, valAddrs[0], types.ValidatorAccumulatedCommission{Commission: valCommission}) - - // withdraw commission - _, err = distrKeeper.WithdrawValidatorCommission(ctx, valAddrs[0]) - assert.NilError(t, err) - - // check balance increase - balance = bankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0])) - assert.DeepEqual(t, sdk.NewCoins( - sdk.NewCoin("mytoken", sdk.NewInt(1)), - sdk.NewCoin("stake", expTokens.AddRaw(1)), - ), balance) - - // check remainder - remainder := distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddrs[0]).Commission - assert.DeepEqual(t, sdk.DecCoins{ - sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(1).Quo(math.LegacyNewDec(4))), - sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(1).Quo(math.LegacyNewDec(2))), - }, remainder) -} - -func TestGetTotalRewards(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - valCommission := sdk.DecCoins{ - sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5).Quo(math.LegacyNewDec(4))), - sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(3).Quo(math.LegacyNewDec(2))), - } - - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(1000000000)) - valAddrs := simtestutil.ConvertAddrsToValAddrs(addr) - - distrKeeper.SetValidatorOutstandingRewards(ctx, valAddrs[0], types.ValidatorOutstandingRewards{Rewards: valCommission}) - distrKeeper.SetValidatorOutstandingRewards(ctx, valAddrs[1], types.ValidatorOutstandingRewards{Rewards: valCommission}) - - expectedRewards := valCommission.MulDec(math.LegacyNewDec(2)) - totalRewards := distrKeeper.GetTotalRewards(ctx) - - assert.DeepEqual(t, expectedRewards, totalRewards) -} - -func TestFundCommunityPool(t *testing.T) { - var ( - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - ) - - app, err := simtestutil.Setup(testutil.AppConfig, - &bankKeeper, - &distrKeeper, - &stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - // reset fee pool - distrKeeper.SetFeePool(ctx, types.InitialFeePool()) - - addr := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 2, math.ZeroInt()) - - amount := sdk.NewCoins(sdk.NewInt64Coin("stake", 100)) - assert.NilError(t, banktestutil.FundAccount(bankKeeper, ctx, addr[0], amount)) - - initPool := distrKeeper.GetFeePool(ctx) - assert.Assert(t, initPool.CommunityPool.Empty()) - - err = distrKeeper.FundCommunityPool(ctx, amount, addr[0]) - assert.NilError(t, err) - - assert.DeepEqual(t, initPool.CommunityPool.Add(sdk.NewDecCoinsFromCoins(amount...)...), distrKeeper.GetFeePool(ctx).CommunityPool) - assert.Assert(t, bankKeeper.GetAllBalances(ctx, addr[0]).Empty()) -} diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go deleted file mode 100644 index 4d0411ed00ce..000000000000 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ /dev/null @@ -1,261 +0,0 @@ -package keeper_test - -import ( - "testing" - - "cosmossdk.io/math" - "gotest.tools/v3/assert" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/distribution/types" - minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" - stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" - stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" -) - -func TestMsgUpdateParams(t *testing.T) { - t.Parallel() - f := initFixture(t) - - // default params - communityTax := sdk.NewDecWithPrec(2, 2) // 2% - withdrawAddrEnabled := true - - testCases := []struct { - name string - input *types.MsgUpdateParams - expErr bool - expErrMsg string - }{ - { - name: "invalid authority", - input: &types.MsgUpdateParams{ - Authority: "invalid", - Params: types.Params{ - CommunityTax: sdk.NewDecWithPrec(2, 0), - WithdrawAddrEnabled: withdrawAddrEnabled, - BaseProposerReward: sdk.ZeroDec(), - BonusProposerReward: sdk.ZeroDec(), - }, - }, - expErr: true, - expErrMsg: "invalid authority", - }, - { - name: "community tax > 1", - input: &types.MsgUpdateParams{ - Authority: f.distrKeeper.GetAuthority(), - Params: types.Params{ - CommunityTax: sdk.NewDecWithPrec(2, 0), - WithdrawAddrEnabled: withdrawAddrEnabled, - BaseProposerReward: sdk.ZeroDec(), - BonusProposerReward: sdk.ZeroDec(), - }, - }, - expErr: true, - expErrMsg: "community tax should be non-negative and less than one", - }, - { - name: "negative community tax", - input: &types.MsgUpdateParams{ - Authority: f.distrKeeper.GetAuthority(), - Params: types.Params{ - CommunityTax: sdk.NewDecWithPrec(-2, 1), - WithdrawAddrEnabled: withdrawAddrEnabled, - BaseProposerReward: sdk.ZeroDec(), - BonusProposerReward: sdk.ZeroDec(), - }, - }, - expErr: true, - expErrMsg: "community tax should be non-negative and less than one", - }, - { - name: "base proposer reward set", - input: &types.MsgUpdateParams{ - Authority: f.distrKeeper.GetAuthority(), - Params: types.Params{ - CommunityTax: communityTax, - BaseProposerReward: sdk.NewDecWithPrec(1, 2), - BonusProposerReward: sdk.ZeroDec(), - WithdrawAddrEnabled: withdrawAddrEnabled, - }, - }, - expErr: true, - expErrMsg: "cannot update base or bonus proposer reward because these are deprecated fields: invalid request", - }, - { - name: "bonus proposer reward set", - input: &types.MsgUpdateParams{ - Authority: f.distrKeeper.GetAuthority(), - Params: types.Params{ - CommunityTax: communityTax, - BaseProposerReward: sdk.ZeroDec(), - BonusProposerReward: sdk.NewDecWithPrec(1, 2), - WithdrawAddrEnabled: withdrawAddrEnabled, - }, - }, - expErr: true, - expErrMsg: "cannot update base or bonus proposer reward because these are deprecated fields: invalid request", - }, - { - name: "all good", - input: &types.MsgUpdateParams{ - Authority: f.distrKeeper.GetAuthority(), - Params: types.Params{ - CommunityTax: communityTax, - BaseProposerReward: sdk.ZeroDec(), - BonusProposerReward: sdk.ZeroDec(), - WithdrawAddrEnabled: withdrawAddrEnabled, - }, - }, - expErr: false, - }, - } - - for _, tc := range testCases { - tc := tc - t.Run(tc.name, func(t *testing.T) { - _, err := f.msgServer.UpdateParams(f.ctx, tc.input) - - if tc.expErr { - assert.ErrorContains(t, err, tc.expErrMsg) - } else { - assert.NilError(t, err) - } - }) - } -} - -func TestCommunityPoolSpend(t *testing.T) { - t.Parallel() - f := initFixture(t) - - recipient := sdk.AccAddress([]byte("addr1_______________")) - - testCases := []struct { - name string - input *types.MsgCommunityPoolSpend - expErr bool - expErrMsg string - }{ - { - name: "invalid authority", - input: &types.MsgCommunityPoolSpend{ - Authority: "invalid", - Recipient: recipient.String(), - Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), - }, - expErr: true, - expErrMsg: "invalid authority", - }, - { - name: "invalid recipient", - input: &types.MsgCommunityPoolSpend{ - Authority: f.distrKeeper.GetAuthority(), - Recipient: "invalid", - Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), - }, - expErr: true, - expErrMsg: "decoding bech32 failed", - }, - { - name: "valid message", - input: &types.MsgCommunityPoolSpend{ - Authority: f.distrKeeper.GetAuthority(), - Recipient: recipient.String(), - Amount: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))), - }, - expErr: false, - }, - } - - for _, tc := range testCases { - tc := tc - t.Run(tc.name, func(t *testing.T) { - _, err := f.msgServer.CommunityPoolSpend(f.ctx, tc.input) - - if tc.expErr { - assert.ErrorContains(t, err, tc.expErrMsg) - } else { - assert.NilError(t, err) - r, err := sdk.AccAddressFromBech32(tc.input.Recipient) - assert.NilError(t, err) - - b := f.bankKeeper.GetAllBalances(f.ctx, r) - - assert.Assert(t, b.IsZero() == false) - } - }) - } -} - -func TestMsgDepositValidatorRewardsPool(t *testing.T) { - t.Parallel() - f := initFixture(t) - - tstaking := stakingtestutil.NewHelper(t, f.ctx, f.stakingKeeper) - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(f.valAddrs[1], valConsPk0, sdk.NewInt(100), true) - - // mint a non-staking token and send to an account - amt := sdk.NewCoins(sdk.NewInt64Coin("foo", 500)) - f.bankKeeper.MintCoins(f.ctx, minttypes.ModuleName, amt) - f.bankKeeper.SendCoinsFromModuleToAccount(f.ctx, minttypes.ModuleName, f.addrs[0], amt) - - testCases := []struct { - name string - input *types.MsgDepositValidatorRewardsPool - expErr bool - expErrMsg string - }{ - { - name: "happy path (staking token)", - input: &types.MsgDepositValidatorRewardsPool{ - Authority: f.addrs[0].String(), - ValidatorAddress: f.valAddrs[1].String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(f.ctx), sdk.NewInt(100))), - }, - }, - { - name: "happy path (non-staking token)", - input: &types.MsgDepositValidatorRewardsPool{ - Authority: f.addrs[0].String(), - ValidatorAddress: f.valAddrs[1].String(), - Amount: amt, - }, - }, - { - name: "invalid validator", - input: &types.MsgDepositValidatorRewardsPool{ - Authority: f.addrs[0].String(), - ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(f.ctx), sdk.NewInt(100))), - }, - expErr: true, - expErrMsg: "validator does not exist", - }, - } - - for _, tc := range testCases { - tc := tc - t.Run(tc.name, func(t *testing.T) { - _, err := f.msgServer.DepositValidatorRewardsPool(f.ctx, tc.input) - - if tc.expErr { - assert.ErrorContains(t, err, tc.expErrMsg) - } else { - assert.NilError(t, err) - - valAddr, err := sdk.ValAddressFromBech32(tc.input.ValidatorAddress) - assert.NilError(t, err) - - // check validator outstanding rewards - outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(f.ctx, valAddr) - for _, c := range tc.input.Amount { - x := outstandingRewards.Rewards.AmountOf(c.Denom) - assert.DeepEqual(t, x, sdk.NewDecFromInt(c.Amount)) - } - } - }) - } -} diff --git a/x/distribution/keeper/integration_test.go b/x/distribution/keeper/msg_server_test.go similarity index 99% rename from x/distribution/keeper/integration_test.go rename to x/distribution/keeper/msg_server_test.go index e55862e9312a..e2ac6d776e44 100644 --- a/x/distribution/keeper/integration_test.go +++ b/x/distribution/keeper/msg_server_test.go @@ -91,7 +91,7 @@ func initFixture(t assert.TestingT) *fixture { return f } -func TestWithdrawDelegatorReward(t *testing.T) { +func TestMsgWithdrawDelegatorReward(t *testing.T) { t.Parallel() f := initFixture(t) From 570b51085c1f0a104b0e5926fcf524202035460a Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 4 Apr 2023 13:15:43 +0530 Subject: [PATCH 13/30] add grpc query tests --- x/distribution/keeper/grpc_query_test.go | 507 +++++++++++++++++++++++ 1 file changed, 507 insertions(+) create mode 100644 x/distribution/keeper/grpc_query_test.go diff --git a/x/distribution/keeper/grpc_query_test.go b/x/distribution/keeper/grpc_query_test.go new file mode 100644 index 000000000000..b4afd25a04f5 --- /dev/null +++ b/x/distribution/keeper/grpc_query_test.go @@ -0,0 +1,507 @@ +package keeper_test + +import ( + "fmt" + "testing" + + "cosmossdk.io/log" + "cosmossdk.io/math" + "gotest.tools/v3/assert" + + "github.com/cosmos/cosmos-sdk/testutil/integration" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/cosmos/cosmos-sdk/x/auth" + authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/cosmos/cosmos-sdk/x/distribution" + distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" + "github.com/cosmos/cosmos-sdk/x/distribution/types" + "github.com/cosmos/cosmos-sdk/x/staking" +) + +func TestGRPCParams(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + f.distrKeeper.SetParams(integrationApp.SDKContext(), types.DefaultParams()) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + var ( + params types.Params + expParams types.Params + ) + + testCases := []struct { + name string + malleate func() + msg *types.QueryParamsRequest + expErrMsg string + }{ + { + name: "empty params request", + malleate: func() { + expParams = types.DefaultParams() + }, + msg: &types.QueryParamsRequest{}, + }, + { + name: "valid request", + malleate: func() { + params = types.Params{ + CommunityTax: sdk.NewDecWithPrec(3, 1), + BaseProposerReward: sdk.ZeroDec(), + BonusProposerReward: sdk.ZeroDec(), + WithdrawAddrEnabled: true, + } + + assert.NilError(t, f.distrKeeper.SetParams(integrationApp.SDKContext(), params)) + expParams = params + }, + msg: &types.QueryParamsRequest{}, + }, + } + for _, testCase := range testCases { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + tc.malleate() + + paramsRes, err := queryClient.Params(integrationApp.SDKContext(), tc.msg) + assert.NilError(t, err) + assert.Assert(t, paramsRes != nil) + assert.DeepEqual(t, paramsRes.Params, expParams) + }) + + } +} + +func TestGRPCValidatorOutstandingRewards(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + valCommission := sdk.DecCoins{ + sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5000)), + sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(300)), + } + + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + + // set outstanding rewards + f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) + rewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr) + + testCases := []struct { + name string + msg *types.QueryValidatorOutstandingRewardsRequest + expPass bool + expErrMsg string + }{ + { + name: "empty request", + msg: &types.QueryValidatorOutstandingRewardsRequest{}, + expPass: false, + expErrMsg: "empty validator address", + }, + { + name: "valid request", + msg: &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: valAddr.String()}, + expPass: true, + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(integrationApp.SDKContext(), tc.msg) + + if tc.expPass { + assert.NilError(t, err) + assert.DeepEqual(t, rewards, validatorOutstandingRewards.Rewards) + assert.DeepEqual(t, valCommission, validatorOutstandingRewards.Rewards.Rewards) + } else { + assert.ErrorContains(t, err, tc.expErrMsg) + assert.Assert(t, validatorOutstandingRewards == nil) + } + }) + } +} + +func TestGRPCValidatorCommission(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + + commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} + f.distrKeeper.SetValidatorAccumulatedCommission(integrationApp.SDKContext(), valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) + + testCases := []struct { + name string + msg *types.QueryValidatorCommissionRequest + expPass bool + expErrMsg string + }{ + { + name: "empty request", + msg: &types.QueryValidatorCommissionRequest{}, + expPass: false, + expErrMsg: "empty validator address", + }, + { + name: "valid request", + msg: &types.QueryValidatorCommissionRequest{ValidatorAddress: valAddr.String()}, + expPass: true, + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + commissionRes, err := queryClient.ValidatorCommission(integrationApp.SDKContext(), tc.msg) + + if tc.expPass { + assert.NilError(t, err) + assert.Assert(t, commissionRes != nil) + assert.DeepEqual(t, commissionRes.Commission.Commission, commission) + } else { + assert.ErrorContains(t, err, tc.expErrMsg) + assert.Assert(t, commissionRes == nil) + } + }) + } +} + +func TestGRPCValidatorSlashes(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + addr2 := sdk.AccAddress(PKS[1].Address()) + valAddr2 := sdk.ValAddress(addr2) + + slashes := []types.ValidatorSlashEvent{ + types.NewValidatorSlashEvent(3, sdk.NewDecWithPrec(5, 1)), + types.NewValidatorSlashEvent(5, sdk.NewDecWithPrec(5, 1)), + types.NewValidatorSlashEvent(7, sdk.NewDecWithPrec(5, 1)), + types.NewValidatorSlashEvent(9, sdk.NewDecWithPrec(5, 1)), + } + + for i, slash := range slashes { + f.distrKeeper.SetValidatorSlashEvent(integrationApp.SDKContext(), valAddr, uint64(i+2), 0, slash) + } + + var ( + req *types.QueryValidatorSlashesRequest + expRes *types.QueryValidatorSlashesResponse + ) + + testCases := []struct { + name string + malleate func() + expPass bool + expErrMsg string + }{ + { + name: "empty request", + malleate: func() { + req = &types.QueryValidatorSlashesRequest{} + expRes = &types.QueryValidatorSlashesResponse{} + }, + expPass: false, + expErrMsg: "empty validator address", + }, + { + name: "Ending height lesser than start height request", + malleate: func() { + req = &types.QueryValidatorSlashesRequest{ + ValidatorAddress: valAddr2.String(), + StartingHeight: 10, + EndingHeight: 1, + } + expRes = &types.QueryValidatorSlashesResponse{Pagination: &query.PageResponse{}} + }, + expPass: false, + expErrMsg: "starting height greater than ending height", + }, + { + name: "no slash event validator request", + malleate: func() { + req = &types.QueryValidatorSlashesRequest{ + ValidatorAddress: valAddr2.String(), + StartingHeight: 1, + EndingHeight: 10, + } + expRes = &types.QueryValidatorSlashesResponse{Pagination: &query.PageResponse{}} + }, + expPass: true, + }, + { + name: "request slashes with offset 2 and limit 2", + malleate: func() { + pageReq := &query.PageRequest{ + Offset: 2, + Limit: 2, + } + + req = &types.QueryValidatorSlashesRequest{ + ValidatorAddress: valAddr.String(), + StartingHeight: 1, + EndingHeight: 10, + Pagination: pageReq, + } + + expRes = &types.QueryValidatorSlashesResponse{ + Slashes: slashes[2:], + } + }, + expPass: true, + }, + { + name: "request slashes with page limit 3 and count total", + malleate: func() { + pageReq := &query.PageRequest{ + Limit: 3, + CountTotal: true, + } + + req = &types.QueryValidatorSlashesRequest{ + ValidatorAddress: valAddr.String(), + StartingHeight: 1, + EndingHeight: 10, + Pagination: pageReq, + } + + expRes = &types.QueryValidatorSlashesResponse{ + Slashes: slashes[:3], + } + }, + expPass: true, + }, + { + name: "request slashes with page limit 4 and count total", + malleate: func() { + pageReq := &query.PageRequest{ + Limit: 4, + CountTotal: true, + } + + req = &types.QueryValidatorSlashesRequest{ + ValidatorAddress: valAddr.String(), + StartingHeight: 1, + EndingHeight: 10, + Pagination: pageReq, + } + + expRes = &types.QueryValidatorSlashesResponse{ + Slashes: slashes[:4], + } + }, + expPass: true, + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + tc.malleate() + + slashesRes, err := queryClient.ValidatorSlashes(integrationApp.SDKContext(), req) + + if tc.expPass { + assert.NilError(t, err) + assert.DeepEqual(t, expRes.GetSlashes(), slashesRes.GetSlashes()) + } else { + assert.ErrorContains(t, err, tc.expErrMsg) + assert.Assert(t, slashesRes == nil) + } + }) + } +} + +func TestGRPCDelegatorWithdrawAddress(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + + f.distrKeeper.SetParams(integrationApp.SDKContext(), types.DefaultParams()) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + addr := sdk.AccAddress(PKS[0].Address()) + addr2 := sdk.AccAddress(PKS[1].Address()) + + err := f.distrKeeper.SetWithdrawAddr(integrationApp.SDKContext(), addr, addr2) + assert.Assert(t, err == nil) + + testCases := []struct { + name string + msg *types.QueryDelegatorWithdrawAddressRequest + expPass bool + expErrMsg string + }{ + { + name: "empty request", + msg: &types.QueryDelegatorWithdrawAddressRequest{}, + expPass: false, + expErrMsg: "empty delegator address", + }, + { + name: "valid request", + msg: &types.QueryDelegatorWithdrawAddressRequest{DelegatorAddress: addr.String()}, + expPass: true, + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + withdrawAddress, err := queryClient.DelegatorWithdrawAddress(integrationApp.SDKContext(), tc.msg) + + if tc.expPass { + assert.NilError(t, err) + assert.Equal(t, withdrawAddress.WithdrawAddress, addr2.String()) + } else { + assert.ErrorContains(t, err, tc.expErrMsg) + assert.Assert(t, withdrawAddress == nil) + } + }) + } +} + +func TestGRPCCommunityPool(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + + f.distrKeeper.SetFeePool(integrationApp.SDKContext(), types.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(0)}), + }) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + addr := sdk.AccAddress(PKS[0].Address()) + + var ( + req *types.QueryCommunityPoolRequest + expPool *types.QueryCommunityPoolResponse + ) + + testCases := []struct { + name string + malleate func() + }{ + { + name: "valid request empty community pool", + malleate: func() { + req = &types.QueryCommunityPoolRequest{} + expPool = &types.QueryCommunityPoolResponse{} + }, + }, + { + name: "valid request", + malleate: func() { + amount := sdk.NewCoins(sdk.NewInt64Coin("stake", 100)) + assert.NilError(t, f.bankKeeper.MintCoins(integrationApp.SDKContext(), types.ModuleName, amount)) + assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), types.ModuleName, addr, amount)) + + err := f.distrKeeper.FundCommunityPool(integrationApp.SDKContext(), amount, addr) + assert.Assert(t, err == nil) + req = &types.QueryCommunityPoolRequest{} + + expPool = &types.QueryCommunityPoolResponse{Pool: sdk.NewDecCoinsFromCoins(amount...)} + }, + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + testCase.malleate() + + pool, err := queryClient.CommunityPool(integrationApp.SDKContext(), req) + + assert.NilError(t, err) + assert.DeepEqual(t, expPool, pool) + }) + } +} From 4d008a8fac4776909ca4a30df30ab9a1ce14298f Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 10 Apr 2023 11:51:10 +0530 Subject: [PATCH 14/30] add one more test --- x/distribution/keeper/grpc_query_test.go | 139 ++++++++++++++++++++++- 1 file changed, 137 insertions(+), 2 deletions(-) diff --git a/x/distribution/keeper/grpc_query_test.go b/x/distribution/keeper/grpc_query_test.go index b4afd25a04f5..494c994d4383 100644 --- a/x/distribution/keeper/grpc_query_test.go +++ b/x/distribution/keeper/grpc_query_test.go @@ -18,6 +18,8 @@ import ( distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/staking" + stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) func TestGRPCParams(t *testing.T) { @@ -449,7 +451,7 @@ func TestGRPCCommunityPool(t *testing.T) { integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) f.distrKeeper.SetFeePool(integrationApp.SDKContext(), types.FeePool{ - CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(0)}), + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(0)}), }) // Register MsgServer and QueryServer @@ -480,7 +482,7 @@ func TestGRPCCommunityPool(t *testing.T) { { name: "valid request", malleate: func() { - amount := sdk.NewCoins(sdk.NewInt64Coin("stake", 100)) + amount := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 100)) assert.NilError(t, f.bankKeeper.MintCoins(integrationApp.SDKContext(), types.ModuleName, amount)) assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), types.ModuleName, addr, amount)) @@ -505,3 +507,136 @@ func TestGRPCCommunityPool(t *testing.T) { }) } } + +func TestGRPCDelegationRewards(t *testing.T) { + t.Parallel() + f := initFixture(t) + + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + + f.distrKeeper.SetFeePool(integrationApp.SDKContext(), types.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(1000)}), + }) + + // set module account coins + initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) + f.bankKeeper.MintCoins(integrationApp.SDKContext(), types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + // Set default staking params + f.stakingKeeper.SetParams(integrationApp.SDKContext(), stakingtypes.DefaultParams()) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + addr2 := sdk.AccAddress(PKS[1].Address()) + valAddr2 := sdk.ValAddress(addr2) + delAddr := sdk.AccAddress(PKS[2].Address()) + + // send funds to val addr + funds := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + + initialStake := int64(10) + tstaking := stakingtestutil.NewHelper(t, integrationApp.SDKContext(), f.stakingKeeper) + tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) + tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) + + val, found := f.stakingKeeper.GetValidator(integrationApp.SDKContext(), valAddr) + assert.Assert(t, found) + + // setup delegation + delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) + validator, issuedShares := val.AddTokensFromDel(delTokens) + delegation := stakingtypes.NewDelegation(delAddr, valAddr, issuedShares) + f.stakingKeeper.SetDelegation(integrationApp.SDKContext(), delegation) + f.distrKeeper.SetDelegatorStartingInfo(integrationApp.SDKContext(), validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) + + // setup validator rewards + decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())} + historicalRewards := types.NewValidatorHistoricalRewards(decCoins, 2) + f.distrKeeper.SetValidatorHistoricalRewards(integrationApp.SDKContext(), validator.GetOperator(), 2, historicalRewards) + // setup current rewards and outstanding rewards + currentRewards := types.NewValidatorCurrentRewards(decCoins, 3) + f.distrKeeper.SetValidatorCurrentRewards(integrationApp.SDKContext(), valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) + + expRes := &types.QueryDelegationRewardsResponse{ + Rewards: sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initialStake / 10)}}, + } + + // test command delegation rewards grpc + testCases := []struct { + name string + msg *types.QueryDelegationRewardsRequest + expPass bool + expErrMsg string + }{ + { + name: "empty request", + msg: &types.QueryDelegationRewardsRequest{}, + expPass: false, + expErrMsg: "empty delegator address", + }, + { + name: "empty delegator address", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: "", + ValidatorAddress: valAddr.String(), + }, + expPass: false, + expErrMsg: "empty delegator address", + }, + { + name: "empty validator address", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: addr2.String(), + ValidatorAddress: "", + }, + expPass: false, + expErrMsg: "empty validator address", + }, + { + name: "request with wrong delegator and validator", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: addr2.String(), + ValidatorAddress: valAddr2.String(), + }, + expPass: false, + expErrMsg: "validator does not exist", + }, + { + name: "valid request", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: delAddr.String(), + ValidatorAddress: valAddr.String(), + }, + expPass: true, + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + rewards, err := queryClient.DelegationRewards(integrationApp.SDKContext(), tc.msg) + + if tc.expPass { + assert.NilError(t, err) + assert.DeepEqual(t, expRes, rewards) + } else { + assert.ErrorContains(t, err, tc.expErrMsg) + assert.Assert(t, rewards == nil) + } + }) + } +} From 314f21ce0b586f3a96876a70db73c15028c91a73 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 10 Apr 2023 12:01:39 +0530 Subject: [PATCH 15/30] fix tests --- x/distribution/keeper/grpc_query_test.go | 85 +++++++------ x/distribution/keeper/msg_server_test.go | 145 ++++++++++++----------- 2 files changed, 122 insertions(+), 108 deletions(-) diff --git a/x/distribution/keeper/grpc_query_test.go b/x/distribution/keeper/grpc_query_test.go index 494c994d4383..281e73ca6f7d 100644 --- a/x/distribution/keeper/grpc_query_test.go +++ b/x/distribution/keeper/grpc_query_test.go @@ -31,13 +31,14 @@ func TestGRPCParams(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - f.distrKeeper.SetParams(integrationApp.SDKContext(), types.DefaultParams()) + f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) qr := integrationApp.QueryHelper() queryClient := types.NewQueryClient(qr) @@ -70,7 +71,7 @@ func TestGRPCParams(t *testing.T) { WithdrawAddrEnabled: true, } - assert.NilError(t, f.distrKeeper.SetParams(integrationApp.SDKContext(), params)) + assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) expParams = params }, msg: &types.QueryParamsRequest{}, @@ -81,7 +82,7 @@ func TestGRPCParams(t *testing.T) { t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { tc.malleate() - paramsRes, err := queryClient.Params(integrationApp.SDKContext(), tc.msg) + paramsRes, err := queryClient.Params(sdkCtx, tc.msg) assert.NilError(t, err) assert.Assert(t, paramsRes != nil) assert.DeepEqual(t, paramsRes.Params, expParams) @@ -99,7 +100,8 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -117,8 +119,8 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { valAddr := sdk.ValAddress(addr) // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) - rewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr) + f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) + rewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) testCases := []struct { name string @@ -142,7 +144,7 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(integrationApp.SDKContext(), tc.msg) + validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) @@ -165,7 +167,8 @@ func TestGRPCValidatorCommission(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -178,7 +181,7 @@ func TestGRPCValidatorCommission(t *testing.T) { valAddr := sdk.ValAddress(addr) commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} - f.distrKeeper.SetValidatorAccumulatedCommission(integrationApp.SDKContext(), valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) + f.distrKeeper.SetValidatorAccumulatedCommission(sdkCtx, valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) testCases := []struct { name string @@ -202,7 +205,7 @@ func TestGRPCValidatorCommission(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - commissionRes, err := queryClient.ValidatorCommission(integrationApp.SDKContext(), tc.msg) + commissionRes, err := queryClient.ValidatorCommission(sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) @@ -225,7 +228,8 @@ func TestGRPCValidatorSlashes(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -247,7 +251,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { } for i, slash := range slashes { - f.distrKeeper.SetValidatorSlashEvent(integrationApp.SDKContext(), valAddr, uint64(i+2), 0, slash) + f.distrKeeper.SetValidatorSlashEvent(sdkCtx, valAddr, uint64(i+2), 0, slash) } var ( @@ -365,7 +369,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { tc.malleate() - slashesRes, err := queryClient.ValidatorSlashes(integrationApp.SDKContext(), req) + slashesRes, err := queryClient.ValidatorSlashes(sdkCtx, req) if tc.expPass { assert.NilError(t, err) @@ -387,9 +391,10 @@ func TestGRPCDelegatorWithdrawAddress(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - f.distrKeeper.SetParams(integrationApp.SDKContext(), types.DefaultParams()) + f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -401,7 +406,7 @@ func TestGRPCDelegatorWithdrawAddress(t *testing.T) { addr := sdk.AccAddress(PKS[0].Address()) addr2 := sdk.AccAddress(PKS[1].Address()) - err := f.distrKeeper.SetWithdrawAddr(integrationApp.SDKContext(), addr, addr2) + err := f.distrKeeper.SetWithdrawAddr(sdkCtx, addr, addr2) assert.Assert(t, err == nil) testCases := []struct { @@ -426,7 +431,7 @@ func TestGRPCDelegatorWithdrawAddress(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - withdrawAddress, err := queryClient.DelegatorWithdrawAddress(integrationApp.SDKContext(), tc.msg) + withdrawAddress, err := queryClient.DelegatorWithdrawAddress(sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) @@ -448,9 +453,10 @@ func TestGRPCCommunityPool(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - f.distrKeeper.SetFeePool(integrationApp.SDKContext(), types.FeePool{ + f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(0)}), }) @@ -483,10 +489,10 @@ func TestGRPCCommunityPool(t *testing.T) { name: "valid request", malleate: func() { amount := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 100)) - assert.NilError(t, f.bankKeeper.MintCoins(integrationApp.SDKContext(), types.ModuleName, amount)) - assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), types.ModuleName, addr, amount)) + assert.NilError(t, f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, amount)) + assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, addr, amount)) - err := f.distrKeeper.FundCommunityPool(integrationApp.SDKContext(), amount, addr) + err := f.distrKeeper.FundCommunityPool(sdkCtx, amount, addr) assert.Assert(t, err == nil) req = &types.QueryCommunityPoolRequest{} @@ -500,7 +506,7 @@ func TestGRPCCommunityPool(t *testing.T) { t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { testCase.malleate() - pool, err := queryClient.CommunityPool(integrationApp.SDKContext(), req) + pool, err := queryClient.CommunityPool(sdkCtx, req) assert.NilError(t, err) assert.DeepEqual(t, expPool, pool) @@ -517,18 +523,19 @@ func TestGRPCDelegationRewards(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - f.distrKeeper.SetFeePool(integrationApp.SDKContext(), types.FeePool{ + f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(1000)}), }) // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Set default staking params - f.stakingKeeper.SetParams(integrationApp.SDKContext(), stakingtypes.DefaultParams()) + f.stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams()) // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -544,32 +551,32 @@ func TestGRPCDelegationRewards(t *testing.T) { delAddr := sdk.AccAddress(PKS[2].Address()) // send funds to val addr - funds := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) initialStake := int64(10) - tstaking := stakingtestutil.NewHelper(t, integrationApp.SDKContext(), f.stakingKeeper) + tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) - val, found := f.stakingKeeper.GetValidator(integrationApp.SDKContext(), valAddr) + val, found := f.stakingKeeper.GetValidator(sdkCtx, valAddr) assert.Assert(t, found) // setup delegation delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator, issuedShares := val.AddTokensFromDel(delTokens) delegation := stakingtypes.NewDelegation(delAddr, valAddr, issuedShares) - f.stakingKeeper.SetDelegation(integrationApp.SDKContext(), delegation) - f.distrKeeper.SetDelegatorStartingInfo(integrationApp.SDKContext(), validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) + f.stakingKeeper.SetDelegation(sdkCtx, delegation) + f.distrKeeper.SetDelegatorStartingInfo(sdkCtx, validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) // setup validator rewards decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())} historicalRewards := types.NewValidatorHistoricalRewards(decCoins, 2) - f.distrKeeper.SetValidatorHistoricalRewards(integrationApp.SDKContext(), validator.GetOperator(), 2, historicalRewards) + f.distrKeeper.SetValidatorHistoricalRewards(sdkCtx, validator.GetOperator(), 2, historicalRewards) // setup current rewards and outstanding rewards currentRewards := types.NewValidatorCurrentRewards(decCoins, 3) - f.distrKeeper.SetValidatorCurrentRewards(integrationApp.SDKContext(), valAddr, currentRewards) - f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) + f.distrKeeper.SetValidatorCurrentRewards(sdkCtx, valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) expRes := &types.QueryDelegationRewardsResponse{ Rewards: sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initialStake / 10)}}, @@ -628,7 +635,7 @@ func TestGRPCDelegationRewards(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - rewards, err := queryClient.DelegationRewards(integrationApp.SDKContext(), tc.msg) + rewards, err := queryClient.DelegationRewards(sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) diff --git a/x/distribution/keeper/msg_server_test.go b/x/distribution/keeper/msg_server_test.go index e2ac6d776e44..1a5c620b17e2 100644 --- a/x/distribution/keeper/msg_server_test.go +++ b/x/distribution/keeper/msg_server_test.go @@ -100,12 +100,13 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ + f.distrKeeper.SetFeePool(sdkCtx, distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), }) - initFeePool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + initFeePool := f.distrKeeper.GetFeePool(sdkCtx) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -128,33 +129,33 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { assert.NilError(t, err) validator.DelegatorShares = math.LegacyNewDec(100) validator.Tokens = sdk.NewInt(1000000) - f.stakingKeeper.SetValidator(integrationApp.SDKContext(), validator) + f.stakingKeeper.SetValidator(sdkCtx, validator) // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // send funds to val addr - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - initBalance := f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), delAddr) + initBalance := f.bankKeeper.GetAllBalances(sdkCtx, delAddr) // setup delegation delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(delTokens) delegation := stakingtypes.NewDelegation(delAddr, validator.GetOperator(), issuedShares) - f.stakingKeeper.SetDelegation(integrationApp.SDKContext(), delegation) - f.distrKeeper.SetDelegatorStartingInfo(integrationApp.SDKContext(), validator.GetOperator(), delAddr, distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 20)) + f.stakingKeeper.SetDelegation(sdkCtx, delegation) + f.distrKeeper.SetDelegatorStartingInfo(sdkCtx, 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) - f.distrKeeper.SetValidatorHistoricalRewards(integrationApp.SDKContext(), validator.GetOperator(), 2, historicalRewards) + f.distrKeeper.SetValidatorHistoricalRewards(sdkCtx, validator.GetOperator(), 2, historicalRewards) // setup current rewards and outstanding rewards currentRewards := distrtypes.NewValidatorCurrentRewards(decCoins, 3) - f.distrKeeper.SetValidatorCurrentRewards(integrationApp.SDKContext(), valAddr, currentRewards) - f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) - initOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewardsCoins(integrationApp.SDKContext(), valAddr) + f.distrKeeper.SetValidatorCurrentRewards(sdkCtx, valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + initOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewardsCoins(sdkCtx, valAddr) testCases := []struct { name string @@ -206,13 +207,13 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { assert.NilError(t, err) // check current balance is greater than initial balance - curBalance := f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), sdk.AccAddress(valAddr)) + curBalance := f.bankKeeper.GetAllBalances(sdkCtx, sdk.AccAddress(valAddr)) assert.Assert(t, initBalance.IsAllLTE(curBalance)) // check rewards - curFeePool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + curFeePool := f.distrKeeper.GetFeePool(sdkCtx) rewards := curFeePool.GetCommunityPool().Sub(initFeePool.CommunityPool) - curOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr) + curOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) assert.DeepEqual(t, rewards, initOutstandingRewards.Sub(curOutstandingRewards.Rewards)) } }) @@ -228,13 +229,14 @@ func TestMsgSetWithdrawAddress(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) + f.distrKeeper.SetParams(sdkCtx, distrtypes.DefaultParams()) delAddr := sdk.AccAddress(PKS[0].Address()) withdrawAddr := sdk.AccAddress(PKS[1].Address()) @@ -249,9 +251,9 @@ func TestMsgSetWithdrawAddress(t *testing.T) { { name: "withdraw address disabled", preRun: func() { - params := f.distrKeeper.GetParams(integrationApp.SDKContext()) + params := f.distrKeeper.GetParams(sdkCtx) params.WithdrawAddrEnabled = false - assert.NilError(t, f.distrKeeper.SetParams(integrationApp.SDKContext(), params)) + assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) }, msg: &distrtypes.MsgSetWithdrawAddress{ DelegatorAddress: delAddr.String(), @@ -263,9 +265,9 @@ func TestMsgSetWithdrawAddress(t *testing.T) { { name: "valid msg", preRun: func() { - params := f.distrKeeper.GetParams(integrationApp.SDKContext()) + params := f.distrKeeper.GetParams(sdkCtx) params.WithdrawAddrEnabled = true - assert.NilError(t, f.distrKeeper.SetParams(integrationApp.SDKContext(), params)) + assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) }, msg: &distrtypes.MsgSetWithdrawAddress{ DelegatorAddress: delAddr.String(), @@ -283,7 +285,7 @@ func TestMsgSetWithdrawAddress(t *testing.T) { assert.ErrorContains(t, err, tc.expErrMsg) // query the delegator withdraw address - addr := f.distrKeeper.GetDelegatorWithdrawAddr(integrationApp.SDKContext(), delAddr) + addr := f.distrKeeper.GetDelegatorWithdrawAddr(sdkCtx, delAddr) assert.DeepEqual(t, addr, delAddr) } else { assert.NilError(t, err) @@ -295,7 +297,7 @@ func TestMsgSetWithdrawAddress(t *testing.T) { assert.NilError(t, err) // query the delegator withdraw address - addr := f.distrKeeper.GetDelegatorWithdrawAddr(integrationApp.SDKContext(), delAddr) + addr := f.distrKeeper.GetDelegatorWithdrawAddr(sdkCtx, delAddr) assert.DeepEqual(t, addr, withdrawAddr) } }) @@ -311,7 +313,8 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -326,26 +329,26 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { valAddr := sdk.ValAddress(addr) // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // send funds to val addr - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) coins := sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(2)), sdk.NewCoin("stake", sdk.NewInt(2))) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, coins) + f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, coins) // check initial balance - balance := f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), sdk.AccAddress(valAddr)) - expTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), 1000) + balance := f.bankKeeper.GetAllBalances(sdkCtx, sdk.AccAddress(valAddr)) + expTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, 1000) expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) assert.DeepEqual(t, expCoins, balance) // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) // set commission - f.distrKeeper.SetValidatorAccumulatedCommission(integrationApp.SDKContext(), valAddr, distrtypes.ValidatorAccumulatedCommission{Commission: valCommission}) + f.distrKeeper.SetValidatorAccumulatedCommission(sdkCtx, valAddr, distrtypes.ValidatorAccumulatedCommission{Commission: valCommission}) testCases := []struct { name string @@ -386,14 +389,14 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { assert.NilError(t, err) // check balance increase - balance = f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), sdk.AccAddress(valAddr)) + balance = f.bankKeeper.GetAllBalances(sdkCtx, sdk.AccAddress(valAddr)) assert.DeepEqual(t, sdk.NewCoins( sdk.NewCoin("mytoken", sdk.NewInt(1)), sdk.NewCoin("stake", expTokens.AddRaw(1)), ), balance) // check remainder - remainder := f.distrKeeper.GetValidatorAccumulatedCommission(integrationApp.SDKContext(), valAddr).Commission + remainder := f.distrKeeper.GetValidatorAccumulatedCommission(sdkCtx, valAddr).Commission assert.DeepEqual(t, sdk.DecCoins{ sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(1).Quo(math.LegacyNewDec(4))), sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(1).Quo(math.LegacyNewDec(2))), @@ -413,15 +416,16 @@ func TestMsgFundCommunityPool(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // reset fee pool - f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.InitialFeePool()) - initPool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + f.distrKeeper.SetFeePool(sdkCtx, distrtypes.InitialFeePool()) + initPool := f.distrKeeper.GetFeePool(sdkCtx) assert.Assert(t, initPool.CommunityPool.Empty()) - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(100)) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(100)) + f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -432,9 +436,9 @@ func TestMsgFundCommunityPool(t *testing.T) { amount := sdk.NewCoins(sdk.NewInt64Coin("stake", 100)) // fund the account by minting and sending amount from distribution module to addr - err := f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, amount) + err := f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, amount) assert.NilError(t, err) - err = f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, addr, amount) + err = f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, addr, amount) assert.NilError(t, err) testCases := []struct { @@ -477,8 +481,8 @@ func TestMsgFundCommunityPool(t *testing.T) { assert.NilError(t, err) // query the community pool funds - assert.DeepEqual(t, initPool.CommunityPool.Add(sdk.NewDecCoinsFromCoins(amount...)...), f.distrKeeper.GetFeePool(integrationApp.SDKContext()).CommunityPool) - assert.Assert(t, f.bankKeeper.GetAllBalances(integrationApp.SDKContext(), addr).Empty()) + assert.DeepEqual(t, initPool.CommunityPool.Add(sdk.NewDecCoinsFromCoins(amount...)...), f.distrKeeper.GetFeePool(sdkCtx).CommunityPool) + assert.Assert(t, f.bankKeeper.GetAllBalances(sdkCtx, addr).Empty()) } }) } @@ -497,7 +501,8 @@ func TestMsgUpdateParams(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -610,7 +615,7 @@ func TestMsgUpdateParams(t *testing.T) { assert.NilError(t, err) // query the params and verify it has been updated - params := f.distrKeeper.GetParams(integrationApp.SDKContext()) + params := f.distrKeeper.GetParams(sdkCtx) assert.DeepEqual(t, distrtypes.DefaultParams(), params) } }) @@ -626,16 +631,17 @@ func TestMsgCommunityPoolSpend(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) - f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ + f.distrKeeper.SetParams(sdkCtx, distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(sdkCtx, distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), }) - initialFeePool := f.distrKeeper.GetFeePool(integrationApp.SDKContext()) + initialFeePool := f.distrKeeper.GetFeePool(sdkCtx) - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(100)) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(100)) + f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -695,7 +701,7 @@ func TestMsgCommunityPoolSpend(t *testing.T) { assert.NilError(t, err) // query the community pool to verify it has been updated - communityPool := f.distrKeeper.GetFeePoolCommunityCoins(integrationApp.SDKContext()) + communityPool := f.distrKeeper.GetFeePoolCommunityCoins(sdkCtx) newPool, negative := initialFeePool.CommunityPool.SafeSub(sdk.NewDecCoinsFromCoins(tc.msg.Amount...)) assert.Assert(t, negative == false) assert.DeepEqual(t, communityPool, newPool) @@ -713,17 +719,18 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(t.Name(), log.NewTestLogger(t), f.keys, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - f.distrKeeper.SetParams(integrationApp.SDKContext(), distrtypes.DefaultParams()) - f.distrKeeper.SetFeePool(integrationApp.SDKContext(), distrtypes.FeePool{ + f.distrKeeper.SetParams(sdkCtx, distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(sdkCtx, distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), }) - initTokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(10000)) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(10000)) + f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Set default staking params - f.stakingKeeper.SetParams(integrationApp.SDKContext(), stakingtypes.DefaultParams()) + f.stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams()) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -734,20 +741,20 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { valAddr1 := sdk.ValAddress(addr1) // send funds to val addr - tokens := f.stakingKeeper.TokensFromConsensusPower(integrationApp.SDKContext(), int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, sdk.AccAddress(valAddr1), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + tokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr1), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) // send funds from module to addr to perform DepositValidatorRewardsPool - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) - tstaking := stakingtestutil.NewHelper(t, integrationApp.SDKContext(), f.stakingKeeper) + tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) tstaking.CreateValidator(valAddr1, valConsPk0, sdk.NewInt(100), true) // mint a non-staking token and send to an account amt := sdk.NewCoins(sdk.NewInt64Coin("foo", 500)) - f.bankKeeper.MintCoins(integrationApp.SDKContext(), distrtypes.ModuleName, amt) - f.bankKeeper.SendCoinsFromModuleToAccount(integrationApp.SDKContext(), distrtypes.ModuleName, addr, amt) + f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, amt) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, addr, amt) testCases := []struct { name string @@ -760,7 +767,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { msg: &distrtypes.MsgDepositValidatorRewardsPool{ Authority: addr.String(), ValidatorAddress: valAddr1.String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.SDKContext()), sdk.NewInt(100))), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(sdkCtx), sdk.NewInt(100))), }, }, { @@ -776,7 +783,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { msg: &distrtypes.MsgDepositValidatorRewardsPool{ Authority: addr.String(), ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(integrationApp.SDKContext()), sdk.NewInt(100))), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(sdkCtx), sdk.NewInt(100))), }, expErr: true, expErrMsg: "validator does not exist", @@ -802,7 +809,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { assert.NilError(t, err) // check validator outstanding rewards - outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(integrationApp.SDKContext(), valAddr) + outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) for _, c := range tc.msg.Amount { x := outstandingRewards.Rewards.AmountOf(c.Denom) assert.DeepEqual(t, x, sdk.NewDecFromInt(c.Amount)) From cc886b86f11036a9557bd302da6843cc5d43f950 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 10 Apr 2023 12:09:09 +0530 Subject: [PATCH 16/30] move tests under tests/integration --- .../distribution/keeper/common_test.go | 11 +- .../distribution/keeper/grpc_query_test.go | 738 ++++++++---------- .../distribution/keeper/msg_server_test.go | 0 x/distribution/keeper/grpc_query_test.go | 649 --------------- 4 files changed, 339 insertions(+), 1059 deletions(-) rename {x => tests/integration}/distribution/keeper/msg_server_test.go (100%) delete mode 100644 x/distribution/keeper/grpc_query_test.go diff --git a/tests/integration/distribution/keeper/common_test.go b/tests/integration/distribution/keeper/common_test.go index 4ab7cead571a..783d44e2dafc 100644 --- a/tests/integration/distribution/keeper/common_test.go +++ b/tests/integration/distribution/keeper/common_test.go @@ -2,19 +2,10 @@ package keeper_test import ( simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" - sdk "github.com/cosmos/cosmos-sdk/types" - authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - "github.com/cosmos/cosmos-sdk/x/distribution/types" ) var ( - PKS = simtestutil.CreateTestPubKeys(5) + PKS = simtestutil.CreateTestPubKeys(3) valConsPk0 = PKS[0] - valConsPk1 = PKS[1] - valConsPk2 = PKS[2] - - valConsAddr0 = sdk.ConsAddress(valConsPk0.Address()) - - distrAcc = authtypes.NewEmptyModuleAccount(types.ModuleName) ) diff --git a/tests/integration/distribution/keeper/grpc_query_test.go b/tests/integration/distribution/keeper/grpc_query_test.go index 7ae9af27a451..281e73ca6f7d 100644 --- a/tests/integration/distribution/keeper/grpc_query_test.go +++ b/tests/integration/distribution/keeper/grpc_query_test.go @@ -1,97 +1,69 @@ package keeper_test import ( - gocontext "context" "fmt" "testing" + "cosmossdk.io/log" "cosmossdk.io/math" - cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" "gotest.tools/v3/assert" - "github.com/cosmos/cosmos-sdk/baseapp" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + "github.com/cosmos/cosmos-sdk/testutil/integration" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/query" - bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" - banktestutil "github.com/cosmos/cosmos-sdk/x/bank/testutil" - "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - "github.com/cosmos/cosmos-sdk/x/distribution/testutil" + "github.com/cosmos/cosmos-sdk/x/auth" + authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/cosmos/cosmos-sdk/x/distribution" + distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/staking" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) -type fixture struct { - ctx sdk.Context - queryClient types.QueryClient - addrs []sdk.AccAddress - valAddrs []sdk.ValAddress - - interfaceRegistry codectypes.InterfaceRegistry - bankKeeper bankkeeper.Keeper - distrKeeper keeper.Keeper - stakingKeeper *stakingkeeper.Keeper - msgServer types.MsgServer -} - -func initFixture(t assert.TestingT) *fixture { - f := &fixture{} - - app, err := simtestutil.Setup( - testutil.AppConfig, - &f.interfaceRegistry, - &f.bankKeeper, - &f.distrKeeper, - &f.stakingKeeper, - ) - assert.NilError(t, err) - - ctx := app.BaseApp.NewContext(false, cmtproto.Header{}) - - queryHelper := baseapp.NewQueryServerTestHelper(ctx, f.interfaceRegistry) - types.RegisterQueryServer(queryHelper, keeper.NewQuerier(f.distrKeeper)) - queryClient := types.NewQueryClient(queryHelper) +func TestGRPCParams(t *testing.T) { + t.Parallel() + f := initFixture(t) - f.ctx = ctx - f.queryClient = queryClient + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - f.addrs = simtestutil.AddTestAddrs(f.bankKeeper, f.stakingKeeper, ctx, 2, sdk.NewInt(1000000000)) - f.valAddrs = simtestutil.ConvertAddrsToValAddrs(f.addrs) - f.msgServer = keeper.NewMsgServerImpl(f.distrKeeper) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - return f -} + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) -func TestGRPCParams(t *testing.T) { - t.Parallel() - f := initFixture(t) + f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) - ctx, queryClient := f.ctx, f.queryClient + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) var ( params types.Params - req *types.QueryParamsRequest expParams types.Params ) testCases := []struct { - msg string - malleate func() + name string + malleate func() + msg *types.QueryParamsRequest + expErrMsg string }{ { - "empty params request", - func() { - req = &types.QueryParamsRequest{} + name: "empty params request", + malleate: func() { expParams = types.DefaultParams() }, + msg: &types.QueryParamsRequest{}, }, { - "valid request", - func() { + name: "valid request", + malleate: func() { params = types.Params{ CommunityTax: sdk.NewDecWithPrec(3, 1), BaseProposerReward: sdk.ZeroDec(), @@ -99,23 +71,23 @@ func TestGRPCParams(t *testing.T) { WithdrawAddrEnabled: true, } - assert.NilError(t, f.distrKeeper.SetParams(ctx, params)) - req = &types.QueryParamsRequest{} + assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) expParams = params }, + msg: &types.QueryParamsRequest{}, }, } - for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() - - paramsRes, err := queryClient.Params(gocontext.Background(), req) + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + tc.malleate() + paramsRes, err := queryClient.Params(sdkCtx, tc.msg) assert.NilError(t, err) assert.Assert(t, paramsRes != nil) - assert.DeepEqual(t, expParams, paramsRes.Params) + assert.DeepEqual(t, paramsRes.Params, expParams) }) + } } @@ -123,54 +95,63 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { t.Parallel() f := initFixture(t) - ctx, queryClient, valAddrs := f.ctx, f.queryClient, f.valAddrs + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) valCommission := sdk.DecCoins{ sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5000)), sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(300)), } - // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(ctx, valAddrs[0], types.ValidatorOutstandingRewards{Rewards: valCommission}) - rewards := f.distrKeeper.GetValidatorOutstandingRewards(ctx, valAddrs[0]) + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) - var req *types.QueryValidatorOutstandingRewardsRequest + // set outstanding rewards + f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) + rewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) testCases := []struct { - msg string - malleate func() + name string + msg *types.QueryValidatorOutstandingRewardsRequest expPass bool expErrMsg string }{ { - "empty request", - func() { - req = &types.QueryValidatorOutstandingRewardsRequest{} - }, - false, - "empty validator address", - }, { - "valid request", - func() { - req = &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: valAddrs[0].String()} - }, - true, - "", + name: "empty request", + msg: &types.QueryValidatorOutstandingRewardsRequest{}, + expPass: false, + expErrMsg: "empty validator address", + }, + { + name: "valid request", + msg: &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: valAddr.String()}, + expPass: true, }, } for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() - - validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(gocontext.Background(), req) + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(sdkCtx, tc.msg) - if testCase.expPass { + if tc.expPass { assert.NilError(t, err) assert.DeepEqual(t, rewards, validatorOutstandingRewards.Rewards) assert.DeepEqual(t, valCommission, validatorOutstandingRewards.Rewards.Rewards) } else { - assert.ErrorContains(t, err, testCase.expErrMsg) + assert.ErrorContains(t, err, tc.expErrMsg) assert.Assert(t, validatorOutstandingRewards == nil) } }) @@ -181,49 +162,57 @@ func TestGRPCValidatorCommission(t *testing.T) { t.Parallel() f := initFixture(t) - ctx, queryClient, valAddrs := f.ctx, f.queryClient, f.valAddrs + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} - f.distrKeeper.SetValidatorAccumulatedCommission(ctx, valAddrs[0], types.ValidatorAccumulatedCommission{Commission: commission}) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - var req *types.QueryValidatorCommissionRequest + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + + commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} + f.distrKeeper.SetValidatorAccumulatedCommission(sdkCtx, valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) testCases := []struct { - msg string - malleate func() + name string + msg *types.QueryValidatorCommissionRequest expPass bool expErrMsg string }{ { - "empty request", - func() { - req = &types.QueryValidatorCommissionRequest{} - }, - false, - "empty validator address", + name: "empty request", + msg: &types.QueryValidatorCommissionRequest{}, + expPass: false, + expErrMsg: "empty validator address", }, { - "valid request", - func() { - req = &types.QueryValidatorCommissionRequest{ValidatorAddress: valAddrs[0].String()} - }, - true, - "", + name: "valid request", + msg: &types.QueryValidatorCommissionRequest{ValidatorAddress: valAddr.String()}, + expPass: true, }, } for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() - - commissionRes, err := queryClient.ValidatorCommission(gocontext.Background(), req) + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + commissionRes, err := queryClient.ValidatorCommission(sdkCtx, tc.msg) - if testCase.expPass { + if tc.expPass { assert.NilError(t, err) assert.Assert(t, commissionRes != nil) assert.DeepEqual(t, commissionRes.Commission.Commission, commission) } else { - assert.ErrorContains(t, err, testCase.expErrMsg) + assert.ErrorContains(t, err, tc.expErrMsg) assert.Assert(t, commissionRes == nil) } }) @@ -234,7 +223,25 @@ func TestGRPCValidatorSlashes(t *testing.T) { t.Parallel() f := initFixture(t) - ctx, queryClient, valAddrs := f.ctx, f.queryClient, f.valAddrs + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) + + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + addr2 := sdk.AccAddress(PKS[1].Address()) + valAddr2 := sdk.ValAddress(addr2) slashes := []types.ValidatorSlashEvent{ types.NewValidatorSlashEvent(3, sdk.NewDecWithPrec(5, 1)), @@ -244,7 +251,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { } for i, slash := range slashes { - f.distrKeeper.SetValidatorSlashEvent(ctx, valAddrs[0], uint64(i+2), 0, slash) + f.distrKeeper.SetValidatorSlashEvent(sdkCtx, valAddr, uint64(i+2), 0, slash) } var ( @@ -253,56 +260,55 @@ func TestGRPCValidatorSlashes(t *testing.T) { ) testCases := []struct { - msg string + name string malleate func() expPass bool expErrMsg string }{ { - "empty request", - func() { + name: "empty request", + malleate: func() { req = &types.QueryValidatorSlashesRequest{} expRes = &types.QueryValidatorSlashesResponse{} }, - false, - "empty validator address", + expPass: false, + expErrMsg: "empty validator address", }, { - "Ending height lesser than start height request", - func() { + name: "Ending height lesser than start height request", + malleate: func() { req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddrs[1].String(), + ValidatorAddress: valAddr2.String(), StartingHeight: 10, EndingHeight: 1, } expRes = &types.QueryValidatorSlashesResponse{Pagination: &query.PageResponse{}} }, - false, - "starting height greater than ending height", + expPass: false, + expErrMsg: "starting height greater than ending height", }, { - "no slash event validator request", - func() { + name: "no slash event validator request", + malleate: func() { req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddrs[1].String(), + ValidatorAddress: valAddr2.String(), StartingHeight: 1, EndingHeight: 10, } expRes = &types.QueryValidatorSlashesResponse{Pagination: &query.PageResponse{}} }, - true, - "", + expPass: true, }, { - "request slashes with offset 2 and limit 2", - func() { + name: "request slashes with offset 2 and limit 2", + malleate: func() { pageReq := &query.PageRequest{ Offset: 2, Limit: 2, } req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddrs[0].String(), + ValidatorAddress: valAddr.String(), StartingHeight: 1, EndingHeight: 10, Pagination: pageReq, @@ -312,19 +318,18 @@ func TestGRPCValidatorSlashes(t *testing.T) { Slashes: slashes[2:], } }, - true, - "", + expPass: true, }, { - "request slashes with page limit 3 and count total", - func() { + name: "request slashes with page limit 3 and count total", + malleate: func() { pageReq := &query.PageRequest{ Limit: 3, CountTotal: true, } req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddrs[0].String(), + ValidatorAddress: valAddr.String(), StartingHeight: 1, EndingHeight: 10, Pagination: pageReq, @@ -334,19 +339,18 @@ func TestGRPCValidatorSlashes(t *testing.T) { Slashes: slashes[:3], } }, - true, - "", + expPass: true, }, { - "request slashes with page limit 4 and count total", - func() { + name: "request slashes with page limit 4 and count total", + malleate: func() { pageReq := &query.PageRequest{ Limit: 4, CountTotal: true, } req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddrs[0].String(), + ValidatorAddress: valAddr.String(), StartingHeight: 1, EndingHeight: 10, Pagination: pageReq, @@ -356,356 +360,290 @@ func TestGRPCValidatorSlashes(t *testing.T) { Slashes: slashes[:4], } }, - true, - "", + expPass: true, }, } for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + tc.malleate() - slashesRes, err := queryClient.ValidatorSlashes(gocontext.Background(), req) + slashesRes, err := queryClient.ValidatorSlashes(sdkCtx, req) - if testCase.expPass { + if tc.expPass { assert.NilError(t, err) assert.DeepEqual(t, expRes.GetSlashes(), slashesRes.GetSlashes()) } else { - assert.ErrorContains(t, err, testCase.expErrMsg) + assert.ErrorContains(t, err, tc.expErrMsg) assert.Assert(t, slashesRes == nil) } }) } } -func TestGRPCDelegationRewards(t *testing.T) { +func TestGRPCDelegatorWithdrawAddress(t *testing.T) { t.Parallel() f := initFixture(t) - ctx, addrs, valAddrs := f.ctx, f.addrs, f.valAddrs + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - tstaking := stakingtestutil.NewHelper(t, ctx, f.stakingKeeper) - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddrs[0], valConsPk0, sdk.NewInt(100), true) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - staking.EndBlocker(ctx, f.stakingKeeper) - ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) + f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) - queryHelper := baseapp.NewQueryServerTestHelper(ctx, f.interfaceRegistry) - types.RegisterQueryServer(queryHelper, keeper.NewQuerier(f.distrKeeper)) - queryClient := types.NewQueryClient(queryHelper) + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - val := f.stakingKeeper.Validator(ctx, valAddrs[0]) + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) - initial := int64(10) - tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial)}} - f.distrKeeper.AllocateTokensToValidator(ctx, val, tokens) + addr := sdk.AccAddress(PKS[0].Address()) + addr2 := sdk.AccAddress(PKS[1].Address()) - // test command delegation rewards grpc - var ( - req *types.QueryDelegationRewardsRequest - expRes *types.QueryDelegationRewardsResponse - ) + err := f.distrKeeper.SetWithdrawAddr(sdkCtx, addr, addr2) + assert.Assert(t, err == nil) testCases := []struct { - msg string - malleate func() + name string + msg *types.QueryDelegatorWithdrawAddressRequest expPass bool expErrMsg string }{ { - "empty request", - func() { - req = &types.QueryDelegationRewardsRequest{} - }, - false, - "empty delegator address", + name: "empty request", + msg: &types.QueryDelegatorWithdrawAddressRequest{}, + expPass: false, + expErrMsg: "empty delegator address", }, { - "empty delegator request", - func() { - req = &types.QueryDelegationRewardsRequest{ - DelegatorAddress: "", - ValidatorAddress: valAddrs[0].String(), - } - }, - false, - "empty delegator address", - }, - { - "empty validator request", - func() { - req = &types.QueryDelegationRewardsRequest{ - DelegatorAddress: addrs[1].String(), - ValidatorAddress: "", - } - }, - false, - "empty validator address", - }, - { - "request with wrong delegator and validator", - func() { - req = &types.QueryDelegationRewardsRequest{ - DelegatorAddress: addrs[1].String(), - ValidatorAddress: valAddrs[1].String(), - } - }, - false, - "validator does not exist", - }, - { - "valid request", - func() { - req = &types.QueryDelegationRewardsRequest{ - DelegatorAddress: addrs[0].String(), - ValidatorAddress: valAddrs[0].String(), - } - - expRes = &types.QueryDelegationRewardsResponse{ - Rewards: sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initial / 2)}}, - } - }, - true, - "", + name: "valid request", + msg: &types.QueryDelegatorWithdrawAddressRequest{DelegatorAddress: addr.String()}, + expPass: true, }, } for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + withdrawAddress, err := queryClient.DelegatorWithdrawAddress(sdkCtx, tc.msg) - rewards, err := queryClient.DelegationRewards(gocontext.Background(), req) - - if testCase.expPass { + if tc.expPass { assert.NilError(t, err) - assert.DeepEqual(t, expRes, rewards) + assert.Equal(t, withdrawAddress.WithdrawAddress, addr2.String()) } else { - assert.ErrorContains(t, err, testCase.expErrMsg) - assert.Assert(t, rewards == nil) + assert.ErrorContains(t, err, tc.expErrMsg) + assert.Assert(t, withdrawAddress == nil) } }) } +} - // test command delegator total rewards grpc - var ( - totalRewardsReq *types.QueryDelegationTotalRewardsRequest - expTotalRewardsRes *types.QueryDelegationTotalRewardsResponse - ) +func TestGRPCCommunityPool(t *testing.T) { + t.Parallel() + f := initFixture(t) - testCases = []struct { - msg string - malleate func() - expPass bool - expErrMsg string - }{ - { - "empty request", - func() { - totalRewardsReq = &types.QueryDelegationTotalRewardsRequest{} - }, - false, - "empty delegator address", - }, - { - "valid total delegation rewards", - func() { - totalRewardsReq = &types.QueryDelegationTotalRewardsRequest{ - DelegatorAddress: addrs[0].String(), - } + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - expectedDelReward := types.NewDelegationDelegatorReward(valAddrs[0], - sdk.DecCoins{sdk.NewInt64DecCoin("stake", 5)}) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - expTotalRewardsRes = &types.QueryDelegationTotalRewardsResponse{ - Rewards: []types.DelegationDelegatorReward{expectedDelReward}, - Total: expectedDelReward.Reward, - } - }, - true, - "", - }, - } + f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(0)}), + }) - for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - totalRewardsRes, err := queryClient.DelegationTotalRewards(gocontext.Background(), totalRewardsReq) + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) - if testCase.expPass { - assert.NilError(t, err) - assert.DeepEqual(t, totalRewardsRes, expTotalRewardsRes) - } else { - assert.ErrorContains(t, err, testCase.expErrMsg) - assert.Assert(t, totalRewardsRes == nil) - } - }) - } + addr := sdk.AccAddress(PKS[0].Address()) - // test command validator delegators grpc var ( - delegatorValidatorsReq *types.QueryDelegatorValidatorsRequest - expDelegatorValidatorsRes *types.QueryDelegatorValidatorsResponse + req *types.QueryCommunityPoolRequest + expPool *types.QueryCommunityPoolResponse ) - testCases = []struct { - msg string - malleate func() - expPass bool - expErrMsg string + testCases := []struct { + name string + malleate func() }{ { - "empty request", - func() { - delegatorValidatorsReq = &types.QueryDelegatorValidatorsRequest{} + name: "valid request empty community pool", + malleate: func() { + req = &types.QueryCommunityPoolRequest{} + expPool = &types.QueryCommunityPoolResponse{} }, - false, - "empty delegator address", }, { - "request no delegations address", - func() { - delegatorValidatorsReq = &types.QueryDelegatorValidatorsRequest{ - DelegatorAddress: addrs[1].String(), - } + name: "valid request", + malleate: func() { + amount := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 100)) + assert.NilError(t, f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, amount)) + assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, addr, amount)) - expDelegatorValidatorsRes = &types.QueryDelegatorValidatorsResponse{} - }, - true, - "", - }, - { - "valid request", - func() { - delegatorValidatorsReq = &types.QueryDelegatorValidatorsRequest{ - DelegatorAddress: addrs[0].String(), - } - expDelegatorValidatorsRes = &types.QueryDelegatorValidatorsResponse{ - Validators: []string{valAddrs[0].String()}, - } + err := f.distrKeeper.FundCommunityPool(sdkCtx, amount, addr) + assert.Assert(t, err == nil) + req = &types.QueryCommunityPoolRequest{} + + expPool = &types.QueryCommunityPoolResponse{Pool: sdk.NewDecCoinsFromCoins(amount...)} }, - true, - "", }, } for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { testCase.malleate() - validators, err := queryClient.DelegatorValidators(gocontext.Background(), delegatorValidatorsReq) + pool, err := queryClient.CommunityPool(sdkCtx, req) - if testCase.expPass { - assert.NilError(t, err) - assert.DeepEqual(t, expDelegatorValidatorsRes, validators) - } else { - assert.ErrorContains(t, err, testCase.expErrMsg) - assert.Assert(t, validators == nil) - } + assert.NilError(t, err) + assert.DeepEqual(t, expPool, pool) }) } } -func TestGRPCDelegatorWithdrawAddress(t *testing.T) { +func TestGRPCDelegationRewards(t *testing.T) { t.Parallel() f := initFixture(t) - ctx, queryClient, addrs := f.ctx, f.queryClient, f.addrs + authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) + stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) + distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - err := f.distrKeeper.SetWithdrawAddr(ctx, addrs[0], addrs[1]) - assert.Assert(t, err == nil) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) + + f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(1000)}), + }) + + // set module account coins + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + + // Set default staking params + f.stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams()) + + // Register MsgServer and QueryServer + types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) + types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + + qr := integrationApp.QueryHelper() + queryClient := types.NewQueryClient(qr) - var req *types.QueryDelegatorWithdrawAddressRequest + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) + addr2 := sdk.AccAddress(PKS[1].Address()) + valAddr2 := sdk.ValAddress(addr2) + delAddr := sdk.AccAddress(PKS[2].Address()) + // send funds to val addr + funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + + initialStake := int64(10) + tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) + tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) + tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) + + val, found := f.stakingKeeper.GetValidator(sdkCtx, valAddr) + assert.Assert(t, found) + + // setup delegation + delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) + validator, issuedShares := val.AddTokensFromDel(delTokens) + delegation := stakingtypes.NewDelegation(delAddr, valAddr, issuedShares) + f.stakingKeeper.SetDelegation(sdkCtx, delegation) + f.distrKeeper.SetDelegatorStartingInfo(sdkCtx, validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) + + // setup validator rewards + decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())} + historicalRewards := types.NewValidatorHistoricalRewards(decCoins, 2) + f.distrKeeper.SetValidatorHistoricalRewards(sdkCtx, validator.GetOperator(), 2, historicalRewards) + // setup current rewards and outstanding rewards + currentRewards := types.NewValidatorCurrentRewards(decCoins, 3) + f.distrKeeper.SetValidatorCurrentRewards(sdkCtx, valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) + + expRes := &types.QueryDelegationRewardsResponse{ + Rewards: sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initialStake / 10)}}, + } + + // test command delegation rewards grpc testCases := []struct { - msg string - malleate func() + name string + msg *types.QueryDelegationRewardsRequest expPass bool expErrMsg string }{ { - "empty request", - func() { - req = &types.QueryDelegatorWithdrawAddressRequest{} + name: "empty request", + msg: &types.QueryDelegationRewardsRequest{}, + expPass: false, + expErrMsg: "empty delegator address", + }, + { + name: "empty delegator address", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: "", + ValidatorAddress: valAddr.String(), }, - false, - "empty delegator address", + expPass: false, + expErrMsg: "empty delegator address", }, { - "valid request", - func() { - req = &types.QueryDelegatorWithdrawAddressRequest{DelegatorAddress: addrs[0].String()} + name: "empty validator address", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: addr2.String(), + ValidatorAddress: "", }, - true, - "", + expPass: false, + expErrMsg: "empty validator address", }, - } - - for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() - - withdrawAddress, err := queryClient.DelegatorWithdrawAddress(gocontext.Background(), req) - - if testCase.expPass { - assert.NilError(t, err) - assert.Equal(t, withdrawAddress.WithdrawAddress, addrs[1].String()) - } else { - assert.ErrorContains(t, err, testCase.expErrMsg) - assert.Assert(t, withdrawAddress == nil) - } - }) - } -} - -func TestGRPCCommunityPool(t *testing.T) { - t.Parallel() - f := initFixture(t) - - ctx, queryClient, addrs := f.ctx, f.queryClient, f.addrs - // reset fee pool - f.distrKeeper.SetFeePool(ctx, types.InitialFeePool()) - - var ( - req *types.QueryCommunityPoolRequest - expPool *types.QueryCommunityPoolResponse - ) - - testCases := []struct { - msg string - malleate func() - }{ { - "valid request empty community pool", - func() { - req = &types.QueryCommunityPoolRequest{} - expPool = &types.QueryCommunityPoolResponse{} + name: "request with wrong delegator and validator", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: addr2.String(), + ValidatorAddress: valAddr2.String(), }, + expPass: false, + expErrMsg: "validator does not exist", }, { - "valid request", - func() { - amount := sdk.NewCoins(sdk.NewInt64Coin("stake", 100)) - assert.NilError(t, banktestutil.FundAccount(f.bankKeeper, ctx, addrs[0], amount)) - - err := f.distrKeeper.FundCommunityPool(ctx, amount, addrs[0]) - assert.Assert(t, err == nil) - req = &types.QueryCommunityPoolRequest{} - - expPool = &types.QueryCommunityPoolResponse{Pool: sdk.NewDecCoinsFromCoins(amount...)} + name: "valid request", + msg: &types.QueryDelegationRewardsRequest{ + DelegatorAddress: delAddr.String(), + ValidatorAddress: valAddr.String(), }, + expPass: true, }, } for _, testCase := range testCases { - t.Run(fmt.Sprintf("Case %s", testCase.msg), func(t *testing.T) { - testCase.malleate() + tc := testCase + t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { + rewards, err := queryClient.DelegationRewards(sdkCtx, tc.msg) - pool, err := queryClient.CommunityPool(gocontext.Background(), req) - - assert.NilError(t, err) - assert.DeepEqual(t, expPool, pool) + if tc.expPass { + assert.NilError(t, err) + assert.DeepEqual(t, expRes, rewards) + } else { + assert.ErrorContains(t, err, tc.expErrMsg) + assert.Assert(t, rewards == nil) + } }) } } diff --git a/x/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go similarity index 100% rename from x/distribution/keeper/msg_server_test.go rename to tests/integration/distribution/keeper/msg_server_test.go diff --git a/x/distribution/keeper/grpc_query_test.go b/x/distribution/keeper/grpc_query_test.go deleted file mode 100644 index 281e73ca6f7d..000000000000 --- a/x/distribution/keeper/grpc_query_test.go +++ /dev/null @@ -1,649 +0,0 @@ -package keeper_test - -import ( - "fmt" - "testing" - - "cosmossdk.io/log" - "cosmossdk.io/math" - "gotest.tools/v3/assert" - - "github.com/cosmos/cosmos-sdk/testutil/integration" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/query" - "github.com/cosmos/cosmos-sdk/x/auth" - authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" - "github.com/cosmos/cosmos-sdk/x/bank" - "github.com/cosmos/cosmos-sdk/x/distribution" - distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking" - stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" - stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" -) - -func TestGRPCParams(t *testing.T) { - t.Parallel() - f := initFixture(t) - - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) - - qr := integrationApp.QueryHelper() - queryClient := types.NewQueryClient(qr) - - var ( - params types.Params - expParams types.Params - ) - - testCases := []struct { - name string - malleate func() - msg *types.QueryParamsRequest - expErrMsg string - }{ - { - name: "empty params request", - malleate: func() { - expParams = types.DefaultParams() - }, - msg: &types.QueryParamsRequest{}, - }, - { - name: "valid request", - malleate: func() { - params = types.Params{ - CommunityTax: sdk.NewDecWithPrec(3, 1), - BaseProposerReward: sdk.ZeroDec(), - BonusProposerReward: sdk.ZeroDec(), - WithdrawAddrEnabled: true, - } - - assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) - expParams = params - }, - msg: &types.QueryParamsRequest{}, - }, - } - for _, testCase := range testCases { - tc := testCase - t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - tc.malleate() - - paramsRes, err := queryClient.Params(sdkCtx, tc.msg) - assert.NilError(t, err) - assert.Assert(t, paramsRes != nil) - assert.DeepEqual(t, paramsRes.Params, expParams) - }) - - } -} - -func TestGRPCValidatorOutstandingRewards(t *testing.T) { - t.Parallel() - f := initFixture(t) - - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() - queryClient := types.NewQueryClient(qr) - - valCommission := sdk.DecCoins{ - sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5000)), - sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(300)), - } - - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) - - // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) - rewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) - - testCases := []struct { - name string - msg *types.QueryValidatorOutstandingRewardsRequest - expPass bool - expErrMsg string - }{ - { - name: "empty request", - msg: &types.QueryValidatorOutstandingRewardsRequest{}, - expPass: false, - expErrMsg: "empty validator address", - }, - { - name: "valid request", - msg: &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: valAddr.String()}, - expPass: true, - }, - } - - for _, testCase := range testCases { - tc := testCase - t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(sdkCtx, tc.msg) - - if tc.expPass { - assert.NilError(t, err) - assert.DeepEqual(t, rewards, validatorOutstandingRewards.Rewards) - assert.DeepEqual(t, valCommission, validatorOutstandingRewards.Rewards.Rewards) - } else { - assert.ErrorContains(t, err, tc.expErrMsg) - assert.Assert(t, validatorOutstandingRewards == nil) - } - }) - } -} - -func TestGRPCValidatorCommission(t *testing.T) { - t.Parallel() - f := initFixture(t) - - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() - queryClient := types.NewQueryClient(qr) - - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) - - commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} - f.distrKeeper.SetValidatorAccumulatedCommission(sdkCtx, valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) - - testCases := []struct { - name string - msg *types.QueryValidatorCommissionRequest - expPass bool - expErrMsg string - }{ - { - name: "empty request", - msg: &types.QueryValidatorCommissionRequest{}, - expPass: false, - expErrMsg: "empty validator address", - }, - { - name: "valid request", - msg: &types.QueryValidatorCommissionRequest{ValidatorAddress: valAddr.String()}, - expPass: true, - }, - } - - for _, testCase := range testCases { - tc := testCase - t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - commissionRes, err := queryClient.ValidatorCommission(sdkCtx, tc.msg) - - if tc.expPass { - assert.NilError(t, err) - assert.Assert(t, commissionRes != nil) - assert.DeepEqual(t, commissionRes.Commission.Commission, commission) - } else { - assert.ErrorContains(t, err, tc.expErrMsg) - assert.Assert(t, commissionRes == nil) - } - }) - } -} - -func TestGRPCValidatorSlashes(t *testing.T) { - t.Parallel() - f := initFixture(t) - - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() - queryClient := types.NewQueryClient(qr) - - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) - addr2 := sdk.AccAddress(PKS[1].Address()) - valAddr2 := sdk.ValAddress(addr2) - - slashes := []types.ValidatorSlashEvent{ - types.NewValidatorSlashEvent(3, sdk.NewDecWithPrec(5, 1)), - types.NewValidatorSlashEvent(5, sdk.NewDecWithPrec(5, 1)), - types.NewValidatorSlashEvent(7, sdk.NewDecWithPrec(5, 1)), - types.NewValidatorSlashEvent(9, sdk.NewDecWithPrec(5, 1)), - } - - for i, slash := range slashes { - f.distrKeeper.SetValidatorSlashEvent(sdkCtx, valAddr, uint64(i+2), 0, slash) - } - - var ( - req *types.QueryValidatorSlashesRequest - expRes *types.QueryValidatorSlashesResponse - ) - - testCases := []struct { - name string - malleate func() - expPass bool - expErrMsg string - }{ - { - name: "empty request", - malleate: func() { - req = &types.QueryValidatorSlashesRequest{} - expRes = &types.QueryValidatorSlashesResponse{} - }, - expPass: false, - expErrMsg: "empty validator address", - }, - { - name: "Ending height lesser than start height request", - malleate: func() { - req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr2.String(), - StartingHeight: 10, - EndingHeight: 1, - } - expRes = &types.QueryValidatorSlashesResponse{Pagination: &query.PageResponse{}} - }, - expPass: false, - expErrMsg: "starting height greater than ending height", - }, - { - name: "no slash event validator request", - malleate: func() { - req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr2.String(), - StartingHeight: 1, - EndingHeight: 10, - } - expRes = &types.QueryValidatorSlashesResponse{Pagination: &query.PageResponse{}} - }, - expPass: true, - }, - { - name: "request slashes with offset 2 and limit 2", - malleate: func() { - pageReq := &query.PageRequest{ - Offset: 2, - Limit: 2, - } - - req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr.String(), - StartingHeight: 1, - EndingHeight: 10, - Pagination: pageReq, - } - - expRes = &types.QueryValidatorSlashesResponse{ - Slashes: slashes[2:], - } - }, - expPass: true, - }, - { - name: "request slashes with page limit 3 and count total", - malleate: func() { - pageReq := &query.PageRequest{ - Limit: 3, - CountTotal: true, - } - - req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr.String(), - StartingHeight: 1, - EndingHeight: 10, - Pagination: pageReq, - } - - expRes = &types.QueryValidatorSlashesResponse{ - Slashes: slashes[:3], - } - }, - expPass: true, - }, - { - name: "request slashes with page limit 4 and count total", - malleate: func() { - pageReq := &query.PageRequest{ - Limit: 4, - CountTotal: true, - } - - req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr.String(), - StartingHeight: 1, - EndingHeight: 10, - Pagination: pageReq, - } - - expRes = &types.QueryValidatorSlashesResponse{ - Slashes: slashes[:4], - } - }, - expPass: true, - }, - } - - for _, testCase := range testCases { - tc := testCase - t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - tc.malleate() - - slashesRes, err := queryClient.ValidatorSlashes(sdkCtx, req) - - if tc.expPass { - assert.NilError(t, err) - assert.DeepEqual(t, expRes.GetSlashes(), slashesRes.GetSlashes()) - } else { - assert.ErrorContains(t, err, tc.expErrMsg) - assert.Assert(t, slashesRes == nil) - } - }) - } -} - -func TestGRPCDelegatorWithdrawAddress(t *testing.T) { - t.Parallel() - f := initFixture(t) - - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() - queryClient := types.NewQueryClient(qr) - - addr := sdk.AccAddress(PKS[0].Address()) - addr2 := sdk.AccAddress(PKS[1].Address()) - - err := f.distrKeeper.SetWithdrawAddr(sdkCtx, addr, addr2) - assert.Assert(t, err == nil) - - testCases := []struct { - name string - msg *types.QueryDelegatorWithdrawAddressRequest - expPass bool - expErrMsg string - }{ - { - name: "empty request", - msg: &types.QueryDelegatorWithdrawAddressRequest{}, - expPass: false, - expErrMsg: "empty delegator address", - }, - { - name: "valid request", - msg: &types.QueryDelegatorWithdrawAddressRequest{DelegatorAddress: addr.String()}, - expPass: true, - }, - } - - for _, testCase := range testCases { - tc := testCase - t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - withdrawAddress, err := queryClient.DelegatorWithdrawAddress(sdkCtx, tc.msg) - - if tc.expPass { - assert.NilError(t, err) - assert.Equal(t, withdrawAddress.WithdrawAddress, addr2.String()) - } else { - assert.ErrorContains(t, err, tc.expErrMsg) - assert.Assert(t, withdrawAddress == nil) - } - }) - } -} - -func TestGRPCCommunityPool(t *testing.T) { - t.Parallel() - f := initFixture(t) - - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ - CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(0)}), - }) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() - queryClient := types.NewQueryClient(qr) - - addr := sdk.AccAddress(PKS[0].Address()) - - var ( - req *types.QueryCommunityPoolRequest - expPool *types.QueryCommunityPoolResponse - ) - - testCases := []struct { - name string - malleate func() - }{ - { - name: "valid request empty community pool", - malleate: func() { - req = &types.QueryCommunityPoolRequest{} - expPool = &types.QueryCommunityPoolResponse{} - }, - }, - { - name: "valid request", - malleate: func() { - amount := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 100)) - assert.NilError(t, f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, amount)) - assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, addr, amount)) - - err := f.distrKeeper.FundCommunityPool(sdkCtx, amount, addr) - assert.Assert(t, err == nil) - req = &types.QueryCommunityPoolRequest{} - - expPool = &types.QueryCommunityPoolResponse{Pool: sdk.NewDecCoinsFromCoins(amount...)} - }, - }, - } - - for _, testCase := range testCases { - tc := testCase - t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - testCase.malleate() - - pool, err := queryClient.CommunityPool(sdkCtx, req) - - assert.NilError(t, err) - assert.DeepEqual(t, expPool, pool) - }) - } -} - -func TestGRPCDelegationRewards(t *testing.T) { - t.Parallel() - f := initFixture(t) - - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ - CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(1000)}), - }) - - // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - - // Set default staking params - f.stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() - queryClient := types.NewQueryClient(qr) - - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) - addr2 := sdk.AccAddress(PKS[1].Address()) - valAddr2 := sdk.ValAddress(addr2) - delAddr := sdk.AccAddress(PKS[2].Address()) - - // send funds to val addr - funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) - - initialStake := int64(10) - tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) - tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) - - val, found := f.stakingKeeper.GetValidator(sdkCtx, valAddr) - assert.Assert(t, found) - - // setup delegation - delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) - validator, issuedShares := val.AddTokensFromDel(delTokens) - delegation := stakingtypes.NewDelegation(delAddr, valAddr, issuedShares) - f.stakingKeeper.SetDelegation(sdkCtx, delegation) - f.distrKeeper.SetDelegatorStartingInfo(sdkCtx, validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) - - // setup validator rewards - decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())} - historicalRewards := types.NewValidatorHistoricalRewards(decCoins, 2) - f.distrKeeper.SetValidatorHistoricalRewards(sdkCtx, validator.GetOperator(), 2, historicalRewards) - // setup current rewards and outstanding rewards - currentRewards := types.NewValidatorCurrentRewards(decCoins, 3) - f.distrKeeper.SetValidatorCurrentRewards(sdkCtx, valAddr, currentRewards) - f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) - - expRes := &types.QueryDelegationRewardsResponse{ - Rewards: sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initialStake / 10)}}, - } - - // test command delegation rewards grpc - testCases := []struct { - name string - msg *types.QueryDelegationRewardsRequest - expPass bool - expErrMsg string - }{ - { - name: "empty request", - msg: &types.QueryDelegationRewardsRequest{}, - expPass: false, - expErrMsg: "empty delegator address", - }, - { - name: "empty delegator address", - msg: &types.QueryDelegationRewardsRequest{ - DelegatorAddress: "", - ValidatorAddress: valAddr.String(), - }, - expPass: false, - expErrMsg: "empty delegator address", - }, - { - name: "empty validator address", - msg: &types.QueryDelegationRewardsRequest{ - DelegatorAddress: addr2.String(), - ValidatorAddress: "", - }, - expPass: false, - expErrMsg: "empty validator address", - }, - { - name: "request with wrong delegator and validator", - msg: &types.QueryDelegationRewardsRequest{ - DelegatorAddress: addr2.String(), - ValidatorAddress: valAddr2.String(), - }, - expPass: false, - expErrMsg: "validator does not exist", - }, - { - name: "valid request", - msg: &types.QueryDelegationRewardsRequest{ - DelegatorAddress: delAddr.String(), - ValidatorAddress: valAddr.String(), - }, - expPass: true, - }, - } - - for _, testCase := range testCases { - tc := testCase - t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - rewards, err := queryClient.DelegationRewards(sdkCtx, tc.msg) - - if tc.expPass { - assert.NilError(t, err) - assert.DeepEqual(t, expRes, rewards) - } else { - assert.ErrorContains(t, err, tc.expErrMsg) - assert.Assert(t, rewards == nil) - } - }) - } -} From 5d9c00d4955829325239c85b0731f61b24b10e8b Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 10 Apr 2023 12:36:42 +0530 Subject: [PATCH 17/30] address few review comments --- .../distribution/keeper/grpc_query_test.go | 38 +++++++++++++++++++ x/distribution/keeper/grpc_query.go | 13 ++++++- 2 files changed, 49 insertions(+), 2 deletions(-) diff --git a/tests/integration/distribution/keeper/grpc_query_test.go b/tests/integration/distribution/keeper/grpc_query_test.go index 281e73ca6f7d..64e4f3efe4f0 100644 --- a/tests/integration/distribution/keeper/grpc_query_test.go +++ b/tests/integration/distribution/keeper/grpc_query_test.go @@ -103,6 +103,10 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) + // set module account coins + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) @@ -118,6 +122,15 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { addr := sdk.AccAddress(PKS[0].Address()) valAddr := sdk.ValAddress(addr) + // send funds to val addr + funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + + initialStake := int64(10) + tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) + tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) + tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) + // set outstanding rewards f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) rewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) @@ -134,6 +147,12 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { expPass: false, expErrMsg: "empty validator address", }, + { + name: "invalid address", + msg: &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String()}, + expPass: false, + expErrMsg: "validator does not exist", + }, { name: "valid request", msg: &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: valAddr.String()}, @@ -170,6 +189,10 @@ func TestGRPCValidatorCommission(t *testing.T) { integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) + // set module account coins + initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + // Register MsgServer and QueryServer types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) @@ -180,6 +203,15 @@ func TestGRPCValidatorCommission(t *testing.T) { addr := sdk.AccAddress(PKS[0].Address()) valAddr := sdk.ValAddress(addr) + // send funds to val addr + funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + + initialStake := int64(10) + tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) + tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) + tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) + commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} f.distrKeeper.SetValidatorAccumulatedCommission(sdkCtx, valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) @@ -195,6 +227,12 @@ func TestGRPCValidatorCommission(t *testing.T) { expPass: false, expErrMsg: "empty validator address", }, + { + name: "invalid validator", + msg: &types.QueryValidatorCommissionRequest{ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String()}, + expPass: false, + expErrMsg: "validator does not exist", + }, { name: "valid request", msg: &types.QueryValidatorCommissionRequest{ValidatorAddress: valAddr.String()}, diff --git a/x/distribution/keeper/grpc_query.go b/x/distribution/keeper/grpc_query.go index 024d10265598..99bc45a410ae 100644 --- a/x/distribution/keeper/grpc_query.go +++ b/x/distribution/keeper/grpc_query.go @@ -6,9 +6,8 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" - "cosmossdk.io/store/prefix" - "cosmossdk.io/errors" + "cosmossdk.io/store/prefix" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/query" @@ -93,6 +92,11 @@ func (k Querier) ValidatorOutstandingRewards(c context.Context, req *types.Query if err != nil { return nil, err } + + validator := k.stakingKeeper.Validator(ctx, valAdr) + if validator == nil { + return nil, errors.Wrapf(types.ErrNoValidatorExists, valAdr.String()) + } rewards := k.GetValidatorOutstandingRewards(ctx, valAdr) return &types.QueryValidatorOutstandingRewardsResponse{Rewards: rewards}, nil @@ -114,6 +118,11 @@ func (k Querier) ValidatorCommission(c context.Context, req *types.QueryValidato if err != nil { return nil, err } + + validator := k.stakingKeeper.Validator(ctx, valAdr) + if validator == nil { + return nil, errors.Wrapf(types.ErrNoValidatorExists, valAdr.String()) + } commission := k.GetValidatorAccumulatedCommission(ctx, valAdr) return &types.QueryValidatorCommissionResponse{Commission: commission}, nil From ded4ccb7ed8bb9fc8d0d7a9ba25bcc8dd39da379 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 10 Apr 2023 14:07:12 +0530 Subject: [PATCH 18/30] refactor tests --- .../distribution/keeper/grpc_query_test.go | 190 ++++---------- .../distribution/keeper/msg_server_test.go | 241 +++++++----------- 2 files changed, 137 insertions(+), 294 deletions(-) diff --git a/tests/integration/distribution/keeper/grpc_query_test.go b/tests/integration/distribution/keeper/grpc_query_test.go index 64e4f3efe4f0..e08a85a5c155 100644 --- a/tests/integration/distribution/keeper/grpc_query_test.go +++ b/tests/integration/distribution/keeper/grpc_query_test.go @@ -4,20 +4,12 @@ import ( "fmt" "testing" - "cosmossdk.io/log" "cosmossdk.io/math" "gotest.tools/v3/assert" - "github.com/cosmos/cosmos-sdk/testutil/integration" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/query" - "github.com/cosmos/cosmos-sdk/x/auth" - authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation" - "github.com/cosmos/cosmos-sdk/x/bank" - "github.com/cosmos/cosmos-sdk/x/distribution" - distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking" stakingtestutil "github.com/cosmos/cosmos-sdk/x/staking/testutil" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -26,21 +18,9 @@ func TestGRPCParams(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) + f.distrKeeper.SetParams(f.sdkCtx, types.DefaultParams()) - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) - - qr := integrationApp.QueryHelper() + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) var ( @@ -71,7 +51,7 @@ func TestGRPCParams(t *testing.T) { WithdrawAddrEnabled: true, } - assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) + assert.NilError(t, f.distrKeeper.SetParams(f.sdkCtx, params)) expParams = params }, msg: &types.QueryParamsRequest{}, @@ -82,7 +62,7 @@ func TestGRPCParams(t *testing.T) { t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { tc.malleate() - paramsRes, err := queryClient.Params(sdkCtx, tc.msg) + paramsRes, err := queryClient.Params(f.sdkCtx, tc.msg) assert.NilError(t, err) assert.Assert(t, paramsRes != nil) assert.DeepEqual(t, paramsRes.Params, expParams) @@ -95,23 +75,11 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(f.sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - qr := integrationApp.QueryHelper() + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) valCommission := sdk.DecCoins{ @@ -123,17 +91,17 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { valAddr := sdk.ValAddress(addr) // send funds to val addr - funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + funds := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) initialStake := int64(10) - tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) + tstaking := stakingtestutil.NewHelper(t, f.sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) - rewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) + rewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, valAddr) testCases := []struct { name string @@ -163,7 +131,7 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(sdkCtx, tc.msg) + validatorOutstandingRewards, err := queryClient.ValidatorOutstandingRewards(f.sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) @@ -181,39 +149,27 @@ func TestGRPCValidatorCommission(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(f.sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - qr := integrationApp.QueryHelper() + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) addr := sdk.AccAddress(PKS[0].Address()) valAddr := sdk.ValAddress(addr) // send funds to val addr - funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + funds := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) initialStake := int64(10) - tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) + tstaking := stakingtestutil.NewHelper(t, f.sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} - f.distrKeeper.SetValidatorAccumulatedCommission(sdkCtx, valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) + f.distrKeeper.SetValidatorAccumulatedCommission(f.sdkCtx, valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) testCases := []struct { name string @@ -243,7 +199,7 @@ func TestGRPCValidatorCommission(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - commissionRes, err := queryClient.ValidatorCommission(sdkCtx, tc.msg) + commissionRes, err := queryClient.ValidatorCommission(f.sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) @@ -261,19 +217,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) addr := sdk.AccAddress(PKS[0].Address()) @@ -289,7 +233,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { } for i, slash := range slashes { - f.distrKeeper.SetValidatorSlashEvent(sdkCtx, valAddr, uint64(i+2), 0, slash) + f.distrKeeper.SetValidatorSlashEvent(f.sdkCtx, valAddr, uint64(i+2), 0, slash) } var ( @@ -407,7 +351,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { tc.malleate() - slashesRes, err := queryClient.ValidatorSlashes(sdkCtx, req) + slashesRes, err := queryClient.ValidatorSlashes(f.sdkCtx, req) if tc.expPass { assert.NilError(t, err) @@ -424,27 +368,15 @@ func TestGRPCDelegatorWithdrawAddress(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetParams(sdkCtx, types.DefaultParams()) + f.distrKeeper.SetParams(f.sdkCtx, types.DefaultParams()) - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) addr := sdk.AccAddress(PKS[0].Address()) addr2 := sdk.AccAddress(PKS[1].Address()) - err := f.distrKeeper.SetWithdrawAddr(sdkCtx, addr, addr2) + err := f.distrKeeper.SetWithdrawAddr(f.sdkCtx, addr, addr2) assert.Assert(t, err == nil) testCases := []struct { @@ -469,7 +401,7 @@ func TestGRPCDelegatorWithdrawAddress(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - withdrawAddress, err := queryClient.DelegatorWithdrawAddress(sdkCtx, tc.msg) + withdrawAddress, err := queryClient.DelegatorWithdrawAddress(f.sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) @@ -486,23 +418,11 @@ func TestGRPCCommunityPool(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ + f.distrKeeper.SetFeePool(f.sdkCtx, types.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(0)}), }) - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - qr := integrationApp.QueryHelper() + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) addr := sdk.AccAddress(PKS[0].Address()) @@ -527,10 +447,10 @@ func TestGRPCCommunityPool(t *testing.T) { name: "valid request", malleate: func() { amount := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 100)) - assert.NilError(t, f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, amount)) - assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, addr, amount)) + assert.NilError(t, f.bankKeeper.MintCoins(f.sdkCtx, types.ModuleName, amount)) + assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, addr, amount)) - err := f.distrKeeper.FundCommunityPool(sdkCtx, amount, addr) + err := f.distrKeeper.FundCommunityPool(f.sdkCtx, amount, addr) assert.Assert(t, err == nil) req = &types.QueryCommunityPoolRequest{} @@ -544,7 +464,7 @@ func TestGRPCCommunityPool(t *testing.T) { t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { testCase.malleate() - pool, err := queryClient.CommunityPool(sdkCtx, req) + pool, err := queryClient.CommunityPool(f.sdkCtx, req) assert.NilError(t, err) assert.DeepEqual(t, expPool, pool) @@ -556,30 +476,18 @@ func TestGRPCDelegationRewards(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetFeePool(sdkCtx, types.FeePool{ + f.distrKeeper.SetFeePool(f.sdkCtx, types.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(1000)}), }) // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.MintCoins(sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(f.sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Set default staking params - f.stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams()) - - // Register MsgServer and QueryServer - types.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - types.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + f.stakingKeeper.SetParams(f.sdkCtx, stakingtypes.DefaultParams()) - qr := integrationApp.QueryHelper() + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) addr := sdk.AccAddress(PKS[0].Address()) @@ -589,32 +497,32 @@ func TestGRPCDelegationRewards(t *testing.T) { delAddr := sdk.AccAddress(PKS[2].Address()) // send funds to val addr - funds := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + funds := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) initialStake := int64(10) - tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) + tstaking := stakingtestutil.NewHelper(t, f.sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) - val, found := f.stakingKeeper.GetValidator(sdkCtx, valAddr) + val, found := f.stakingKeeper.GetValidator(f.sdkCtx, valAddr) assert.Assert(t, found) // setup delegation delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator, issuedShares := val.AddTokensFromDel(delTokens) delegation := stakingtypes.NewDelegation(delAddr, valAddr, issuedShares) - f.stakingKeeper.SetDelegation(sdkCtx, delegation) - f.distrKeeper.SetDelegatorStartingInfo(sdkCtx, validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) + f.stakingKeeper.SetDelegation(f.sdkCtx, delegation) + f.distrKeeper.SetDelegatorStartingInfo(f.sdkCtx, validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) // setup validator rewards decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())} historicalRewards := types.NewValidatorHistoricalRewards(decCoins, 2) - f.distrKeeper.SetValidatorHistoricalRewards(sdkCtx, validator.GetOperator(), 2, historicalRewards) + f.distrKeeper.SetValidatorHistoricalRewards(f.sdkCtx, validator.GetOperator(), 2, historicalRewards) // setup current rewards and outstanding rewards currentRewards := types.NewValidatorCurrentRewards(decCoins, 3) - f.distrKeeper.SetValidatorCurrentRewards(sdkCtx, valAddr, currentRewards) - f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) + f.distrKeeper.SetValidatorCurrentRewards(f.sdkCtx, valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) expRes := &types.QueryDelegationRewardsResponse{ Rewards: sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initialStake / 10)}}, @@ -673,7 +581,7 @@ func TestGRPCDelegationRewards(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(fmt.Sprintf("Case %s", tc.name), func(t *testing.T) { - rewards, err := queryClient.DelegationRewards(sdkCtx, tc.msg) + rewards, err := queryClient.DelegationRewards(f.sdkCtx, tc.msg) if tc.expPass { assert.NilError(t, err) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index 1a5c620b17e2..4965afca258a 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -37,6 +37,9 @@ type fixture struct { bankKeeper bankkeeper.Keeper distrKeeper distrkeeper.Keeper stakingKeeper *stakingkeeper.Keeper + + sdkCtx sdk.Context + app *integration.App } func initFixture(t assert.TestingT) *fixture { @@ -88,30 +91,34 @@ func initFixture(t assert.TestingT) *fixture { f.stakingKeeper = stakingKeeper f.distrKeeper = distrKeeper - return f -} - -func TestMsgWithdrawDelegatorReward(t *testing.T) { - t.Parallel() - f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetFeePool(sdkCtx, distrtypes.FeePool{ - CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), - }) - initFeePool := f.distrKeeper.GetFeePool(sdkCtx) + integrationApp := integration.NewIntegrationApp(log.NewTestLogger(&testing.T{}), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + f.app = integrationApp + + sdkCtx := sdk.UnwrapSDKContext(f.app.Context()) + f.sdkCtx = sdkCtx + + return f +} + +func TestMsgWithdrawDelegatorReward(t *testing.T) { + t.Parallel() + f := initFixture(t) + + f.distrKeeper.SetFeePool(f.sdkCtx, distrtypes.FeePool{ + CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), + }) + initFeePool := f.distrKeeper.GetFeePool(f.sdkCtx) + addr := sdk.AccAddress(PKS[0].Address()) delAddr := sdk.AccAddress(PKS[1].Address()) @@ -129,33 +136,33 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { assert.NilError(t, err) validator.DelegatorShares = math.LegacyNewDec(100) validator.Tokens = sdk.NewInt(1000000) - f.stakingKeeper.SetValidator(sdkCtx, validator) + f.stakingKeeper.SetValidator(f.sdkCtx, validator) // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // send funds to val addr - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - initBalance := f.bankKeeper.GetAllBalances(sdkCtx, delAddr) + initBalance := f.bankKeeper.GetAllBalances(f.sdkCtx, delAddr) // setup delegation delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(delTokens) delegation := stakingtypes.NewDelegation(delAddr, validator.GetOperator(), issuedShares) - f.stakingKeeper.SetDelegation(sdkCtx, delegation) - f.distrKeeper.SetDelegatorStartingInfo(sdkCtx, validator.GetOperator(), delAddr, distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 20)) + f.stakingKeeper.SetDelegation(f.sdkCtx, delegation) + f.distrKeeper.SetDelegatorStartingInfo(f.sdkCtx, 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) - f.distrKeeper.SetValidatorHistoricalRewards(sdkCtx, validator.GetOperator(), 2, historicalRewards) + f.distrKeeper.SetValidatorHistoricalRewards(f.sdkCtx, validator.GetOperator(), 2, historicalRewards) // setup current rewards and outstanding rewards currentRewards := distrtypes.NewValidatorCurrentRewards(decCoins, 3) - f.distrKeeper.SetValidatorCurrentRewards(sdkCtx, valAddr, currentRewards) - f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) - initOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewardsCoins(sdkCtx, valAddr) + f.distrKeeper.SetValidatorCurrentRewards(f.sdkCtx, valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + initOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewardsCoins(f.sdkCtx, valAddr) testCases := []struct { name string @@ -194,7 +201,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.RunMsg(tc.msg) + res, err := f.app.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -207,13 +214,13 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { assert.NilError(t, err) // check current balance is greater than initial balance - curBalance := f.bankKeeper.GetAllBalances(sdkCtx, sdk.AccAddress(valAddr)) + curBalance := f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(valAddr)) assert.Assert(t, initBalance.IsAllLTE(curBalance)) // check rewards - curFeePool := f.distrKeeper.GetFeePool(sdkCtx) + curFeePool := f.distrKeeper.GetFeePool(f.sdkCtx) rewards := curFeePool.GetCommunityPool().Sub(initFeePool.CommunityPool) - curOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) + curOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, valAddr) assert.DeepEqual(t, rewards, initOutstandingRewards.Sub(curOutstandingRewards.Rewards)) } }) @@ -224,19 +231,7 @@ func TestMsgSetWithdrawAddress(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - - f.distrKeeper.SetParams(sdkCtx, distrtypes.DefaultParams()) + f.distrKeeper.SetParams(f.sdkCtx, distrtypes.DefaultParams()) delAddr := sdk.AccAddress(PKS[0].Address()) withdrawAddr := sdk.AccAddress(PKS[1].Address()) @@ -251,9 +246,9 @@ func TestMsgSetWithdrawAddress(t *testing.T) { { name: "withdraw address disabled", preRun: func() { - params := f.distrKeeper.GetParams(sdkCtx) + params := f.distrKeeper.GetParams(f.sdkCtx) params.WithdrawAddrEnabled = false - assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) + assert.NilError(t, f.distrKeeper.SetParams(f.sdkCtx, params)) }, msg: &distrtypes.MsgSetWithdrawAddress{ DelegatorAddress: delAddr.String(), @@ -265,9 +260,9 @@ func TestMsgSetWithdrawAddress(t *testing.T) { { name: "valid msg", preRun: func() { - params := f.distrKeeper.GetParams(sdkCtx) + params := f.distrKeeper.GetParams(f.sdkCtx) params.WithdrawAddrEnabled = true - assert.NilError(t, f.distrKeeper.SetParams(sdkCtx, params)) + assert.NilError(t, f.distrKeeper.SetParams(f.sdkCtx, params)) }, msg: &distrtypes.MsgSetWithdrawAddress{ DelegatorAddress: delAddr.String(), @@ -280,12 +275,12 @@ func TestMsgSetWithdrawAddress(t *testing.T) { tc := tc t.Run(tc.name, func(t *testing.T) { tc.preRun() - res, err := integrationApp.RunMsg(tc.msg) + res, err := f.app.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) // query the delegator withdraw address - addr := f.distrKeeper.GetDelegatorWithdrawAddr(sdkCtx, delAddr) + addr := f.distrKeeper.GetDelegatorWithdrawAddr(f.sdkCtx, delAddr) assert.DeepEqual(t, addr, delAddr) } else { assert.NilError(t, err) @@ -297,7 +292,7 @@ func TestMsgSetWithdrawAddress(t *testing.T) { assert.NilError(t, err) // query the delegator withdraw address - addr := f.distrKeeper.GetDelegatorWithdrawAddr(sdkCtx, delAddr) + addr := f.distrKeeper.GetDelegatorWithdrawAddr(f.sdkCtx, delAddr) assert.DeepEqual(t, addr, withdrawAddr) } }) @@ -308,18 +303,6 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - valCommission := sdk.DecCoins{ sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5).Quo(math.LegacyNewDec(4))), sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(3).Quo(math.LegacyNewDec(2))), @@ -329,26 +312,26 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { valAddr := sdk.ValAddress(addr) // set module account coins - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // send funds to val addr - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) coins := sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(2)), sdk.NewCoin("stake", sdk.NewInt(2))) - f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, coins) + f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, coins) // check initial balance - balance := f.bankKeeper.GetAllBalances(sdkCtx, sdk.AccAddress(valAddr)) - expTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, 1000) + balance := f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(valAddr)) + expTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 1000) expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) assert.DeepEqual(t, expCoins, balance) // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) // set commission - f.distrKeeper.SetValidatorAccumulatedCommission(sdkCtx, valAddr, distrtypes.ValidatorAccumulatedCommission{Commission: valCommission}) + f.distrKeeper.SetValidatorAccumulatedCommission(f.sdkCtx, valAddr, distrtypes.ValidatorAccumulatedCommission{Commission: valCommission}) testCases := []struct { name string @@ -376,7 +359,7 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.RunMsg(tc.msg) + res, err := f.app.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -389,14 +372,14 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { assert.NilError(t, err) // check balance increase - balance = f.bankKeeper.GetAllBalances(sdkCtx, sdk.AccAddress(valAddr)) + balance = f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(valAddr)) assert.DeepEqual(t, sdk.NewCoins( sdk.NewCoin("mytoken", sdk.NewInt(1)), sdk.NewCoin("stake", expTokens.AddRaw(1)), ), balance) // check remainder - remainder := f.distrKeeper.GetValidatorAccumulatedCommission(sdkCtx, valAddr).Commission + remainder := f.distrKeeper.GetValidatorAccumulatedCommission(f.sdkCtx, valAddr).Commission assert.DeepEqual(t, sdk.DecCoins{ sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(1).Quo(math.LegacyNewDec(4))), sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(1).Quo(math.LegacyNewDec(2))), @@ -411,34 +394,22 @@ func TestMsgFundCommunityPool(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - // reset fee pool - f.distrKeeper.SetFeePool(sdkCtx, distrtypes.InitialFeePool()) - initPool := f.distrKeeper.GetFeePool(sdkCtx) + f.distrKeeper.SetFeePool(f.sdkCtx, distrtypes.InitialFeePool()) + initPool := f.distrKeeper.GetFeePool(f.sdkCtx) assert.Assert(t, initPool.CommunityPool.Empty()) - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(100)) - f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) - - // Register MsgServer and QueryServer - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(100)) + f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) addr := sdk.AccAddress(PKS[0].Address()) addr2 := sdk.AccAddress(PKS[1].Address()) amount := sdk.NewCoins(sdk.NewInt64Coin("stake", 100)) // fund the account by minting and sending amount from distribution module to addr - err := f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, amount) + err := f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, amount) assert.NilError(t, err) - err = f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, addr, amount) + err = f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, addr, amount) assert.NilError(t, err) testCases := []struct { @@ -468,7 +439,7 @@ func TestMsgFundCommunityPool(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.RunMsg(tc.msg) + res, err := f.app.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -481,8 +452,8 @@ func TestMsgFundCommunityPool(t *testing.T) { assert.NilError(t, err) // query the community pool funds - assert.DeepEqual(t, initPool.CommunityPool.Add(sdk.NewDecCoinsFromCoins(amount...)...), f.distrKeeper.GetFeePool(sdkCtx).CommunityPool) - assert.Assert(t, f.bankKeeper.GetAllBalances(sdkCtx, addr).Empty()) + assert.DeepEqual(t, initPool.CommunityPool.Add(sdk.NewDecCoinsFromCoins(amount...)...), f.distrKeeper.GetFeePool(f.sdkCtx).CommunityPool) + assert.Assert(t, f.bankKeeper.GetAllBalances(f.sdkCtx, addr).Empty()) } }) } @@ -496,18 +467,6 @@ func TestMsgUpdateParams(t *testing.T) { communityTax := sdk.NewDecWithPrec(2, 2) // 2% withdrawAddrEnabled := true - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - // Register MsgServer and QueryServer - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) - testCases := []struct { name string msg *distrtypes.MsgUpdateParams @@ -602,7 +561,7 @@ func TestMsgUpdateParams(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.RunMsg(tc.msg) + res, err := f.app.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -615,7 +574,7 @@ func TestMsgUpdateParams(t *testing.T) { assert.NilError(t, err) // query the params and verify it has been updated - params := f.distrKeeper.GetParams(sdkCtx) + params := f.distrKeeper.GetParams(f.sdkCtx) assert.DeepEqual(t, distrtypes.DefaultParams(), params) } }) @@ -626,26 +585,14 @@ func TestMsgCommunityPoolSpend(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetParams(sdkCtx, distrtypes.DefaultParams()) - f.distrKeeper.SetFeePool(sdkCtx, distrtypes.FeePool{ + f.distrKeeper.SetParams(f.sdkCtx, distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(f.sdkCtx, distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), }) - initialFeePool := f.distrKeeper.GetFeePool(sdkCtx) - - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(100)) - f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initialFeePool := f.distrKeeper.GetFeePool(f.sdkCtx) - // Register MsgServer and QueryServer - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(100)) + f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) recipient := sdk.AccAddress([]byte("addr1")) @@ -688,7 +635,7 @@ func TestMsgCommunityPoolSpend(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.RunMsg(tc.msg) + res, err := f.app.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -701,7 +648,7 @@ func TestMsgCommunityPoolSpend(t *testing.T) { assert.NilError(t, err) // query the community pool to verify it has been updated - communityPool := f.distrKeeper.GetFeePoolCommunityCoins(sdkCtx) + communityPool := f.distrKeeper.GetFeePoolCommunityCoins(f.sdkCtx) newPool, negative := initialFeePool.CommunityPool.SafeSub(sdk.NewDecCoinsFromCoins(tc.msg.Amount...)) assert.Assert(t, negative == false) assert.DeepEqual(t, communityPool, newPool) @@ -714,47 +661,35 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { t.Parallel() f := initFixture(t) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(t), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) - sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) - - f.distrKeeper.SetParams(sdkCtx, distrtypes.DefaultParams()) - f.distrKeeper.SetFeePool(sdkCtx, distrtypes.FeePool{ + f.distrKeeper.SetParams(f.sdkCtx, distrtypes.DefaultParams()) + f.distrKeeper.SetFeePool(f.sdkCtx, distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(100)}), }) - initTokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(10000)) - f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(10000)) + f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // Set default staking params - f.stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams()) - - // Register MsgServer and QueryServer - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + f.stakingKeeper.SetParams(f.sdkCtx, stakingtypes.DefaultParams()) addr := sdk.AccAddress([]byte("addr")) addr1 := sdk.AccAddress(PKS[0].Address()) valAddr1 := sdk.ValAddress(addr1) // send funds to val addr - tokens := f.stakingKeeper.TokensFromConsensusPower(sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr1), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr1), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) // send funds from module to addr to perform DepositValidatorRewardsPool - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, tokens))) - tstaking := stakingtestutil.NewHelper(t, sdkCtx, f.stakingKeeper) + tstaking := stakingtestutil.NewHelper(t, f.sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) tstaking.CreateValidator(valAddr1, valConsPk0, sdk.NewInt(100), true) // mint a non-staking token and send to an account amt := sdk.NewCoins(sdk.NewInt64Coin("foo", 500)) - f.bankKeeper.MintCoins(sdkCtx, distrtypes.ModuleName, amt) - f.bankKeeper.SendCoinsFromModuleToAccount(sdkCtx, distrtypes.ModuleName, addr, amt) + f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, amt) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, addr, amt) testCases := []struct { name string @@ -767,7 +702,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { msg: &distrtypes.MsgDepositValidatorRewardsPool{ Authority: addr.String(), ValidatorAddress: valAddr1.String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(sdkCtx), sdk.NewInt(100))), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(f.sdkCtx), sdk.NewInt(100))), }, }, { @@ -783,7 +718,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { msg: &distrtypes.MsgDepositValidatorRewardsPool{ Authority: addr.String(), ValidatorAddress: sdk.ValAddress([]byte("addr1_______________")).String(), - Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(sdkCtx), sdk.NewInt(100))), + Amount: sdk.NewCoins(sdk.NewCoin(f.stakingKeeper.BondDenom(f.sdkCtx), sdk.NewInt(100))), }, expErr: true, expErrMsg: "validator does not exist", @@ -793,7 +728,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := integrationApp.RunMsg(tc.msg) + res, err := f.app.RunMsg(tc.msg) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -809,7 +744,7 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { assert.NilError(t, err) // check validator outstanding rewards - outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(sdkCtx, valAddr) + outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, valAddr) for _, c := range tc.msg.Amount { x := outstandingRewards.Rewards.AmountOf(c.Denom) assert.DeepEqual(t, x, sdk.NewDecFromInt(c.Amount)) From 85d8135e3cd26f73a4839c2e54ce22bdfc62f93c Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Mon, 10 Apr 2023 15:19:44 +0530 Subject: [PATCH 19/30] add begin and end blocker of the module in tests --- .../distribution/keeper/msg_server_test.go | 44 +++++++++++++++---- 1 file changed, 36 insertions(+), 8 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index 4965afca258a..502b2a917d74 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -81,7 +81,7 @@ func initFixture(t assert.TestingT) *fixture { stakingKeeper := stakingkeeper.NewKeeper(cdc, keys[stakingtypes.StoreKey], accountKeeper, bankKeeper, authority.String()) distrKeeper := distrkeeper.NewKeeper( - cdc, keys[distrtypes.StoreKey], accountKeeper, bankKeeper, stakingKeeper, authtypes.FeeCollectorName, authority.String(), + cdc, keys[distrtypes.StoreKey], accountKeeper, bankKeeper, stakingKeeper, distrtypes.ModuleName, authority.String(), ) f.cdc = cdc @@ -201,7 +201,11 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := f.app.RunMsg(tc.msg) + res, err := f.app.RunMsg( + tc.msg, + integration.WithAutomaticBeginEndBlock(), + integration.WithAutomaticCommit(), + ) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -275,7 +279,11 @@ func TestMsgSetWithdrawAddress(t *testing.T) { tc := tc t.Run(tc.name, func(t *testing.T) { tc.preRun() - res, err := f.app.RunMsg(tc.msg) + res, err := f.app.RunMsg( + tc.msg, + integration.WithAutomaticBeginEndBlock(), + integration.WithAutomaticCommit(), + ) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) @@ -359,7 +367,11 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := f.app.RunMsg(tc.msg) + res, err := f.app.RunMsg( + tc.msg, + integration.WithAutomaticBeginEndBlock(), + integration.WithAutomaticCommit(), + ) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -439,7 +451,11 @@ func TestMsgFundCommunityPool(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := f.app.RunMsg(tc.msg) + res, err := f.app.RunMsg( + tc.msg, + integration.WithAutomaticBeginEndBlock(), + integration.WithAutomaticCommit(), + ) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -561,7 +577,11 @@ func TestMsgUpdateParams(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := f.app.RunMsg(tc.msg) + res, err := f.app.RunMsg( + tc.msg, + integration.WithAutomaticBeginEndBlock(), + integration.WithAutomaticCommit(), + ) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -635,7 +655,11 @@ func TestMsgCommunityPoolSpend(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := f.app.RunMsg(tc.msg) + res, err := f.app.RunMsg( + tc.msg, + integration.WithAutomaticBeginEndBlock(), + integration.WithAutomaticCommit(), + ) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { @@ -728,7 +752,11 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - res, err := f.app.RunMsg(tc.msg) + res, err := f.app.RunMsg( + tc.msg, + integration.WithAutomaticBeginEndBlock(), + integration.WithAutomaticCommit(), + ) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { From 9fa8e865bcbb8cbc213efeab5cf295c9055f145b Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 11 Apr 2023 12:52:08 +0530 Subject: [PATCH 20/30] wip: add custom begin blocker --- .../distribution/keeper/msg_server_test.go | 29 +++++++++++++++++-- testutil/integration/options.go | 11 +++++++ testutil/integration/router.go | 6 ++-- 3 files changed, 42 insertions(+), 4 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index 502b2a917d74..987e08b6c95b 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -1,11 +1,13 @@ package keeper_test import ( + "fmt" "testing" "cosmossdk.io/log" "cosmossdk.io/math" storetypes "cosmossdk.io/store/types" + cmtabcitypes "github.com/cometbft/cometbft/abci/types" "gotest.tools/v3/assert" "github.com/cosmos/cosmos-sdk/codec" @@ -197,15 +199,38 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { expErr: false, }, } - + height := f.app.LastBlockHeight() for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { + req := cmtabcitypes.RequestBeginBlock{ + LastCommitInfo: cmtabcitypes.CommitInfo{ + Round: 1, + Votes: []cmtabcitypes.VoteInfo{ + { + Validator: cmtabcitypes.Validator{ + Address: valAddr, + Power: 100, + }, + SignedLastBlock: true, + }, + }, + }, + } res, err := f.app.RunMsg( tc.msg, - integration.WithAutomaticBeginEndBlock(), + // integration.WithAutomaticBeginEndBlock(), + integration.WithCustomBeginBlock(req), integration.WithAutomaticCommit(), ) + + height++ + if f.app.LastBlockHeight() != height { + panic(fmt.Errorf("expected block height to be %d, got %d", height, f.app.LastBlockHeight())) + } + + + if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) } else { diff --git a/testutil/integration/options.go b/testutil/integration/options.go index a67327c01b21..ba4ca820d771 100644 --- a/testutil/integration/options.go +++ b/testutil/integration/options.go @@ -1,14 +1,25 @@ package integration +import cmtabcitypes "github.com/cometbft/cometbft/abci/types" + // Config is the configuration for the integration app. type Config struct { AutomaticBeginEndBlock bool AutomaticCommit bool + CustomBeginBlock cmtabcitypes.RequestBeginBlock } // Option is a function that can be used to configure the integration app. type Option func(*Config) +// WithCustomBeginBlock takes additional params into the configuration. +func WithCustomBeginBlock(req cmtabcitypes.RequestBeginBlock) Option { + return func(cfg *Config) { + cfg.AutomaticBeginEndBlock = true + cfg.CustomBeginBlock = req + } +} + // WithAutomaticBlockCreation enables begin/end block calls. func WithAutomaticBeginEndBlock() Option { return func(cfg *Config) { diff --git a/testutil/integration/router.go b/testutil/integration/router.go index 3cbf34172bc1..c2b2612bcb97 100644 --- a/testutil/integration/router.go +++ b/testutil/integration/router.go @@ -102,8 +102,10 @@ func (app *App) RunMsg(msg sdk.Msg, option ...Option) (*codectypes.Any, error) { if cfg.AutomaticBeginEndBlock { height := app.LastBlockHeight() + 1 - app.logger.Info("Running beging block", "height", height) - app.BeginBlock(cmtabcitypes.RequestBeginBlock{Header: cmtproto.Header{Height: height, ChainID: appName}}) + cfg.CustomBeginBlock.Header.Height = height + cfg.CustomBeginBlock.Header.ChainID = appName + app.logger.Info("Running begin block", "height", height) + app.BeginBlock(cfg.CustomBeginBlock) defer func() { app.logger.Info("Running end block", "height", height) app.EndBlock(cmtabcitypes.RequestEndBlock{}) From 352962b7f41139fefa0b07da0dce28486f0ec5ec Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 11 Apr 2023 14:23:25 +0530 Subject: [PATCH 21/30] wip: contains commented code --- .../distribution/keeper/msg_server_test.go | 52 +++++++++++++------ 1 file changed, 35 insertions(+), 17 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index 987e08b6c95b..ce1d9d423ed5 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -131,6 +131,17 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { // setup staking validator valAddr := sdk.ValAddress(addr) + valConsAddr := sdk.ConsAddress(valConsPk0.Address()) + f.sdkCtx = f.sdkCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ + { + Validator: cmtabcitypes.Validator{ + Address: valAddr, + Power: 100, + }, + SignedLastBlock: true, + }, + }) + validator, err := stakingtypes.NewValidator(valAddr, PKS[0], stakingtypes.Description{}) assert.NilError(t, err) commission := stakingtypes.NewCommission(math.LegacyZeroDec(), math.LegacyOneDec(), math.LegacyOneDec()) @@ -203,24 +214,9 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - req := cmtabcitypes.RequestBeginBlock{ - LastCommitInfo: cmtabcitypes.CommitInfo{ - Round: 1, - Votes: []cmtabcitypes.VoteInfo{ - { - Validator: cmtabcitypes.Validator{ - Address: valAddr, - Power: 100, - }, - SignedLastBlock: true, - }, - }, - }, - } res, err := f.app.RunMsg( tc.msg, - // integration.WithAutomaticBeginEndBlock(), - integration.WithCustomBeginBlock(req), + integration.WithAutomaticBeginEndBlock(), integration.WithAutomaticCommit(), ) @@ -229,7 +225,29 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { panic(fmt.Errorf("expected block height to be %d, got %d", height, f.app.LastBlockHeight())) } - + // queryClient := distrtypes.NewQueryClient(f.app.QueryHelper()) + prevProposerConsAddr := f.distrKeeper.GetPreviousProposerConsAddr(f.sdkCtx) + assert.Assert(t, prevProposerConsAddr.Empty() == false) + // // fmt.Printf("f.sdkCtx.VoteInfos(): %v\n", f.sdkCtx.VoteInfos()) + // check := func(ctx sdk.Context, expRewards sdk.DecCoins) { + // // fmt.Printf("ctx.VoteInfos(): %v\n", ctx.VoteInfos()) + // // macc := f.accountKeeper.GetModuleAccount(ctx, distrtypes.ModuleName) + // // amount := f.bankKeeper.GetAllBalances(ctx, macc.GetAddress()) + // // fmt.Printf("amount: %v\n", amount) + // // fmt.Printf("macc: %v\n", macc) + // distribution.BeginBlocker(ctx, f.distrKeeper) + // resp, err := queryClient.DelegationTotalRewards(ctx, &distrtypes.QueryDelegationTotalRewardsRequest{ + // DelegatorAddress: delAddr.String(), + // }) + // assert.NilError(t, err) + // assert.Assert(t, resp != nil) + // fmt.Printf("res.Rewards: %v\n", resp.Rewards) + // assert.DeepEqual(t, resp.Total, expRewards) + // consAddr := f.distrKeeper.GetPreviousProposerConsAddr(ctx) + // assert.DeepEqual(t, consAddr, valConsAddr) + // } + + // check(f.sdkCtx, sdk.NewDecCoins(sdk.NewDecCoin(sdk.DefaultBondDenom, sdk.NewInt(10)))) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) From 2cdf676491df05233dc397473919267f7d8963d4 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 11 Apr 2023 15:42:43 +0530 Subject: [PATCH 22/30] wip: begin/end block tests --- testutil/integration/example_test.go | 10 +++++++++- testutil/integration/router.go | 10 ++++------ 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/testutil/integration/example_test.go b/testutil/integration/example_test.go index 4811109483fd..9c2458df0df2 100644 --- a/testutil/integration/example_test.go +++ b/testutil/integration/example_test.go @@ -6,7 +6,11 @@ import ( "cosmossdk.io/log" storetypes "cosmossdk.io/store/types" + + "github.com/google/go-cmp/cmp" + "github.com/cosmos/cosmos-sdk/runtime" + "github.com/cosmos/cosmos-sdk/testutil" "github.com/cosmos/cosmos-sdk/testutil/integration" sdk "github.com/cosmos/cosmos-sdk/types" moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" @@ -17,7 +21,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/mint" mintkeeper "github.com/cosmos/cosmos-sdk/x/mint/keeper" minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" - "github.com/google/go-cmp/cmp" ) // Example shows how to use the integration test framework to test the integration of SDK modules. @@ -29,6 +32,8 @@ func Example() { keys := storetypes.NewKVStoreKeys(authtypes.StoreKey, minttypes.StoreKey) authority := authtypes.NewModuleAddress("gov").String() + testCtx := testutil.DefaultContext(keys[minttypes.StoreKey], storetypes.NewTransientStoreKey("transient_test")) + accountKeeper := authkeeper.NewAccountKeeper( encodingCfg.Codec, runtime.NewKVStoreService(keys[authtypes.StoreKey]), @@ -49,6 +54,7 @@ func Example() { // create the application and register all the modules from the previous step // replace the logger by testing values in a real test case (e.g. log.NewTestLogger(t)) integrationApp := integration.NewIntegrationApp( + testCtx, log.NewLogger(io.Discard, log.OutputJSONOption()), keys, encodingCfg.Codec, @@ -103,6 +109,7 @@ func Example_oneModule() { encodingCfg := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}) keys := storetypes.NewKVStoreKeys(authtypes.StoreKey) authority := authtypes.NewModuleAddress("gov").String() + testCtx := testutil.DefaultContext(keys[authtypes.StoreKey], storetypes.NewTransientStoreKey("transient_test")) accountKeeper := authkeeper.NewAccountKeeper( encodingCfg.Codec, @@ -119,6 +126,7 @@ func Example_oneModule() { // create the application and register all the modules from the previous step // replace the logger by testing values in a real test case (e.g. log.NewTestLogger(t)) integrationApp := integration.NewIntegrationApp( + testCtx, log.NewLogger(io.Discard), keys, encodingCfg.Codec, diff --git a/testutil/integration/router.go b/testutil/integration/router.go index c2b2612bcb97..64e8613ef740 100644 --- a/testutil/integration/router.go +++ b/testutil/integration/router.go @@ -31,7 +31,7 @@ type App struct { } // NewIntegrationApp creates an application for testing purposes. This application is able to route messages to their respective handlers. -func NewIntegrationApp(logger log.Logger, keys map[string]*storetypes.KVStoreKey, appCodec codec.Codec, modules ...module.AppModule) *App { +func NewIntegrationApp(sdkCtx sdk.Context, logger log.Logger, keys map[string]*storetypes.KVStoreKey, appCodec codec.Codec, modules ...module.AppModule) *App { db := dbm.NewMemDB() interfaceRegistry := codectypes.NewInterfaceRegistry() @@ -72,7 +72,7 @@ func NewIntegrationApp(logger log.Logger, keys map[string]*storetypes.KVStoreKey bApp.InitChain(cmtabcitypes.RequestInitChain{ChainId: appName}) bApp.Commit() - ctx := bApp.NewContext(true, cmtproto.Header{ChainID: appName}) + ctx := sdkCtx.WithBlockHeader(cmtproto.Header{ChainID: appName}).WithIsCheckTx(true) return &App{ BaseApp: bApp, @@ -102,10 +102,8 @@ func (app *App) RunMsg(msg sdk.Msg, option ...Option) (*codectypes.Any, error) { if cfg.AutomaticBeginEndBlock { height := app.LastBlockHeight() + 1 - cfg.CustomBeginBlock.Header.Height = height - cfg.CustomBeginBlock.Header.ChainID = appName - app.logger.Info("Running begin block", "height", height) - app.BeginBlock(cfg.CustomBeginBlock) + app.logger.Info("Running beging block", "height", height) + app.BeginBlock(cmtabcitypes.RequestBeginBlock{Header: cmtproto.Header{Height: height, ChainID: appName}}) defer func() { app.logger.Info("Running end block", "height", height) app.EndBlock(cmtabcitypes.RequestEndBlock{}) From 3156ca508feaffd8f56eb0ccf5e7180e2938272e Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 11 Apr 2023 15:43:07 +0530 Subject: [PATCH 23/30] wip: msg server changes --- .../distribution/keeper/msg_server_test.go | 76 +++++++++++++------ 1 file changed, 51 insertions(+), 25 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index ce1d9d423ed5..c0c28062d62e 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -6,10 +6,15 @@ import ( "cosmossdk.io/log" "cosmossdk.io/math" + "cosmossdk.io/store" + "cosmossdk.io/store/metrics" storetypes "cosmossdk.io/store/types" cmtabcitypes "github.com/cometbft/cometbft/abci/types" + "github.com/cometbft/cometbft/proto/tendermint/types" "gotest.tools/v3/assert" + dbm "github.com/cosmos/cosmos-db" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/testutil/integration" @@ -42,6 +47,9 @@ type fixture struct { sdkCtx sdk.Context app *integration.App + + addr sdk.AccAddress + valAddr sdk.ValAddress } func initFixture(t assert.TestingT) *fixture { @@ -52,6 +60,15 @@ func initFixture(t assert.TestingT) *fixture { ) cdc := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}, distribution.AppModuleBasic{}).Codec + db := dbm.NewMemDB() + cms := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics()) + for key := range keys { + cms.MountStoreWithDB(keys[key], storetypes.StoreTypeIAVL, db) + } + _ = cms.LoadLatestVersion() + + newCtx := sdk.NewContext(cms, types.Header{}, true, log.NewTestLogger(&testing.T{})) + authority := authtypes.NewModuleAddress("gov") maccPerms := map[string][]string{ @@ -98,7 +115,20 @@ func initFixture(t assert.TestingT) *fixture { stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - integrationApp := integration.NewIntegrationApp(log.NewTestLogger(&testing.T{}), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + f.addr = sdk.AccAddress(PKS[0].Address()) + f.valAddr = sdk.ValAddress(f.addr) + valConsAddr := sdk.ConsAddress(valConsPk0.Address()) + ctx := newCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ + { + Validator: cmtabcitypes.Validator{ + Address: f.valAddr, + Power: 100, + }, + SignedLastBlock: true, + }, + }) + + integrationApp := integration.NewIntegrationApp(ctx, log.NewTestLogger(&testing.T{}), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) @@ -121,7 +151,6 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { }) initFeePool := f.distrKeeper.GetFeePool(f.sdkCtx) - addr := sdk.AccAddress(PKS[0].Address()) delAddr := sdk.AccAddress(PKS[1].Address()) valCommission := sdk.DecCoins{ @@ -130,19 +159,19 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { } // setup staking validator - valAddr := sdk.ValAddress(addr) valConsAddr := sdk.ConsAddress(valConsPk0.Address()) f.sdkCtx = f.sdkCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ { Validator: cmtabcitypes.Validator{ - Address: valAddr, + Address: f.valAddr, Power: 100, }, SignedLastBlock: true, }, }) + f.distrKeeper.SetPreviousProposerConsAddr(f.sdkCtx, valConsAddr) - validator, err := stakingtypes.NewValidator(valAddr, PKS[0], stakingtypes.Description{}) + validator, err := stakingtypes.NewValidator(f.valAddr, PKS[0], stakingtypes.Description{}) assert.NilError(t, err) commission := stakingtypes.NewCommission(math.LegacyZeroDec(), math.LegacyOneDec(), math.LegacyOneDec()) validator, err = validator.SetInitialCommission(commission) @@ -156,7 +185,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // send funds to val addr - f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, sdk.AccAddress(f.valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) initBalance := f.bankKeeper.GetAllBalances(f.sdkCtx, delAddr) @@ -173,9 +202,9 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { f.distrKeeper.SetValidatorHistoricalRewards(f.sdkCtx, validator.GetOperator(), 2, historicalRewards) // setup current rewards and outstanding rewards currentRewards := distrtypes.NewValidatorCurrentRewards(decCoins, 3) - f.distrKeeper.SetValidatorCurrentRewards(f.sdkCtx, valAddr, currentRewards) - f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) - initOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewardsCoins(f.sdkCtx, valAddr) + f.distrKeeper.SetValidatorCurrentRewards(f.sdkCtx, f.valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, f.valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + initOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewardsCoins(f.sdkCtx, f.valAddr) testCases := []struct { name string @@ -187,7 +216,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { name: "delegator with no delegations", msg: &distrtypes.MsgWithdrawDelegatorReward{ DelegatorAddress: sdk.AccAddress([]byte("invalid")).String(), - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), }, expErr: true, expErrMsg: "no delegation distribution info", @@ -205,7 +234,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { name: "valid msg", msg: &distrtypes.MsgWithdrawDelegatorReward{ DelegatorAddress: delAddr.String(), - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), }, expErr: false, }, @@ -261,13 +290,13 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { assert.NilError(t, err) // check current balance is greater than initial balance - curBalance := f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(valAddr)) + curBalance := f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(f.valAddr)) assert.Assert(t, initBalance.IsAllLTE(curBalance)) // check rewards curFeePool := f.distrKeeper.GetFeePool(f.sdkCtx) rewards := curFeePool.GetCommunityPool().Sub(initFeePool.CommunityPool) - curOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, valAddr) + curOutstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, f.valAddr) assert.DeepEqual(t, rewards, initOutstandingRewards.Sub(curOutstandingRewards.Rewards)) } }) @@ -359,30 +388,27 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(3).Quo(math.LegacyNewDec(2))), } - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) - // set module account coins initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) // send funds to val addr - f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, distrtypes.ModuleName, sdk.AccAddress(f.valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) coins := sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(2)), sdk.NewCoin("stake", sdk.NewInt(2))) f.bankKeeper.MintCoins(f.sdkCtx, distrtypes.ModuleName, coins) // check initial balance - balance := f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(valAddr)) + balance := f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(f.valAddr)) expTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 1000) expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) assert.DeepEqual(t, expCoins, balance) // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, f.valAddr, distrtypes.ValidatorOutstandingRewards{Rewards: valCommission}) // set commission - f.distrKeeper.SetValidatorAccumulatedCommission(f.sdkCtx, valAddr, distrtypes.ValidatorAccumulatedCommission{Commission: valCommission}) + f.distrKeeper.SetValidatorAccumulatedCommission(f.sdkCtx, f.valAddr, distrtypes.ValidatorAccumulatedCommission{Commission: valCommission}) testCases := []struct { name string @@ -401,7 +427,7 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { { name: "valid msg", msg: &distrtypes.MsgWithdrawValidatorCommission{ - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), }, expErr: false, }, @@ -427,14 +453,14 @@ func TestMsgWithdrawValidatorCommission(t *testing.T) { assert.NilError(t, err) // check balance increase - balance = f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(valAddr)) + balance = f.bankKeeper.GetAllBalances(f.sdkCtx, sdk.AccAddress(f.valAddr)) assert.DeepEqual(t, sdk.NewCoins( sdk.NewCoin("mytoken", sdk.NewInt(1)), sdk.NewCoin("stake", expTokens.AddRaw(1)), ), balance) // check remainder - remainder := f.distrKeeper.GetValidatorAccumulatedCommission(f.sdkCtx, valAddr).Commission + remainder := f.distrKeeper.GetValidatorAccumulatedCommission(f.sdkCtx, f.valAddr).Commission assert.DeepEqual(t, sdk.DecCoins{ sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(1).Quo(math.LegacyNewDec(4))), sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(1).Quo(math.LegacyNewDec(2))), @@ -811,11 +837,11 @@ func TestMsgDepositValidatorRewardsPool(t *testing.T) { err = f.cdc.Unmarshal(res.Value, &result) assert.NilError(t, err) - valAddr, err := sdk.ValAddressFromBech32(tc.msg.ValidatorAddress) + val, err := sdk.ValAddressFromBech32(tc.msg.ValidatorAddress) assert.NilError(t, err) // check validator outstanding rewards - outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, valAddr) + outstandingRewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, val) for _, c := range tc.msg.Amount { x := outstandingRewards.Rewards.AmountOf(c.Denom) assert.DeepEqual(t, x, sdk.NewDecFromInt(c.Amount)) From ca0e60bfd068857e1ca3d081160816421ed1c157 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 11 Apr 2023 15:45:55 +0530 Subject: [PATCH 24/30] wip: add nit --- testutil/integration/example_test.go | 30 +++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/testutil/integration/example_test.go b/testutil/integration/example_test.go index 9c2458df0df2..ae696e3c008c 100644 --- a/testutil/integration/example_test.go +++ b/testutil/integration/example_test.go @@ -3,14 +3,19 @@ package integration_test import ( "fmt" "io" + "testing" "cosmossdk.io/log" + "cosmossdk.io/store" + "cosmossdk.io/store/metrics" storetypes "cosmossdk.io/store/types" + "github.com/cometbft/cometbft/proto/tendermint/types" "github.com/google/go-cmp/cmp" + dbm "github.com/cosmos/cosmos-db" + "github.com/cosmos/cosmos-sdk/runtime" - "github.com/cosmos/cosmos-sdk/testutil" "github.com/cosmos/cosmos-sdk/testutil/integration" sdk "github.com/cosmos/cosmos-sdk/types" moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" @@ -32,7 +37,14 @@ func Example() { keys := storetypes.NewKVStoreKeys(authtypes.StoreKey, minttypes.StoreKey) authority := authtypes.NewModuleAddress("gov").String() - testCtx := testutil.DefaultContext(keys[minttypes.StoreKey], storetypes.NewTransientStoreKey("transient_test")) + db := dbm.NewMemDB() + cms := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics()) + for key := range keys { + cms.MountStoreWithDB(keys[key], storetypes.StoreTypeIAVL, db) + } + _ = cms.LoadLatestVersion() + + newCtx := sdk.NewContext(cms, types.Header{}, true, log.NewTestLogger(&testing.T{})) accountKeeper := authkeeper.NewAccountKeeper( encodingCfg.Codec, @@ -54,7 +66,7 @@ func Example() { // create the application and register all the modules from the previous step // replace the logger by testing values in a real test case (e.g. log.NewTestLogger(t)) integrationApp := integration.NewIntegrationApp( - testCtx, + newCtx, log.NewLogger(io.Discard, log.OutputJSONOption()), keys, encodingCfg.Codec, @@ -109,7 +121,15 @@ func Example_oneModule() { encodingCfg := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}) keys := storetypes.NewKVStoreKeys(authtypes.StoreKey) authority := authtypes.NewModuleAddress("gov").String() - testCtx := testutil.DefaultContext(keys[authtypes.StoreKey], storetypes.NewTransientStoreKey("transient_test")) + + db := dbm.NewMemDB() + cms := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics()) + for key := range keys { + cms.MountStoreWithDB(keys[key], storetypes.StoreTypeIAVL, db) + } + _ = cms.LoadLatestVersion() + + newCtx := sdk.NewContext(cms, types.Header{}, true, log.NewTestLogger(&testing.T{})) accountKeeper := authkeeper.NewAccountKeeper( encodingCfg.Codec, @@ -126,7 +146,7 @@ func Example_oneModule() { // create the application and register all the modules from the previous step // replace the logger by testing values in a real test case (e.g. log.NewTestLogger(t)) integrationApp := integration.NewIntegrationApp( - testCtx, + newCtx, log.NewLogger(io.Discard), keys, encodingCfg.Codec, From 05ed42c94115c62b426d9b621e56d1d718ec2603 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 11 Apr 2023 16:13:42 +0530 Subject: [PATCH 25/30] wip: more checks --- .../distribution/keeper/msg_server_test.go | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index c0c28062d62e..75ea5dcf7ffa 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -118,6 +118,8 @@ func initFixture(t assert.TestingT) *fixture { f.addr = sdk.AccAddress(PKS[0].Address()) f.valAddr = sdk.ValAddress(f.addr) valConsAddr := sdk.ConsAddress(valConsPk0.Address()) + + // set proposer and vote infos ctx := newCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ { Validator: cmtabcitypes.Validator{ @@ -160,15 +162,6 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { // setup staking validator valConsAddr := sdk.ConsAddress(valConsPk0.Address()) - f.sdkCtx = f.sdkCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ - { - Validator: cmtabcitypes.Validator{ - Address: f.valAddr, - Power: 100, - }, - SignedLastBlock: true, - }, - }) f.distrKeeper.SetPreviousProposerConsAddr(f.sdkCtx, valConsAddr) validator, err := stakingtypes.NewValidator(f.valAddr, PKS[0], stakingtypes.Description{}) @@ -257,6 +250,8 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { // queryClient := distrtypes.NewQueryClient(f.app.QueryHelper()) prevProposerConsAddr := f.distrKeeper.GetPreviousProposerConsAddr(f.sdkCtx) assert.Assert(t, prevProposerConsAddr.Empty() == false) + assert.DeepEqual(t, prevProposerConsAddr, valConsAddr) + // // fmt.Printf("f.sdkCtx.VoteInfos(): %v\n", f.sdkCtx.VoteInfos()) // check := func(ctx sdk.Context, expRewards sdk.DecCoins) { // // fmt.Printf("ctx.VoteInfos(): %v\n", ctx.VoteInfos()) From c19147cf9abc91286b4af8b779852c03b456209e Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Tue, 11 Apr 2023 16:53:55 +0530 Subject: [PATCH 26/30] discard unncessary changes --- testutil/integration/options.go | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/testutil/integration/options.go b/testutil/integration/options.go index ba4ca820d771..a67327c01b21 100644 --- a/testutil/integration/options.go +++ b/testutil/integration/options.go @@ -1,25 +1,14 @@ package integration -import cmtabcitypes "github.com/cometbft/cometbft/abci/types" - // Config is the configuration for the integration app. type Config struct { AutomaticBeginEndBlock bool AutomaticCommit bool - CustomBeginBlock cmtabcitypes.RequestBeginBlock } // Option is a function that can be used to configure the integration app. type Option func(*Config) -// WithCustomBeginBlock takes additional params into the configuration. -func WithCustomBeginBlock(req cmtabcitypes.RequestBeginBlock) Option { - return func(cfg *Config) { - cfg.AutomaticBeginEndBlock = true - cfg.CustomBeginBlock = req - } -} - // WithAutomaticBlockCreation enables begin/end block calls. func WithAutomaticBeginEndBlock() Option { return func(cfg *Config) { From 4288cc96add166e04af2e45fa177c0c0e41beeac Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Wed, 12 Apr 2023 11:42:40 +0530 Subject: [PATCH 27/30] cleanup tests --- .../distribution/keeper/msg_server_test.go | 46 +++++++------------ testutil/integration/router.go | 4 +- 2 files changed, 18 insertions(+), 32 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index 75ea5dcf7ffa..1dbcff6d146a 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -11,6 +11,7 @@ import ( storetypes "cosmossdk.io/store/types" cmtabcitypes "github.com/cometbft/cometbft/abci/types" "github.com/cometbft/cometbft/proto/tendermint/types" + "github.com/stretchr/testify/require" "gotest.tools/v3/assert" dbm "github.com/cosmos/cosmos-db" @@ -48,8 +49,9 @@ type fixture struct { sdkCtx sdk.Context app *integration.App - addr sdk.AccAddress - valAddr sdk.ValAddress + addr sdk.AccAddress + valAddr sdk.ValAddress + valConsAddr sdk.ConsAddress } func initFixture(t assert.TestingT) *fixture { @@ -117,10 +119,10 @@ func initFixture(t assert.TestingT) *fixture { f.addr = sdk.AccAddress(PKS[0].Address()) f.valAddr = sdk.ValAddress(f.addr) - valConsAddr := sdk.ConsAddress(valConsPk0.Address()) + f.valConsAddr = sdk.ConsAddress(valConsPk0.Address()) // set proposer and vote infos - ctx := newCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ + ctx := newCtx.WithProposer(f.valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ { Validator: cmtabcitypes.Validator{ Address: f.valAddr, @@ -151,6 +153,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { f.distrKeeper.SetFeePool(f.sdkCtx, distrtypes.FeePool{ CommunityPool: sdk.NewDecCoins(sdk.DecCoin{Denom: "stake", Amount: math.LegacyNewDec(10000)}), }) + f.distrKeeper.SetParams(f.sdkCtx, distrtypes.DefaultParams()) initFeePool := f.distrKeeper.GetFeePool(f.sdkCtx) delAddr := sdk.AccAddress(PKS[1].Address()) @@ -161,9 +164,6 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { } // setup staking validator - valConsAddr := sdk.ConsAddress(valConsPk0.Address()) - f.distrKeeper.SetPreviousProposerConsAddr(f.sdkCtx, valConsAddr) - validator, err := stakingtypes.NewValidator(f.valAddr, PKS[0], stakingtypes.Description{}) assert.NilError(t, err) commission := stakingtypes.NewCommission(math.LegacyZeroDec(), math.LegacyOneDec(), math.LegacyOneDec()) @@ -233,6 +233,9 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { }, } height := f.app.LastBlockHeight() + require.Panics(t, func() { + f.distrKeeper.GetPreviousProposerConsAddr(f.sdkCtx) + }) for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { @@ -247,31 +250,14 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { panic(fmt.Errorf("expected block height to be %d, got %d", height, f.app.LastBlockHeight())) } - // queryClient := distrtypes.NewQueryClient(f.app.QueryHelper()) prevProposerConsAddr := f.distrKeeper.GetPreviousProposerConsAddr(f.sdkCtx) assert.Assert(t, prevProposerConsAddr.Empty() == false) - assert.DeepEqual(t, prevProposerConsAddr, valConsAddr) - - // // fmt.Printf("f.sdkCtx.VoteInfos(): %v\n", f.sdkCtx.VoteInfos()) - // check := func(ctx sdk.Context, expRewards sdk.DecCoins) { - // // fmt.Printf("ctx.VoteInfos(): %v\n", ctx.VoteInfos()) - // // macc := f.accountKeeper.GetModuleAccount(ctx, distrtypes.ModuleName) - // // amount := f.bankKeeper.GetAllBalances(ctx, macc.GetAddress()) - // // fmt.Printf("amount: %v\n", amount) - // // fmt.Printf("macc: %v\n", macc) - // distribution.BeginBlocker(ctx, f.distrKeeper) - // resp, err := queryClient.DelegationTotalRewards(ctx, &distrtypes.QueryDelegationTotalRewardsRequest{ - // DelegatorAddress: delAddr.String(), - // }) - // assert.NilError(t, err) - // assert.Assert(t, resp != nil) - // fmt.Printf("res.Rewards: %v\n", resp.Rewards) - // assert.DeepEqual(t, resp.Total, expRewards) - // consAddr := f.distrKeeper.GetPreviousProposerConsAddr(ctx) - // assert.DeepEqual(t, consAddr, valConsAddr) - // } - - // check(f.sdkCtx, sdk.NewDecCoins(sdk.NewDecCoin(sdk.DefaultBondDenom, sdk.NewInt(10)))) + assert.DeepEqual(t, prevProposerConsAddr, f.valConsAddr) + var previousTotalPower int64 + for _, voteInfo := range f.sdkCtx.VoteInfos() { + previousTotalPower += voteInfo.Validator.Power + } + assert.Equal(t, previousTotalPower, int64(100)) if tc.expErr { assert.ErrorContains(t, err, tc.expErrMsg) diff --git a/testutil/integration/router.go b/testutil/integration/router.go index 64e8613ef740..4126ecc1ee2e 100644 --- a/testutil/integration/router.go +++ b/testutil/integration/router.go @@ -55,10 +55,10 @@ func NewIntegrationApp(sdkCtx sdk.Context, logger log.Logger, keys map[string]*s moduleManager := module.NewManager(modules...) bApp.SetBeginBlocker(func(ctx sdk.Context, req cmtabcitypes.RequestBeginBlock) (cmtabcitypes.ResponseBeginBlock, error) { - return moduleManager.BeginBlock(ctx, req) + return moduleManager.BeginBlock(sdkCtx, req) }) bApp.SetEndBlocker(func(ctx sdk.Context, req cmtabcitypes.RequestEndBlock) (cmtabcitypes.ResponseEndBlock, error) { - return moduleManager.EndBlock(ctx, req) + return moduleManager.EndBlock(sdkCtx, req) }) router := baseapp.NewMsgServiceRouter() From d5bc2abf0a75be8ac97caa19b231f7a3f56a1055 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Wed, 12 Apr 2023 14:47:50 +0530 Subject: [PATCH 28/30] fix tests --- .../distribution/keeper/grpc_query_test.go | 69 +++++++++---------- .../distribution/keeper/msg_server_test.go | 12 ++-- 2 files changed, 37 insertions(+), 44 deletions(-) diff --git a/tests/integration/distribution/keeper/grpc_query_test.go b/tests/integration/distribution/keeper/grpc_query_test.go index e08a85a5c155..1c949e8595fa 100644 --- a/tests/integration/distribution/keeper/grpc_query_test.go +++ b/tests/integration/distribution/keeper/grpc_query_test.go @@ -79,6 +79,9 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) f.bankKeeper.MintCoins(f.sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + // Set default staking params + f.stakingKeeper.SetParams(f.sdkCtx, stakingtypes.DefaultParams()) + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) @@ -87,21 +90,18 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(300)), } - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) - // send funds to val addr funds := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(f.valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) initialStake := int64(10) tstaking := stakingtestutil.NewHelper(t, f.sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) + tstaking.CreateValidator(f.valAddr, valConsPk0, sdk.NewInt(initialStake), true) // set outstanding rewards - f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) - rewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, valAddr) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, f.valAddr, types.ValidatorOutstandingRewards{Rewards: valCommission}) + rewards := f.distrKeeper.GetValidatorOutstandingRewards(f.sdkCtx, f.valAddr) testCases := []struct { name string @@ -123,7 +123,7 @@ func TestGRPCValidatorOutstandingRewards(t *testing.T) { }, { name: "valid request", - msg: &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: valAddr.String()}, + msg: &types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: f.valAddr.String()}, expPass: true, }, } @@ -153,23 +153,23 @@ func TestGRPCValidatorCommission(t *testing.T) { initTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) f.bankKeeper.MintCoins(f.sdkCtx, types.ModuleName, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))) + // Set default staking params + f.stakingKeeper.SetParams(f.sdkCtx, stakingtypes.DefaultParams()) + qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) - // send funds to val addr funds := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(f.valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) initialStake := int64(10) tstaking := stakingtestutil.NewHelper(t, f.sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) + tstaking.CreateValidator(f.valAddr, valConsPk0, sdk.NewInt(initialStake), true) commission := sdk.DecCoins{{Denom: "token1", Amount: math.LegacyNewDec(4)}, {Denom: "token2", Amount: math.LegacyNewDec(2)}} - f.distrKeeper.SetValidatorAccumulatedCommission(f.sdkCtx, valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) + f.distrKeeper.SetValidatorAccumulatedCommission(f.sdkCtx, f.valAddr, types.ValidatorAccumulatedCommission{Commission: commission}) testCases := []struct { name string @@ -191,7 +191,7 @@ func TestGRPCValidatorCommission(t *testing.T) { }, { name: "valid request", - msg: &types.QueryValidatorCommissionRequest{ValidatorAddress: valAddr.String()}, + msg: &types.QueryValidatorCommissionRequest{ValidatorAddress: f.valAddr.String()}, expPass: true, }, } @@ -220,8 +220,6 @@ func TestGRPCValidatorSlashes(t *testing.T) { qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) addr2 := sdk.AccAddress(PKS[1].Address()) valAddr2 := sdk.ValAddress(addr2) @@ -233,7 +231,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { } for i, slash := range slashes { - f.distrKeeper.SetValidatorSlashEvent(f.sdkCtx, valAddr, uint64(i+2), 0, slash) + f.distrKeeper.SetValidatorSlashEvent(f.sdkCtx, f.valAddr, uint64(i+2), 0, slash) } var ( @@ -290,7 +288,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { } req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), StartingHeight: 1, EndingHeight: 10, Pagination: pageReq, @@ -311,7 +309,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { } req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), StartingHeight: 1, EndingHeight: 10, Pagination: pageReq, @@ -332,7 +330,7 @@ func TestGRPCValidatorSlashes(t *testing.T) { } req = &types.QueryValidatorSlashesRequest{ - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), StartingHeight: 1, EndingHeight: 10, Pagination: pageReq, @@ -373,10 +371,9 @@ func TestGRPCDelegatorWithdrawAddress(t *testing.T) { qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) - addr := sdk.AccAddress(PKS[0].Address()) addr2 := sdk.AccAddress(PKS[1].Address()) - err := f.distrKeeper.SetWithdrawAddr(f.sdkCtx, addr, addr2) + err := f.distrKeeper.SetWithdrawAddr(f.sdkCtx, f.addr, addr2) assert.Assert(t, err == nil) testCases := []struct { @@ -393,7 +390,7 @@ func TestGRPCDelegatorWithdrawAddress(t *testing.T) { }, { name: "valid request", - msg: &types.QueryDelegatorWithdrawAddressRequest{DelegatorAddress: addr.String()}, + msg: &types.QueryDelegatorWithdrawAddressRequest{DelegatorAddress: f.addr.String()}, expPass: true, }, } @@ -425,8 +422,6 @@ func TestGRPCCommunityPool(t *testing.T) { qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) - addr := sdk.AccAddress(PKS[0].Address()) - var ( req *types.QueryCommunityPoolRequest expPool *types.QueryCommunityPoolResponse @@ -448,9 +443,9 @@ func TestGRPCCommunityPool(t *testing.T) { malleate: func() { amount := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 100)) assert.NilError(t, f.bankKeeper.MintCoins(f.sdkCtx, types.ModuleName, amount)) - assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, addr, amount)) + assert.NilError(t, f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, f.addr, amount)) - err := f.distrKeeper.FundCommunityPool(f.sdkCtx, amount, addr) + err := f.distrKeeper.FundCommunityPool(f.sdkCtx, amount, f.addr) assert.Assert(t, err == nil) req = &types.QueryCommunityPoolRequest{} @@ -490,28 +485,26 @@ func TestGRPCDelegationRewards(t *testing.T) { qr := f.app.QueryHelper() queryClient := types.NewQueryClient(qr) - addr := sdk.AccAddress(PKS[0].Address()) - valAddr := sdk.ValAddress(addr) addr2 := sdk.AccAddress(PKS[1].Address()) valAddr2 := sdk.ValAddress(addr2) delAddr := sdk.AccAddress(PKS[2].Address()) // send funds to val addr funds := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, int64(1000)) - f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) + f.bankKeeper.SendCoinsFromModuleToAccount(f.sdkCtx, types.ModuleName, sdk.AccAddress(f.valAddr), sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))) initialStake := int64(10) tstaking := stakingtestutil.NewHelper(t, f.sdkCtx, f.stakingKeeper) tstaking.Commission = stakingtypes.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0)) - tstaking.CreateValidator(valAddr, valConsPk0, sdk.NewInt(initialStake), true) + tstaking.CreateValidator(f.valAddr, valConsPk0, sdk.NewInt(initialStake), true) - val, found := f.stakingKeeper.GetValidator(f.sdkCtx, valAddr) + val, found := f.stakingKeeper.GetValidator(f.sdkCtx, f.valAddr) assert.Assert(t, found) // setup delegation delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator, issuedShares := val.AddTokensFromDel(delTokens) - delegation := stakingtypes.NewDelegation(delAddr, valAddr, issuedShares) + delegation := stakingtypes.NewDelegation(delAddr, f.valAddr, issuedShares) f.stakingKeeper.SetDelegation(f.sdkCtx, delegation) f.distrKeeper.SetDelegatorStartingInfo(f.sdkCtx, validator.GetOperator(), delAddr, types.NewDelegatorStartingInfo(2, math.LegacyNewDec(initialStake), 20)) @@ -521,8 +514,8 @@ func TestGRPCDelegationRewards(t *testing.T) { f.distrKeeper.SetValidatorHistoricalRewards(f.sdkCtx, validator.GetOperator(), 2, historicalRewards) // setup current rewards and outstanding rewards currentRewards := types.NewValidatorCurrentRewards(decCoins, 3) - f.distrKeeper.SetValidatorCurrentRewards(f.sdkCtx, valAddr, currentRewards) - f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) + f.distrKeeper.SetValidatorCurrentRewards(f.sdkCtx, f.valAddr, currentRewards) + f.distrKeeper.SetValidatorOutstandingRewards(f.sdkCtx, f.valAddr, types.ValidatorOutstandingRewards{Rewards: decCoins}) expRes := &types.QueryDelegationRewardsResponse{ Rewards: sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(initialStake / 10)}}, @@ -545,7 +538,7 @@ func TestGRPCDelegationRewards(t *testing.T) { name: "empty delegator address", msg: &types.QueryDelegationRewardsRequest{ DelegatorAddress: "", - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), }, expPass: false, expErrMsg: "empty delegator address", @@ -572,7 +565,7 @@ func TestGRPCDelegationRewards(t *testing.T) { name: "valid request", msg: &types.QueryDelegationRewardsRequest{ DelegatorAddress: delAddr.String(), - ValidatorAddress: valAddr.String(), + ValidatorAddress: f.valAddr.String(), }, expPass: true, }, diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index 23888a2204f7..f51b5ce3c3b4 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -54,9 +54,8 @@ type fixture struct { sdkCtx sdk.Context app *integration.App - addr sdk.AccAddress - valAddr sdk.ValAddress - valConsAddr sdk.ConsAddress + addr sdk.AccAddress + valAddr sdk.ValAddress } func initFixture(t assert.TestingT) *fixture { @@ -124,10 +123,10 @@ func initFixture(t assert.TestingT) *fixture { f.addr = sdk.AccAddress(PKS[0].Address()) f.valAddr = sdk.ValAddress(f.addr) - f.valConsAddr = sdk.ConsAddress(valConsPk0.Address()) + valConsAddr := sdk.ConsAddress(valConsPk0.Address()) // set proposer and vote infos - ctx := newCtx.WithProposer(f.valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ + ctx := newCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ { Validator: cmtabcitypes.Validator{ Address: f.valAddr, @@ -162,6 +161,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { initFeePool := f.distrKeeper.GetFeePool(f.sdkCtx) delAddr := sdk.AccAddress(PKS[1].Address()) + valConsAddr := sdk.ConsAddress(valConsPk0.Address()) valCommission := sdk.DecCoins{ sdk.NewDecCoinFromDec("mytoken", math.LegacyNewDec(5).Quo(math.LegacyNewDec(4))), @@ -284,7 +284,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) { prevProposerConsAddr := f.distrKeeper.GetPreviousProposerConsAddr(f.sdkCtx) assert.Assert(t, prevProposerConsAddr.Empty() == false) - assert.DeepEqual(t, prevProposerConsAddr, f.valConsAddr) + assert.DeepEqual(t, prevProposerConsAddr, valConsAddr) var previousTotalPower int64 for _, voteInfo := range f.sdkCtx.VoteInfos() { previousTotalPower += voteInfo.Validator.Power From e68a79aab2c4cbcd10bd4f9baaed4527d7252fd9 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Wed, 12 Apr 2023 21:06:25 +0530 Subject: [PATCH 29/30] address review comments --- .../distribution/keeper/msg_server_test.go | 60 +++++++++---------- testutil/integration/router.go | 4 +- 2 files changed, 30 insertions(+), 34 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index f51b5ce3c3b4..9f6317ec7cf8 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -6,13 +6,10 @@ import ( "cosmossdk.io/log" "cosmossdk.io/math" - "cosmossdk.io/store" - "cosmossdk.io/store/metrics" storetypes "cosmossdk.io/store/types" cmtabcitypes "github.com/cometbft/cometbft/abci/types" "github.com/cometbft/cometbft/proto/tendermint/types" - dbm "github.com/cosmos/cosmos-db" "github.com/stretchr/testify/require" "gotest.tools/v3/assert" @@ -43,17 +40,17 @@ var ( ) type fixture struct { - cdc codec.Codec - keys map[string]*storetypes.KVStoreKey + app *integration.App + + sdkCtx sdk.Context + cdc codec.Codec + keys map[string]*storetypes.KVStoreKey accountKeeper authkeeper.AccountKeeper bankKeeper bankkeeper.Keeper distrKeeper distrkeeper.Keeper stakingKeeper *stakingkeeper.Keeper - sdkCtx sdk.Context - app *integration.App - addr sdk.AccAddress valAddr sdk.ValAddress } @@ -66,14 +63,10 @@ func initFixture(t assert.TestingT) *fixture { ) cdc := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}, distribution.AppModuleBasic{}).Codec - db := dbm.NewMemDB() - cms := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics()) - for key := range keys { - cms.MountStoreWithDB(keys[key], storetypes.StoreTypeIAVL, db) - } - _ = cms.LoadLatestVersion() + logger := log.NewTestLogger(&testing.T{}) + cms := integration.CreateMultiStore(keys, logger) - newCtx := sdk.NewContext(cms, types.Header{}, true, log.NewTestLogger(&testing.T{})) + newCtx := sdk.NewContext(cms, types.Header{}, true, logger) authority := authtypes.NewModuleAddress("gov") @@ -109,43 +102,46 @@ func initFixture(t assert.TestingT) *fixture { cdc, keys[distrtypes.StoreKey], accountKeeper, bankKeeper, stakingKeeper, distrtypes.ModuleName, authority.String(), ) - f.cdc = cdc - f.keys = keys - f.accountKeeper = accountKeeper - f.bankKeeper = bankKeeper - f.stakingKeeper = stakingKeeper - f.distrKeeper = distrKeeper + authModule := auth.NewAppModule(cdc, accountKeeper, authsims.RandomGenesisAccounts, nil) + bankModule := bank.NewAppModule(cdc, bankKeeper, accountKeeper, nil) + stakingModule := staking.NewAppModule(cdc, stakingKeeper, accountKeeper, bankKeeper, nil) + distrModule := distribution.NewAppModule(cdc, distrKeeper, accountKeeper, bankKeeper, stakingKeeper, nil) - authModule := auth.NewAppModule(f.cdc, f.accountKeeper, authsims.RandomGenesisAccounts, nil) - bankModule := bank.NewAppModule(f.cdc, f.bankKeeper, f.accountKeeper, nil) - stakingModule := staking.NewAppModule(f.cdc, f.stakingKeeper, f.accountKeeper, f.bankKeeper, nil) - distrModule := distribution.NewAppModule(f.cdc, f.distrKeeper, f.accountKeeper, f.bankKeeper, f.stakingKeeper, nil) - - f.addr = sdk.AccAddress(PKS[0].Address()) - f.valAddr = sdk.ValAddress(f.addr) + addr := sdk.AccAddress(PKS[0].Address()) + valAddr := sdk.ValAddress(addr) valConsAddr := sdk.ConsAddress(valConsPk0.Address()) // set proposer and vote infos ctx := newCtx.WithProposer(valConsAddr).WithVoteInfos([]cmtabcitypes.VoteInfo{ { Validator: cmtabcitypes.Validator{ - Address: f.valAddr, + Address: valAddr, Power: 100, }, SignedLastBlock: true, }, }) - integrationApp := integration.NewIntegrationApp(ctx, log.NewTestLogger(&testing.T{}), f.keys, f.cdc, authModule, bankModule, stakingModule, distrModule) + integrationApp := integration.NewIntegrationApp(ctx, logger, keys, cdc, authModule, bankModule, stakingModule, distrModule) // Register MsgServer and QueryServer - distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(f.distrKeeper)) - distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(f.distrKeeper)) + distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(distrKeeper)) + distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(distrKeeper)) f.app = integrationApp sdkCtx := sdk.UnwrapSDKContext(f.app.Context()) f.sdkCtx = sdkCtx + f.cdc = cdc + f.keys = keys + + f.accountKeeper = accountKeeper + f.bankKeeper = bankKeeper + f.stakingKeeper = stakingKeeper + f.distrKeeper = distrKeeper + + f.addr = addr + f.valAddr = valAddr return f } diff --git a/testutil/integration/router.go b/testutil/integration/router.go index 5ebe5aa2e647..efae2d5cc9b7 100644 --- a/testutil/integration/router.go +++ b/testutil/integration/router.go @@ -56,10 +56,10 @@ func NewIntegrationApp(sdkCtx sdk.Context, logger log.Logger, keys map[string]*s }) moduleManager := module.NewManager(modules...) - bApp.SetBeginBlocker(func(ctx sdk.Context, req cmtabcitypes.RequestBeginBlock) (cmtabcitypes.ResponseBeginBlock, error) { + bApp.SetBeginBlocker(func(_ sdk.Context, req cmtabcitypes.RequestBeginBlock) (cmtabcitypes.ResponseBeginBlock, error) { return moduleManager.BeginBlock(sdkCtx, req) }) - bApp.SetEndBlocker(func(ctx sdk.Context, req cmtabcitypes.RequestEndBlock) (cmtabcitypes.ResponseEndBlock, error) { + bApp.SetEndBlocker(func(_ sdk.Context, req cmtabcitypes.RequestEndBlock) (cmtabcitypes.ResponseEndBlock, error) { return moduleManager.EndBlock(sdkCtx, req) }) From e5ed9c6ea3402ce0ceddb5b23d4b5c6f28407f16 Mon Sep 17 00:00:00 2001 From: likhita-809 Date: Wed, 12 Apr 2023 21:12:42 +0530 Subject: [PATCH 30/30] add more changes --- .../distribution/keeper/msg_server_test.go | 36 +++++++++---------- 1 file changed, 16 insertions(+), 20 deletions(-) diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go index 9f6317ec7cf8..65bd57837ba5 100644 --- a/tests/integration/distribution/keeper/msg_server_test.go +++ b/tests/integration/distribution/keeper/msg_server_test.go @@ -55,15 +55,13 @@ type fixture struct { valAddr sdk.ValAddress } -func initFixture(t assert.TestingT) *fixture { - f := &fixture{} - +func initFixture(t testing.TB) *fixture { keys := storetypes.NewKVStoreKeys( authtypes.StoreKey, banktypes.StoreKey, distrtypes.StoreKey, stakingtypes.StoreKey, ) cdc := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}, distribution.AppModuleBasic{}).Codec - logger := log.NewTestLogger(&testing.T{}) + logger := log.NewTestLogger(t) cms := integration.CreateMultiStore(keys, logger) newCtx := sdk.NewContext(cms, types.Header{}, true, logger) @@ -124,26 +122,24 @@ func initFixture(t assert.TestingT) *fixture { integrationApp := integration.NewIntegrationApp(ctx, logger, keys, cdc, authModule, bankModule, stakingModule, distrModule) + sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context()) + // Register MsgServer and QueryServer distrtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), distrkeeper.NewMsgServerImpl(distrKeeper)) distrtypes.RegisterQueryServer(integrationApp.QueryHelper(), distrkeeper.NewQuerier(distrKeeper)) - f.app = integrationApp - - sdkCtx := sdk.UnwrapSDKContext(f.app.Context()) - f.sdkCtx = sdkCtx - f.cdc = cdc - f.keys = keys - - f.accountKeeper = accountKeeper - f.bankKeeper = bankKeeper - f.stakingKeeper = stakingKeeper - f.distrKeeper = distrKeeper - - f.addr = addr - f.valAddr = valAddr - - return f + return &fixture{ + app: integrationApp, + sdkCtx: sdkCtx, + cdc: cdc, + keys: keys, + accountKeeper: accountKeeper, + bankKeeper: bankKeeper, + distrKeeper: distrKeeper, + stakingKeeper: stakingKeeper, + addr: addr, + valAddr: valAddr, + } } func TestMsgWithdrawDelegatorReward(t *testing.T) {