LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity
0de174ae12
cosmos-sdk/x/group/simulation/operations_test.go
Amaury da36c46f3a
refactor(group): Distinguish Voting period and Execution period for group policies (#11198) 
## Description

Closes: #11092

## TODOs

I'm thinking to do the 2 todos in a separate PR, or else this PR is too big. WDYT?

- [ ] #11246 This involves adding a new index ProposalsByVotingPeriodEnd, so might be better to do in another PR
- [ ] #11245  Also should be done in a separate PR (as it needs the above index)

### Main change 1: Group policy proto defs have `voting_period` and `min_execution_period`

For group policies:

```diff
- // Within this times votes and exec messages can be submitted.
- // timeout is the duration from submission of a proposal to the end of voting period
- google.protobuf.Duration timeout = 2 [(gogoproto.stdduration) = true, (gogoproto.nullable) = false];

+  // voting_period is the duration from submission of a proposal to the end of voting period
+  // Within this times votes can be submitted with MsgVote.
+  google.protobuf.Duration voting_period = 2 [(gogoproto.stdduration) = true, (gogoproto.nullable) = false];

+  // min_execution_period is the minimum duration after the proposal submission
+  // where members can start sending MsgExec. This means that the window for
+  // sending a MsgExec transaction is:
+  // `[ submission + min_execution_period ; submission + voting_period + max_execution_period]`
+  // where max_execution_period is a app-specific config, defined in the keeper.
+  // If not set, min_execution_period will default to 0.
+  google.protobuf.Duration min_execution_period = 3 [(gogoproto.stdduration) = true, (gogoproto.nullable) = false];
```

### Main Change 2: We don't update proposal's FinalTallyResult result on MsgVote/MsgSubmitProposal

Unless the msg has TryExec set to true, in which case the FinalTallyResult is updated ONLY if the tally is final.

### Main Change 3: Add a keeper-level `MaxExecutionPeriod`

MsgExecs will be rejected if they are sent after `voting_period_end + MaxExecutionPeriod`



---

### Author Checklist

*All items are required. Please add a note to the item if the item is not applicable and
please add links to any relevant follow up issues.*

I have...

- [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] added `!` to the type prefix if API or client breaking change
- [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/master/CONTRIBUTING.md#pr-targeting))
- [ ] provided a link to the relevant issue or specification
- [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/master/docs/building-modules)
- [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/master/CONTRIBUTING.md#testing)
- [ ] added a changelog entry to `CHANGELOG.md`
- [ ] included comments for [documenting Go code](https://blog.golang.org/godoc)
- [ ] updated the relevant documentation or specification
- [ ] reviewed "Files changed" and left comments if necessary
- [ ] confirmed all CI checks have passed

### Reviewers Checklist

*All items are required. Please add a note if the item is not applicable and please add
your handle next to the items reviewed if you only reviewed selected items.*

I have...

- [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] confirmed `!` in the type prefix if API or client breaking change
- [ ] confirmed all author checklist items have been addressed 
- [ ] reviewed state machine logic
- [ ] reviewed API design and naming
- [ ] reviewed documentation is accurate
- [ ] reviewed tests and test coverage
- [ ] manually tested (if applicable)
2022-03-02 12:00:59 +00:00

746 lines
23 KiB
Go
Raw Blame History

package simulation_test
import (
"math/rand"
"testing"
"time"
"github.com/cosmos/cosmos-sdk/codec/legacy"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
"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/simulation"
)
type SimTestSuite struct {
suite.Suite
ctx sdk.Context
app *simapp.SimApp
}
func (suite *SimTestSuite) SetupTest() {
checkTx := false
app := simapp.Setup(suite.T(), checkTx)
suite.app = app
suite.ctx = app.BaseApp.NewContext(checkTx, tmproto.Header{})
}
func (suite *SimTestSuite) TestWeightedOperations() {
cdc := suite.app.AppCodec()
appParams := make(simtypes.AppParams)
weightedOps := simulation.WeightedOperations(appParams, cdc, suite.app.AccountKeeper,
suite.app.BankKeeper, suite.app.GroupKeeper, cdc,
)
s := rand.NewSource(2)
r := rand.New(s)
accs := suite.getTestingAccounts(r, 3)
expected := []struct {
weight int
opMsgRoute string
opMsgName string
}{
{simulation.WeightMsgCreateGroup, group.MsgCreateGroup{}.Route(), simulation.TypeMsgCreateGroup},
{simulation.WeightMsgCreateGroupPolicy, group.MsgCreateGroupPolicy{}.Route(), simulation.TypeMsgCreateGroupPolicy},
// {simulation.WeightMsgCreateGroupWithPolicy, group.MsgCreateGroupWithPolicy{}.Route(), simulation.TypeMsgCreateGroupWithPolicy},
{simulation.WeightMsgSubmitProposal, group.MsgSubmitProposal{}.Route(), simulation.TypeMsgSubmitProposal},
{simulation.WeightMsgSubmitProposal, group.MsgSubmitProposal{}.Route(), simulation.TypeMsgSubmitProposal},
{simulation.WeightMsgWithdrawProposal, group.MsgWithdrawProposal{}.Route(), simulation.TypeMsgWithdrawProposal},
{simulation.WeightMsgVote, group.MsgVote{}.Route(), simulation.TypeMsgVote},
{simulation.WeightMsgExec, group.MsgExec{}.Route(), simulation.TypeMsgExec},
{simulation.WeightMsgUpdateGroupMetadata, group.MsgUpdateGroupMetadata{}.Route(), simulation.TypeMsgUpdateGroupMetadata},
{simulation.WeightMsgUpdateGroupAdmin, group.MsgUpdateGroupAdmin{}.Route(), simulation.TypeMsgUpdateGroupAdmin},
{simulation.WeightMsgUpdateGroupMembers, group.MsgUpdateGroupMembers{}.Route(), simulation.TypeMsgUpdateGroupMembers},
{simulation.WeightMsgUpdateGroupPolicyAdmin, group.MsgUpdateGroupPolicyAdmin{}.Route(), simulation.TypeMsgUpdateGroupPolicyAdmin},
{simulation.WeightMsgUpdateGroupPolicyDecisionPolicy, group.MsgUpdateGroupPolicyDecisionPolicy{}.Route(), simulation.TypeMsgUpdateGroupPolicyDecisionPolicy},
{simulation.WeightMsgUpdateGroupPolicyMetadata, group.MsgUpdateGroupPolicyMetadata{}.Route(), simulation.TypeMsgUpdateGroupPolicyMetadata},
}
for i, w := range weightedOps {
operationMsg, _, _ := w.Op()(r, suite.app.BaseApp, suite.ctx, accs, "")
// the following checks are very much dependent from the ordering of the output given
// by WeightedOperations. if the ordering in WeightedOperations changes some tests
// will fail
suite.Require().Equal(expected[i].weight, w.Weight(), "weight should be the same")
suite.Require().Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
suite.Require().Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
}
}
func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
accounts := simtypes.RandomAccounts(r, n)
initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// 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))
}
return accounts
}
func (suite *SimTestSuite) TestSimulateCreateGroup() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 1)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
acc := accounts[0]
// execute operation
op := simulation.SimulateMsgCreateGroup(suite.app.AccountKeeper, suite.app.BankKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgCreateGroup
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(acc.Address.String(), msg.Admin)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateCreateGroupWithPolicy() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 1)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
acc := accounts[0]
// execute operation
op := simulation.SimulateMsgCreateGroupWithPolicy(suite.app.AccountKeeper, suite.app.BankKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgCreateGroupWithPolicy
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(acc.Address.String(), msg.Admin)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateCreateGroupPolicy() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 1)
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgCreateGroupPolicy(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgCreateGroupPolicy
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(acc.Address.String(), msg.Admin)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateSubmitProposal() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 1)
acc := accounts[0]
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// setup a group account
accountReq := &group.MsgCreateGroupPolicy{
Admin: acc.Address.String(),
GroupId: groupRes.GroupId,
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgSubmitProposal(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgSubmitProposal
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(groupPolicyRes.Address, msg.Address)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestWithdrawProposal() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 3)
acc := accounts[0]
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
addr := acc.Address.String()
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: addr,
Members: []group.Member{
{
Address: addr,
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// setup a group account
accountReq := &group.MsgCreateGroupPolicy{
Admin: addr,
GroupId: groupRes.GroupId,
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// setup a proposal
proposalReq, err := group.NewMsgSubmitProposalRequest(groupPolicyRes.Address, []string{addr}, []sdk.Msg{
&banktypes.MsgSend{
FromAddress: groupPolicyRes.Address,
ToAddress: addr,
Amount: sdk.Coins{sdk.NewInt64Coin("token", 100)},
},
}, "", 0)
suite.Require().NoError(err)
_, err = suite.app.GroupKeeper.SubmitProposal(ctx, proposalReq)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgWithdrawProposal(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgWithdrawProposal
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(addr, msg.Address)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateVote() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 1)
acc := accounts[0]
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
addr := acc.Address.String()
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: addr,
Members: []group.Member{
{
Address: addr,
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// setup a group account
accountReq := &group.MsgCreateGroupPolicy{
Admin: addr,
GroupId: groupRes.GroupId,
Metadata: "",
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// setup a proposal
proposalReq, err := group.NewMsgSubmitProposalRequest(groupPolicyRes.Address, []string{addr}, []sdk.Msg{
&banktypes.MsgSend{
FromAddress: groupPolicyRes.Address,
ToAddress: addr,
Amount: sdk.Coins{sdk.NewInt64Coin("token", 100)},
},
}, "", 0)
suite.Require().NoError(err)
_, err = suite.app.GroupKeeper.SubmitProposal(ctx, proposalReq)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgVote(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgVote
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(addr, msg.Voter)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateExec() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 1)
acc := accounts[0]
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
addr := acc.Address.String()
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: addr,
Members: []group.Member{
{
Address: addr,
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// setup a group account
accountReq := &group.MsgCreateGroupPolicy{
Admin: addr,
GroupId: groupRes.GroupId,
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// setup a proposal
proposalReq, err := group.NewMsgSubmitProposalRequest(groupPolicyRes.Address, []string{addr}, []sdk.Msg{
&banktypes.MsgSend{
FromAddress: groupPolicyRes.Address,
ToAddress: addr,
Amount: sdk.Coins{sdk.NewInt64Coin("token", 100)},
},
}, "", 0)
suite.Require().NoError(err)
proposalRes, err := suite.app.GroupKeeper.SubmitProposal(ctx, proposalReq)
suite.Require().NoError(err)
// vote
_, err = suite.app.GroupKeeper.Vote(ctx, &group.MsgVote{
ProposalId: proposalRes.ProposalId,
Voter: addr,
Option: group.VOTE_OPTION_YES,
Exec: 1,
})
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgExec(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgExec
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(addr, msg.Signer)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateUpdateGroupAdmin() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 2)
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgUpdateGroupAdmin(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgUpdateGroupAdmin
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(acc.Address.String(), msg.Admin)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateUpdateGroupMetadata() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 2)
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgUpdateGroupMetadata(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgUpdateGroupMetadata
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(acc.Address.String(), msg.Admin)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateUpdateGroupMembers() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 2)
acc := accounts[0]
// setup a group
_, err := suite.app.GroupKeeper.CreateGroup(sdk.WrapSDKContext(suite.ctx),
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgUpdateGroupMembers(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgUpdateGroupMembers
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(acc.Address.String(), msg.Admin)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyAdmin() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 2)
acc := accounts[0]
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// setup a group account
accountReq := &group.MsgCreateGroupPolicy{
Admin: acc.Address.String(),
GroupId: groupRes.GroupId,
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgUpdateGroupPolicyAdmin(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgUpdateGroupPolicyAdmin
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(groupPolicyRes.Address, msg.Address)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyDecisionPolicy() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 2)
acc := accounts[0]
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// setup a group account
accountReq := &group.MsgCreateGroupPolicy{
Admin: acc.Address.String(),
GroupId: groupRes.GroupId,
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgUpdateGroupPolicyDecisionPolicy(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgUpdateGroupPolicyDecisionPolicy
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(groupPolicyRes.Address, msg.Address)
suite.Require().Len(futureOperations, 0)
}
func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyMetadata() {
// setup 1 account
s := rand.NewSource(1)
r := rand.New(s)
accounts := suite.getTestingAccounts(r, 2)
acc := accounts[0]
// setup a group
ctx := sdk.WrapSDKContext(suite.ctx)
groupRes, err := suite.app.GroupKeeper.CreateGroup(ctx,
&group.MsgCreateGroup{
Admin: acc.Address.String(),
Members: []group.Member{
{
Address: acc.Address.String(),
Weight: "1",
},
},
},
)
suite.Require().NoError(err)
// setup a group account
accountReq := &group.MsgCreateGroupPolicy{
Admin: acc.Address.String(),
GroupId: groupRes.GroupId,
}
err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
suite.Require().NoError(err)
groupPolicyRes, err := suite.app.GroupKeeper.CreateGroupPolicy(ctx, accountReq)
suite.Require().NoError(err)
// begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{
Header: tmproto.Header{
Height: suite.app.LastBlockHeight() + 1,
AppHash: suite.app.LastCommitID().Hash,
},
})
// execute operation
op := simulation.SimulateMsgUpdateGroupPolicyMetadata(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.GroupKeeper)
operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
suite.Require().NoError(err)
var msg group.MsgUpdateGroupPolicyMetadata
err = legacy.Cdc.UnmarshalJSON(operationMsg.Msg, &msg)
suite.Require().NoError(err)
suite.Require().True(operationMsg.OK)
suite.Require().Equal(groupPolicyRes.Address, msg.Address)
suite.Require().Len(futureOperations, 0)
}
func TestSimTestSuite(t *testing.T) {
suite.Run(t, new(SimTestSuite))
}
Reference in New Issue View Git Blame Copy Permalink