github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/gov/endblocker_test.go (about)

     1  package gov
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/fibonacci-chain/fbc/x/gov/keeper"
     8  	"github.com/fibonacci-chain/fbc/x/gov/types"
     9  	"github.com/fibonacci-chain/fbc/x/params"
    10  	paramsTypes "github.com/fibonacci-chain/fbc/x/params/types"
    11  	"github.com/fibonacci-chain/fbc/x/staking"
    12  
    13  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func newTextProposal(t *testing.T, ctx sdk.Context, initialDeposit sdk.SysCoins, govHandler sdk.Handler) *sdk.Result {
    18  	content := types.NewTextProposal("Test", "description")
    19  	newProposalMsg := NewMsgSubmitProposal(content, initialDeposit, keeper.Addrs[0])
    20  	res, err := govHandler(ctx, newProposalMsg)
    21  	require.Nil(t, err)
    22  	return res
    23  }
    24  
    25  func TestTickPassedVotingPeriod(t *testing.T) {
    26  	ctx, _, gk, _, _ := keeper.CreateTestInput(t, false, 1000)
    27  	govHandler := NewHandler(gk)
    28  
    29  	inactiveQueue := gk.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
    30  	require.False(t, inactiveQueue.Valid())
    31  	inactiveQueue.Close()
    32  	activeQueue := gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
    33  	require.False(t, activeQueue.Valid())
    34  	activeQueue.Close()
    35  
    36  	proposalCoins := sdk.SysCoins{sdk.NewInt64DecCoin(sdk.DefaultBondDenom, 500)}
    37  	content := types.NewTextProposal("Test", "description")
    38  	newProposalMsg := NewMsgSubmitProposal(content, proposalCoins, keeper.Addrs[0])
    39  	res, err := govHandler(ctx, newProposalMsg)
    40  	require.Nil(t, err)
    41  	var proposalID uint64
    42  	gk.Cdc().MustUnmarshalBinaryLengthPrefixed(res.Data, &proposalID)
    43  
    44  	newHeader := ctx.BlockHeader()
    45  	newHeader.Time = ctx.BlockHeader().Time.Add(time.Duration(1) * time.Second)
    46  	ctx.SetBlockHeader(newHeader)
    47  
    48  	newDepositMsg := NewMsgDeposit(keeper.Addrs[1], proposalID, proposalCoins)
    49  	res, err = govHandler(ctx, newDepositMsg)
    50  	require.NotNil(t, err)
    51  
    52  	newHeader = ctx.BlockHeader()
    53  	newHeader.Time = ctx.BlockHeader().Time.Add(gk.GetDepositParams(ctx).MaxDepositPeriod).
    54  		Add(gk.GetVotingParams(ctx).VotingPeriod)
    55  	ctx.SetBlockHeader(newHeader)
    56  
    57  	inactiveQueue = gk.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
    58  	require.False(t, inactiveQueue.Valid())
    59  	inactiveQueue.Close()
    60  
    61  	activeQueue = gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
    62  	require.True(t, activeQueue.Valid())
    63  	var activeProposalID uint64
    64  	err = gk.Cdc().UnmarshalBinaryLengthPrefixed(activeQueue.Value(), &activeProposalID)
    65  	require.Nil(t, err)
    66  	proposal, ok := gk.GetProposal(ctx, activeProposalID)
    67  	require.True(t, ok)
    68  	require.Equal(t, StatusVotingPeriod, proposal.Status)
    69  	depositsIterator := gk.GetDeposits(ctx, proposalID)
    70  	require.NotEqual(t, depositsIterator, []Deposit{})
    71  	activeQueue.Close()
    72  
    73  	EndBlocker(ctx, gk)
    74  
    75  	activeQueue = gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
    76  	require.False(t, activeQueue.Valid())
    77  	activeQueue.Close()
    78  }
    79  
    80  // test deposit is not enough when expire max deposit period
    81  func TestEndBlockerIterateInactiveProposalsQueue(t *testing.T) {
    82  	ctx, _, gk, _, _ := keeper.CreateTestInput(t, false, 1000)
    83  
    84  	initialDeposit := sdk.SysCoins{sdk.NewInt64DecCoin(sdk.DefaultBondDenom, 10)}
    85  	newTextProposal(t, ctx, initialDeposit, NewHandler(gk))
    86  
    87  	newHeader := ctx.BlockHeader()
    88  	newHeader.Time = ctx.BlockHeader().Time.Add(gk.GetMaxDepositPeriod(ctx, nil))
    89  	ctx.SetBlockHeader(newHeader)
    90  	inactiveQueue := gk.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
    91  	require.True(t, inactiveQueue.Valid())
    92  	inactiveQueue.Close()
    93  	EndBlocker(ctx, gk)
    94  	inactiveQueue = gk.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
    95  	require.False(t, inactiveQueue.Valid())
    96  	inactiveQueue.Close()
    97  }
    98  
    99  func TestEndBlockerIterateActiveProposalsQueue1(t *testing.T) {
   100  	ctx, _, gk, _, _ := keeper.CreateTestInput(t, false, 1000)
   101  
   102  	initialDeposit := sdk.SysCoins{sdk.NewInt64DecCoin(sdk.DefaultBondDenom, 150)}
   103  	newTextProposal(t, ctx, initialDeposit, NewHandler(gk))
   104  
   105  	newHeader := ctx.BlockHeader()
   106  	newHeader.Time = ctx.BlockHeader().Time.Add(gk.GetVotingPeriod(ctx, nil))
   107  	ctx.SetBlockHeader(newHeader)
   108  	activeQueue := gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
   109  	require.True(t, activeQueue.Valid())
   110  	activeQueue.Close()
   111  	EndBlocker(ctx, gk)
   112  	activeQueue = gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
   113  	require.False(t, activeQueue.Valid())
   114  	activeQueue.Close()
   115  }
   116  
   117  // test distribute
   118  func TestEndBlockerIterateActiveProposalsQueue2(t *testing.T) {
   119  	ctx, _, gk, sk, _ := keeper.CreateTestInput(t, false, 100000)
   120  	govHandler := NewHandler(gk)
   121  
   122  	ctx.SetBlockHeight(int64(sk.GetEpoch(ctx)))
   123  	skHandler := staking.NewHandler(sk)
   124  	valAddrs := make([]sdk.ValAddress, len(keeper.Addrs[:3]))
   125  	for i, addr := range keeper.Addrs[:3] {
   126  		valAddrs[i] = sdk.ValAddress(addr)
   127  	}
   128  	keeper.CreateValidators(t, skHandler, ctx, valAddrs, []int64{10, 10, 10})
   129  	staking.EndBlocker(ctx, sk)
   130  
   131  	initialDeposit := sdk.SysCoins{sdk.NewInt64DecCoin(sdk.DefaultBondDenom, 150)}
   132  	res := newTextProposal(t, ctx, initialDeposit, NewHandler(gk))
   133  
   134  	var proposalID uint64
   135  	gk.Cdc().MustUnmarshalBinaryLengthPrefixed(res.Data, &proposalID)
   136  
   137  	require.Equal(t, initialDeposit, gk.SupplyKeeper().
   138  		GetModuleAccount(ctx, types.ModuleName).GetCoins())
   139  	newVoteMsg := NewMsgVote(keeper.Addrs[0], proposalID, types.OptionNoWithVeto)
   140  	res, err := govHandler(ctx, newVoteMsg)
   141  	require.Nil(t, err)
   142  
   143  	newHeader := ctx.BlockHeader()
   144  	newHeader.Time = ctx.BlockHeader().Time.Add(gk.GetVotingPeriod(ctx, nil))
   145  	ctx.SetBlockHeader(newHeader)
   146  	activeQueue := gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
   147  	require.True(t, activeQueue.Valid())
   148  	activeQueue.Close()
   149  	EndBlocker(ctx, gk)
   150  	activeQueue = gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
   151  	require.False(t, activeQueue.Valid())
   152  	activeQueue.Close()
   153  
   154  	require.Equal(t, sdk.Coins(nil), gk.SupplyKeeper().GetModuleAccount(ctx, types.ModuleName).GetCoins())
   155  }
   156  
   157  // test passed
   158  func TestEndBlockerIterateActiveProposalsQueue3(t *testing.T) {
   159  	ctx, _, gk, sk, _ := keeper.CreateTestInput(t, false, 100000)
   160  	govHandler := NewHandler(gk)
   161  
   162  	ctx.SetBlockHeight(int64(sk.GetEpoch(ctx)))
   163  	skHandler := staking.NewHandler(sk)
   164  	valAddrs := make([]sdk.ValAddress, len(keeper.Addrs[:4]))
   165  	for i, addr := range keeper.Addrs[:4] {
   166  		valAddrs[i] = sdk.ValAddress(addr)
   167  	}
   168  	keeper.CreateValidators(t, skHandler, ctx, valAddrs, []int64{10, 10, 10, 10})
   169  	staking.EndBlocker(ctx, sk)
   170  
   171  	initialDeposit := sdk.SysCoins{sdk.NewInt64DecCoin(sdk.DefaultBondDenom, 150)}
   172  	res := newTextProposal(t, ctx, initialDeposit, NewHandler(gk))
   173  	var proposalID uint64
   174  	gk.Cdc().MustUnmarshalBinaryLengthPrefixed(res.Data, &proposalID)
   175  
   176  	require.Equal(t, initialDeposit, gk.SupplyKeeper().
   177  		GetModuleAccount(ctx, types.ModuleName).GetCoins())
   178  	newVoteMsg := NewMsgVote(keeper.Addrs[0], proposalID, types.OptionYes)
   179  	res, err := govHandler(ctx, newVoteMsg)
   180  	require.Nil(t, err)
   181  	newVoteMsg = NewMsgVote(keeper.Addrs[1], proposalID, types.OptionYes)
   182  	res, err = govHandler(ctx, newVoteMsg)
   183  	require.Nil(t, err)
   184  
   185  	newHeader := ctx.BlockHeader()
   186  	newHeader.Time = ctx.BlockHeader().Time.Add(gk.GetVotingPeriod(ctx, nil))
   187  	ctx.SetBlockHeader(newHeader)
   188  	activeQueue := gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
   189  	require.True(t, activeQueue.Valid())
   190  	activeQueue.Close()
   191  	EndBlocker(ctx, gk)
   192  	activeQueue = gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
   193  	require.False(t, activeQueue.Valid())
   194  	activeQueue.Close()
   195  
   196  	require.Equal(t, sdk.Coins(nil), gk.SupplyKeeper().GetModuleAccount(ctx, types.ModuleName).GetCoins())
   197  }
   198  
   199  func TestEndBlockerIterateWaitingProposalsQueue(t *testing.T) {
   200  	ctx, _, gk, sk, _ := keeper.CreateTestInput(t, false, 100000)
   201  	govHandler := NewHandler(gk)
   202  
   203  	ctx.SetBlockHeight(int64(sk.GetEpoch(ctx)))
   204  	skHandler := staking.NewHandler(sk)
   205  	valAddrs := make([]sdk.ValAddress, len(keeper.Addrs[:4]))
   206  	for i, addr := range keeper.Addrs[:4] {
   207  		valAddrs[i] = sdk.ValAddress(addr)
   208  	}
   209  	keeper.CreateValidators(t, skHandler, ctx, valAddrs, []int64{10, 10, 10, 10})
   210  	staking.EndBlocker(ctx, sk)
   211  
   212  	initialDeposit := sdk.SysCoins{sdk.NewInt64DecCoin(sdk.DefaultBondDenom, 150)}
   213  	paramsChanges := []params.ParamChange{{Subspace: "staking", Key: "MaxValidators", Value: "105"}}
   214  	height := uint64(ctx.BlockHeight() + 1000)
   215  	content := paramsTypes.NewParameterChangeProposal("Test", "", paramsChanges, height)
   216  	newProposalMsg := NewMsgSubmitProposal(content, initialDeposit, keeper.Addrs[0])
   217  	res, err := govHandler(ctx, newProposalMsg)
   218  	require.Nil(t, err)
   219  	var proposalID uint64
   220  	gk.Cdc().MustUnmarshalBinaryLengthPrefixed(res.Data, &proposalID)
   221  
   222  	newVoteMsg := NewMsgVote(keeper.Addrs[0], proposalID, types.OptionYes)
   223  	res, err = govHandler(ctx, newVoteMsg)
   224  	require.Nil(t, err)
   225  	newVoteMsg = NewMsgVote(keeper.Addrs[1], proposalID, types.OptionYes)
   226  	res, err = govHandler(ctx, newVoteMsg)
   227  	require.Nil(t, err)
   228  	newVoteMsg = NewMsgVote(keeper.Addrs[2], proposalID, types.OptionYes)
   229  	res, err = govHandler(ctx, newVoteMsg)
   230  	require.Nil(t, err)
   231  
   232  	ctx.SetBlockHeight(int64(height))
   233  	waitingQueue := gk.WaitingProposalQueueIterator(ctx, uint64(ctx.BlockHeight()))
   234  	require.True(t, waitingQueue.Valid())
   235  	waitingQueue.Close()
   236  	EndBlocker(ctx, gk)
   237  	waitingQueue = gk.ActiveProposalQueueIterator(ctx, ctx.BlockHeader().Time)
   238  	require.False(t, waitingQueue.Valid())
   239  	waitingQueue.Close()
   240  }