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

feat: decouple x/group from simapp (#12277)

Browse Source
This commit is contained in:
likhita-809 2022-06-18 04:13:39 +05:30 committed by GitHub
parent 7623603440
commit 5d3fd85396
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 496 additions and 378 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
x/group/keeper/genesis_test.go
View File

@ -7,28 +7,30 @@ import (
"time"
"github.com/stretchr/testify/suite"
"github.com/tendermint/tendermint/libs/log"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/codec"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/runtime"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
sdk "github.com/cosmos/cosmos-sdk/types"
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/keeper"
"github.com/cosmos/cosmos-sdk/x/group/testutil"
)
type GenesisTestSuite struct {
suite.Suite
app *simapp.SimApp
ctx context.Context
sdkCtx sdk.Context
keeper keeper.Keeper
cdc *codec.ProtoCodec
app *runtime.App
ctx context.Context
sdkCtx sdk.Context
keeper keeper.Keeper
cdc *codec.ProtoCodec
interfaceRegistry codectypes.InterfaceRegistry
}
func TestGenesisTestSuite(t *testing.T) {
@ -43,15 +45,16 @@ var (
)
func (s *GenesisTestSuite) SetupSuite() {
checkTx := false
db := dbm.NewMemDB()
encCdc := simapp.MakeTestEncodingConfig()
app := simapp.NewSimApp(log.NewNopLogger(), db, nil, true, map[int64]bool{}, simapp.DefaultNodeHome, 5, encCdc, simapp.EmptyAppOptions{})
app, err := simtestutil.SetupAtGenesis(
testutil.AppConfig,
&s.interfaceRegistry,
&s.keeper,
)
s.Require().NoError(err)
s.app = app
s.sdkCtx = app.BaseApp.NewUncachedContext(checkTx, tmproto.Header{})
s.keeper = app.GroupKeeper
s.cdc = codec.NewProtoCodec(app.InterfaceRegistry())
s.sdkCtx = app.BaseApp.NewUncachedContext(false, tmproto.Header{})
s.cdc = codec.NewProtoCodec(s.interfaceRegistry)
s.ctx = sdk.WrapSDKContext(s.sdkCtx)
}

34
x/group/keeper/grpc_query_test.go
View File

@ -5,28 +5,48 @@ import (
"testing"
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/simapp"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
sdk "github.com/cosmos/cosmos-sdk/types"
bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
"github.com/cosmos/cosmos-sdk/x/group"
groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper"
"github.com/cosmos/cosmos-sdk/x/group/testutil"
stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
"github.com/stretchr/testify/require"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
)
func TestQueryGroupsByMember(t *testing.T) {
app := simapp.Setup(t, false)
var (
bankKeeper bankkeeper.Keeper
groupKeeper groupkeeper.Keeper
stakingKeeper *stakingkeeper.Keeper
interfaceRegistry codectypes.InterfaceRegistry
)
app, err := simtestutil.Setup(
testutil.AppConfig,
&interfaceRegistry,
&bankKeeper,
&groupKeeper,
&stakingKeeper,
)
require.NoError(t, err)
ctx := app.BaseApp.NewContext(false, tmproto.Header{})
queryHelper := baseapp.NewQueryServerTestHelper(ctx, app.InterfaceRegistry())
group.RegisterQueryServer(queryHelper, app.GroupKeeper)
queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry)
group.RegisterQueryServer(queryHelper, groupKeeper)
queryClient := group.NewQueryClient(queryHelper)
sdkCtx := sdk.WrapSDKContext(ctx)
addrs := simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.NewInt(30000000))
addrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 6, sdk.NewInt(30000000))
// Initial group, group policy and balance setup
members := []group.MemberRequest{
{Address: addrs[2].String(), Weight: "1"}, {Address: addrs[3].String(), Weight: "2"},
}
_, err := app.GroupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{
_, err = groupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{
Admin: addrs[0].String(),
Members: members,
})
@ -35,7 +55,7 @@ func TestQueryGroupsByMember(t *testing.T) {
members = []group.MemberRequest{
{Address: addrs[3].String(), Weight: "1"}, {Address: addrs[4].String(), Weight: "2"},
}
_, err = app.GroupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{
_, err = groupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{
Admin: addrs[1].String(),
Members: members,
})

240
x/group/keeper/keeper_test.go
View File

@ -12,33 +12,49 @@ import (
tmtime "github.com/tendermint/tendermint/libs/time"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
"github.com/cosmos/cosmos-sdk/simapp"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/runtime"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
sdk "github.com/cosmos/cosmos-sdk/types"
bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
"github.com/cosmos/cosmos-sdk/x/bank/testutil"
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/internal/math"
"github.com/cosmos/cosmos-sdk/x/group/keeper"
"github.com/cosmos/cosmos-sdk/x/group/module"
grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
)
type TestSuite struct {
suite.Suite
app *simapp.SimApp
sdkCtx sdk.Context
ctx context.Context
addrs []sdk.AccAddress
groupID uint64
groupPolicyAddr sdk.AccAddress
policy group.DecisionPolicy
keeper keeper.Keeper
blockTime time.Time
app *runtime.App
sdkCtx sdk.Context
ctx context.Context
addrs []sdk.AccAddress
groupID uint64
groupPolicyAddr sdk.AccAddress
policy group.DecisionPolicy
groupKeeper keeper.Keeper
blockTime time.Time
bankKeeper bankkeeper.Keeper
stakingKeeper *stakingkeeper.Keeper
interfaceRegistry codectypes.InterfaceRegistry
}
func (s *TestSuite) SetupTest() {
app := simapp.Setup(s.T(), false)
app, err := simtestutil.Setup(
grouptestutil.AppConfig,
&s.interfaceRegistry,
&s.bankKeeper,
&s.stakingKeeper,
&s.groupKeeper,
)
s.Require().NoError(err)
ctx := app.BaseApp.NewContext(false, tmproto.Header{})
s.blockTime = tmtime.Now()
@ -47,14 +63,13 @@ func (s *TestSuite) SetupTest() {
s.app = app
s.sdkCtx = ctx
s.ctx = sdk.WrapSDKContext(ctx)
s.keeper = s.app.GroupKeeper
s.addrs = simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.NewInt(30000000))
s.addrs = simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, ctx, 6, sdk.NewInt(30000000))
// Initial group, group policy and balance setup
members := []group.MemberRequest{
{Address: s.addrs[4].String(), Weight: "1"}, {Address: s.addrs[1].String(), Weight: "2"},
}
groupRes, err := s.keeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
Admin: s.addrs[0].String(),
Members: members,
})
@ -72,13 +87,13 @@ func (s *TestSuite) SetupTest() {
}
err = policyReq.SetDecisionPolicy(policy)
s.Require().NoError(err)
policyRes, err := s.keeper.CreateGroupPolicy(s.ctx, policyReq)
policyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
s.Require().NoError(err)
s.policy = policy
addr, err := sdk.AccAddressFromBech32(policyRes.Address)
s.Require().NoError(err)
s.groupPolicyAddr = addr
s.Require().NoError(testutil.FundAccount(s.app.BankKeeper, s.sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, s.sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
}
func TestKeeperTestSuite(t *testing.T) {
@ -165,10 +180,10 @@ func (s *TestSuite) TestCreateGroup() {
spec := spec
s.Run(msg, func() {
blockTime := sdk.UnwrapSDKContext(s.ctx).BlockTime()
res, err := s.keeper.CreateGroup(s.ctx, spec.req)
res, err := s.groupKeeper.CreateGroup(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
_, err := s.keeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: uint64(seq + 1)})
_, err := s.groupKeeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: uint64(seq + 1)})
s.Require().Error(err)
return
}
@ -179,7 +194,7 @@ func (s *TestSuite) TestCreateGroup() {
s.Assert().Equal(uint64(seq), id)
// then all data persisted
loadedGroupRes, err := s.keeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: id})
loadedGroupRes, err := s.groupKeeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: id})
s.Require().NoError(err)
s.Assert().Equal(spec.req.Admin, loadedGroupRes.Info.Admin)
s.Assert().Equal(spec.req.Metadata, loadedGroupRes.Info.Metadata)
@ -187,7 +202,7 @@ func (s *TestSuite) TestCreateGroup() {
s.Assert().Equal(uint64(1), loadedGroupRes.Info.Version)
// and members are stored as well
membersRes, err := s.keeper.GroupMembers(s.ctx, &group.QueryGroupMembersRequest{GroupId: id})
membersRes, err := s.groupKeeper.GroupMembers(s.ctx, &group.QueryGroupMembersRequest{GroupId: id})
s.Require().NoError(err)
loadedMembers := membersRes.Members
s.Require().Equal(len(members), len(loadedMembers))
@ -208,7 +223,7 @@ func (s *TestSuite) TestCreateGroup() {
}
// query groups by admin
groupsRes, err := s.keeper.GroupsByAdmin(s.ctx, &group.QueryGroupsByAdminRequest{Admin: addr1.String()})
groupsRes, err := s.groupKeeper.GroupsByAdmin(s.ctx, &group.QueryGroupsByAdminRequest{Admin: addr1.String()})
s.Require().NoError(err)
loadedGroups := groupsRes.Groups
s.Require().Equal(len(spec.expGroups), len(loadedGroups))
@ -237,7 +252,7 @@ func (s *TestSuite) TestUpdateGroupAdmin() {
}}
oldAdmin := addr2.String()
newAdmin := addr3.String()
groupRes, err := s.keeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
Admin: oldAdmin,
Members: members,
})
@ -296,7 +311,7 @@ func (s *TestSuite) TestUpdateGroupAdmin() {
for msg, spec := range specs {
spec := spec
s.Run(msg, func() {
_, err := s.keeper.UpdateGroupAdmin(s.ctx, spec.req)
_, err := s.groupKeeper.UpdateGroupAdmin(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
@ -304,7 +319,7 @@ func (s *TestSuite) TestUpdateGroupAdmin() {
s.Require().NoError(err)
// then
res, err := s.keeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: groupID})
res, err := s.groupKeeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: groupID})
s.Require().NoError(err)
s.Assert().Equal(spec.expStored, res.Info)
})
@ -371,7 +386,7 @@ func (s *TestSuite) TestUpdateGroupMetadata() {
s.Run(msg, func() {
sdkCtx, _ := s.sdkCtx.CacheContext()
ctx := sdk.WrapSDKContext(sdkCtx)
_, err := s.keeper.UpdateGroupMetadata(ctx, spec.req)
_, err := s.groupKeeper.UpdateGroupMetadata(ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
@ -379,7 +394,7 @@ func (s *TestSuite) TestUpdateGroupMetadata() {
s.Require().NoError(err)
// then
res, err := s.keeper.GroupInfo(ctx, &group.QueryGroupInfoRequest{GroupId: groupID})
res, err := s.groupKeeper.GroupInfo(ctx, &group.QueryGroupInfoRequest{GroupId: groupID})
s.Require().NoError(err)
s.Assert().Equal(spec.expStored, res.Info)
})
@ -401,7 +416,7 @@ func (s *TestSuite) TestUpdateGroupMembers() {
}}
myAdmin := addr4.String()
groupRes, err := s.keeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
Admin: myAdmin,
Members: members,
})
@ -633,7 +648,7 @@ func (s *TestSuite) TestUpdateGroupMembers() {
s.Run(msg, func() {
sdkCtx, _ := s.sdkCtx.CacheContext()
ctx := sdk.WrapSDKContext(sdkCtx)
_, err := s.keeper.UpdateGroupMembers(ctx, spec.req)
_, err := s.groupKeeper.UpdateGroupMembers(ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
@ -641,12 +656,12 @@ func (s *TestSuite) TestUpdateGroupMembers() {
s.Require().NoError(err)
// then
res, err := s.keeper.GroupInfo(ctx, &group.QueryGroupInfoRequest{GroupId: groupID})
res, err := s.groupKeeper.GroupInfo(ctx, &group.QueryGroupInfoRequest{GroupId: groupID})
s.Require().NoError(err)
s.Assert().Equal(spec.expGroup, res.Info)
// and members persisted
membersRes, err := s.keeper.GroupMembers(ctx, &group.QueryGroupMembersRequest{GroupId: groupID})
membersRes, err := s.groupKeeper.GroupMembers(ctx, &group.QueryGroupMembersRequest{GroupId: groupID})
s.Require().NoError(err)
loadedMembers := membersRes.Members
s.Require().Equal(len(spec.expMembers), len(loadedMembers))
@ -801,7 +816,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
s.Require().NoError(err)
blockTime := sdk.UnwrapSDKContext(s.ctx).BlockTime()
res, err := s.keeper.CreateGroupWithPolicy(s.ctx, spec.req)
res, err := s.groupKeeper.CreateGroupWithPolicy(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
s.Require().Contains(err.Error(), spec.expErrMsg)
@ -812,7 +827,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
groupPolicyAddr := res.GroupPolicyAddress
// then all data persisted in group
loadedGroupRes, err := s.keeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: id})
loadedGroupRes, err := s.groupKeeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: id})
s.Require().NoError(err)
s.Assert().Equal(spec.req.GroupMetadata, loadedGroupRes.Info.Metadata)
s.Assert().Equal(id, loadedGroupRes.Info.Id)
@ -824,7 +839,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
}
// and members are stored as well
membersRes, err := s.keeper.GroupMembers(s.ctx, &group.QueryGroupMembersRequest{GroupId: id})
membersRes, err := s.groupKeeper.GroupMembers(s.ctx, &group.QueryGroupMembersRequest{GroupId: id})
s.Require().NoError(err)
loadedMembers := membersRes.Members
s.Require().Equal(len(members), len(loadedMembers))
@ -845,7 +860,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
}
// then all data persisted in group policy
groupPolicyRes, err := s.keeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{Address: groupPolicyAddr})
groupPolicyRes, err := s.groupKeeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{Address: groupPolicyAddr})
s.Require().NoError(err)
groupPolicy := groupPolicyRes.Info
@ -870,7 +885,7 @@ func (s *TestSuite) TestCreateGroupPolicy() {
addr1 := addrs[0]
addr4 := addrs[3]
groupRes, err := s.keeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
Admin: addr1.String(),
Members: nil,
})
@ -989,7 +1004,7 @@ func (s *TestSuite) TestCreateGroupPolicy() {
err := spec.req.SetDecisionPolicy(spec.policy)
s.Require().NoError(err)
res, err := s.keeper.CreateGroupPolicy(s.ctx, spec.req)
res, err := s.groupKeeper.CreateGroupPolicy(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
s.Require().Contains(err.Error(), spec.expErrMsg)
@ -999,7 +1014,7 @@ func (s *TestSuite) TestCreateGroupPolicy() {
addr := res.Address
// then all data persisted
groupPolicyRes, err := s.keeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{Address: addr})
groupPolicyRes, err := s.groupKeeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{Address: addr})
s.Require().NoError(err)
groupPolicy := groupPolicyRes.Info
@ -1096,13 +1111,13 @@ func (s *TestSuite) TestUpdateGroupPolicyAdmin() {
s.Require().NoError(err)
s.Run(msg, func() {
_, err := s.keeper.UpdateGroupPolicyAdmin(s.ctx, spec.req)
_, err := s.groupKeeper.UpdateGroupPolicyAdmin(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
}
s.Require().NoError(err)
res, err := s.keeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{
res, err := s.groupKeeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{
Address: groupPolicyAddr,
})
s.Require().NoError(err)
@ -1175,13 +1190,13 @@ func (s *TestSuite) TestUpdateGroupPolicyMetadata() {
s.Require().NoError(err)
s.Run(msg, func() {
_, err := s.keeper.UpdateGroupPolicyMetadata(s.ctx, spec.req)
_, err := s.groupKeeper.UpdateGroupPolicyMetadata(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
}
s.Require().NoError(err)
res, err := s.keeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{
res, err := s.groupKeeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{
Address: groupPolicyAddr,
})
s.Require().NoError(err)
@ -1291,13 +1306,13 @@ func (s *TestSuite) TestUpdateGroupPolicyDecisionPolicy() {
s.Require().NoError(err)
s.Run(msg, func() {
_, err := s.keeper.UpdateGroupPolicyDecisionPolicy(s.ctx, spec.req)
_, err := s.groupKeeper.UpdateGroupPolicyDecisionPolicy(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
}
s.Require().NoError(err)
res, err := s.keeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{
res, err := s.groupKeeper.GroupPolicyInfo(s.ctx, &group.QueryGroupPolicyInfoRequest{
Address: policyAddr,
})
s.Require().NoError(err)
@ -1311,7 +1326,7 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() {
addr2 := addrs[1]
admin := addr2
groupRes, err := s.keeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
Admin: admin.String(),
Members: nil,
})
@ -1345,7 +1360,7 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() {
}
err := req.SetDecisionPolicy(policies[i])
s.Require().NoError(err)
res, err := s.keeper.CreateGroupPolicy(s.ctx, req)
res, err := s.groupKeeper.CreateGroupPolicy(s.ctx, req)
s.Require().NoError(err)
expectAcc := &group.GroupPolicyInfo{
@ -1362,7 +1377,7 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() {
sort.Slice(expectAccs, func(i, j int) bool { return expectAccs[i].Address < expectAccs[j].Address })
// query group policy by group
policiesByGroupRes, err := s.keeper.GroupPoliciesByGroup(s.ctx, &group.QueryGroupPoliciesByGroupRequest{
policiesByGroupRes, err := s.groupKeeper.GroupPoliciesByGroup(s.ctx, &group.QueryGroupPoliciesByGroupRequest{
GroupId: myGroupID,
})
s.Require().NoError(err)
@ -1385,7 +1400,7 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() {
}
// query group policy by admin
policiesByAdminRes, err := s.keeper.GroupPoliciesByAdmin(s.ctx, &group.QueryGroupPoliciesByAdminRequest{
policiesByAdminRes, err := s.groupKeeper.GroupPoliciesByAdmin(s.ctx, &group.QueryGroupPoliciesByAdminRequest{
Admin: admin.String(),
})
s.Require().NoError(err)
@ -1435,7 +1450,7 @@ func (s *TestSuite) TestSubmitProposal() {
)
err := policyReq.SetDecisionPolicy(policy)
s.Require().NoError(err)
bigThresholdRes, err := s.keeper.CreateGroupPolicy(s.ctx, policyReq)
bigThresholdRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
s.Require().NoError(err)
bigThresholdAddr := bigThresholdRes.Address
@ -1568,9 +1583,9 @@ func (s *TestSuite) TestSubmitProposal() {
ExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_SUCCESS,
},
postRun: func(sdkCtx sdk.Context) {
fromBalances := s.app.BankKeeper.GetAllBalances(sdkCtx, accountAddr)
fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, accountAddr)
s.Require().Contains(fromBalances, sdk.NewInt64Coin("test", 9900))
toBalances := s.app.BankKeeper.GetAllBalances(sdkCtx, addr2)
toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr2)
s.Require().Contains(toBalances, sdk.NewInt64Coin("test", 100))
},
},
@ -1601,7 +1616,7 @@ func (s *TestSuite) TestSubmitProposal() {
err := spec.req.SetMsgs(spec.msgs)
s.Require().NoError(err)
res, err := s.keeper.SubmitProposal(s.ctx, spec.req)
res, err := s.groupKeeper.SubmitProposal(s.ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
@ -1611,7 +1626,7 @@ func (s *TestSuite) TestSubmitProposal() {
if !(spec.expProposal.ExecutorResult == group.PROPOSAL_EXECUTOR_RESULT_SUCCESS) {
// then all data persisted
proposalRes, err := s.keeper.Proposal(s.ctx, &group.QueryProposalRequest{ProposalId: id})
proposalRes, err := s.groupKeeper.Proposal(s.ctx, &group.QueryProposalRequest{ProposalId: id})
s.Require().NoError(err)
proposal := proposalRes.Proposal
@ -1684,7 +1699,7 @@ func (s *TestSuite) TestWithdrawProposal() {
"already closed proposal": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId := submitProposal(s.ctx, s, []sdk.Msg{msgSend}, proposers)
_, err := s.keeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
_, err := s.groupKeeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: proposers[0],
})
@ -1708,7 +1723,7 @@ func (s *TestSuite) TestWithdrawProposal() {
s.Run(msg, func() {
pId := spec.preRun(s.sdkCtx)
_, err := s.keeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
_, err := s.groupKeeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: spec.admin,
})
@ -1720,7 +1735,7 @@ func (s *TestSuite) TestWithdrawProposal() {
}
s.Require().NoError(err)
resp, err := s.keeper.Proposal(s.ctx, &group.QueryProposalRequest{ProposalId: pId})
resp, err := s.groupKeeper.Proposal(s.ctx, &group.QueryProposalRequest{ProposalId: pId})
s.Require().NoError(err)
s.Require().Equal(resp.GetProposal().Status, group.PROPOSAL_STATUS_WITHDRAWN)
})
@ -1738,7 +1753,7 @@ func (s *TestSuite) TestVote() {
{Address: addr4.String(), Weight: "1"},
{Address: addr3.String(), Weight: "2"},
}
groupRes, err := s.keeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
Admin: addr1.String(),
Members: members,
})
@ -1756,14 +1771,14 @@ func (s *TestSuite) TestVote() {
}
err = policyReq.SetDecisionPolicy(policy)
s.Require().NoError(err)
policyRes, err := s.keeper.CreateGroupPolicy(s.ctx, policyReq)
policyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
s.Require().NoError(err)
accountAddr := policyRes.Address
groupPolicy, err := sdk.AccAddressFromBech32(accountAddr)
s.Require().NoError(err)
s.Require().NotNil(groupPolicy)
s.Require().NoError(testutil.FundAccount(s.app.BankKeeper, s.sdkCtx, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, s.sdkCtx, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
req := &group.MsgSubmitProposal{
GroupPolicyAddress: accountAddr,
@ -1777,12 +1792,12 @@ func (s *TestSuite) TestVote() {
}})
s.Require().NoError(err)
proposalRes, err := s.keeper.SubmitProposal(s.ctx, req)
proposalRes, err := s.groupKeeper.SubmitProposal(s.ctx, req)
s.Require().NoError(err)
myProposalID := proposalRes.ProposalId
// proposals by group policy
proposalsRes, err := s.keeper.ProposalsByGroupPolicy(s.ctx, &group.QueryProposalsByGroupPolicyRequest{
proposalsRes, err := s.groupKeeper.ProposalsByGroupPolicy(s.ctx, &group.QueryProposalsByGroupPolicyRequest{
Address: accountAddr,
})
s.Require().NoError(err)
@ -1841,9 +1856,9 @@ func (s *TestSuite) TestVote() {
expProposalStatus: group.PROPOSAL_STATUS_ACCEPTED,
expExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_SUCCESS,
postRun: func(sdkCtx sdk.Context) {
fromBalances := s.app.BankKeeper.GetAllBalances(sdkCtx, groupPolicy)
fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, groupPolicy)
s.Require().Contains(fromBalances, sdk.NewInt64Coin("test", 9900))
toBalances := s.app.BankKeeper.GetAllBalances(sdkCtx, addr5)
toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr5)
s.Require().Contains(toBalances, sdk.NewInt64Coin("test", 100))
},
},
@ -1935,7 +1950,7 @@ func (s *TestSuite) TestVote() {
Option: group.VOTE_OPTION_YES,
},
doBefore: func(ctx context.Context) {
_, err := s.keeper.Vote(ctx, &group.MsgVote{
_, err := s.groupKeeper.Vote(ctx, &group.MsgVote{
ProposalId: myProposalID,
Voter: addr3.String(),
Option: group.VOTE_OPTION_NO_WITH_VETO,
@ -2017,7 +2032,7 @@ func (s *TestSuite) TestVote() {
Option: group.VOTE_OPTION_NO,
},
doBefore: func(ctx context.Context) {
_, err := s.keeper.Vote(ctx, &group.MsgVote{
_, err := s.groupKeeper.Vote(ctx, &group.MsgVote{
ProposalId: myProposalID,
Voter: addr3.String(),
Option: group.VOTE_OPTION_YES,
@ -2035,7 +2050,7 @@ func (s *TestSuite) TestVote() {
Option: group.VOTE_OPTION_NO,
},
doBefore: func(ctx context.Context) {
_, err := s.keeper.Vote(ctx, &group.MsgVote{
_, err := s.groupKeeper.Vote(ctx, &group.MsgVote{
ProposalId: myProposalID,
Voter: addr4.String(),
Option: group.VOTE_OPTION_YES,
@ -2059,7 +2074,7 @@ func (s *TestSuite) TestVote() {
if spec.doBefore != nil {
spec.doBefore(ctx)
}
_, err := s.keeper.Vote(ctx, spec.req)
_, err := s.groupKeeper.Vote(ctx, spec.req)
if spec.expErr {
s.Require().Error(err)
return
@ -2070,7 +2085,7 @@ func (s *TestSuite) TestVote() {
if !(spec.expExecutorResult == group.PROPOSAL_EXECUTOR_RESULT_SUCCESS) {
// vote is stored and all data persisted
res, err := s.keeper.VoteByProposalVoter(ctx, &group.QueryVoteByProposalVoterRequest{
res, err := s.groupKeeper.VoteByProposalVoter(ctx, &group.QueryVoteByProposalVoterRequest{
ProposalId: spec.req.ProposalId,
Voter: spec.req.Voter,
})
@ -2083,7 +2098,7 @@ func (s *TestSuite) TestVote() {
s.Assert().Equal(s.blockTime, loaded.SubmitTime)
// query votes by proposal
votesByProposalRes, err := s.keeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{
votesByProposalRes, err := s.groupKeeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{
ProposalId: spec.req.ProposalId,
})
s.Require().NoError(err)
@ -2098,7 +2113,7 @@ func (s *TestSuite) TestVote() {
// query votes by voter
voter := spec.req.Voter
votesByVoterRes, err := s.keeper.VotesByVoter(ctx, &group.QueryVotesByVoterRequest{
votesByVoterRes, err := s.groupKeeper.VotesByVoter(ctx, &group.QueryVotesByVoterRequest{
Voter: voter,
})
s.Require().NoError(err)
@ -2110,7 +2125,7 @@ func (s *TestSuite) TestVote() {
s.Assert().Equal(spec.req.Metadata, votesByVoter[0].Metadata)
s.Assert().Equal(s.blockTime, votesByVoter[0].SubmitTime)
proposalRes, err := s.keeper.Proposal(ctx, &group.QueryProposalRequest{
proposalRes, err := s.groupKeeper.Proposal(ctx, &group.QueryProposalRequest{
ProposalId: spec.req.ProposalId,
})
s.Require().NoError(err)
@ -2124,7 +2139,7 @@ func (s *TestSuite) TestVote() {
s.Assert().Equal(group.DefaultTallyResult(), proposal.FinalTallyResult) // Make sure proposal isn't mutated.
// do a round of tallying
tallyResult, err := s.keeper.Tally(sdkCtx, *proposal, myGroupID)
tallyResult, err := s.groupKeeper.Tally(sdkCtx, *proposal, myGroupID)
s.Require().NoError(err)
s.Assert().Equal(spec.expTallyResult, tallyResult)
@ -2154,7 +2169,7 @@ func (s *TestSuite) TestVote() {
0,
)
require.NoError(reqCreate.SetDecisionPolicy(policy))
result, err := s.keeper.CreateGroupWithPolicy(s.ctx, reqCreate)
result, err := s.groupKeeper.CreateGroupWithPolicy(s.ctx, reqCreate)
require.NoError(err)
require.NotNil(result)
@ -2170,30 +2185,30 @@ func (s *TestSuite) TestVote() {
Amount: sdk.Coins{sdk.NewInt64Coin("test", 100)},
}}))
resSubmitProposal, err := s.keeper.SubmitProposal(s.ctx, reqProposal)
resSubmitProposal, err := s.groupKeeper.SubmitProposal(s.ctx, reqProposal)
require.NoError(err)
require.NotNil(resSubmitProposal)
proposalID := resSubmitProposal.ProposalId
for _, voter := range []string{addr4.String(), addr3.String(), addr2.String()} {
_, err := s.keeper.Vote(s.ctx,
_, err := s.groupKeeper.Vote(s.ctx,
&group.MsgVote{ProposalId: proposalID, Voter: voter, Option: group.VOTE_OPTION_YES},
)
require.NoError(err)
}
qProposals, err := s.keeper.Proposal(s.ctx, &group.QueryProposalRequest{
qProposals, err := s.groupKeeper.Proposal(s.ctx, &group.QueryProposalRequest{
ProposalId: proposalID,
})
require.NoError(err)
tallyResult, err := s.keeper.Tally(s.sdkCtx, *qProposals.Proposal, groupID)
tallyResult, err := s.groupKeeper.Tally(s.sdkCtx, *qProposals.Proposal, groupID)
require.NoError(err)
_, err = s.keeper.LeaveGroup(s.ctx, &group.MsgLeaveGroup{Address: addr4.String(), GroupId: groupID})
_, err = s.groupKeeper.LeaveGroup(s.ctx, &group.MsgLeaveGroup{Address: addr4.String(), GroupId: groupID})
require.NoError(err)
tallyResult1, err := s.keeper.Tally(s.sdkCtx, *qProposals.Proposal, groupID)
tallyResult1, err := s.groupKeeper.Tally(s.sdkCtx, *qProposals.Proposal, groupID)
require.NoError(err)
require.NotEqual(tallyResult.String(), tallyResult1.String())
}
@ -2290,7 +2305,7 @@ func (s *TestSuite) TestExecProposal() {
setupProposal: func(ctx context.Context) uint64 {
myProposalID := submitProposalAndVote(ctx, s, []sdk.Msg{msgSend1}, proposers, group.VOTE_OPTION_YES)
_, err := s.keeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
s.Require().NoError(err)
return myProposalID
},
@ -2314,10 +2329,10 @@ func (s *TestSuite) TestExecProposal() {
msgs := []sdk.Msg{msgSend2}
myProposalID := submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
_, err := s.keeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
s.Require().NoError(err)
sdkCtx := sdk.UnwrapSDKContext(ctx)
s.Require().NoError(testutil.FundAccount(s.app.BankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
return myProposalID
},
@ -2337,7 +2352,7 @@ func (s *TestSuite) TestExecProposal() {
}
ctx = sdk.WrapSDKContext(sdkCtx)
_, err := s.keeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: proposalID})
_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: proposalID})
if spec.expErr {
s.Require().Error(err)
return
@ -2347,7 +2362,7 @@ func (s *TestSuite) TestExecProposal() {
if !(spec.expExecutorResult == group.PROPOSAL_EXECUTOR_RESULT_SUCCESS) {
// and proposal is updated
res, err := s.keeper.Proposal(ctx, &group.QueryProposalRequest{ProposalId: proposalID})
res, err := s.groupKeeper.Proposal(ctx, &group.QueryProposalRequest{ProposalId: proposalID})
s.Require().NoError(err)
proposal := res.Proposal
@ -2361,9 +2376,9 @@ func (s *TestSuite) TestExecProposal() {
}
if spec.expBalance {
fromBalances := s.app.BankKeeper.GetAllBalances(sdkCtx, s.groupPolicyAddr)
fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, s.groupPolicyAddr)
s.Require().Contains(fromBalances, spec.expFromBalances)
toBalances := s.app.BankKeeper.GetAllBalances(sdkCtx, addr2)
toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr2)
s.Require().Contains(toBalances, spec.expToBalances)
}
})
@ -2427,7 +2442,7 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
myProposalID := submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers)
// then modify group
_, err := s.keeper.UpdateGroupMetadata(ctx, &group.MsgUpdateGroupMetadata{
_, err := s.groupKeeper.UpdateGroupMetadata(ctx, &group.MsgUpdateGroupMetadata{
Admin: addr1.String(),
GroupId: s.groupID,
})
@ -2439,7 +2454,7 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
"proposal not pruned with group policy modified before tally": {
setupProposal: func(ctx context.Context) uint64 {
myProposalID := submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers)
_, err := s.keeper.UpdateGroupPolicyMetadata(ctx, &group.MsgUpdateGroupPolicyMetadata{
_, err := s.groupKeeper.UpdateGroupPolicyMetadata(ctx, &group.MsgUpdateGroupPolicyMetadata{
Admin: addr1.String(),
GroupPolicyAddress: s.groupPolicyAddr.String(),
})
@ -2462,10 +2477,10 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
msgs := []sdk.Msg{msgSend2}
myProposalID := submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
_, err := s.keeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
s.Require().NoError(err)
sdkCtx := sdk.UnwrapSDKContext(ctx)
s.Require().NoError(testutil.FundAccount(s.app.BankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
return myProposalID
},
@ -2485,7 +2500,7 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
}
ctx = sdk.WrapSDKContext(sdkCtx)
_, err := s.keeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: proposalID})
_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: proposalID})
if spec.expErr {
s.Require().Error(err)
s.Require().Contains(err.Error(), spec.expErrMsg)
@ -2495,17 +2510,17 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
if spec.expExecutorResult == group.PROPOSAL_EXECUTOR_RESULT_SUCCESS {
// Make sure proposal is deleted from state
_, err := s.keeper.Proposal(ctx, &group.QueryProposalRequest{ProposalId: proposalID})
_, err := s.groupKeeper.Proposal(ctx, &group.QueryProposalRequest{ProposalId: proposalID})
s.Require().Contains(err.Error(), spec.expErrMsg)
res, err := s.keeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: proposalID})
res, err := s.groupKeeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: proposalID})
s.Require().NoError(err)
s.Require().Empty(res.GetVotes())
} else {
// Check that proposal and votes exists
res, err := s.keeper.Proposal(ctx, &group.QueryProposalRequest{ProposalId: proposalID})
res, err := s.groupKeeper.Proposal(ctx, &group.QueryProposalRequest{ProposalId: proposalID})
s.Require().NoError(err)
_, err = s.keeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: res.Proposal.Id})
_, err = s.groupKeeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: res.Proposal.Id})
s.Require().NoError(err)
s.Require().Equal("", spec.expErrMsg)
@ -2601,7 +2616,7 @@ func (s *TestSuite) TestProposalsByVPEnd() {
"tally of withdrawn proposal": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId := submitProposal(s.ctx, s, []sdk.Msg{msgSend}, proposers)
_, err := s.keeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
_, err := s.groupKeeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: proposers[0],
})
@ -2617,7 +2632,7 @@ func (s *TestSuite) TestProposalsByVPEnd() {
"tally of withdrawn proposal (with votes)": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId := submitProposalAndVote(s.ctx, s, []sdk.Msg{msgSend}, proposers, group.VOTE_OPTION_YES)
_, err := s.keeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
_, err := s.groupKeeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: proposers[0],
})
@ -2637,8 +2652,8 @@ func (s *TestSuite) TestProposalsByVPEnd() {
s.Run(msg, func() {
pId := spec.preRun(s.sdkCtx)
module.EndBlocker(spec.newCtx, s.keeper)
resp, err := s.keeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
module.EndBlocker(spec.newCtx, s.groupKeeper)
resp, err := s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
ProposalId: pId,
})
@ -2656,7 +2671,8 @@ func (s *TestSuite) TestProposalsByVPEnd() {
}
func (s *TestSuite) TestLeaveGroup() {
addrs := simapp.AddTestAddrsIncremental(s.app, s.sdkCtx, 7, sdk.NewInt(3000000))
addrs := simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, s.sdkCtx, 7, sdk.NewInt(30000000))
admin1 := addrs[0]
member1 := addrs[1]
member2 := addrs[2]
@ -2797,26 +2813,26 @@ func (s *TestSuite) TestLeaveGroup() {
s.Run(tc.name, func() {
var groupWeight1 math.Dec
if !tc.expErr {
groupRes, err := s.keeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: tc.req.GroupId})
groupRes, err := s.groupKeeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: tc.req.GroupId})
require.NoError(err)
groupWeight1, err = math.NewNonNegativeDecFromString(groupRes.Info.TotalWeight)
require.NoError(err)
}
res, err := s.keeper.LeaveGroup(s.ctx, tc.req)
res, err := s.groupKeeper.LeaveGroup(s.ctx, tc.req)
if tc.expErr {
require.Error(err)
require.Contains(err.Error(), tc.errMsg)
} else {
require.NoError(err)
require.NotNil(res)
res, err := s.keeper.GroupMembers(s.ctx, &group.QueryGroupMembersRequest{
res, err := s.groupKeeper.GroupMembers(s.ctx, &group.QueryGroupMembersRequest{
GroupId: tc.req.GroupId,
})
require.NoError(err)
require.Len(res.Members, tc.expMembersSize)
groupRes, err := s.keeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: tc.req.GroupId})
groupRes, err := s.groupKeeper.GroupInfo(s.ctx, &group.QueryGroupInfoRequest{GroupId: tc.req.GroupId})
require.NoError(err)
groupWeight2, err := math.NewNonNegativeDecFromString(groupRes.Info.TotalWeight)
require.NoError(err)
@ -2849,7 +2865,7 @@ func (s *TestSuite) TestPruneProposals() {
policy := group.NewThresholdDecisionPolicy("100", time.Microsecond, time.Microsecond)
err := policyReq.SetDecisionPolicy(policy)
s.Require().NoError(err)
_, err = s.keeper.CreateGroupPolicy(s.ctx, policyReq)
_, err = s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
s.Require().NoError(err)
req := &group.MsgSubmitProposal{
@ -2858,19 +2874,19 @@ func (s *TestSuite) TestPruneProposals() {
}
err = req.SetMsgs([]sdk.Msg{msgSend})
s.Require().NoError(err)
submittedProposal, err := s.keeper.SubmitProposal(s.ctx, req)
submittedProposal, err := s.groupKeeper.SubmitProposal(s.ctx, req)
s.Require().NoError(err)
queryProposal := group.QueryProposalRequest{ProposalId: submittedProposal.ProposalId}
prePrune, err := s.keeper.Proposal(s.ctx, &queryProposal)
prePrune, err := s.groupKeeper.Proposal(s.ctx, &queryProposal)
s.Require().NoError(err)
s.Require().Equal(prePrune.Proposal.Id, submittedProposal.ProposalId)
// Move Forward in time for 15 days, after voting period end + max_execution_period
s.sdkCtx = s.sdkCtx.WithBlockTime(s.sdkCtx.BlockTime().Add(expirationTime))
// Prune Expired Proposals
err = s.keeper.PruneProposals(s.sdkCtx)
err = s.groupKeeper.PruneProposals(s.sdkCtx)
s.Require().NoError(err)
postPrune, err := s.keeper.Proposal(s.ctx, &queryProposal)
postPrune, err := s.groupKeeper.Proposal(s.ctx, &queryProposal)
s.Require().Nil(postPrune)
s.Require().Error(err)
s.Require().Contains(err.Error(), "load proposal: not found")
@ -2887,7 +2903,7 @@ func submitProposal(
err := proposalReq.SetMsgs(msgs)
s.Require().NoError(err)
proposalRes, err := s.keeper.SubmitProposal(ctx, proposalReq)
proposalRes, err := s.groupKeeper.SubmitProposal(ctx, proposalReq)
s.Require().NoError(err)
return proposalRes.ProposalId
}
@ -2899,7 +2915,7 @@ func submitProposalAndVote(
s.Require().Greater(len(proposers), 0)
myProposalID := submitProposal(ctx, s, msgs, proposers)
_, err := s.keeper.Vote(ctx, &group.MsgVote{
_, err := s.groupKeeper.Vote(ctx, &group.MsgVote{
ProposalId: myProposalID,
Voter: proposers[0],
Option: voteOption,
@ -2913,7 +2929,7 @@ func (s *TestSuite) createGroupAndGroupPolicy(
members []group.MemberRequest,
policy group.DecisionPolicy,
) (policyAddr string, groupID uint64) {
groupRes, err := s.keeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
Admin: admin.String(),
Members: members,
})
@ -2929,7 +2945,7 @@ func (s *TestSuite) createGroupAndGroupPolicy(
err = groupPolicy.SetDecisionPolicy(policy)
s.Require().NoError(err)
groupPolicyRes, err := s.keeper.CreateGroupPolicy(s.ctx, groupPolicy)
groupPolicyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, groupPolicy)
s.Require().NoError(err)
policyAddr = groupPolicyRes.Address
}

4
x/group/keeper/tally_test.go
View File

@ -43,7 +43,7 @@ func (s *TestSuite) TestTally() {
setupProposal: func(ctx context.Context) uint64 {
msgs := []sdk.Msg{msgSend1}
proposalId := submitProposal(ctx, s, msgs, proposers)
_, err := s.app.GroupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
_, err := s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
ProposalId: proposalId,
Address: proposers[0],
})
@ -78,7 +78,7 @@ func (s *TestSuite) TestTally() {
ProposalId: pId,
}
res, err := s.keeper.TallyResult(ctx, req)
res, err := s.groupKeeper.TallyResult(ctx, req)
if spec.expErr {
s.Require().Error(err)
} else {

304
x/group/module/abci_test.go
View File

@ -5,42 +5,80 @@ import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/simapp"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/runtime"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
sdk "github.com/cosmos/cosmos-sdk/types"
bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
"github.com/cosmos/cosmos-sdk/x/bank/testutil"
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/keeper"
"github.com/cosmos/cosmos-sdk/x/group/module"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
"github.com/stretchr/testify/suite"
tmtime "github.com/tendermint/tendermint/libs/time"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
)
func TestEndBlockerPruning(t *testing.T) {
app := simapp.Setup(t, false)
type IntegrationTestSuite struct {
suite.Suite
app *runtime.App
ctx sdk.Context
addrs []sdk.AccAddress
groupKeeper keeper.Keeper
bankKeeper bankkeeper.Keeper
stakingKeeper *stakingkeeper.Keeper
interfaceRegistry codectypes.InterfaceRegistry
}
func TestIntegrationTestSuite(t *testing.T) {
suite.Run(t, new(IntegrationTestSuite))
}
func (s *IntegrationTestSuite) SetupTest() {
app, err := simtestutil.Setup(
grouptestutil.AppConfig,
&s.interfaceRegistry,
&s.bankKeeper,
&s.stakingKeeper,
&s.groupKeeper,
)
s.Require().NoError(err)
ctx := app.BaseApp.NewContext(false, tmproto.Header{})
addrs := simapp.AddTestAddrsIncremental(app, ctx, 3, sdk.NewInt(30000000))
addr1 := addrs[0]
addr2 := addrs[1]
addr3 := addrs[2]
ctx = ctx.WithBlockHeader(tmproto.Header{Time: tmtime.Now()})
s.ctx = ctx
s.addrs = simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, ctx, 4, sdk.NewInt(30000000))
}
func (s *IntegrationTestSuite) TestEndBlockerPruning() {
ctx := s.ctx
addr1 := s.addrs[0]
addr2 := s.addrs[1]
addr3 := s.addrs[2]
// Initial group, group policy and balance setup
members := []group.MemberRequest{
{Address: addr1.String(), Weight: "1"}, {Address: addr2.String(), Weight: "2"},
}
groupRes, err := app.GroupKeeper.CreateGroup(ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(ctx, &group.MsgCreateGroup{
Admin: addr1.String(),
Members: members,
})
require.NoError(t, err)
s.Require().NoError(err)
groupRes2, err := app.GroupKeeper.CreateGroup(ctx, &group.MsgCreateGroup{
groupRes2, err := s.groupKeeper.CreateGroup(ctx, &group.MsgCreateGroup{
Admin: addr2.String(),
Members: members,
})
require.NoError(t, err)
s.Require().NoError(err)
groupID := groupRes.GroupId
groupID2 := groupRes2.GroupId
@ -57,9 +95,9 @@ func TestEndBlockerPruning(t *testing.T) {
}
err = policyReq.SetDecisionPolicy(policy)
require.NoError(t, err)
policyRes, err := app.GroupKeeper.CreateGroupPolicy(ctx, policyReq)
require.NoError(t, err)
s.Require().NoError(err)
policyRes, err := s.groupKeeper.CreateGroupPolicy(ctx, policyReq)
s.Require().NoError(err)
policy2 := group.NewThresholdDecisionPolicy(
"1",
@ -73,17 +111,17 @@ func TestEndBlockerPruning(t *testing.T) {
}
err = policyReq2.SetDecisionPolicy(policy2)
require.NoError(t, err)
policyRes2, err := app.GroupKeeper.CreateGroupPolicy(ctx, policyReq2)
require.NoError(t, err)
s.Require().NoError(err)
policyRes2, err := s.groupKeeper.CreateGroupPolicy(ctx, policyReq2)
s.Require().NoError(err)
groupPolicyAddr, err := sdk.AccAddressFromBech32(policyRes.Address)
require.NoError(t, err)
require.NoError(t, testutil.FundAccount(app.BankKeeper, ctx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
s.Require().NoError(err)
s.Require().NoError(testutil.FundAccount(s.bankKeeper, ctx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
groupPolicyAddr2, err := sdk.AccAddressFromBech32(policyRes2.Address)
require.NoError(t, err)
require.NoError(t, testutil.FundAccount(app.BankKeeper, ctx, groupPolicyAddr2, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
s.Require().NoError(err)
s.Require().NoError(testutil.FundAccount(s.bankKeeper, ctx, groupPolicyAddr2, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
votingPeriod := policy.GetVotingPeriod()
@ -110,12 +148,12 @@ func TestEndBlockerPruning(t *testing.T) {
"proposal pruned after executor result success": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1}
pID, err := submitProposalAndVote(app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
require.NoError(t, err)
_, err = app.GroupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
require.NoError(t, err)
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
sdkCtx := sdk.UnwrapSDKContext(ctx)
require.NoError(t, testutil.FundAccount(app.BankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
return pID
},
@ -126,12 +164,12 @@ func TestEndBlockerPruning(t *testing.T) {
"proposal with multiple messages pruned when executed with result success": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1, msgSend1}
pID, err := submitProposalAndVote(app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
require.NoError(t, err)
_, err = app.GroupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
require.NoError(t, err)
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
sdkCtx := sdk.UnwrapSDKContext(ctx)
require.NoError(t, testutil.FundAccount(app.BankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
return pID
},
@ -142,12 +180,12 @@ func TestEndBlockerPruning(t *testing.T) {
"proposal not pruned when not executed and rejected": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1}
pID, err := submitProposalAndVote(app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_NO)
require.NoError(t, err)
_, err = app.GroupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
require.NoError(t, err)
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_NO)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
sdkCtx := sdk.UnwrapSDKContext(ctx)
require.NoError(t, testutil.FundAccount(app.BankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
return pID
},
@ -157,12 +195,12 @@ func TestEndBlockerPruning(t *testing.T) {
},
"open proposal is not pruned which must not fail ": {
setupProposal: func(ctx sdk.Context) uint64 {
pID, err := submitProposal(app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
require.NoError(t, err)
_, err = app.GroupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
require.NoError(t, err)
pID, err := submitProposal(s, s.app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
sdkCtx := sdk.UnwrapSDKContext(ctx)
require.NoError(t, testutil.FundAccount(app.BankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
return pID
},
@ -172,17 +210,17 @@ func TestEndBlockerPruning(t *testing.T) {
},
"proposal not pruned with group policy modified before tally": {
setupProposal: func(ctx sdk.Context) uint64 {
pID, err := submitProposal(app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
require.NoError(t, err)
_, err = app.GroupKeeper.UpdateGroupPolicyMetadata(ctx, &group.MsgUpdateGroupPolicyMetadata{
pID, err := submitProposal(s, s.app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.UpdateGroupPolicyMetadata(ctx, &group.MsgUpdateGroupPolicyMetadata{
Admin: addr1.String(),
GroupPolicyAddress: groupPolicyAddr.String(),
})
require.NoError(t, err)
_, err = app.GroupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
require.Error(t, err) // since proposal with status Aborted cannot be executed
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().Error(err) // since proposal with status Aborted cannot be executed
sdkCtx := sdk.UnwrapSDKContext(ctx)
require.NoError(t, testutil.FundAccount(app.BankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
return pID
},
@ -193,10 +231,10 @@ func TestEndBlockerPruning(t *testing.T) {
"pruned when proposal is executable when failed before": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1}
pID, err := submitProposalAndVote(app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
require.NoError(t, err)
_, err = app.GroupKeeper.Exec(ctx, &group.MsgExec{Executor: addrs[2].String(), ProposalId: pID})
require.NoError(t, err)
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: s.addrs[2].String(), ProposalId: pID})
s.Require().NoError(err)
return pID
},
newCtx: ctx,
@ -205,13 +243,13 @@ func TestEndBlockerPruning(t *testing.T) {
},
"proposal with status withdrawn is pruned after voting period end": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposal(app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
require.NoError(t, err)
_, err = app.GroupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
pId, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: proposers[0],
})
require.NoError(t, err)
s.Require().NoError(err)
return pId
},
newCtx: ctx.WithBlockTime(ctx.BlockTime().Add(votingPeriod).Add(time.Hour)),
@ -220,13 +258,13 @@ func TestEndBlockerPruning(t *testing.T) {
},
"proposal with status withdrawn is not pruned (before voting period)": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposal(app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
require.NoError(t, err)
_, err = app.GroupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
pId, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: proposers[0],
})
require.NoError(t, err)
s.Require().NoError(err)
return pId
},
newCtx: ctx,
@ -236,18 +274,18 @@ func TestEndBlockerPruning(t *testing.T) {
},
"proposal with status aborted is pruned after voting period end (due to updated group policy decision policy)": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposal(app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
require.NoError(t, err)
pId, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
s.Require().NoError(err)
policy := group.NewThresholdDecisionPolicy("3", time.Second, 0)
msg := &group.MsgUpdateGroupPolicyDecisionPolicy{
Admin: addrs[1].String(),
Admin: s.addrs[1].String(),
GroupPolicyAddress: groupPolicyAddr2.String(),
}
err = msg.SetDecisionPolicy(policy)
require.NoError(t, err)
_, err = app.GroupKeeper.UpdateGroupPolicyDecisionPolicy(ctx, msg)
require.NoError(t, err)
s.Require().NoError(err)
_, err = s.groupKeeper.UpdateGroupPolicyDecisionPolicy(ctx, msg)
s.Require().NoError(err)
return pId
},
@ -258,18 +296,18 @@ func TestEndBlockerPruning(t *testing.T) {
},
"proposal with status aborted is not pruned before voting period end (due to updated group policy)": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposal(app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
require.NoError(t, err)
pId, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
s.Require().NoError(err)
policy := group.NewThresholdDecisionPolicy("3", time.Second, 0)
msg := &group.MsgUpdateGroupPolicyDecisionPolicy{
Admin: addrs[1].String(),
Admin: s.addrs[1].String(),
GroupPolicyAddress: groupPolicyAddr2.String(),
}
err = msg.SetDecisionPolicy(policy)
require.NoError(t, err)
_, err = app.GroupKeeper.UpdateGroupPolicyDecisionPolicy(ctx, msg)
require.NoError(t, err)
s.Require().NoError(err)
_, err = s.groupKeeper.UpdateGroupPolicyDecisionPolicy(ctx, msg)
s.Require().NoError(err)
return pId
},
@ -281,59 +319,59 @@ func TestEndBlockerPruning(t *testing.T) {
}
for msg, spec := range specs {
spec := spec
t.Run(msg, func(t *testing.T) {
s.Run(msg, func() {
proposalID := spec.setupProposal(ctx)
module.EndBlocker(spec.newCtx, app.GroupKeeper)
module.EndBlocker(spec.newCtx, s.groupKeeper)
if spec.expErrMsg != "" && spec.expExecutorResult != group.PROPOSAL_EXECUTOR_RESULT_SUCCESS {
_, err = app.GroupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{ProposalId: proposalID})
require.Error(t, err)
require.Contains(t, err.Error(), spec.expErrMsg)
_, err = s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{ProposalId: proposalID})
s.Require().Error(err)
s.Require().Contains(err.Error(), spec.expErrMsg)
return
}
if spec.expExecutorResult == group.PROPOSAL_EXECUTOR_RESULT_SUCCESS {
// Make sure proposal is deleted from state
_, err = app.GroupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{ProposalId: proposalID})
require.Contains(t, err.Error(), spec.expErrMsg)
res, err := app.GroupKeeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: proposalID})
require.NoError(t, err)
require.Empty(t, res.GetVotes())
_, err = s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{ProposalId: proposalID})
s.Require().Contains(err.Error(), spec.expErrMsg)
res, err := s.groupKeeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: proposalID})
s.Require().NoError(err)
s.Require().Empty(res.GetVotes())
} else {
// Check that proposal and votes exists
res, err := app.GroupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{ProposalId: proposalID})
require.NoError(t, err)
_, err = app.GroupKeeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: res.Proposal.Id})
require.NoError(t, err)
require.Equal(t, "", spec.expErrMsg)
res, err := s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{ProposalId: proposalID})
s.Require().NoError(err)
_, err = s.groupKeeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{ProposalId: res.Proposal.Id})
s.Require().NoError(err)
s.Require().Equal("", spec.expErrMsg)
exp := group.ProposalExecutorResult_name[int32(spec.expExecutorResult)]
got := group.ProposalExecutorResult_name[int32(res.Proposal.ExecutorResult)]
assert.Equal(t, exp, got)
s.Assert().Equal(exp, got)
require.Equal(t, res.GetProposal().Status, spec.expStatus)
s.Require().Equal(res.GetProposal().Status, spec.expStatus)
}
})
}
}
func TestEndBlockerTallying(t *testing.T) {
app := simapp.Setup(t, false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{})
func (s *IntegrationTestSuite) TestEndBlockerTallying() {
app := s.app
ctx := s.ctx
addrs := simapp.AddTestAddrsIncremental(app, ctx, 4, sdk.NewInt(30000000))
addrs := s.addrs
// Initial group, group policy and balance setup
members := []group.MemberRequest{
{Address: addrs[1].String(), Weight: "1"}, {Address: addrs[2].String(), Weight: "2"},
}
groupRes, err := app.GroupKeeper.CreateGroup(ctx, &group.MsgCreateGroup{
groupRes, err := s.groupKeeper.CreateGroup(ctx, &group.MsgCreateGroup{
Admin: addrs[0].String(),
Members: members,
})
s.Require().NoError(err)
require.NoError(t, err)
groupID := groupRes.GroupId
policy := group.NewThresholdDecisionPolicy(
@ -348,12 +386,12 @@ func TestEndBlockerTallying(t *testing.T) {
}
err = policyReq.SetDecisionPolicy(policy)
require.NoError(t, err)
policyRes, err := app.GroupKeeper.CreateGroupPolicy(ctx, policyReq)
require.NoError(t, err)
s.Require().NoError(err)
policyRes, err := s.groupKeeper.CreateGroupPolicy(ctx, policyReq)
s.Require().NoError(err)
groupPolicyAddr, err := sdk.AccAddressFromBech32(policyRes.Address)
require.NoError(t, err)
s.Require().NoError(err)
votingPeriod := policy.GetVotingPeriod()
@ -375,8 +413,8 @@ func TestEndBlockerTallying(t *testing.T) {
}{
"tally updated after voting period end": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposal(app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
require.NoError(t, err)
pId, err := submitProposal(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
s.Require().NoError(err)
return pId
},
admin: proposers[0],
@ -386,8 +424,8 @@ func TestEndBlockerTallying(t *testing.T) {
},
"tally within voting period": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposal(app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
require.NoError(t, err)
pId, err := submitProposal(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
s.Require().NoError(err)
return pId
},
@ -398,8 +436,8 @@ func TestEndBlockerTallying(t *testing.T) {
},
"tally within voting period(with votes)": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposalAndVote(app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
require.NoError(t, err)
pId, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
return pId
},
@ -411,8 +449,8 @@ func TestEndBlockerTallying(t *testing.T) {
"tally after voting period (not passing)": {
preRun: func(sdkCtx sdk.Context) uint64 {
// `addrs[1]` has weight 1
pId, err := submitProposalAndVote(app, ctx, []sdk.Msg{msgSend}, []string{addrs[1].String()}, groupPolicyAddr, group.VOTE_OPTION_YES)
require.NoError(t, err)
pId, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, []string{addrs[1].String()}, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
return pId
},
@ -428,8 +466,8 @@ func TestEndBlockerTallying(t *testing.T) {
},
"tally after voting period(with votes)": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposalAndVote(app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
require.NoError(t, err)
pId, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
return pId
},
@ -445,15 +483,15 @@ func TestEndBlockerTallying(t *testing.T) {
},
"tally of withdrawn proposal": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposal(app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
require.NoError(t, err)
pId, err := submitProposal(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = app.GroupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: proposers[0],
})
require.NoError(t, err)
s.Require().NoError(err)
return pId
},
admin: proposers[0],
@ -463,15 +501,15 @@ func TestEndBlockerTallying(t *testing.T) {
},
"tally of withdrawn proposal (with votes)": {
preRun: func(sdkCtx sdk.Context) uint64 {
pId, err := submitProposalAndVote(app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
require.NoError(t, err)
pId, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = app.GroupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
ProposalId: pId,
Address: proposers[0],
})
require.NoError(t, err)
s.Require().NoError(err)
return pId
},
admin: proposers[0],
@ -482,29 +520,29 @@ func TestEndBlockerTallying(t *testing.T) {
}
for msg, spec := range specs {
t.Run(msg, func(t *testing.T) {
s.Run(msg, func() {
spec := spec
pId := spec.preRun(ctx)
module.EndBlocker(spec.newCtx, app.GroupKeeper)
resp, err := app.GroupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
module.EndBlocker(spec.newCtx, s.groupKeeper)
resp, err := s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
ProposalId: pId,
})
if spec.expErrMsg != "" {
require.Error(t, err)
require.Contains(t, err.Error(), spec.expErrMsg)
s.Require().NoError(err)
s.Require().Contains(err.Error(), spec.expErrMsg)
return
}
require.NoError(t, err)
require.Equal(t, resp.GetProposal().FinalTallyResult, spec.tallyRes)
require.Equal(t, resp.GetProposal().Status, spec.expStatus)
s.Require().NoError(err)
s.Require().Equal(resp.GetProposal().FinalTallyResult, spec.tallyRes)
s.Require().Equal(resp.GetProposal().Status, spec.expStatus)
})
}
}
func submitProposal(app *simapp.SimApp, ctx context.Context, msgs []sdk.Msg, proposers []string, groupPolicyAddr sdk.AccAddress) (uint64, error) {
func submitProposal(s *IntegrationTestSuite, app *runtime.App, ctx context.Context, msgs []sdk.Msg, proposers []string, groupPolicyAddr sdk.AccAddress) (uint64, error) {
proposalReq := &group.MsgSubmitProposal{
GroupPolicyAddress: groupPolicyAddr.String(),
Proposers: proposers,
@ -514,7 +552,7 @@ func submitProposal(app *simapp.SimApp, ctx context.Context, msgs []sdk.Msg, pro
return 0, err
}
proposalRes, err := app.GroupKeeper.SubmitProposal(ctx, proposalReq)
proposalRes, err := s.groupKeeper.SubmitProposal(ctx, proposalReq)
if err != nil {
return 0, err
}
@ -523,14 +561,14 @@ func submitProposal(app *simapp.SimApp, ctx context.Context, msgs []sdk.Msg, pro
}
func submitProposalAndVote(
app *simapp.SimApp, ctx context.Context, msgs []sdk.Msg,
s *IntegrationTestSuite, app *runtime.App, ctx context.Context, msgs []sdk.Msg,
proposers []string, groupPolicyAddr sdk.AccAddress, voteOption group.VoteOption,
) (uint64, error) {
myProposalID, err := submitProposal(app, ctx, msgs, proposers, groupPolicyAddr)
myProposalID, err := submitProposal(s, app, ctx, msgs, proposers, groupPolicyAddr)
if err != nil {
return 0, err
}
_, err = app.GroupKeeper.Vote(ctx, &group.MsgVote{
_, err = s.groupKeeper.Vote(ctx, &group.MsgVote{
ProposalId: myProposalID,
Voter: proposers[0],
Option: voteOption,

1
x/group/module/module.go
View File

@ -234,6 +234,7 @@ func (am AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry) {
// WeightedOperations returns the all the gov module operations with their respective weights.
func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation {
return simulation.WeightedOperations(
am.registry,
simState.AppParams, simState.Cdc,
am.accKeeper, am.bankKeeper, am.keeper, am.cdc,
)

9
x/group/proposal_test.go
View File

@ -5,8 +5,10 @@ import (
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/depinject"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/testutil"
)
// TestGogoUnmarshalProposal tests some weird behavior in gogoproto
@ -14,7 +16,10 @@ import (
// This test serves as a showcase that we need to be careful when unmarshalling
// multiple times into the same reference.
func TestGogoUnmarshalProposal(t *testing.T) {
cdc := simapp.MakeTestEncodingConfig().Codec
var cdc codec.Codec
err := depinject.Inject(testutil.AppConfig, &cdc)
require.NoError(t, err)
p1 := group.Proposal{Proposers: []string{"foo"}}
p2 := group.Proposal{Proposers: []string{"bar"}}

8
x/group/simulation/decoder_test.go
View File

@ -6,17 +6,21 @@ import (
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/depinject"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/internal/orm"
"github.com/cosmos/cosmos-sdk/x/group/keeper"
"github.com/cosmos/cosmos-sdk/x/group/simulation"
grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
)
func TestDecodeStore(t *testing.T) {
cdc := simapp.MakeTestEncodingConfig().Codec
var cdc codec.Codec
err := depinject.Inject(grouptestutil.AppConfig, &cdc)
require.NoError(t, err)
dec := simulation.NewDecodeStore(cdc)
g := group.GroupInfo{Id: 1}

10
x/group/simulation/genesis_test.go
View File

@ -8,22 +8,26 @@ import (
"github.com/stretchr/testify/require"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/depinject"
"github.com/cosmos/cosmos-sdk/types/module"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/simulation"
"github.com/cosmos/cosmos-sdk/x/group/testutil"
)
func TestRandomizedGenState(t *testing.T) {
app := simapp.Setup(t, false)
var cdc codec.Codec
err := depinject.Inject(testutil.AppConfig, &cdc)
require.NoError(t, err)
s := rand.NewSource(1)
r := rand.New(s)
simState := module.SimulationState{
AppParams: make(simtypes.AppParams),
Cdc: app.AppCodec(),
Cdc: cdc,
Rand: r,
NumBonded: 3,
Accounts: simtypes.RandomAccounts(r, 3),

87
x/group/simulation/operations.go
View File

@ -10,10 +10,10 @@ import (
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/codec"
cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
simappparams "github.com/cosmos/cosmos-sdk/simapp/params"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
sdk "github.com/cosmos/cosmos-sdk/types"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
"github.com/cosmos/cosmos-sdk/x/auth/tx"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
"github.com/cosmos/cosmos-sdk/x/group/keeper"
"github.com/cosmos/cosmos-sdk/x/simulation"
@ -81,6 +81,7 @@ const (
// WeightedOperations returns all the operations from the module with their respective weights
func WeightedOperations(
registry cdctypes.InterfaceRegistry,
appParams simtypes.AppParams, cdc codec.JSONCodec, ak group.AccountKeeper,
bk group.BankKeeper, k keeper.Keeper, appCdc cdctypes.AnyUnpacker,
) simulation.WeightedOperations {
@ -177,65 +178,65 @@ func WeightedOperations(
for i := 0; i < 2; i++ {
createProposalOps = append(createProposalOps, simulation.NewWeightedOperation(
weightMsgSubmitProposal,
SimulateMsgSubmitProposal(ak, bk, k),
SimulateMsgSubmitProposal(codec.NewProtoCodec(registry), ak, bk, k),
))
}
wPreCreateProposalOps := simulation.WeightedOperations{
simulation.NewWeightedOperation(
weightMsgCreateGroup,
SimulateMsgCreateGroup(ak, bk),
SimulateMsgCreateGroup(codec.NewProtoCodec(registry), ak, bk),
),
simulation.NewWeightedOperation(
weightMsgCreateGroupPolicy,
SimulateMsgCreateGroupPolicy(ak, bk, k),
SimulateMsgCreateGroupPolicy(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgCreateGroupWithPolicy,
SimulateMsgCreateGroupWithPolicy(ak, bk),
SimulateMsgCreateGroupWithPolicy(codec.NewProtoCodec(registry), ak, bk),
),
}
wPostCreateProposalOps := simulation.WeightedOperations{
simulation.NewWeightedOperation(
WeightMsgWithdrawProposal,
SimulateMsgWithdrawProposal(ak, bk, k),
SimulateMsgWithdrawProposal(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgVote,
SimulateMsgVote(ak, bk, k),
SimulateMsgVote(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgExec,
SimulateMsgExec(ak, bk, k),
SimulateMsgExec(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgUpdateGroupMetadata,
SimulateMsgUpdateGroupMetadata(ak, bk, k),
SimulateMsgUpdateGroupMetadata(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgUpdateGroupAdmin,
SimulateMsgUpdateGroupAdmin(ak, bk, k),
SimulateMsgUpdateGroupAdmin(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgUpdateGroupMembers,
SimulateMsgUpdateGroupMembers(ak, bk, k),
SimulateMsgUpdateGroupMembers(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgUpdateGroupPolicyAdmin,
SimulateMsgUpdateGroupPolicyAdmin(ak, bk, k),
SimulateMsgUpdateGroupPolicyAdmin(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgUpdateGroupPolicyDecisionPolicy,
SimulateMsgUpdateGroupPolicyDecisionPolicy(ak, bk, k),
SimulateMsgUpdateGroupPolicyDecisionPolicy(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgUpdateGroupPolicyMetadata,
SimulateMsgUpdateGroupPolicyMetadata(ak, bk, k),
SimulateMsgUpdateGroupPolicyMetadata(codec.NewProtoCodec(registry), ak, bk, k),
),
simulation.NewWeightedOperation(
weightMsgLeaveGroup,
SimulateMsgLeaveGroup(k, ak, bk),
SimulateMsgLeaveGroup(codec.NewProtoCodec(registry), k, ak, bk),
),
}
@ -243,7 +244,7 @@ func WeightedOperations(
}
// SimulateMsgCreateGroup generates a MsgCreateGroup with random values
func SimulateMsgCreateGroup(ak group.AccountKeeper, bk group.BankKeeper) simtypes.Operation {
func SimulateMsgCreateGroup(cdc *codec.ProtoCodec, ak group.AccountKeeper, bk group.BankKeeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -260,7 +261,7 @@ func SimulateMsgCreateGroup(ak group.AccountKeeper, bk group.BankKeeper) simtype
members := genGroupMembers(r, accounts)
msg := &group.MsgCreateGroup{Admin: accAddr, Members: members, Metadata: simtypes.RandStringOfLength(r, 10)}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{msg},
@ -285,7 +286,7 @@ func SimulateMsgCreateGroup(ak group.AccountKeeper, bk group.BankKeeper) simtype
}
// SimulateMsgCreateGroupWithPolicy generates a MsgCreateGroupWithPolicy with random values
func SimulateMsgCreateGroupWithPolicy(ak group.AccountKeeper, bk group.BankKeeper) simtypes.Operation {
func SimulateMsgCreateGroupWithPolicy(cdc *codec.ProtoCodec, ak group.AccountKeeper, bk group.BankKeeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -319,7 +320,7 @@ func SimulateMsgCreateGroupWithPolicy(ak group.AccountKeeper, bk group.BankKeepe
return simtypes.NoOpMsg(group.ModuleName, msg.Type(), "unable to set decision policy"), nil, err
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{msg},
@ -344,7 +345,7 @@ func SimulateMsgCreateGroupWithPolicy(ak group.AccountKeeper, bk group.BankKeepe
}
// SimulateMsgCreateGroupPolicy generates a NewMsgCreateGroupPolicy with random values
func SimulateMsgCreateGroupPolicy(ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
func SimulateMsgCreateGroupPolicy(cdc *codec.ProtoCodec, ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, sdkCtx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -378,7 +379,7 @@ func SimulateMsgCreateGroupPolicy(ak group.AccountKeeper, bk group.BankKeeper, k
return simtypes.NoOpMsg(group.ModuleName, TypeMsgCreateGroupPolicy, err.Error()), nil, err
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{msg},
@ -404,7 +405,7 @@ func SimulateMsgCreateGroupPolicy(ak group.AccountKeeper, bk group.BankKeeper, k
}
// SimulateMsgSubmitProposal generates a NewMsgSubmitProposal with random values
func SimulateMsgSubmitProposal(ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
func SimulateMsgSubmitProposal(cdc *codec.ProtoCodec, ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, sdkCtx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -453,7 +454,7 @@ func SimulateMsgSubmitProposal(ak group.AccountKeeper, bk group.BankKeeper, k ke
Metadata: simtypes.RandStringOfLength(r, 10),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -478,7 +479,7 @@ func SimulateMsgSubmitProposal(ak group.AccountKeeper, bk group.BankKeeper, k ke
}
// SimulateMsgUpdateGroupAdmin generates a MsgUpdateGroupAdmin with random values
func SimulateMsgUpdateGroupAdmin(ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
func SimulateMsgUpdateGroupAdmin(cdc *codec.ProtoCodec, ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, sdkCtx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -512,7 +513,7 @@ func SimulateMsgUpdateGroupAdmin(ak group.AccountKeeper, bk group.BankKeeper, k
NewAdmin: newAdmin.Address.String(),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -537,7 +538,7 @@ func SimulateMsgUpdateGroupAdmin(ak group.AccountKeeper, bk group.BankKeeper, k
}
// SimulateMsgUpdateGroupMetadata generates a MsgUpdateGroupMetadata with random values
func SimulateMsgUpdateGroupMetadata(ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
func SimulateMsgUpdateGroupMetadata(cdc *codec.ProtoCodec, ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, sdkCtx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -562,7 +563,7 @@ func SimulateMsgUpdateGroupMetadata(ak group.AccountKeeper, bk group.BankKeeper,
Metadata: simtypes.RandStringOfLength(r, 10),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -587,7 +588,7 @@ func SimulateMsgUpdateGroupMetadata(ak group.AccountKeeper, bk group.BankKeeper,
}
// SimulateMsgUpdateGroupMembers generates a MsgUpdateGroupMembers with random values
func SimulateMsgUpdateGroupMembers(ak group.AccountKeeper,
func SimulateMsgUpdateGroupMembers(cdc *codec.ProtoCodec, ak group.AccountKeeper,
bk group.BankKeeper, k keeper.Keeper,
) simtypes.Operation {
return func(
@ -641,7 +642,7 @@ func SimulateMsgUpdateGroupMembers(ak group.AccountKeeper,
MemberUpdates: members,
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -666,7 +667,7 @@ func SimulateMsgUpdateGroupMembers(ak group.AccountKeeper,
}
// SimulateMsgUpdateGroupPolicyAdmin generates a MsgUpdateGroupPolicyAdmin with random values
func SimulateMsgUpdateGroupPolicyAdmin(ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
func SimulateMsgUpdateGroupPolicyAdmin(cdc *codec.ProtoCodec, ak group.AccountKeeper, bk group.BankKeeper, k keeper.Keeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, sdkCtx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -700,7 +701,7 @@ func SimulateMsgUpdateGroupPolicyAdmin(ak group.AccountKeeper, bk group.BankKeep
NewAdmin: newAdmin.Address.String(),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -725,7 +726,7 @@ func SimulateMsgUpdateGroupPolicyAdmin(ak group.AccountKeeper, bk group.BankKeep
}
// // SimulateMsgUpdateGroupPolicyDecisionPolicy generates a NewMsgUpdateGroupPolicyDecisionPolicy with random values
func SimulateMsgUpdateGroupPolicyDecisionPolicy(ak group.AccountKeeper,
func SimulateMsgUpdateGroupPolicyDecisionPolicy(cdc *codec.ProtoCodec, ak group.AccountKeeper,
bk group.BankKeeper, k keeper.Keeper,
) simtypes.Operation {
return func(
@ -761,7 +762,7 @@ func SimulateMsgUpdateGroupPolicyDecisionPolicy(ak group.AccountKeeper,
return simtypes.NoOpMsg(group.ModuleName, TypeMsgUpdateGroupPolicyDecisionPolicy, err.Error()), nil, err
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{msg},
@ -785,7 +786,7 @@ func SimulateMsgUpdateGroupPolicyDecisionPolicy(ak group.AccountKeeper,
}
// // SimulateMsgUpdateGroupPolicyMetadata generates a MsgUpdateGroupPolicyMetadata with random values
func SimulateMsgUpdateGroupPolicyMetadata(ak group.AccountKeeper,
func SimulateMsgUpdateGroupPolicyMetadata(cdc *codec.ProtoCodec, ak group.AccountKeeper,
bk group.BankKeeper, k keeper.Keeper,
) simtypes.Operation {
return func(
@ -812,7 +813,7 @@ func SimulateMsgUpdateGroupPolicyMetadata(ak group.AccountKeeper,
Metadata: simtypes.RandStringOfLength(r, 10),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -837,7 +838,7 @@ func SimulateMsgUpdateGroupPolicyMetadata(ak group.AccountKeeper,
}
// SimulateMsgWithdrawProposal generates a MsgWithdrawProposal with random values
func SimulateMsgWithdrawProposal(ak group.AccountKeeper,
func SimulateMsgWithdrawProposal(cdc *codec.ProtoCodec, ak group.AccountKeeper,
bk group.BankKeeper, k keeper.Keeper,
) simtypes.Operation {
return func(
@ -914,7 +915,7 @@ func SimulateMsgWithdrawProposal(ak group.AccountKeeper,
Address: proposer.Address.String(),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -943,7 +944,7 @@ func SimulateMsgWithdrawProposal(ak group.AccountKeeper,
}
// SimulateMsgVote generates a MsgVote with random values
func SimulateMsgVote(ak group.AccountKeeper,
func SimulateMsgVote(cdc *codec.ProtoCodec, ak group.AccountKeeper,
bk group.BankKeeper, k keeper.Keeper,
) simtypes.Operation {
return func(
@ -1019,7 +1020,7 @@ func SimulateMsgVote(ak group.AccountKeeper,
Option: group.VOTE_OPTION_YES,
Metadata: simtypes.RandStringOfLength(r, 10),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -1048,7 +1049,7 @@ func SimulateMsgVote(ak group.AccountKeeper,
}
// // SimulateMsgExec generates a MsgExec with random values
func SimulateMsgExec(ak group.AccountKeeper,
func SimulateMsgExec(cdc *codec.ProtoCodec, ak group.AccountKeeper,
bk group.BankKeeper, k keeper.Keeper,
) simtypes.Operation {
return func(
@ -1097,7 +1098,7 @@ func SimulateMsgExec(ak group.AccountKeeper,
ProposalId: uint64(proposalID),
Executor: acc.Address.String(),
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{&msg},
@ -1125,7 +1126,7 @@ func SimulateMsgExec(ak group.AccountKeeper,
}
// SimulateMsgLeaveGroup generates a MsgLeaveGroup with random values
func SimulateMsgLeaveGroup(k keeper.Keeper, ak group.AccountKeeper, bk group.BankKeeper) simtypes.Operation {
func SimulateMsgLeaveGroup(cdc *codec.ProtoCodec, k keeper.Keeper, ak group.AccountKeeper, bk group.BankKeeper) simtypes.Operation {
return func(
r *rand.Rand, app *baseapp.BaseApp, sdkCtx sdk.Context, accounts []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
@ -1159,7 +1160,7 @@ func SimulateMsgLeaveGroup(k keeper.Keeper, ak group.AccountKeeper, bk group.Ban
GroupId: groupInfo.Id,
}
txGen := simappparams.MakeTestEncodingConfig().TxConfig
txGen := tx.NewTxConfig(cdc, tx.DefaultSignModes)
tx, err := simtestutil.GenSignedMockTx(
txGen,
[]sdk.Msg{msg},

123
x/group/simulation/operations_test.go
View File

@ -9,35 +9,58 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/codec"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/runtime"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
sdk "github.com/cosmos/cosmos-sdk/types"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
"github.com/cosmos/cosmos-sdk/x/bank/testutil"
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
"github.com/cosmos/cosmos-sdk/x/group"
groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper"
"github.com/cosmos/cosmos-sdk/x/group/simulation"
grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
)
type SimTestSuite struct {
suite.Suite
ctx sdk.Context
app *simapp.SimApp
ctx sdk.Context
app *runtime.App
codec codec.Codec
interfaceRegistry codectypes.InterfaceRegistry
accountKeeper authkeeper.AccountKeeper
bankKeeper bankkeeper.Keeper
stakingKeeper *stakingkeeper.Keeper
groupKeeper groupkeeper.Keeper
}
func (suite *SimTestSuite) SetupTest() {
checkTx := false
app := simapp.Setup(suite.T(), checkTx)
app, err := simtestutil.Setup(
grouptestutil.AppConfig,
&suite.codec,
&suite.interfaceRegistry,
&suite.accountKeeper,
&suite.bankKeeper,
&suite.stakingKeeper,
&suite.groupKeeper,
)
suite.Require().NoError(err)
suite.app = app
suite.ctx = app.BaseApp.NewContext(checkTx, tmproto.Header{})
suite.ctx = app.BaseApp.NewContext(false, tmproto.Header{})
}
func (suite *SimTestSuite) TestWeightedOperations() {
cdc := suite.app.AppCodec()
cdc := suite.codec
appParams := make(simtypes.AppParams)
weightedOps := simulation.WeightedOperations(appParams, cdc, suite.app.AccountKeeper,
suite.app.BankKeeper, suite.app.GroupKeeper, cdc,
weightedOps := simulation.WeightedOperations(suite.interfaceRegistry, appParams, cdc, suite.accountKeeper,
suite.bankKeeper, suite.groupKeeper, cdc,
)
s := rand.NewSource(2)
@ -87,9 +110,9 @@ func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Ac
// add coins to the accounts
for _, account := range accounts {
acc := suite.app.AccountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
suite.Require().NoError(testutil.FundAccount(suite.app.BankKeeper, suite.ctx, account.Address, initCoins))
acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
suite.accountKeeper.SetAccount(suite.ctx, acc)
suite.Require().NoError(testutil.FundAccount(suite.bankKeeper, suite.ctx, account.Address, initCoins))
}
return accounts
@ -112,7 +135,7 @@ func (suite *SimTestSuite) TestSimulateCreateGroup() {
acc := accounts[0]
// execute operation
op := simulation.SimulateMsgCreateGroup(suite.app.AccountKeeper, suite.app.BankKeeper)
op := simulation.SimulateMsgCreateGroup(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -141,7 +164,7 @@ func (suite *SimTestSuite) TestSimulateCreateGroupWithPolicy() {
acc := accounts[0]
// execute operation
op := simulation.SimulateMsgCreateGroupWithPolicy(suite.app.AccountKeeper, suite.app.BankKeeper)
op := simulation.SimulateMsgCreateGroupWithPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -161,7 +184,7 @@ func (suite *SimTestSuite) TestSimulateCreateGroupPolicy() {
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
_, err := suite.groupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -183,7 +206,7 @@ func (suite *SimTestSuite) TestSimulateCreateGroupPolicy() {
})
// execute operation
op := simulation.SimulateMsgCreateGroupPolicy(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgCreateGroupPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -204,7 +227,7 @@ func (suite *SimTestSuite) TestSimulateSubmitProposal() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -224,7 +247,7 @@ func (suite *SimTestSuite) TestSimulateSubmitProposal() {
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
@ -236,7 +259,7 @@ func (suite *SimTestSuite) TestSimulateSubmitProposal() {
})
// execute operation
op := simulation.SimulateMsgSubmitProposal(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgSubmitProposal(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -258,7 +281,7 @@ func (suite *SimTestSuite) TestWithdrawProposal() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
addr := acc.Address.String()
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: addr,
Members: []group.MemberRequest{
@ -278,7 +301,7 @@ func (suite *SimTestSuite) TestWithdrawProposal() {
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// setup a proposal
@ -290,7 +313,7 @@ func (suite *SimTestSuite) TestWithdrawProposal() {
},
}, "", 0)
suite.Require().NoError(err)
_, err = suite.app.GroupKeeper.SubmitProposal(ctx, proposalReq)
_, err = suite.groupKeeper.SubmitProposal(ctx, proposalReq)
suite.Require().NoError(err)
// begin a new block
@ -302,7 +325,7 @@ func (suite *SimTestSuite) TestWithdrawProposal() {
})
// execute operation
op := simulation.SimulateMsgWithdrawProposal(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgWithdrawProposal(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -324,7 +347,7 @@ func (suite *SimTestSuite) TestSimulateVote() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
addr := acc.Address.String()
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: addr,
Members: []group.MemberRequest{
@ -345,7 +368,7 @@ func (suite *SimTestSuite) TestSimulateVote() {
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// setup a proposal
@ -357,7 +380,7 @@ func (suite *SimTestSuite) TestSimulateVote() {
},
}, "", 0)
suite.Require().NoError(err)
_, err = suite.app.GroupKeeper.SubmitProposal(ctx, proposalReq)
_, err = suite.groupKeeper.SubmitProposal(ctx, proposalReq)
suite.Require().NoError(err)
// begin a new block
@ -369,7 +392,7 @@ func (suite *SimTestSuite) TestSimulateVote() {
})
// execute operation
op := simulation.SimulateMsgVote(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgVote(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -391,7 +414,7 @@ func (suite *SimTestSuite) TestSimulateExec() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
addr := acc.Address.String()
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: addr,
Members: []group.MemberRequest{
@ -411,7 +434,7 @@ func (suite *SimTestSuite) TestSimulateExec() {
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// setup a proposal
@ -423,11 +446,11 @@ func (suite *SimTestSuite) TestSimulateExec() {
},
}, "", 0)
suite.Require().NoError(err)
proposalRes, err := suite.app.GroupKeeper.SubmitProposal(ctx, proposalReq)
proposalRes, err := suite.groupKeeper.SubmitProposal(ctx, proposalReq)
suite.Require().NoError(err)
// vote
_, err = suite.app.GroupKeeper.Vote(ctx, &group.MsgVote{
_, err = suite.groupKeeper.Vote(ctx, &group.MsgVote{
ProposalId: proposalRes.ProposalId,
Voter: addr,
Option: group.VOTE_OPTION_YES,
@ -444,7 +467,7 @@ func (suite *SimTestSuite) TestSimulateExec() {
})
// execute operation
op := simulation.SimulateMsgExec(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgExec(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -464,7 +487,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupAdmin() {
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
_, err := suite.groupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -486,7 +509,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupAdmin() {
})
// execute operation
op := simulation.SimulateMsgUpdateGroupAdmin(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgUpdateGroupAdmin(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -506,7 +529,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupMetadata() {
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
_, err := suite.groupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -528,7 +551,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupMetadata() {
})
// execute operation
op := simulation.SimulateMsgUpdateGroupMetadata(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgUpdateGroupMetadata(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -548,7 +571,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupMembers() {
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
_, err := suite.groupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -570,7 +593,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupMembers() {
})
// execute operation
op := simulation.SimulateMsgUpdateGroupMembers(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgUpdateGroupMembers(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -591,7 +614,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyAdmin() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -611,7 +634,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyAdmin() {
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
@ -623,7 +646,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyAdmin() {
})
// execute operation
op := simulation.SimulateMsgUpdateGroupPolicyAdmin(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgUpdateGroupPolicyAdmin(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -644,7 +667,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyDecisionPolicy() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -664,7 +687,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyDecisionPolicy() {
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
@ -676,7 +699,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyDecisionPolicy() {
})
// execute operation
op := simulation.SimulateMsgUpdateGroupPolicyDecisionPolicy(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgUpdateGroupPolicyDecisionPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -697,7 +720,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyMetadata() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.MemberRequest{
@ -717,7 +740,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyMetadata() {
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
@ -729,7 +752,7 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyMetadata() {
})
// execute operation
op := simulation.SimulateMsgUpdateGroupPolicyMetadata(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
op := simulation.SimulateMsgUpdateGroupPolicyMetadata(codec.NewProtoCodec(suite.interfaceRegistry), suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
@ -755,7 +778,7 @@ func (suite *SimTestSuite) TestSimulateLeaveGroup() {
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
groupRes, err := suite.groupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: admin.Address.String(),
Members: []group.MemberRequest{
@ -783,7 +806,7 @@ func (suite *SimTestSuite) TestSimulateLeaveGroup() {
Metadata: "",
}
require.NoError(accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("3", time.Hour, time.Hour)))
_, err = suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
_, err = suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
require.NoError(err)
// begin a new block
@ -795,7 +818,7 @@ func (suite *SimTestSuite) TestSimulateLeaveGroup() {
})
// execute operation
op := simulation.SimulateMsgLeaveGroup(suite.app.GroupKeeper, suite.app.AccountKeeper, suite.app.BankKeeper)
op := simulation.SimulateMsgLeaveGroup(codec.NewProtoCodec(suite.interfaceRegistry), suite.groupKeeper, suite.accountKeeper, suite.bankKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)

18
x/group/testutil/app.yaml
View File

@ -5,9 +5,9 @@ modules:
app_name: GroupApp
begin_blockers: [staking, auth, bank, genutil, authz, group, params]
end_blockers: [staking, auth, bank, genutil, authz, group, params]
init_genesis: [auth, bank, staking, genutil, authz, group, params]
begin_blockers: [mint, staking, auth, bank, genutil, group, params]
end_blockers: [staking, auth, bank, mint, genutil, group, params]
init_genesis: [auth, bank, staking, mint, genutil, group, params]
- name: auth
config:
@ -15,6 +15,8 @@ modules:
bech32_prefix: cosmos
module_account_permissions:
- account: fee_collector
- account: mint
permissions: [minter]
- account: bonded_tokens_pool
permissions: [burner, staking]
- account: not_bonded_tokens_pool
@ -36,14 +38,14 @@ modules:
config:
"@type": cosmos.staking.module.v1.Module
- name: authz
config:
"@type": cosmos.authz.module.v1.Module
- name: group
config:
"@type": cosmos.group.v1.module.v1.Module
- name: genutil
config:
"@type": cosmos.genutil.module.v1.Module
"@type": cosmos.genutil.module.v1.Module
- name: mint
config:
"@type": cosmos.mint.module.v1.Module

3
x/group/testutil/app_config.go
View File

@ -9,7 +9,8 @@ import (
_ "github.com/cosmos/cosmos-sdk/x/authz"
_ "github.com/cosmos/cosmos-sdk/x/bank"
_ "github.com/cosmos/cosmos-sdk/x/genutil"
_ "github.com/cosmos/cosmos-sdk/x/group"
_ "github.com/cosmos/cosmos-sdk/x/group/module"
_ "github.com/cosmos/cosmos-sdk/x/mint"
_ "github.com/cosmos/cosmos-sdk/x/params"
_ "github.com/cosmos/cosmos-sdk/x/staking"
)