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

     1  package keeper_test
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/golang/mock/gomock"
    10  	"github.com/stretchr/testify/suite"
    11  
    12  	"cosmossdk.io/log"
    13  	storetypes "cosmossdk.io/store/types"
    14  
    15  	"github.com/cosmos/cosmos-sdk/baseapp"
    16  	"github.com/cosmos/cosmos-sdk/codec"
    17  	"github.com/cosmos/cosmos-sdk/codec/address"
    18  	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
    19  	"github.com/cosmos/cosmos-sdk/testutil"
    20  	sdk "github.com/cosmos/cosmos-sdk/types"
    21  	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
    22  	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
    23  	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
    24  	"github.com/cosmos/cosmos-sdk/x/group"
    25  	"github.com/cosmos/cosmos-sdk/x/group/keeper"
    26  	"github.com/cosmos/cosmos-sdk/x/group/module"
    27  	grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
    28  )
    29  
    30  type GenesisTestSuite struct {
    31  	suite.Suite
    32  
    33  	ctx    context.Context
    34  	sdkCtx sdk.Context
    35  	keeper keeper.Keeper
    36  	cdc    *codec.ProtoCodec
    37  }
    38  
    39  func TestGenesisTestSuite(t *testing.T) {
    40  	suite.Run(t, new(GenesisTestSuite))
    41  }
    42  
    43  var (
    44  	memberPub  = secp256k1.GenPrivKey().PubKey()
    45  	accPub     = secp256k1.GenPrivKey().PubKey()
    46  	accAddr    = sdk.AccAddress(accPub.Address())
    47  	memberAddr = sdk.AccAddress(memberPub.Address())
    48  )
    49  
    50  func (s *GenesisTestSuite) SetupTest() {
    51  	key := storetypes.NewKVStoreKey(group.StoreKey)
    52  	testCtx := testutil.DefaultContextWithDB(s.T(), key, storetypes.NewTransientStoreKey("transient_test"))
    53  	encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{})
    54  
    55  	ctrl := gomock.NewController(s.T())
    56  	accountKeeper := grouptestutil.NewMockAccountKeeper(ctrl)
    57  	accountKeeper.EXPECT().GetAccount(gomock.Any(), accAddr).Return(authtypes.NewBaseAccountWithAddress(accAddr)).AnyTimes()
    58  	accountKeeper.EXPECT().GetAccount(gomock.Any(), memberAddr).Return(authtypes.NewBaseAccountWithAddress(memberAddr)).AnyTimes()
    59  	accountKeeper.EXPECT().AddressCodec().Return(address.NewBech32Codec("cosmos")).AnyTimes()
    60  
    61  	bApp := baseapp.NewBaseApp(
    62  		"group",
    63  		log.NewNopLogger(),
    64  		testCtx.DB,
    65  		encCfg.TxConfig.TxDecoder(),
    66  	)
    67  
    68  	banktypes.RegisterInterfaces(encCfg.InterfaceRegistry)
    69  
    70  	s.sdkCtx = testCtx.Ctx
    71  	s.cdc = codec.NewProtoCodec(encCfg.InterfaceRegistry)
    72  	s.ctx = s.sdkCtx
    73  
    74  	s.keeper = keeper.NewKeeper(key, s.cdc, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig())
    75  }
    76  
    77  func (s *GenesisTestSuite) TestInitExportGenesis() {
    78  	sdkCtx := s.sdkCtx
    79  	ctx := s.ctx
    80  	cdc := s.cdc
    81  
    82  	submittedAt := time.Now().UTC()
    83  	timeout := submittedAt.Add(time.Second * 1).UTC()
    84  
    85  	groupPolicy := &group.GroupPolicyInfo{
    86  		Address:  accAddr.String(),
    87  		GroupId:  1,
    88  		Admin:    accAddr.String(),
    89  		Version:  1,
    90  		Metadata: "policy metadata",
    91  	}
    92  	err := groupPolicy.SetDecisionPolicy(&group.ThresholdDecisionPolicy{
    93  		Threshold: "1",
    94  		Windows: &group.DecisionPolicyWindows{
    95  			VotingPeriod: time.Second,
    96  		},
    97  	})
    98  	s.Require().NoError(err)
    99  
   100  	proposal := &group.Proposal{
   101  		Id:                 1,
   102  		GroupPolicyAddress: accAddr.String(),
   103  		Metadata:           "proposal metadata",
   104  		GroupVersion:       1,
   105  		GroupPolicyVersion: 1,
   106  		Proposers: []string{
   107  			memberAddr.String(),
   108  		},
   109  		SubmitTime: submittedAt,
   110  		Status:     group.PROPOSAL_STATUS_ACCEPTED,
   111  		FinalTallyResult: group.TallyResult{
   112  			YesCount:        "1",
   113  			NoCount:         "0",
   114  			AbstainCount:    "0",
   115  			NoWithVetoCount: "0",
   116  		},
   117  		VotingPeriodEnd: timeout,
   118  		ExecutorResult:  group.PROPOSAL_EXECUTOR_RESULT_SUCCESS,
   119  	}
   120  	err = proposal.SetMsgs([]sdk.Msg{&banktypes.MsgSend{
   121  		FromAddress: accAddr.String(),
   122  		ToAddress:   memberAddr.String(),
   123  		Amount:      sdk.Coins{sdk.NewInt64Coin("test", 100)},
   124  	}})
   125  	s.Require().NoError(err)
   126  
   127  	genesisState := &group.GenesisState{
   128  		GroupSeq:       2,
   129  		Groups:         []*group.GroupInfo{{Id: 1, Admin: accAddr.String(), Metadata: "1", Version: 1, TotalWeight: "1"}, {Id: 2, Admin: accAddr.String(), Metadata: "2", Version: 2, TotalWeight: "2"}},
   130  		GroupMembers:   []*group.GroupMember{{GroupId: 1, Member: &group.Member{Address: memberAddr.String(), Weight: "1", Metadata: "member metadata"}}, {GroupId: 2, Member: &group.Member{Address: memberAddr.String(), Weight: "2", Metadata: "member metadata"}}},
   131  		GroupPolicySeq: 1,
   132  		GroupPolicies:  []*group.GroupPolicyInfo{groupPolicy},
   133  		ProposalSeq:    1,
   134  		Proposals:      []*group.Proposal{proposal},
   135  		Votes:          []*group.Vote{{ProposalId: proposal.Id, Voter: memberAddr.String(), SubmitTime: submittedAt, Option: group.VOTE_OPTION_YES}},
   136  	}
   137  	genesisBytes, err := cdc.MarshalJSON(genesisState)
   138  	s.Require().NoError(err)
   139  
   140  	genesisData := map[string]json.RawMessage{
   141  		group.ModuleName: genesisBytes,
   142  	}
   143  
   144  	s.keeper.InitGenesis(sdkCtx, cdc, genesisData[group.ModuleName])
   145  
   146  	for i, g := range genesisState.Groups {
   147  		res, err := s.keeper.GroupInfo(ctx, &group.QueryGroupInfoRequest{
   148  			GroupId: g.Id,
   149  		})
   150  		s.Require().NoError(err)
   151  		s.Require().Equal(g, res.Info)
   152  
   153  		membersRes, err := s.keeper.GroupMembers(ctx, &group.QueryGroupMembersRequest{
   154  			GroupId: g.Id,
   155  		})
   156  		s.Require().NoError(err)
   157  		s.Require().Equal(len(membersRes.Members), 1)
   158  		s.Require().Equal(membersRes.Members[0], genesisState.GroupMembers[i])
   159  	}
   160  
   161  	for _, g := range genesisState.GroupPolicies {
   162  		res, err := s.keeper.GroupPolicyInfo(ctx, &group.QueryGroupPolicyInfoRequest{
   163  			Address: g.Address,
   164  		})
   165  		s.Require().NoError(err)
   166  		s.assertGroupPoliciesEqual(g, res.Info)
   167  	}
   168  
   169  	for _, g := range genesisState.Proposals {
   170  		res, err := s.keeper.Proposal(ctx, &group.QueryProposalRequest{
   171  			ProposalId: g.Id,
   172  		})
   173  		s.Require().NoError(err)
   174  		s.assertProposalsEqual(g, res.Proposal)
   175  
   176  		votesRes, err := s.keeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{
   177  			ProposalId: g.Id,
   178  		})
   179  		s.Require().NoError(err)
   180  		s.Require().Equal(len(votesRes.Votes), 1)
   181  		s.Require().Equal(votesRes.Votes[0], genesisState.Votes[0])
   182  	}
   183  
   184  	exported := s.keeper.ExportGenesis(sdkCtx, cdc)
   185  	bz, err := cdc.MarshalJSON(exported)
   186  	s.Require().NoError(err)
   187  
   188  	var exportedGenesisState group.GenesisState
   189  	err = cdc.UnmarshalJSON(bz, &exportedGenesisState)
   190  	s.Require().NoError(err)
   191  
   192  	s.Require().Equal(genesisState.Groups, exportedGenesisState.Groups)
   193  	s.Require().Equal(genesisState.GroupMembers, exportedGenesisState.GroupMembers)
   194  
   195  	s.Require().Equal(len(genesisState.GroupPolicies), len(exportedGenesisState.GroupPolicies))
   196  	for i, g := range genesisState.GroupPolicies {
   197  		res := exportedGenesisState.GroupPolicies[i]
   198  		s.Require().NoError(err)
   199  		s.assertGroupPoliciesEqual(g, res)
   200  	}
   201  
   202  	s.Require().Equal(len(genesisState.Proposals), len(exportedGenesisState.Proposals))
   203  	for i, g := range genesisState.Proposals {
   204  		res := exportedGenesisState.Proposals[i]
   205  		s.Require().NoError(err)
   206  		s.assertProposalsEqual(g, res)
   207  	}
   208  	s.Require().Equal(genesisState.Votes, exportedGenesisState.Votes)
   209  
   210  	s.Require().Equal(genesisState.GroupSeq, exportedGenesisState.GroupSeq)
   211  	s.Require().Equal(genesisState.GroupPolicySeq, exportedGenesisState.GroupPolicySeq)
   212  	s.Require().Equal(genesisState.ProposalSeq, exportedGenesisState.ProposalSeq)
   213  }
   214  
   215  func (s *GenesisTestSuite) assertGroupPoliciesEqual(g, other *group.GroupPolicyInfo) {
   216  	require := s.Require()
   217  	require.Equal(g.Address, other.Address)
   218  	require.Equal(g.GroupId, other.GroupId)
   219  	require.Equal(g.Admin, other.Admin)
   220  	require.Equal(g.Metadata, other.Metadata)
   221  	require.Equal(g.Version, other.Version)
   222  	dp1, err := g.GetDecisionPolicy()
   223  	require.NoError(err)
   224  	dp2, err := other.GetDecisionPolicy()
   225  	require.NoError(err)
   226  	require.Equal(dp1, dp2)
   227  }
   228  
   229  func (s *GenesisTestSuite) assertProposalsEqual(g, other *group.Proposal) {
   230  	require := s.Require()
   231  	require.Equal(g.Id, other.Id)
   232  	require.Equal(g.GroupPolicyAddress, other.GroupPolicyAddress)
   233  	require.Equal(g.Metadata, other.Metadata)
   234  	require.Equal(g.Proposers, other.Proposers)
   235  	require.Equal(g.SubmitTime, other.SubmitTime)
   236  	require.Equal(g.GroupVersion, other.GroupVersion)
   237  	require.Equal(g.GroupPolicyVersion, other.GroupPolicyVersion)
   238  	require.Equal(g.Status, other.Status)
   239  	require.Equal(g.FinalTallyResult, other.FinalTallyResult)
   240  	require.Equal(g.VotingPeriodEnd, other.VotingPeriodEnd)
   241  	require.Equal(g.ExecutorResult, other.ExecutorResult)
   242  	msgs1, err := g.GetMsgs()
   243  	require.NoError(err)
   244  	msgs2, err := other.GetMsgs()
   245  	require.NoError(err)
   246  	require.Equal(msgs1, msgs2)
   247  }