github.com/cosmos/cosmos-sdk@v0.50.10/x/group/simulation/operations_test.go (about)

     1  package simulation_test
     2  
     3  import (
     4  	"math/rand"
     5  	"testing"
     6  	"time"
     7  
     8  	abci "github.com/cometbft/cometbft/abci/types"
     9  	"github.com/cosmos/gogoproto/proto"
    10  	"github.com/stretchr/testify/suite"
    11  
    12  	"cosmossdk.io/depinject"
    13  	"cosmossdk.io/log"
    14  
    15  	"github.com/cosmos/cosmos-sdk/client"
    16  	"github.com/cosmos/cosmos-sdk/codec"
    17  	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
    18  	"github.com/cosmos/cosmos-sdk/runtime"
    19  	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
    20  	sdk "github.com/cosmos/cosmos-sdk/types"
    21  	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
    22  	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
    23  	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
    24  	"github.com/cosmos/cosmos-sdk/x/bank/testutil"
    25  	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
    26  	"github.com/cosmos/cosmos-sdk/x/group"
    27  	groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper"
    28  	"github.com/cosmos/cosmos-sdk/x/group/simulation"
    29  	grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
    30  )
    31  
    32  type SimTestSuite struct {
    33  	suite.Suite
    34  
    35  	ctx               sdk.Context
    36  	app               *runtime.App
    37  	codec             codec.Codec
    38  	interfaceRegistry codectypes.InterfaceRegistry
    39  	txConfig          client.TxConfig
    40  	accountKeeper     authkeeper.AccountKeeper
    41  	bankKeeper        bankkeeper.Keeper
    42  	groupKeeper       groupkeeper.Keeper
    43  }
    44  
    45  func (suite *SimTestSuite) SetupTest() {
    46  	app, err := simtestutil.Setup(
    47  		depinject.Configs(
    48  			grouptestutil.AppConfig,
    49  			depinject.Supply(log.NewNopLogger()),
    50  		),
    51  		&suite.codec,
    52  		&suite.interfaceRegistry,
    53  		&suite.txConfig,
    54  		&suite.accountKeeper,
    55  		&suite.bankKeeper,
    56  		&suite.groupKeeper,
    57  	)
    58  	suite.Require().NoError(err)
    59  
    60  	suite.app = app
    61  	suite.ctx = app.BaseApp.NewContext(false)
    62  }
    63  
    64  func (suite *SimTestSuite) TestWeightedOperations() {
    65  	cdc := suite.codec
    66  	appParams := make(simtypes.AppParams)
    67  
    68  	weightedOps := simulation.WeightedOperations(suite.interfaceRegistry, appParams, cdc, suite.txConfig, suite.accountKeeper,
    69  		suite.bankKeeper, suite.groupKeeper, cdc,
    70  	)
    71  
    72  	s := rand.NewSource(2)
    73  	r := rand.New(s)
    74  	accs := suite.getTestingAccounts(r, 3)
    75  
    76  	expected := []struct {
    77  		weight     int
    78  		opMsgRoute string
    79  		opMsgName  string
    80  	}{
    81  		{simulation.WeightMsgCreateGroup, group.ModuleName, simulation.TypeMsgCreateGroup},
    82  		{simulation.WeightMsgCreateGroupPolicy, group.ModuleName, simulation.TypeMsgCreateGroupPolicy},
    83  		{simulation.WeightMsgCreateGroupWithPolicy, group.ModuleName, simulation.TypeMsgCreateGroupWithPolicy},
    84  		{simulation.WeightMsgSubmitProposal, group.ModuleName, simulation.TypeMsgSubmitProposal},
    85  		{simulation.WeightMsgSubmitProposal, group.ModuleName, simulation.TypeMsgSubmitProposal},
    86  		{simulation.WeightMsgWithdrawProposal, group.ModuleName, simulation.TypeMsgWithdrawProposal},
    87  		{simulation.WeightMsgVote, group.ModuleName, simulation.TypeMsgVote},
    88  		{simulation.WeightMsgExec, group.ModuleName, simulation.TypeMsgExec},
    89  		{simulation.WeightMsgUpdateGroupMetadata, group.ModuleName, simulation.TypeMsgUpdateGroupMetadata},
    90  		{simulation.WeightMsgUpdateGroupAdmin, group.ModuleName, simulation.TypeMsgUpdateGroupAdmin},
    91  		{simulation.WeightMsgUpdateGroupMembers, group.ModuleName, simulation.TypeMsgUpdateGroupMembers},
    92  		{simulation.WeightMsgUpdateGroupPolicyAdmin, group.ModuleName, simulation.TypeMsgUpdateGroupPolicyAdmin},
    93  		{simulation.WeightMsgUpdateGroupPolicyDecisionPolicy, group.ModuleName, simulation.TypeMsgUpdateGroupPolicyDecisionPolicy},
    94  		{simulation.WeightMsgUpdateGroupPolicyMetadata, group.ModuleName, simulation.TypeMsgUpdateGroupPolicyMetadata},
    95  		{simulation.WeightMsgLeaveGroup, group.ModuleName, simulation.TypeMsgLeaveGroup},
    96  	}
    97  
    98  	for i, w := range weightedOps {
    99  		operationMsg, _, err := w.Op()(r, suite.app.BaseApp, suite.ctx, accs, "")
   100  		suite.Require().NoError(err)
   101  
   102  		// the following checks are very much dependent from the ordering of the output given
   103  		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
   104  		// will fail
   105  		suite.Require().Equal(expected[i].weight, w.Weight(), "weight should be the same")
   106  		suite.Require().Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
   107  		suite.Require().Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
   108  	}
   109  }
   110  
   111  func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
   112  	accounts := simtypes.RandomAccounts(r, n)
   113  
   114  	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
   115  	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
   116  
   117  	// add coins to the accounts
   118  	for _, account := range accounts {
   119  		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
   120  		suite.accountKeeper.SetAccount(suite.ctx, acc)
   121  		suite.Require().NoError(testutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins))
   122  	}
   123  
   124  	return accounts
   125  }
   126  
   127  func (suite *SimTestSuite) TestSimulateCreateGroup() {
   128  	// setup 1 account
   129  	s := rand.NewSource(1)
   130  	r := rand.New(s)
   131  	accounts := suite.getTestingAccounts(r, 1)
   132  
   133  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   134  		Height: suite.app.LastBlockHeight() + 1,
   135  		Hash:   suite.app.LastCommitID().Hash,
   136  	})
   137  
   138  	acc := accounts[0]
   139  
   140  	// execute operation
   141  	op := simulation.SimulateMsgCreateGroup(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper)
   142  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   143  	suite.Require().NoError(err)
   144  
   145  	var msg group.MsgCreateGroup
   146  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   147  	suite.Require().NoError(err)
   148  	suite.Require().True(operationMsg.OK)
   149  	suite.Require().Equal(acc.Address.String(), msg.Admin)
   150  	suite.Require().Len(futureOperations, 0)
   151  }
   152  
   153  func (suite *SimTestSuite) TestSimulateCreateGroupWithPolicy() {
   154  	// setup 1 account
   155  	s := rand.NewSource(1)
   156  	r := rand.New(s)
   157  	accounts := suite.getTestingAccounts(r, 1)
   158  
   159  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   160  		Height: suite.app.LastBlockHeight() + 1,
   161  		Hash:   suite.app.LastCommitID().Hash,
   162  	})
   163  
   164  	acc := accounts[0]
   165  
   166  	// execute operation
   167  	op := simulation.SimulateMsgCreateGroupWithPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper)
   168  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   169  	suite.Require().NoError(err)
   170  
   171  	var msg group.MsgCreateGroupWithPolicy
   172  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   173  	suite.Require().NoError(err)
   174  	suite.Require().True(operationMsg.OK)
   175  	suite.Require().Equal(acc.Address.String(), msg.Admin)
   176  	suite.Require().Len(futureOperations, 0)
   177  }
   178  
   179  func (suite *SimTestSuite) TestSimulateCreateGroupPolicy() {
   180  	// setup 1 account
   181  	s := rand.NewSource(1)
   182  	r := rand.New(s)
   183  	accounts := suite.getTestingAccounts(r, 1)
   184  	acc := accounts[0]
   185  
   186  	// setup a group
   187  	_, err := suite.groupKeeper.CreateGroup(suite.ctx,
   188  		&group.MsgCreateGroup{
   189  			Admin: acc.Address.String(),
   190  			Members: []group.MemberRequest{
   191  				{
   192  					Address: acc.Address.String(),
   193  					Weight:  "1",
   194  				},
   195  			},
   196  		},
   197  	)
   198  	suite.Require().NoError(err)
   199  
   200  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   201  		Height: suite.app.LastBlockHeight() + 1,
   202  		Hash:   suite.app.LastCommitID().Hash,
   203  	})
   204  
   205  	// execute operation
   206  	op := simulation.SimulateMsgCreateGroupPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   207  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   208  	suite.Require().NoError(err)
   209  
   210  	var msg group.MsgCreateGroupPolicy
   211  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   212  	suite.Require().NoError(err)
   213  	suite.Require().True(operationMsg.OK)
   214  	suite.Require().Equal(acc.Address.String(), msg.Admin)
   215  	suite.Require().Len(futureOperations, 0)
   216  }
   217  
   218  func (suite *SimTestSuite) TestSimulateSubmitProposal() {
   219  	// setup 1 account
   220  	s := rand.NewSource(2)
   221  	r := rand.New(s)
   222  	accounts := suite.getTestingAccounts(r, 1)
   223  	acc := accounts[0]
   224  
   225  	// setup a group
   226  	ctx := suite.ctx
   227  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   228  		&group.MsgCreateGroup{
   229  			Admin: acc.Address.String(),
   230  			Members: []group.MemberRequest{
   231  				{
   232  					Address: acc.Address.String(),
   233  					Weight:  "1",
   234  				},
   235  			},
   236  		},
   237  	)
   238  	suite.Require().NoError(err)
   239  
   240  	// setup a group account
   241  	accountReq := &group.MsgCreateGroupPolicy{
   242  		Admin:   acc.Address.String(),
   243  		GroupId: groupRes.GroupId,
   244  	}
   245  	err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
   246  	suite.Require().NoError(err)
   247  	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   248  	suite.Require().NoError(err)
   249  
   250  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   251  		Height: suite.app.LastBlockHeight() + 1,
   252  		Hash:   suite.app.LastCommitID().Hash,
   253  	})
   254  
   255  	// execute operation
   256  	op := simulation.SimulateMsgSubmitProposal(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   257  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   258  	suite.Require().NoError(err)
   259  
   260  	var msg group.MsgSubmitProposal
   261  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   262  	suite.Require().NoError(err)
   263  	suite.Require().True(operationMsg.OK)
   264  	suite.Require().Equal(groupPolicyRes.Address, msg.GroupPolicyAddress)
   265  	suite.Require().Len(futureOperations, 0)
   266  }
   267  
   268  func (suite *SimTestSuite) TestWithdrawProposal() {
   269  	// setup 1 account
   270  	s := rand.NewSource(1)
   271  	r := rand.New(s)
   272  	accounts := suite.getTestingAccounts(r, 3)
   273  	acc := accounts[0]
   274  
   275  	// setup a group
   276  	ctx := suite.ctx
   277  	addr := acc.Address.String()
   278  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   279  		&group.MsgCreateGroup{
   280  			Admin: addr,
   281  			Members: []group.MemberRequest{
   282  				{
   283  					Address: addr,
   284  					Weight:  "1",
   285  				},
   286  			},
   287  		},
   288  	)
   289  	suite.Require().NoError(err)
   290  
   291  	// setup a group account
   292  	accountReq := &group.MsgCreateGroupPolicy{
   293  		Admin:   addr,
   294  		GroupId: groupRes.GroupId,
   295  	}
   296  	err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
   297  	suite.Require().NoError(err)
   298  	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   299  	suite.Require().NoError(err)
   300  
   301  	// setup a proposal
   302  	proposalReq, err := group.NewMsgSubmitProposal(groupPolicyRes.Address, []string{addr}, []sdk.Msg{
   303  		&banktypes.MsgSend{
   304  			FromAddress: groupPolicyRes.Address,
   305  			ToAddress:   addr,
   306  			Amount:      sdk.Coins{sdk.NewInt64Coin("token", 100)},
   307  		},
   308  	}, "", 0, "MsgSend", "this is a test proposal")
   309  	suite.Require().NoError(err)
   310  	_, err = suite.groupKeeper.SubmitProposal(ctx, proposalReq)
   311  	suite.Require().NoError(err)
   312  
   313  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   314  		Height: suite.app.LastBlockHeight() + 1,
   315  		Hash:   suite.app.LastCommitID().Hash,
   316  	})
   317  
   318  	// execute operation
   319  	op := simulation.SimulateMsgWithdrawProposal(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   320  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   321  	suite.Require().NoError(err)
   322  
   323  	var msg group.MsgWithdrawProposal
   324  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   325  	suite.Require().NoError(err)
   326  	suite.Require().True(operationMsg.OK)
   327  	suite.Require().Equal(addr, msg.Address)
   328  	suite.Require().Len(futureOperations, 0)
   329  }
   330  
   331  func (suite *SimTestSuite) TestSimulateVote() {
   332  	// setup 1 account
   333  	s := rand.NewSource(1)
   334  	r := rand.New(s)
   335  	accounts := suite.getTestingAccounts(r, 1)
   336  	acc := accounts[0]
   337  
   338  	// setup a group
   339  	ctx := suite.ctx
   340  	addr := acc.Address.String()
   341  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   342  		&group.MsgCreateGroup{
   343  			Admin: addr,
   344  			Members: []group.MemberRequest{
   345  				{
   346  					Address: addr,
   347  					Weight:  "1",
   348  				},
   349  			},
   350  		},
   351  	)
   352  	suite.Require().NoError(err)
   353  
   354  	// setup a group account
   355  	accountReq := &group.MsgCreateGroupPolicy{
   356  		Admin:    addr,
   357  		GroupId:  groupRes.GroupId,
   358  		Metadata: "",
   359  	}
   360  	err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
   361  	suite.Require().NoError(err)
   362  	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   363  	suite.Require().NoError(err)
   364  
   365  	// setup a proposal
   366  	proposalReq, err := group.NewMsgSubmitProposal(groupPolicyRes.Address, []string{addr}, []sdk.Msg{
   367  		&banktypes.MsgSend{
   368  			FromAddress: groupPolicyRes.Address,
   369  			ToAddress:   addr,
   370  			Amount:      sdk.Coins{sdk.NewInt64Coin("token", 100)},
   371  		},
   372  	}, "", 0, "MsgSend", "this is a test proposal")
   373  	suite.Require().NoError(err)
   374  	_, err = suite.groupKeeper.SubmitProposal(ctx, proposalReq)
   375  	suite.Require().NoError(err)
   376  
   377  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   378  		Height: suite.app.LastBlockHeight() + 1,
   379  		Hash:   suite.app.LastCommitID().Hash,
   380  	})
   381  
   382  	// execute operation
   383  	op := simulation.SimulateMsgVote(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   384  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   385  	suite.Require().NoError(err)
   386  
   387  	var msg group.MsgVote
   388  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   389  	suite.Require().NoError(err)
   390  	suite.Require().True(operationMsg.OK)
   391  	suite.Require().Equal(addr, msg.Voter)
   392  	suite.Require().Len(futureOperations, 0)
   393  }
   394  
   395  func (suite *SimTestSuite) TestSimulateExec() {
   396  	// setup 1 account
   397  	s := rand.NewSource(1)
   398  	r := rand.New(s)
   399  	accounts := suite.getTestingAccounts(r, 1)
   400  	acc := accounts[0]
   401  
   402  	// setup a group
   403  	ctx := suite.ctx
   404  	addr := acc.Address.String()
   405  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   406  		&group.MsgCreateGroup{
   407  			Admin: addr,
   408  			Members: []group.MemberRequest{
   409  				{
   410  					Address: addr,
   411  					Weight:  "1",
   412  				},
   413  			},
   414  		},
   415  	)
   416  	suite.Require().NoError(err)
   417  
   418  	// setup a group account
   419  	accountReq := &group.MsgCreateGroupPolicy{
   420  		Admin:   addr,
   421  		GroupId: groupRes.GroupId,
   422  	}
   423  	err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
   424  	suite.Require().NoError(err)
   425  	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   426  	suite.Require().NoError(err)
   427  
   428  	// setup a proposal
   429  	proposalReq, err := group.NewMsgSubmitProposal(groupPolicyRes.Address, []string{addr}, []sdk.Msg{
   430  		&banktypes.MsgSend{
   431  			FromAddress: groupPolicyRes.Address,
   432  			ToAddress:   addr,
   433  			Amount:      sdk.Coins{sdk.NewInt64Coin("token", 100)},
   434  		},
   435  	}, "", 0, "MsgSend", "this is a test proposal")
   436  	suite.Require().NoError(err)
   437  	proposalRes, err := suite.groupKeeper.SubmitProposal(ctx, proposalReq)
   438  	suite.Require().NoError(err)
   439  
   440  	// vote
   441  	_, err = suite.groupKeeper.Vote(ctx, &group.MsgVote{
   442  		ProposalId: proposalRes.ProposalId,
   443  		Voter:      addr,
   444  		Option:     group.VOTE_OPTION_YES,
   445  		Exec:       1,
   446  	})
   447  	suite.Require().NoError(err)
   448  
   449  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   450  		Height: suite.app.LastBlockHeight() + 1,
   451  		Hash:   suite.app.LastCommitID().Hash,
   452  	})
   453  
   454  	// execute operation
   455  	op := simulation.SimulateMsgExec(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   456  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   457  	suite.Require().NoError(err)
   458  
   459  	var msg group.MsgExec
   460  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   461  	suite.Require().NoError(err)
   462  	suite.Require().True(operationMsg.OK)
   463  	suite.Require().Equal(addr, msg.Executor)
   464  	suite.Require().Len(futureOperations, 0)
   465  }
   466  
   467  func (suite *SimTestSuite) TestSimulateUpdateGroupAdmin() {
   468  	// setup 1 account
   469  	s := rand.NewSource(1)
   470  	r := rand.New(s)
   471  	accounts := suite.getTestingAccounts(r, 2)
   472  	acc := accounts[0]
   473  
   474  	// setup a group
   475  	_, err := suite.groupKeeper.CreateGroup(suite.ctx,
   476  		&group.MsgCreateGroup{
   477  			Admin: acc.Address.String(),
   478  			Members: []group.MemberRequest{
   479  				{
   480  					Address: acc.Address.String(),
   481  					Weight:  "1",
   482  				},
   483  			},
   484  		},
   485  	)
   486  	suite.Require().NoError(err)
   487  
   488  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   489  		Height: suite.app.LastBlockHeight() + 1,
   490  		Hash:   suite.app.LastCommitID().Hash,
   491  	})
   492  
   493  	// execute operation
   494  	op := simulation.SimulateMsgUpdateGroupAdmin(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   495  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   496  	suite.Require().NoError(err)
   497  
   498  	var msg group.MsgUpdateGroupAdmin
   499  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   500  	suite.Require().NoError(err)
   501  	suite.Require().True(operationMsg.OK)
   502  	suite.Require().Equal(acc.Address.String(), msg.Admin)
   503  	suite.Require().Len(futureOperations, 0)
   504  }
   505  
   506  func (suite *SimTestSuite) TestSimulateUpdateGroupMetadata() {
   507  	// setup 1 account
   508  	s := rand.NewSource(1)
   509  	r := rand.New(s)
   510  	accounts := suite.getTestingAccounts(r, 2)
   511  	acc := accounts[0]
   512  
   513  	// setup a group
   514  	_, err := suite.groupKeeper.CreateGroup(suite.ctx,
   515  		&group.MsgCreateGroup{
   516  			Admin: acc.Address.String(),
   517  			Members: []group.MemberRequest{
   518  				{
   519  					Address: acc.Address.String(),
   520  					Weight:  "1",
   521  				},
   522  			},
   523  		},
   524  	)
   525  	suite.Require().NoError(err)
   526  
   527  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   528  		Height: suite.app.LastBlockHeight() + 1,
   529  		Hash:   suite.app.LastCommitID().Hash,
   530  	})
   531  
   532  	// execute operation
   533  	op := simulation.SimulateMsgUpdateGroupMetadata(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   534  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   535  	suite.Require().NoError(err)
   536  
   537  	var msg group.MsgUpdateGroupMetadata
   538  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   539  	suite.Require().NoError(err)
   540  	suite.Require().True(operationMsg.OK)
   541  	suite.Require().Equal(acc.Address.String(), msg.Admin)
   542  	suite.Require().Len(futureOperations, 0)
   543  }
   544  
   545  func (suite *SimTestSuite) TestSimulateUpdateGroupMembers() {
   546  	// setup 1 account
   547  	s := rand.NewSource(1)
   548  	r := rand.New(s)
   549  	accounts := suite.getTestingAccounts(r, 2)
   550  	acc := accounts[0]
   551  
   552  	// setup a group
   553  	_, err := suite.groupKeeper.CreateGroup(suite.ctx,
   554  		&group.MsgCreateGroup{
   555  			Admin: acc.Address.String(),
   556  			Members: []group.MemberRequest{
   557  				{
   558  					Address: acc.Address.String(),
   559  					Weight:  "1",
   560  				},
   561  			},
   562  		},
   563  	)
   564  	suite.Require().NoError(err)
   565  
   566  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   567  		Height: suite.app.LastBlockHeight() + 1,
   568  		Hash:   suite.app.LastCommitID().Hash,
   569  	})
   570  
   571  	// execute operation
   572  	op := simulation.SimulateMsgUpdateGroupMembers(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   573  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   574  	suite.Require().NoError(err)
   575  
   576  	var msg group.MsgUpdateGroupMembers
   577  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   578  	suite.Require().NoError(err)
   579  	suite.Require().True(operationMsg.OK)
   580  	suite.Require().Equal(acc.Address.String(), msg.Admin)
   581  	suite.Require().Len(futureOperations, 0)
   582  }
   583  
   584  func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyAdmin() {
   585  	// setup 1 account
   586  	s := rand.NewSource(1)
   587  	r := rand.New(s)
   588  	accounts := suite.getTestingAccounts(r, 2)
   589  	acc := accounts[0]
   590  
   591  	// setup a group
   592  	ctx := suite.ctx
   593  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   594  		&group.MsgCreateGroup{
   595  			Admin: acc.Address.String(),
   596  			Members: []group.MemberRequest{
   597  				{
   598  					Address: acc.Address.String(),
   599  					Weight:  "1",
   600  				},
   601  			},
   602  		},
   603  	)
   604  	suite.Require().NoError(err)
   605  
   606  	// setup a group account
   607  	accountReq := &group.MsgCreateGroupPolicy{
   608  		Admin:   acc.Address.String(),
   609  		GroupId: groupRes.GroupId,
   610  	}
   611  	err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
   612  	suite.Require().NoError(err)
   613  	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   614  	suite.Require().NoError(err)
   615  
   616  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   617  		Height: suite.app.LastBlockHeight() + 1,
   618  		Hash:   suite.app.LastCommitID().Hash,
   619  	})
   620  
   621  	// execute operation
   622  	op := simulation.SimulateMsgUpdateGroupPolicyAdmin(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   623  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   624  	suite.Require().NoError(err)
   625  
   626  	var msg group.MsgUpdateGroupPolicyAdmin
   627  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   628  	suite.Require().NoError(err)
   629  	suite.Require().True(operationMsg.OK)
   630  	suite.Require().Equal(groupPolicyRes.Address, msg.GroupPolicyAddress)
   631  	suite.Require().Len(futureOperations, 0)
   632  }
   633  
   634  func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyDecisionPolicy() {
   635  	// setup 1 account
   636  	s := rand.NewSource(1)
   637  	r := rand.New(s)
   638  	accounts := suite.getTestingAccounts(r, 2)
   639  	acc := accounts[0]
   640  
   641  	// setup a group
   642  	ctx := suite.ctx
   643  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   644  		&group.MsgCreateGroup{
   645  			Admin: acc.Address.String(),
   646  			Members: []group.MemberRequest{
   647  				{
   648  					Address: acc.Address.String(),
   649  					Weight:  "1",
   650  				},
   651  			},
   652  		},
   653  	)
   654  	suite.Require().NoError(err)
   655  
   656  	// setup a group account
   657  	accountReq := &group.MsgCreateGroupPolicy{
   658  		Admin:   acc.Address.String(),
   659  		GroupId: groupRes.GroupId,
   660  	}
   661  	err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
   662  	suite.Require().NoError(err)
   663  	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   664  	suite.Require().NoError(err)
   665  
   666  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   667  		Height: suite.app.LastBlockHeight() + 1,
   668  		Hash:   suite.app.LastCommitID().Hash,
   669  	})
   670  
   671  	// execute operation
   672  	op := simulation.SimulateMsgUpdateGroupPolicyDecisionPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   673  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   674  	suite.Require().NoError(err)
   675  
   676  	var msg group.MsgUpdateGroupPolicyDecisionPolicy
   677  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   678  	suite.Require().NoError(err)
   679  	suite.Require().True(operationMsg.OK)
   680  	suite.Require().Equal(groupPolicyRes.Address, msg.GroupPolicyAddress)
   681  	suite.Require().Len(futureOperations, 0)
   682  }
   683  
   684  func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyMetadata() {
   685  	// setup 1 account
   686  	s := rand.NewSource(1)
   687  	r := rand.New(s)
   688  	accounts := suite.getTestingAccounts(r, 2)
   689  	acc := accounts[0]
   690  
   691  	// setup a group
   692  	ctx := suite.ctx
   693  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   694  		&group.MsgCreateGroup{
   695  			Admin: acc.Address.String(),
   696  			Members: []group.MemberRequest{
   697  				{
   698  					Address: acc.Address.String(),
   699  					Weight:  "1",
   700  				},
   701  			},
   702  		},
   703  	)
   704  	suite.Require().NoError(err)
   705  
   706  	// setup a group account
   707  	accountReq := &group.MsgCreateGroupPolicy{
   708  		Admin:   acc.Address.String(),
   709  		GroupId: groupRes.GroupId,
   710  	}
   711  	err = accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("1", time.Hour, 0))
   712  	suite.Require().NoError(err)
   713  	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   714  	suite.Require().NoError(err)
   715  
   716  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   717  		Height: suite.app.LastBlockHeight() + 1,
   718  		Hash:   suite.app.LastCommitID().Hash,
   719  	})
   720  
   721  	// execute operation
   722  	op := simulation.SimulateMsgUpdateGroupPolicyMetadata(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
   723  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   724  	suite.Require().NoError(err)
   725  
   726  	var msg group.MsgUpdateGroupPolicyMetadata
   727  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   728  	suite.Require().NoError(err)
   729  	suite.Require().True(operationMsg.OK)
   730  	suite.Require().Equal(groupPolicyRes.Address, msg.GroupPolicyAddress)
   731  	suite.Require().Len(futureOperations, 0)
   732  }
   733  
   734  func (suite *SimTestSuite) TestSimulateLeaveGroup() {
   735  	s := rand.NewSource(1)
   736  	r := rand.New(s)
   737  	require := suite.Require()
   738  
   739  	// setup 4 account
   740  	accounts := suite.getTestingAccounts(r, 4)
   741  	admin := accounts[0]
   742  	member1 := accounts[1]
   743  	member2 := accounts[2]
   744  	member3 := accounts[3]
   745  
   746  	// setup a group
   747  	ctx := suite.ctx
   748  	groupRes, err := suite.groupKeeper.CreateGroup(ctx,
   749  		&group.MsgCreateGroup{
   750  			Admin: admin.Address.String(),
   751  			Members: []group.MemberRequest{
   752  				{
   753  					Address: member1.Address.String(),
   754  					Weight:  "1",
   755  				},
   756  				{
   757  					Address: member2.Address.String(),
   758  					Weight:  "2",
   759  				},
   760  				{
   761  					Address: member3.Address.String(),
   762  					Weight:  "1",
   763  				},
   764  			},
   765  		},
   766  	)
   767  	require.NoError(err)
   768  
   769  	// setup a group account
   770  	accountReq := &group.MsgCreateGroupPolicy{
   771  		Admin:    admin.Address.String(),
   772  		GroupId:  groupRes.GroupId,
   773  		Metadata: "",
   774  	}
   775  	require.NoError(accountReq.SetDecisionPolicy(group.NewThresholdDecisionPolicy("3", time.Hour, time.Hour)))
   776  	_, err = suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
   777  	require.NoError(err)
   778  
   779  	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
   780  		Height: suite.app.LastBlockHeight() + 1,
   781  		Hash:   suite.app.LastCommitID().Hash,
   782  	})
   783  
   784  	// execute operation
   785  	op := simulation.SimulateMsgLeaveGroup(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.groupKeeper, suite.accountKeeper, suite.bankKeeper)
   786  	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
   787  	suite.Require().NoError(err)
   788  
   789  	var msg group.MsgLeaveGroup
   790  	err = proto.Unmarshal(operationMsg.Msg, &msg)
   791  	suite.Require().NoError(err)
   792  	suite.Require().True(operationMsg.OK)
   793  	suite.Require().Equal(groupRes.GroupId, msg.GroupId)
   794  	suite.Require().Len(futureOperations, 0)
   795  }
   796  
   797  func TestSimTestSuite(t *testing.T) {
   798  	suite.Run(t, new(SimTestSuite))
   799  }