From 3fa47df519d3a5d4fb4b3b8599f7182bb8147d78 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 15:52:43 +0100 Subject: [PATCH 01/24] migrate test TestDeposits from gov to simapp --- x/gov/keeper/common_test.go | 7 +++ x/gov/keeper/deposit_test.go | 60 ++++++++++--------- .../{test_common.go => old_test_common.go} | 0 3 files changed, 40 insertions(+), 27 deletions(-) create mode 100644 x/gov/keeper/common_test.go rename x/gov/keeper/{test_common.go => old_test_common.go} (100%) diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go new file mode 100644 index 000000000..66ab6db7d --- /dev/null +++ b/x/gov/keeper/common_test.go @@ -0,0 +1,7 @@ +package keeper_test + +import "github.com/cosmos/cosmos-sdk/x/gov/types" + +var ( + TestProposal = types.NewTextProposal("Test", "description") +) diff --git a/x/gov/keeper/deposit_test.go b/x/gov/keeper/deposit_test.go index ed17d4481..12e152c0a 100644 --- a/x/gov/keeper/deposit_test.go +++ b/x/gov/keeper/deposit_test.go @@ -1,4 +1,4 @@ -package keeper +package keeper_test import ( "testing" @@ -6,93 +6,99 @@ import ( "github.com/stretchr/testify/require" + abci "github.com/tendermint/tendermint/abci/types" + + "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" ) func TestDeposits(t *testing.T) { - ctx, _, bk, keeper, _, _ := createTestInput(t, false, 100) + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(10000000)) tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) proposalID := proposal.ProposalID fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4))) fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5))) - addr0Initial := bk.GetAllBalances(ctx, TestAddrs[0]) - addr1Initial := bk.GetAllBalances(ctx, TestAddrs[1]) + addr0Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[0]) + addr1Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[1]) require.True(t, proposal.TotalDeposit.IsEqual(sdk.NewCoins())) // Check no deposits at beginning - deposit, found := keeper.GetDeposit(ctx, proposalID, TestAddrs[1]) + deposit, found := app.GovKeeper.GetDeposit(ctx, proposalID, TestAddrs[1]) require.False(t, found) - proposal, ok := keeper.GetProposal(ctx, proposalID) + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) require.True(t, proposal.VotingStartTime.Equal(time.Time{})) // Check first deposit - votingStarted, err := keeper.AddDeposit(ctx, proposalID, TestAddrs[0], fourStake) + votingStarted, err := app.GovKeeper.AddDeposit(ctx, proposalID, TestAddrs[0], fourStake) require.NoError(t, err) require.False(t, votingStarted) - deposit, found = keeper.GetDeposit(ctx, proposalID, TestAddrs[0]) + deposit, found = app.GovKeeper.GetDeposit(ctx, proposalID, TestAddrs[0]) require.True(t, found) require.Equal(t, fourStake, deposit.Amount) require.Equal(t, TestAddrs[0], deposit.Depositor) - proposal, ok = keeper.GetProposal(ctx, proposalID) + proposal, ok = app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) require.Equal(t, fourStake, proposal.TotalDeposit) - require.Equal(t, addr0Initial.Sub(fourStake), bk.GetAllBalances(ctx, TestAddrs[0])) + require.Equal(t, addr0Initial.Sub(fourStake), app.BankKeeper.GetAllBalances(ctx, TestAddrs[0])) // Check a second deposit from same address - votingStarted, err = keeper.AddDeposit(ctx, proposalID, TestAddrs[0], fiveStake) + votingStarted, err = app.GovKeeper.AddDeposit(ctx, proposalID, TestAddrs[0], fiveStake) require.NoError(t, err) require.False(t, votingStarted) - deposit, found = keeper.GetDeposit(ctx, proposalID, TestAddrs[0]) + deposit, found = app.GovKeeper.GetDeposit(ctx, proposalID, TestAddrs[0]) require.True(t, found) require.Equal(t, fourStake.Add(fiveStake...), deposit.Amount) require.Equal(t, TestAddrs[0], deposit.Depositor) - proposal, ok = keeper.GetProposal(ctx, proposalID) + proposal, ok = app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) require.Equal(t, fourStake.Add(fiveStake...), proposal.TotalDeposit) - require.Equal(t, addr0Initial.Sub(fourStake).Sub(fiveStake), bk.GetAllBalances(ctx, TestAddrs[0])) + require.Equal(t, addr0Initial.Sub(fourStake).Sub(fiveStake), app.BankKeeper.GetAllBalances(ctx, TestAddrs[0])) // Check third deposit from a new address - votingStarted, err = keeper.AddDeposit(ctx, proposalID, TestAddrs[1], fourStake) + votingStarted, err = app.GovKeeper.AddDeposit(ctx, proposalID, TestAddrs[1], fourStake) require.NoError(t, err) require.True(t, votingStarted) - deposit, found = keeper.GetDeposit(ctx, proposalID, TestAddrs[1]) + deposit, found = app.GovKeeper.GetDeposit(ctx, proposalID, TestAddrs[1]) require.True(t, found) require.Equal(t, TestAddrs[1], deposit.Depositor) require.Equal(t, fourStake, deposit.Amount) - proposal, ok = keeper.GetProposal(ctx, proposalID) + proposal, ok = app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) require.Equal(t, fourStake.Add(fiveStake...).Add(fourStake...), proposal.TotalDeposit) - require.Equal(t, addr1Initial.Sub(fourStake), bk.GetAllBalances(ctx, TestAddrs[1])) + require.Equal(t, addr1Initial.Sub(fourStake), app.BankKeeper.GetAllBalances(ctx, TestAddrs[1])) // Check that proposal moved to voting period - proposal, ok = keeper.GetProposal(ctx, proposalID) + proposal, ok = app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time)) // Test deposit iterator // NOTE order of deposits is determined by the addresses - deposits := keeper.GetAllDeposits(ctx) + deposits := app.GovKeeper.GetAllDeposits(ctx) require.Len(t, deposits, 2) - require.Equal(t, deposits, keeper.GetDeposits(ctx, proposalID)) + require.Equal(t, deposits, app.GovKeeper.GetDeposits(ctx, proposalID)) require.Equal(t, TestAddrs[0], deposits[0].Depositor) require.Equal(t, fourStake.Add(fiveStake...), deposits[0].Amount) require.Equal(t, TestAddrs[1], deposits[1].Depositor) require.Equal(t, fourStake, deposits[1].Amount) // Test Refund Deposits - deposit, found = keeper.GetDeposit(ctx, proposalID, TestAddrs[1]) + deposit, found = app.GovKeeper.GetDeposit(ctx, proposalID, TestAddrs[1]) require.True(t, found) require.Equal(t, fourStake, deposit.Amount) - keeper.RefundDeposits(ctx, proposalID) - deposit, found = keeper.GetDeposit(ctx, proposalID, TestAddrs[1]) + app.GovKeeper.RefundDeposits(ctx, proposalID) + deposit, found = app.GovKeeper.GetDeposit(ctx, proposalID, TestAddrs[1]) require.False(t, found) - require.Equal(t, addr0Initial, bk.GetAllBalances(ctx, TestAddrs[0])) - require.Equal(t, addr1Initial, bk.GetAllBalances(ctx, TestAddrs[1])) + require.Equal(t, addr0Initial, app.BankKeeper.GetAllBalances(ctx, TestAddrs[0])) + require.Equal(t, addr1Initial, app.BankKeeper.GetAllBalances(ctx, TestAddrs[1])) } diff --git a/x/gov/keeper/test_common.go b/x/gov/keeper/old_test_common.go similarity index 100% rename from x/gov/keeper/test_common.go rename to x/gov/keeper/old_test_common.go From 0c938123d93071b9de22c215d8e15a19f7c81234 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 15:56:26 +0100 Subject: [PATCH 02/24] migrate TestIncrementProposalNumber to simap --- x/gov/keeper/keeper_test.go | 49 ++++++++------------------------- x/gov/keeper/old_keeper_test.go | 36 ++++++++++++++++++++++++ 2 files changed, 48 insertions(+), 37 deletions(-) create mode 100644 x/gov/keeper/old_keeper_test.go diff --git a/x/gov/keeper/keeper_test.go b/x/gov/keeper/keeper_test.go index 9cd2a0559..e824760d1 100644 --- a/x/gov/keeper/keeper_test.go +++ b/x/gov/keeper/keeper_test.go @@ -1,51 +1,26 @@ -package keeper +package keeper_test import ( "testing" - "github.com/stretchr/testify/require" + "github.com/cosmos/cosmos-sdk/simapp" + abci "github.com/tendermint/tendermint/abci/types" - "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/stretchr/testify/require" ) func TestIncrementProposalNumber(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) tp := TestProposal - keeper.SubmitProposal(ctx, tp) - keeper.SubmitProposal(ctx, tp) - keeper.SubmitProposal(ctx, tp) - keeper.SubmitProposal(ctx, tp) - keeper.SubmitProposal(ctx, tp) - proposal6, err := keeper.SubmitProposal(ctx, tp) + app.GovKeeper.SubmitProposal(ctx, tp) + app.GovKeeper.SubmitProposal(ctx, tp) + app.GovKeeper.SubmitProposal(ctx, tp) + app.GovKeeper.SubmitProposal(ctx, tp) + app.GovKeeper.SubmitProposal(ctx, tp) + proposal6, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) require.Equal(t, uint64(6), proposal6.ProposalID) } - -func TestProposalQueues(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - - // create test proposals - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - - inactiveIterator := keeper.InactiveProposalQueueIterator(ctx, proposal.DepositEndTime) - require.True(t, inactiveIterator.Valid()) - - proposalID := types.GetProposalIDFromBytes(inactiveIterator.Value()) - require.Equal(t, proposalID, proposal.ProposalID) - inactiveIterator.Close() - - keeper.activateVotingPeriod(ctx, proposal) - - proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID) - require.True(t, ok) - - activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) - require.True(t, activeIterator.Valid()) - keeper.cdc.UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID) - require.Equal(t, proposalID, proposal.ProposalID) - activeIterator.Close() -} diff --git a/x/gov/keeper/old_keeper_test.go b/x/gov/keeper/old_keeper_test.go new file mode 100644 index 000000000..4b21f3eac --- /dev/null +++ b/x/gov/keeper/old_keeper_test.go @@ -0,0 +1,36 @@ +package keeper + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +func TestProposalQueues(t *testing.T) { + ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled + + // create test proposals + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + + inactiveIterator := keeper.InactiveProposalQueueIterator(ctx, proposal.DepositEndTime) + require.True(t, inactiveIterator.Valid()) + + proposalID := types.GetProposalIDFromBytes(inactiveIterator.Value()) + require.Equal(t, proposalID, proposal.ProposalID) + inactiveIterator.Close() + + keeper.activateVotingPeriod(ctx, proposal) + + proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID) + require.True(t, ok) + + activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) + require.True(t, activeIterator.Valid()) + keeper.cdc.UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID) + require.Equal(t, proposalID, proposal.ProposalID) + activeIterator.Close() +} From 2afd22f37ec48f0e95d585835acd1a91a129fd0a Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 15:59:55 +0100 Subject: [PATCH 03/24] migrate TestProposalQueues to use simapp --- x/gov/keeper/deposit.go | 2 +- x/gov/keeper/keeper_test.go | 30 +++++++++++++++++++++++++++ x/gov/keeper/old_keeper_test.go | 36 --------------------------------- x/gov/keeper/proposal.go | 2 +- x/gov/keeper/proposal_test.go | 2 +- 5 files changed, 33 insertions(+), 39 deletions(-) delete mode 100644 x/gov/keeper/old_keeper_test.go diff --git a/x/gov/keeper/deposit.go b/x/gov/keeper/deposit.go index 423679998..4fcf26390 100644 --- a/x/gov/keeper/deposit.go +++ b/x/gov/keeper/deposit.go @@ -119,7 +119,7 @@ func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID uint64, depositorAdd // Check if deposit has provided sufficient total funds to transition the proposal into the voting period activatedVotingPeriod := false if proposal.Status == types.StatusDepositPeriod && proposal.TotalDeposit.IsAllGTE(keeper.GetDepositParams(ctx).MinDeposit) { - keeper.activateVotingPeriod(ctx, proposal) + keeper.ActivateVotingPeriod(ctx, proposal) activatedVotingPeriod = true } diff --git a/x/gov/keeper/keeper_test.go b/x/gov/keeper/keeper_test.go index e824760d1..0d2f424dd 100644 --- a/x/gov/keeper/keeper_test.go +++ b/x/gov/keeper/keeper_test.go @@ -3,6 +3,8 @@ package keeper_test import ( "testing" + "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/cosmos/cosmos-sdk/simapp" abci "github.com/tendermint/tendermint/abci/types" @@ -24,3 +26,31 @@ func TestIncrementProposalNumber(t *testing.T) { require.Equal(t, uint64(6), proposal6.ProposalID) } + +func TestProposalQueues(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + // create test proposals + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + + inactiveIterator := app.GovKeeper.InactiveProposalQueueIterator(ctx, proposal.DepositEndTime) + require.True(t, inactiveIterator.Valid()) + + proposalID := types.GetProposalIDFromBytes(inactiveIterator.Value()) + require.Equal(t, proposalID, proposal.ProposalID) + inactiveIterator.Close() + + app.GovKeeper.ActivateVotingPeriod(ctx, proposal) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposal.ProposalID) + require.True(t, ok) + + activeIterator := app.GovKeeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) + require.True(t, activeIterator.Valid()) + app.Codec().UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID) + require.Equal(t, proposalID, proposal.ProposalID) + activeIterator.Close() +} diff --git a/x/gov/keeper/old_keeper_test.go b/x/gov/keeper/old_keeper_test.go deleted file mode 100644 index 4b21f3eac..000000000 --- a/x/gov/keeper/old_keeper_test.go +++ /dev/null @@ -1,36 +0,0 @@ -package keeper - -import ( - "testing" - - "github.com/stretchr/testify/require" - - "github.com/cosmos/cosmos-sdk/x/gov/types" -) - -func TestProposalQueues(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - - // create test proposals - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - - inactiveIterator := keeper.InactiveProposalQueueIterator(ctx, proposal.DepositEndTime) - require.True(t, inactiveIterator.Valid()) - - proposalID := types.GetProposalIDFromBytes(inactiveIterator.Value()) - require.Equal(t, proposalID, proposal.ProposalID) - inactiveIterator.Close() - - keeper.activateVotingPeriod(ctx, proposal) - - proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID) - require.True(t, ok) - - activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) - require.True(t, activeIterator.Valid()) - keeper.cdc.UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID) - require.Equal(t, proposalID, proposal.ProposalID) - activeIterator.Close() -} diff --git a/x/gov/keeper/proposal.go b/x/gov/keeper/proposal.go index c5d569314..70435ea58 100644 --- a/x/gov/keeper/proposal.go +++ b/x/gov/keeper/proposal.go @@ -167,7 +167,7 @@ func (keeper Keeper) SetProposalID(ctx sdk.Context, proposalID uint64) { store.Set(types.ProposalIDKey, types.GetProposalIDBytes(proposalID)) } -func (keeper Keeper) activateVotingPeriod(ctx sdk.Context, proposal types.Proposal) { +func (keeper Keeper) ActivateVotingPeriod(ctx sdk.Context, proposal types.Proposal) { proposal.VotingStartTime = ctx.BlockHeader().Time votingPeriod := keeper.GetVotingParams(ctx).VotingPeriod proposal.VotingEndTime = proposal.VotingStartTime.Add(votingPeriod) diff --git a/x/gov/keeper/proposal_test.go b/x/gov/keeper/proposal_test.go index 5848e0d75..ca345ad9f 100644 --- a/x/gov/keeper/proposal_test.go +++ b/x/gov/keeper/proposal_test.go @@ -36,7 +36,7 @@ func TestActivateVotingPeriod(t *testing.T) { require.True(t, proposal.VotingStartTime.Equal(time.Time{})) - keeper.activateVotingPeriod(ctx, proposal) + keeper.ActivateVotingPeriod(ctx, proposal) require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time)) From eedd2b2341562e1ae83ac67d478bd93d676e4f29 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:04:49 +0100 Subject: [PATCH 04/24] migrate part of proposal to simapp --- x/gov/keeper/common_test.go | 12 ++- x/gov/keeper/keeper_test.go | 6 +- x/gov/keeper/old_proposal_test.go | 164 ++++++++++++++++++++++++++++ x/gov/keeper/proposal_test.go | 170 ++---------------------------- 4 files changed, 187 insertions(+), 165 deletions(-) create mode 100644 x/gov/keeper/old_proposal_test.go diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go index 66ab6db7d..e4c48463f 100644 --- a/x/gov/keeper/common_test.go +++ b/x/gov/keeper/common_test.go @@ -1,7 +1,17 @@ package keeper_test -import "github.com/cosmos/cosmos-sdk/x/gov/types" +import ( + "bytes" + + "github.com/cosmos/cosmos-sdk/x/gov/types" +) var ( TestProposal = types.NewTextProposal("Test", "description") ) + +// ProposalEqual checks if two proposals are equal (note: slow, for tests only) +func ProposalEqual(proposalA types.Proposal, proposalB types.Proposal) bool { + return bytes.Equal(types.ModuleCdc.MustMarshalBinaryBare(proposalA), + types.ModuleCdc.MustMarshalBinaryBare(proposalB)) +} diff --git a/x/gov/keeper/keeper_test.go b/x/gov/keeper/keeper_test.go index 0d2f424dd..b03bd1d11 100644 --- a/x/gov/keeper/keeper_test.go +++ b/x/gov/keeper/keeper_test.go @@ -3,12 +3,12 @@ package keeper_test import ( "testing" - "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/stretchr/testify/require" - "github.com/cosmos/cosmos-sdk/simapp" abci "github.com/tendermint/tendermint/abci/types" - "github.com/stretchr/testify/require" + "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/x/gov/types" ) func TestIncrementProposalNumber(t *testing.T) { diff --git a/x/gov/keeper/old_proposal_test.go b/x/gov/keeper/old_proposal_test.go new file mode 100644 index 000000000..e65126df5 --- /dev/null +++ b/x/gov/keeper/old_proposal_test.go @@ -0,0 +1,164 @@ +package keeper + +import ( + "errors" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +func TestActivateVotingPeriod(t *testing.T) { + ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + + require.True(t, proposal.VotingStartTime.Equal(time.Time{})) + + keeper.ActivateVotingPeriod(ctx, proposal) + + require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time)) + + proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID) + require.True(t, ok) + + activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) + require.True(t, activeIterator.Valid()) + + proposalID := types.GetProposalIDFromBytes(activeIterator.Value()) + require.Equal(t, proposalID, proposal.ProposalID) + activeIterator.Close() +} + +type validProposal struct{} + +func (validProposal) GetTitle() string { return "title" } +func (validProposal) GetDescription() string { return "description" } +func (validProposal) ProposalRoute() string { return types.RouterKey } +func (validProposal) ProposalType() string { return types.ProposalTypeText } +func (validProposal) String() string { return "" } +func (validProposal) ValidateBasic() error { return nil } + +type invalidProposalTitle1 struct{ validProposal } + +func (invalidProposalTitle1) GetTitle() string { return "" } + +type invalidProposalTitle2 struct{ validProposal } + +func (invalidProposalTitle2) GetTitle() string { return strings.Repeat("1234567890", 100) } + +type invalidProposalDesc1 struct{ validProposal } + +func (invalidProposalDesc1) GetDescription() string { return "" } + +type invalidProposalDesc2 struct{ validProposal } + +func (invalidProposalDesc2) GetDescription() string { return strings.Repeat("1234567890", 1000) } + +type invalidProposalRoute struct{ validProposal } + +func (invalidProposalRoute) ProposalRoute() string { return "nonexistingroute" } + +type invalidProposalValidation struct{ validProposal } + +func (invalidProposalValidation) ValidateBasic() error { + return errors.New("invalid proposal") +} + +func registerTestCodec(cdc *codec.Codec) { + cdc.RegisterConcrete(validProposal{}, "test/validproposal", nil) + cdc.RegisterConcrete(invalidProposalTitle1{}, "test/invalidproposalt1", nil) + cdc.RegisterConcrete(invalidProposalTitle2{}, "test/invalidproposalt2", nil) + cdc.RegisterConcrete(invalidProposalDesc1{}, "test/invalidproposald1", nil) + cdc.RegisterConcrete(invalidProposalDesc2{}, "test/invalidproposald2", nil) + cdc.RegisterConcrete(invalidProposalRoute{}, "test/invalidproposalr", nil) + cdc.RegisterConcrete(invalidProposalValidation{}, "test/invalidproposalv", nil) +} + +func TestSubmitProposal(t *testing.T) { + ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled + + registerTestCodec(keeper.cdc) + + testCases := []struct { + content types.Content + expectedErr error + }{ + {validProposal{}, nil}, + // Keeper does not check the validity of title and description, no error + {invalidProposalTitle1{}, nil}, + {invalidProposalTitle2{}, nil}, + {invalidProposalDesc1{}, nil}, + {invalidProposalDesc2{}, nil}, + // error only when invalid route + {invalidProposalRoute{}, types.ErrNoProposalHandlerExists}, + // Keeper does not call ValidateBasic, msg.ValidateBasic does + {invalidProposalValidation{}, nil}, + } + + for i, tc := range testCases { + _, err := keeper.SubmitProposal(ctx, tc.content) + require.True(t, errors.Is(tc.expectedErr, err), "tc #%d; got: %v, expected: %v", i, err, tc.expectedErr) + } +} + +func TestGetProposalsFiltered(t *testing.T) { + proposalID := uint64(1) + ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled + status := []types.ProposalStatus{types.StatusDepositPeriod, types.StatusVotingPeriod} + + addr1 := sdk.AccAddress("foo") + + for _, s := range status { + for i := 0; i < 50; i++ { + p := types.NewProposal(TestProposal, proposalID, time.Now(), time.Now()) + p.Status = s + + if i%2 == 0 { + d := types.NewDeposit(proposalID, addr1, nil) + v := types.NewVote(proposalID, addr1, types.OptionYes) + keeper.SetDeposit(ctx, d) + keeper.SetVote(ctx, v) + } + + keeper.SetProposal(ctx, p) + proposalID++ + } + } + + testCases := []struct { + params types.QueryProposalsParams + expectedNumResults int + }{ + {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 25, types.StatusNil, nil, nil), 25}, + {types.NewQueryProposalsParams(2, 25, types.StatusNil, nil, nil), 25}, + {types.NewQueryProposalsParams(1, 50, types.StatusRejected, nil, nil), 0}, + {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, addr1), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, addr1), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, addr1, addr1), 25}, + {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, + } + + for _, tc := range testCases { + proposals := keeper.GetProposalsFiltered(ctx, tc.params) + require.Len(t, proposals, tc.expectedNumResults) + + for _, p := range proposals { + if len(tc.params.ProposalStatus.String()) != 0 { + require.Equal(t, tc.params.ProposalStatus, p.Status) + } + } + } +} diff --git a/x/gov/keeper/proposal_test.go b/x/gov/keeper/proposal_test.go index ca345ad9f..1158e54dc 100644 --- a/x/gov/keeper/proposal_test.go +++ b/x/gov/keeper/proposal_test.go @@ -1,178 +1,26 @@ -package keeper +package keeper_test import ( - "errors" - "strings" "testing" - "time" "github.com/stretchr/testify/require" - "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/gov/types" + abci "github.com/tendermint/tendermint/abci/types" + + "github.com/cosmos/cosmos-sdk/simapp" ) func TestGetSetProposal(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) proposalID := proposal.ProposalID - keeper.SetProposal(ctx, proposal) + app.GovKeeper.SetProposal(ctx, proposal) - gotProposal, ok := keeper.GetProposal(ctx, proposalID) + gotProposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) require.True(t, ProposalEqual(proposal, gotProposal)) } - -func TestActivateVotingPeriod(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - - require.True(t, proposal.VotingStartTime.Equal(time.Time{})) - - keeper.ActivateVotingPeriod(ctx, proposal) - - require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time)) - - proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID) - require.True(t, ok) - - activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) - require.True(t, activeIterator.Valid()) - - proposalID := types.GetProposalIDFromBytes(activeIterator.Value()) - require.Equal(t, proposalID, proposal.ProposalID) - activeIterator.Close() -} - -type validProposal struct{} - -func (validProposal) GetTitle() string { return "title" } -func (validProposal) GetDescription() string { return "description" } -func (validProposal) ProposalRoute() string { return types.RouterKey } -func (validProposal) ProposalType() string { return types.ProposalTypeText } -func (validProposal) String() string { return "" } -func (validProposal) ValidateBasic() error { return nil } - -type invalidProposalTitle1 struct{ validProposal } - -func (invalidProposalTitle1) GetTitle() string { return "" } - -type invalidProposalTitle2 struct{ validProposal } - -func (invalidProposalTitle2) GetTitle() string { return strings.Repeat("1234567890", 100) } - -type invalidProposalDesc1 struct{ validProposal } - -func (invalidProposalDesc1) GetDescription() string { return "" } - -type invalidProposalDesc2 struct{ validProposal } - -func (invalidProposalDesc2) GetDescription() string { return strings.Repeat("1234567890", 1000) } - -type invalidProposalRoute struct{ validProposal } - -func (invalidProposalRoute) ProposalRoute() string { return "nonexistingroute" } - -type invalidProposalValidation struct{ validProposal } - -func (invalidProposalValidation) ValidateBasic() error { - return errors.New("invalid proposal") -} - -func registerTestCodec(cdc *codec.Codec) { - cdc.RegisterConcrete(validProposal{}, "test/validproposal", nil) - cdc.RegisterConcrete(invalidProposalTitle1{}, "test/invalidproposalt1", nil) - cdc.RegisterConcrete(invalidProposalTitle2{}, "test/invalidproposalt2", nil) - cdc.RegisterConcrete(invalidProposalDesc1{}, "test/invalidproposald1", nil) - cdc.RegisterConcrete(invalidProposalDesc2{}, "test/invalidproposald2", nil) - cdc.RegisterConcrete(invalidProposalRoute{}, "test/invalidproposalr", nil) - cdc.RegisterConcrete(invalidProposalValidation{}, "test/invalidproposalv", nil) -} - -func TestSubmitProposal(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - - registerTestCodec(keeper.cdc) - - testCases := []struct { - content types.Content - expectedErr error - }{ - {validProposal{}, nil}, - // Keeper does not check the validity of title and description, no error - {invalidProposalTitle1{}, nil}, - {invalidProposalTitle2{}, nil}, - {invalidProposalDesc1{}, nil}, - {invalidProposalDesc2{}, nil}, - // error only when invalid route - {invalidProposalRoute{}, types.ErrNoProposalHandlerExists}, - // Keeper does not call ValidateBasic, msg.ValidateBasic does - {invalidProposalValidation{}, nil}, - } - - for i, tc := range testCases { - _, err := keeper.SubmitProposal(ctx, tc.content) - require.True(t, errors.Is(tc.expectedErr, err), "tc #%d; got: %v, expected: %v", i, err, tc.expectedErr) - } -} - -func TestGetProposalsFiltered(t *testing.T) { - proposalID := uint64(1) - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - status := []types.ProposalStatus{types.StatusDepositPeriod, types.StatusVotingPeriod} - - addr1 := sdk.AccAddress("foo") - - for _, s := range status { - for i := 0; i < 50; i++ { - p := types.NewProposal(TestProposal, proposalID, time.Now(), time.Now()) - p.Status = s - - if i%2 == 0 { - d := types.NewDeposit(proposalID, addr1, nil) - v := types.NewVote(proposalID, addr1, types.OptionYes) - keeper.SetDeposit(ctx, d) - keeper.SetVote(ctx, v) - } - - keeper.SetProposal(ctx, p) - proposalID++ - } - } - - testCases := []struct { - params types.QueryProposalsParams - expectedNumResults int - }{ - {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 25, types.StatusNil, nil, nil), 25}, - {types.NewQueryProposalsParams(2, 25, types.StatusNil, nil, nil), 25}, - {types.NewQueryProposalsParams(1, 50, types.StatusRejected, nil, nil), 0}, - {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, addr1), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, addr1), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, addr1, addr1), 25}, - {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, - } - - for _, tc := range testCases { - proposals := keeper.GetProposalsFiltered(ctx, tc.params) - require.Len(t, proposals, tc.expectedNumResults) - - for _, p := range proposals { - if len(tc.params.ProposalStatus.String()) != 0 { - require.Equal(t, tc.params.ProposalStatus, p.Status) - } - } - } -} From 00396145d518646f3d72824be00ad54b424f0263 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:07:23 +0100 Subject: [PATCH 05/24] migrate TestActivateVotingPeriod to simapp --- x/gov/keeper/old_proposal_test.go | 24 ------------------------ x/gov/keeper/proposal_test.go | 27 +++++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 24 deletions(-) diff --git a/x/gov/keeper/old_proposal_test.go b/x/gov/keeper/old_proposal_test.go index e65126df5..1ddfa916d 100644 --- a/x/gov/keeper/old_proposal_test.go +++ b/x/gov/keeper/old_proposal_test.go @@ -13,30 +13,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/gov/types" ) -func TestActivateVotingPeriod(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - - require.True(t, proposal.VotingStartTime.Equal(time.Time{})) - - keeper.ActivateVotingPeriod(ctx, proposal) - - require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time)) - - proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID) - require.True(t, ok) - - activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) - require.True(t, activeIterator.Valid()) - - proposalID := types.GetProposalIDFromBytes(activeIterator.Value()) - require.Equal(t, proposalID, proposal.ProposalID) - activeIterator.Close() -} - type validProposal struct{} func (validProposal) GetTitle() string { return "title" } diff --git a/x/gov/keeper/proposal_test.go b/x/gov/keeper/proposal_test.go index 1158e54dc..4b6df06e5 100644 --- a/x/gov/keeper/proposal_test.go +++ b/x/gov/keeper/proposal_test.go @@ -2,12 +2,14 @@ package keeper_test import ( "testing" + "time" "github.com/stretchr/testify/require" abci "github.com/tendermint/tendermint/abci/types" "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/x/gov/types" ) func TestGetSetProposal(t *testing.T) { @@ -24,3 +26,28 @@ func TestGetSetProposal(t *testing.T) { require.True(t, ok) require.True(t, ProposalEqual(proposal, gotProposal)) } + +func TestActivateVotingPeriod(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + + require.True(t, proposal.VotingStartTime.Equal(time.Time{})) + + app.GovKeeper.ActivateVotingPeriod(ctx, proposal) + + require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposal.ProposalID) + require.True(t, ok) + + activeIterator := app.GovKeeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime) + require.True(t, activeIterator.Valid()) + + proposalID := types.GetProposalIDFromBytes(activeIterator.Value()) + require.Equal(t, proposalID, proposal.ProposalID) + activeIterator.Close() +} From 2c231e2fa0011379035bcccafa57a248c09828fc Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:10:19 +0100 Subject: [PATCH 06/24] TestGetProposalsFiltered migrate to simapp --- x/gov/keeper/old_proposal_test.go | 140 ------------------------------ x/gov/keeper/proposal_test.go | 134 ++++++++++++++++++++++++++++ 2 files changed, 134 insertions(+), 140 deletions(-) delete mode 100644 x/gov/keeper/old_proposal_test.go diff --git a/x/gov/keeper/old_proposal_test.go b/x/gov/keeper/old_proposal_test.go deleted file mode 100644 index 1ddfa916d..000000000 --- a/x/gov/keeper/old_proposal_test.go +++ /dev/null @@ -1,140 +0,0 @@ -package keeper - -import ( - "errors" - "strings" - "testing" - "time" - - "github.com/stretchr/testify/require" - - "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/gov/types" -) - -type validProposal struct{} - -func (validProposal) GetTitle() string { return "title" } -func (validProposal) GetDescription() string { return "description" } -func (validProposal) ProposalRoute() string { return types.RouterKey } -func (validProposal) ProposalType() string { return types.ProposalTypeText } -func (validProposal) String() string { return "" } -func (validProposal) ValidateBasic() error { return nil } - -type invalidProposalTitle1 struct{ validProposal } - -func (invalidProposalTitle1) GetTitle() string { return "" } - -type invalidProposalTitle2 struct{ validProposal } - -func (invalidProposalTitle2) GetTitle() string { return strings.Repeat("1234567890", 100) } - -type invalidProposalDesc1 struct{ validProposal } - -func (invalidProposalDesc1) GetDescription() string { return "" } - -type invalidProposalDesc2 struct{ validProposal } - -func (invalidProposalDesc2) GetDescription() string { return strings.Repeat("1234567890", 1000) } - -type invalidProposalRoute struct{ validProposal } - -func (invalidProposalRoute) ProposalRoute() string { return "nonexistingroute" } - -type invalidProposalValidation struct{ validProposal } - -func (invalidProposalValidation) ValidateBasic() error { - return errors.New("invalid proposal") -} - -func registerTestCodec(cdc *codec.Codec) { - cdc.RegisterConcrete(validProposal{}, "test/validproposal", nil) - cdc.RegisterConcrete(invalidProposalTitle1{}, "test/invalidproposalt1", nil) - cdc.RegisterConcrete(invalidProposalTitle2{}, "test/invalidproposalt2", nil) - cdc.RegisterConcrete(invalidProposalDesc1{}, "test/invalidproposald1", nil) - cdc.RegisterConcrete(invalidProposalDesc2{}, "test/invalidproposald2", nil) - cdc.RegisterConcrete(invalidProposalRoute{}, "test/invalidproposalr", nil) - cdc.RegisterConcrete(invalidProposalValidation{}, "test/invalidproposalv", nil) -} - -func TestSubmitProposal(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - - registerTestCodec(keeper.cdc) - - testCases := []struct { - content types.Content - expectedErr error - }{ - {validProposal{}, nil}, - // Keeper does not check the validity of title and description, no error - {invalidProposalTitle1{}, nil}, - {invalidProposalTitle2{}, nil}, - {invalidProposalDesc1{}, nil}, - {invalidProposalDesc2{}, nil}, - // error only when invalid route - {invalidProposalRoute{}, types.ErrNoProposalHandlerExists}, - // Keeper does not call ValidateBasic, msg.ValidateBasic does - {invalidProposalValidation{}, nil}, - } - - for i, tc := range testCases { - _, err := keeper.SubmitProposal(ctx, tc.content) - require.True(t, errors.Is(tc.expectedErr, err), "tc #%d; got: %v, expected: %v", i, err, tc.expectedErr) - } -} - -func TestGetProposalsFiltered(t *testing.T) { - proposalID := uint64(1) - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled - status := []types.ProposalStatus{types.StatusDepositPeriod, types.StatusVotingPeriod} - - addr1 := sdk.AccAddress("foo") - - for _, s := range status { - for i := 0; i < 50; i++ { - p := types.NewProposal(TestProposal, proposalID, time.Now(), time.Now()) - p.Status = s - - if i%2 == 0 { - d := types.NewDeposit(proposalID, addr1, nil) - v := types.NewVote(proposalID, addr1, types.OptionYes) - keeper.SetDeposit(ctx, d) - keeper.SetVote(ctx, v) - } - - keeper.SetProposal(ctx, p) - proposalID++ - } - } - - testCases := []struct { - params types.QueryProposalsParams - expectedNumResults int - }{ - {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 25, types.StatusNil, nil, nil), 25}, - {types.NewQueryProposalsParams(2, 25, types.StatusNil, nil, nil), 25}, - {types.NewQueryProposalsParams(1, 50, types.StatusRejected, nil, nil), 0}, - {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, addr1), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, addr1), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, addr1, addr1), 25}, - {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, - {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, - } - - for _, tc := range testCases { - proposals := keeper.GetProposalsFiltered(ctx, tc.params) - require.Len(t, proposals, tc.expectedNumResults) - - for _, p := range proposals { - if len(tc.params.ProposalStatus.String()) != 0 { - require.Equal(t, tc.params.ProposalStatus, p.Status) - } - } - } -} diff --git a/x/gov/keeper/proposal_test.go b/x/gov/keeper/proposal_test.go index 4b6df06e5..41bc35aab 100644 --- a/x/gov/keeper/proposal_test.go +++ b/x/gov/keeper/proposal_test.go @@ -1,13 +1,18 @@ package keeper_test import ( + "errors" + "strings" "testing" "time" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" abci "github.com/tendermint/tendermint/abci/types" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/x/gov/types" ) @@ -51,3 +56,132 @@ func TestActivateVotingPeriod(t *testing.T) { require.Equal(t, proposalID, proposal.ProposalID) activeIterator.Close() } + +type validProposal struct{} + +func (validProposal) GetTitle() string { return "title" } +func (validProposal) GetDescription() string { return "description" } +func (validProposal) ProposalRoute() string { return types.RouterKey } +func (validProposal) ProposalType() string { return types.ProposalTypeText } +func (validProposal) String() string { return "" } +func (validProposal) ValidateBasic() error { return nil } + +type invalidProposalTitle1 struct{ validProposal } + +func (invalidProposalTitle1) GetTitle() string { return "" } + +type invalidProposalTitle2 struct{ validProposal } + +func (invalidProposalTitle2) GetTitle() string { return strings.Repeat("1234567890", 100) } + +type invalidProposalDesc1 struct{ validProposal } + +func (invalidProposalDesc1) GetDescription() string { return "" } + +type invalidProposalDesc2 struct{ validProposal } + +func (invalidProposalDesc2) GetDescription() string { return strings.Repeat("1234567890", 1000) } + +type invalidProposalRoute struct{ validProposal } + +func (invalidProposalRoute) ProposalRoute() string { return "nonexistingroute" } + +type invalidProposalValidation struct{ validProposal } + +func (invalidProposalValidation) ValidateBasic() error { + return errors.New("invalid proposal") +} + +func registerTestCodec(cdc *codec.Codec) { + cdc.RegisterConcrete(validProposal{}, "test/validproposal", nil) + cdc.RegisterConcrete(invalidProposalTitle1{}, "test/invalidproposalt1", nil) + cdc.RegisterConcrete(invalidProposalTitle2{}, "test/invalidproposalt2", nil) + cdc.RegisterConcrete(invalidProposalDesc1{}, "test/invalidproposald1", nil) + cdc.RegisterConcrete(invalidProposalDesc2{}, "test/invalidproposald2", nil) + cdc.RegisterConcrete(invalidProposalRoute{}, "test/invalidproposalr", nil) + cdc.RegisterConcrete(invalidProposalValidation{}, "test/invalidproposalv", nil) +} + +func TestSubmitProposal(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + registerTestCodec(app.Codec()) + + testCases := []struct { + content types.Content + expectedErr error + }{ + {validProposal{}, nil}, + // Keeper does not check the validity of title and description, no error + {invalidProposalTitle1{}, nil}, + {invalidProposalTitle2{}, nil}, + {invalidProposalDesc1{}, nil}, + {invalidProposalDesc2{}, nil}, + // error only when invalid route + {invalidProposalRoute{}, types.ErrNoProposalHandlerExists}, + // Keeper does not call ValidateBasic, msg.ValidateBasic does + {invalidProposalValidation{}, nil}, + } + + for i, tc := range testCases { + _, err := app.GovKeeper.SubmitProposal(ctx, tc.content) + require.True(t, errors.Is(tc.expectedErr, err), "tc #%d; got: %v, expected: %v", i, err, tc.expectedErr) + } +} + +func TestGetProposalsFiltered(t *testing.T) { + proposalID := uint64(1) + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + status := []types.ProposalStatus{types.StatusDepositPeriod, types.StatusVotingPeriod} + + addr1 := sdk.AccAddress("foo") + + for _, s := range status { + for i := 0; i < 50; i++ { + p := types.NewProposal(TestProposal, proposalID, time.Now(), time.Now()) + p.Status = s + + if i%2 == 0 { + d := types.NewDeposit(proposalID, addr1, nil) + v := types.NewVote(proposalID, addr1, types.OptionYes) + app.GovKeeper.SetDeposit(ctx, d) + app.GovKeeper.SetVote(ctx, v) + } + + app.GovKeeper.SetProposal(ctx, p) + proposalID++ + } + } + + testCases := []struct { + params types.QueryProposalsParams + expectedNumResults int + }{ + {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 25, types.StatusNil, nil, nil), 25}, + {types.NewQueryProposalsParams(2, 25, types.StatusNil, nil, nil), 25}, + {types.NewQueryProposalsParams(1, 50, types.StatusRejected, nil, nil), 0}, + {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusNil, nil, addr1), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusNil, addr1, addr1), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, addr1, addr1), 25}, + {types.NewQueryProposalsParams(1, 50, types.StatusDepositPeriod, nil, nil), 50}, + {types.NewQueryProposalsParams(1, 50, types.StatusVotingPeriod, nil, nil), 50}, + } + + for _, tc := range testCases { + proposals := app.GovKeeper.GetProposalsFiltered(ctx, tc.params) + require.Len(t, proposals, tc.expectedNumResults) + + for _, p := range proposals { + if len(tc.params.ProposalStatus.String()) != 0 { + require.Equal(t, tc.params.ProposalStatus, p.Status) + } + } + } +} From 80bfd0d2dcabeb0353b345fbb0f7fe66d0680d8e Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:22:36 +0100 Subject: [PATCH 07/24] migrate TestQueries to new test simapp --- x/gov/keeper/old_querier_test.go | 1 + x/gov/keeper/querier_test.go | 82 ++++++++++++++++++-------------- 2 files changed, 46 insertions(+), 37 deletions(-) create mode 100644 x/gov/keeper/old_querier_test.go diff --git a/x/gov/keeper/old_querier_test.go b/x/gov/keeper/old_querier_test.go new file mode 100644 index 000000000..b55569d4a --- /dev/null +++ b/x/gov/keeper/old_querier_test.go @@ -0,0 +1 @@ +package keeper diff --git a/x/gov/keeper/querier_test.go b/x/gov/keeper/querier_test.go index 54aeae6fe..368b51e67 100644 --- a/x/gov/keeper/querier_test.go +++ b/x/gov/keeper/querier_test.go @@ -1,4 +1,4 @@ -package keeper +package keeper_test import ( "math/rand" @@ -7,10 +7,13 @@ import ( "time" "github.com/stretchr/testify/require" + abci "github.com/tendermint/tendermint/abci/types" "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/gov/keeper" "github.com/cosmos/cosmos-sdk/x/gov/types" ) @@ -142,45 +145,49 @@ func getQueriedVotes(t *testing.T, ctx sdk.Context, cdc *codec.Codec, querier sd } func TestQueries(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 1000) // nolint: dogsled - querier := NewQuerier(keeper) + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + querier := keeper.NewQuerier(app.GovKeeper) + + TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(20000001)) oneCoins := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1)) consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10))) tp := TestProposal - depositParams, _, _ := getQueriedParams(t, ctx, keeper.cdc, querier) + depositParams, _, _ := getQueriedParams(t, ctx, app.Codec(), querier) // TestAddrs[0] proposes (and deposits) proposals #1 and #2 - proposal1, err := keeper.SubmitProposal(ctx, tp) + proposal1, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) deposit1 := types.NewDeposit(proposal1.ProposalID, TestAddrs[0], oneCoins) - _, err = keeper.AddDeposit(ctx, deposit1.ProposalID, deposit1.Depositor, deposit1.Amount) + _, err = app.GovKeeper.AddDeposit(ctx, deposit1.ProposalID, deposit1.Depositor, deposit1.Amount) require.NoError(t, err) proposal1.TotalDeposit = proposal1.TotalDeposit.Add(deposit1.Amount...) - proposal2, err := keeper.SubmitProposal(ctx, tp) + proposal2, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) deposit2 := types.NewDeposit(proposal2.ProposalID, TestAddrs[0], consCoins) - _, err = keeper.AddDeposit(ctx, deposit2.ProposalID, deposit2.Depositor, deposit2.Amount) + _, err = app.GovKeeper.AddDeposit(ctx, deposit2.ProposalID, deposit2.Depositor, deposit2.Amount) require.NoError(t, err) proposal2.TotalDeposit = proposal2.TotalDeposit.Add(deposit2.Amount...) // TestAddrs[1] proposes (and deposits) on proposal #3 - proposal3, err := keeper.SubmitProposal(ctx, tp) + proposal3, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) deposit3 := types.NewDeposit(proposal3.ProposalID, TestAddrs[1], oneCoins) - _, err = keeper.AddDeposit(ctx, deposit3.ProposalID, deposit3.Depositor, deposit3.Amount) + _, err = app.GovKeeper.AddDeposit(ctx, deposit3.ProposalID, deposit3.Depositor, deposit3.Amount) require.NoError(t, err) proposal3.TotalDeposit = proposal3.TotalDeposit.Add(deposit3.Amount...) // TestAddrs[1] deposits on proposals #2 & #3 deposit4 := types.NewDeposit(proposal2.ProposalID, TestAddrs[1], depositParams.MinDeposit) - _, err = keeper.AddDeposit(ctx, deposit4.ProposalID, deposit4.Depositor, deposit4.Amount) + _, err = app.GovKeeper.AddDeposit(ctx, deposit4.ProposalID, deposit4.Depositor, deposit4.Amount) require.NoError(t, err) proposal2.TotalDeposit = proposal2.TotalDeposit.Add(deposit4.Amount...) @@ -188,7 +195,7 @@ func TestQueries(t *testing.T) { proposal2.VotingEndTime = proposal2.VotingEndTime.Add(types.DefaultPeriod) deposit5 := types.NewDeposit(proposal3.ProposalID, TestAddrs[1], depositParams.MinDeposit) - _, err = keeper.AddDeposit(ctx, deposit5.ProposalID, deposit5.Depositor, deposit5.Amount) + _, err = app.GovKeeper.AddDeposit(ctx, deposit5.ProposalID, deposit5.Depositor, deposit5.Amount) require.NoError(t, err) proposal3.TotalDeposit = proposal3.TotalDeposit.Add(deposit5.Amount...) @@ -198,35 +205,35 @@ func TestQueries(t *testing.T) { deposit5.Amount = deposit5.Amount.Add(deposit3.Amount...) // check deposits on proposal1 match individual deposits - deposits := getQueriedDeposits(t, ctx, keeper.cdc, querier, proposal1.ProposalID) + deposits := getQueriedDeposits(t, ctx, app.Codec(), querier, proposal1.ProposalID) require.Len(t, deposits, 1) require.Equal(t, deposit1, deposits[0]) - deposit := getQueriedDeposit(t, ctx, keeper.cdc, querier, proposal1.ProposalID, TestAddrs[0]) + deposit := getQueriedDeposit(t, ctx, app.Codec(), querier, proposal1.ProposalID, TestAddrs[0]) require.Equal(t, deposit1, deposit) // check deposits on proposal2 match individual deposits - deposits = getQueriedDeposits(t, ctx, keeper.cdc, querier, proposal2.ProposalID) + deposits = getQueriedDeposits(t, ctx, app.Codec(), querier, proposal2.ProposalID) require.Len(t, deposits, 2) // NOTE order of deposits is determined by the addresses require.Equal(t, deposit2, deposits[0]) require.Equal(t, deposit4, deposits[1]) // check deposits on proposal3 match individual deposits - deposits = getQueriedDeposits(t, ctx, keeper.cdc, querier, proposal3.ProposalID) + deposits = getQueriedDeposits(t, ctx, app.Codec(), querier, proposal3.ProposalID) require.Len(t, deposits, 1) require.Equal(t, deposit5, deposits[0]) - deposit = getQueriedDeposit(t, ctx, keeper.cdc, querier, proposal3.ProposalID, TestAddrs[1]) + deposit = getQueriedDeposit(t, ctx, app.Codec(), querier, proposal3.ProposalID, TestAddrs[1]) require.Equal(t, deposit5, deposit) // Only proposal #1 should be in types.Deposit Period - proposals := getQueriedProposals(t, ctx, keeper.cdc, querier, nil, nil, types.StatusDepositPeriod, 1, 0) + proposals := getQueriedProposals(t, ctx, app.Codec(), querier, nil, nil, types.StatusDepositPeriod, 1, 0) require.Len(t, proposals, 1) require.Equal(t, proposal1, proposals[0]) // Only proposals #2 and #3 should be in Voting Period - proposals = getQueriedProposals(t, ctx, keeper.cdc, querier, nil, nil, types.StatusVotingPeriod, 1, 0) + proposals = getQueriedProposals(t, ctx, app.Codec(), querier, nil, nil, types.StatusVotingPeriod, 1, 0) require.Len(t, proposals, 2) require.Equal(t, proposal2, proposals[0]) require.Equal(t, proposal3, proposals[1]) @@ -234,64 +241,65 @@ func TestQueries(t *testing.T) { // Addrs[0] votes on proposals #2 & #3 vote1 := types.NewVote(proposal2.ProposalID, TestAddrs[0], types.OptionYes) vote2 := types.NewVote(proposal3.ProposalID, TestAddrs[0], types.OptionYes) - keeper.SetVote(ctx, vote1) - keeper.SetVote(ctx, vote2) + app.GovKeeper.SetVote(ctx, vote1) + app.GovKeeper.SetVote(ctx, vote2) // Addrs[1] votes on proposal #3 vote3 := types.NewVote(proposal3.ProposalID, TestAddrs[1], types.OptionYes) - keeper.SetVote(ctx, vote3) + app.GovKeeper.SetVote(ctx, vote3) // Test query voted by TestAddrs[0] - proposals = getQueriedProposals(t, ctx, keeper.cdc, querier, nil, TestAddrs[0], types.StatusNil, 1, 0) + proposals = getQueriedProposals(t, ctx, app.Codec(), querier, nil, TestAddrs[0], types.StatusNil, 1, 0) require.Equal(t, proposal2, proposals[0]) require.Equal(t, proposal3, proposals[1]) // Test query votes on types.Proposal 2 - votes := getQueriedVotes(t, ctx, keeper.cdc, querier, proposal2.ProposalID, 1, 0) + votes := getQueriedVotes(t, ctx, app.Codec(), querier, proposal2.ProposalID, 1, 0) require.Len(t, votes, 1) require.Equal(t, vote1, votes[0]) - vote := getQueriedVote(t, ctx, keeper.cdc, querier, proposal2.ProposalID, TestAddrs[0]) + vote := getQueriedVote(t, ctx, app.Codec(), querier, proposal2.ProposalID, TestAddrs[0]) require.Equal(t, vote1, vote) // Test query votes on types.Proposal 3 - votes = getQueriedVotes(t, ctx, keeper.cdc, querier, proposal3.ProposalID, 1, 0) + votes = getQueriedVotes(t, ctx, app.Codec(), querier, proposal3.ProposalID, 1, 0) require.Len(t, votes, 2) require.Equal(t, vote2, votes[0]) require.Equal(t, vote3, votes[1]) // Test query all proposals - proposals = getQueriedProposals(t, ctx, keeper.cdc, querier, nil, nil, types.StatusNil, 1, 0) + proposals = getQueriedProposals(t, ctx, app.Codec(), querier, nil, nil, types.StatusNil, 1, 0) require.Equal(t, proposal1, proposals[0]) require.Equal(t, proposal2, proposals[1]) require.Equal(t, proposal3, proposals[2]) // Test query voted by TestAddrs[1] - proposals = getQueriedProposals(t, ctx, keeper.cdc, querier, nil, TestAddrs[1], types.StatusNil, 1, 0) + proposals = getQueriedProposals(t, ctx, app.Codec(), querier, nil, TestAddrs[1], types.StatusNil, 1, 0) require.Equal(t, proposal3.ProposalID, proposals[0].ProposalID) // Test query deposited by TestAddrs[0] - proposals = getQueriedProposals(t, ctx, keeper.cdc, querier, TestAddrs[0], nil, types.StatusNil, 1, 0) + proposals = getQueriedProposals(t, ctx, app.Codec(), querier, TestAddrs[0], nil, types.StatusNil, 1, 0) require.Equal(t, proposal1.ProposalID, proposals[0].ProposalID) // Test query deposited by addr2 - proposals = getQueriedProposals(t, ctx, keeper.cdc, querier, TestAddrs[1], nil, types.StatusNil, 1, 0) + proposals = getQueriedProposals(t, ctx, app.Codec(), querier, TestAddrs[1], nil, types.StatusNil, 1, 0) require.Equal(t, proposal2.ProposalID, proposals[0].ProposalID) require.Equal(t, proposal3.ProposalID, proposals[1].ProposalID) // Test query voted AND deposited by addr1 - proposals = getQueriedProposals(t, ctx, keeper.cdc, querier, TestAddrs[0], TestAddrs[0], types.StatusNil, 1, 0) + proposals = getQueriedProposals(t, ctx, app.Codec(), querier, TestAddrs[0], TestAddrs[0], types.StatusNil, 1, 0) require.Equal(t, proposal2.ProposalID, proposals[0].ProposalID) } func TestPaginatedVotesQuery(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 1000) // nolint: dogsled + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) proposal := types.Proposal{ ProposalID: 100, Status: types.StatusVotingPeriod, } - keeper.SetProposal(ctx, proposal) + app.GovKeeper.SetProposal(ctx, proposal) votes := make([]types.Vote, 20) rand := rand.New(rand.NewSource(time.Now().UnixNano())) @@ -304,13 +312,13 @@ func TestPaginatedVotesQuery(t *testing.T) { Option: types.OptionYes, } votes[i] = vote - keeper.SetVote(ctx, vote) + app.GovKeeper.SetVote(ctx, vote) } - querier := NewQuerier(keeper) + querier := keeper.NewQuerier(app.GovKeeper) // keeper preserves consistent order for each query, but this is not the insertion order - all := getQueriedVotes(t, ctx, keeper.cdc, querier, proposal.ProposalID, 1, 0) + all := getQueriedVotes(t, ctx, app.Codec(), querier, proposal.ProposalID, 1, 0) require.Equal(t, len(all), len(votes)) type testCase struct { @@ -344,7 +352,7 @@ func TestPaginatedVotesQuery(t *testing.T) { } { tc := tc t.Run(tc.description, func(t *testing.T) { - votes := getQueriedVotes(t, ctx, keeper.cdc, querier, proposal.ProposalID, tc.page, tc.limit) + votes := getQueriedVotes(t, ctx, app.Codec(), querier, proposal.ProposalID, tc.page, tc.limit) require.Equal(t, len(tc.votes), len(votes)) for i := range votes { require.Equal(t, tc.votes[i], votes[i]) From 8c0d32c8a8bf9cb9dba851876c2a6452b98beacd Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:38:24 +0100 Subject: [PATCH 08/24] migrate TestTallyNoOneVotes to use simapp --- x/gov/keeper/common_test.go | 42 +++ x/gov/keeper/old_querier_test.go | 1 - x/gov/keeper/old_tally_test.go | 416 ++++++++++++++++++++++++++++++ x/gov/keeper/tally_test.go | 426 +------------------------------ 4 files changed, 470 insertions(+), 415 deletions(-) delete mode 100644 x/gov/keeper/old_querier_test.go create mode 100644 x/gov/keeper/old_tally_test.go diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go index e4c48463f..bf21f71c4 100644 --- a/x/gov/keeper/common_test.go +++ b/x/gov/keeper/common_test.go @@ -3,6 +3,13 @@ package keeper_test import ( "bytes" + "github.com/cosmos/cosmos-sdk/simapp/codec" + + "github.com/cosmos/cosmos-sdk/simapp" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/gov/types" ) @@ -15,3 +22,38 @@ func ProposalEqual(proposalA types.Proposal, proposalB types.Proposal) bool { return bytes.Equal(types.ModuleCdc.MustMarshalBinaryBare(proposalA), types.ModuleCdc.MustMarshalBinaryBare(proposalB)) } + +func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) { + addrs := simapp.AddTestAddrsIncremental(app, ctx, 3, sdk.NewInt(10000000)) + valAddrs := simapp.ConvertAddrsToValAddrs(addrs) + pks := simapp.CreateTestPubKeys(3) + + appCodec := codec.NewAppCodec(app.Codec()) + app.StakingKeeper = staking.NewKeeper( + appCodec, + app.GetKey(staking.StoreKey), + app.BankKeeper, + app.SupplyKeeper, + app.GetSubspace(staking.ModuleName), + ) + + val1 := staking.NewValidator(valAddrs[0], pks[0], staking.Description{}) + val2 := staking.NewValidator(valAddrs[1], pks[1], staking.Description{}) + val3 := staking.NewValidator(valAddrs[2], pks[2], staking.Description{}) + + app.StakingKeeper.SetValidator(ctx, val1) + app.StakingKeeper.SetValidator(ctx, val2) + app.StakingKeeper.SetValidator(ctx, val3) + app.StakingKeeper.SetValidatorByConsAddr(ctx, val1) + app.StakingKeeper.SetValidatorByConsAddr(ctx, val2) + app.StakingKeeper.SetValidatorByConsAddr(ctx, val3) + app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val1) + app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2) + app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val3) + + _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), sdk.Unbonded, val1, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), sdk.Unbonded, val2, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2]), sdk.Unbonded, val3, true) + + _ = staking.EndBlocker(ctx, app.StakingKeeper) +} diff --git a/x/gov/keeper/old_querier_test.go b/x/gov/keeper/old_querier_test.go deleted file mode 100644 index b55569d4a..000000000 --- a/x/gov/keeper/old_querier_test.go +++ /dev/null @@ -1 +0,0 @@ -package keeper diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go new file mode 100644 index 000000000..e81e84874 --- /dev/null +++ b/x/gov/keeper/old_tally_test.go @@ -0,0 +1,416 @@ +package keeper + +import ( + "testing" + + "github.com/stretchr/testify/require" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/cosmos/cosmos-sdk/x/staking" +) + +func TestTallyNoQuorum(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{2, 5, 0}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + err = keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionYes) + require.Nil(t, err) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, _ := keeper.Tally(ctx, proposal) + require.False(t, passes) + require.True(t, burnDeposits) +} + +func TestTallyOnlyValidatorsAllYes(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{5, 5, 5}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyOnlyValidators51No(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{5, 6, 0}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, _ := keeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) +} + +func TestTallyOnlyValidators51Yes(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{5, 6, 0}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyOnlyValidatorsVetoed(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{6, 6, 7}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNoWithVeto)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.False(t, passes) + require.True(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) + +} + +func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{6, 6, 7}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{6, 6, 7}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyOnlyValidatorsNonVoter(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{5, 6, 7}) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyDelgatorOverride(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{5, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(30) + val1, found := sk.GetValidator(ctx, valOpAddr1) + require.True(t, found) + + _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, sk) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionNo)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyDelgatorInherit(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{5, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(30) + val3, found := sk.GetValidator(ctx, valOpAddr3) + require.True(t, found) + + _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, sk) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyDelgatorMultipleOverride(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{5, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(10) + val1, found := sk.GetValidator(ctx, valOpAddr1) + require.True(t, found) + val2, found := sk.GetValidator(ctx, valOpAddr2) + require.True(t, found) + + _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true) + require.NoError(t, err) + _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, sk) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionNo)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyDelgatorMultipleInherit(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{25, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(10) + val2, found := sk.GetValidator(ctx, valOpAddr2) + require.True(t, found) + val3, found := sk.GetValidator(ctx, valOpAddr3) + require.True(t, found) + + _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, sk) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyJailedValidator(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{25, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(10) + val2, found := sk.GetValidator(ctx, valOpAddr2) + require.True(t, found) + val3, found := sk.GetValidator(ctx, valOpAddr3) + require.True(t, found) + + _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, sk) + + sk.Jail(ctx, sdk.ConsAddress(val2.GetConsPubKey().Address())) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyValidatorMultipleDelegations(t *testing.T) { + ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) + createValidators(ctx, sk, []int64{10, 10, 10}) + + delTokens := sdk.TokensFromConsensusPower(10) + val2, found := sk.GetValidator(ctx, valOpAddr2) + require.True(t, found) + + _, err := sk.Delegate(ctx, valAccAddr1, delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + + tp := TestProposal + proposal, err := keeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + keeper.SetProposal(ctx, proposal) + + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + + proposal, ok := keeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + + expectedYes := sdk.TokensFromConsensusPower(30) + expectedAbstain := sdk.TokensFromConsensusPower(0) + expectedNo := sdk.TokensFromConsensusPower(10) + expectedNoWithVeto := sdk.TokensFromConsensusPower(0) + expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto) + + require.True(t, tallyResults.Equals(expectedTallyResult)) +} diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index e93f6b387..f86871b55 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -1,436 +1,34 @@ -package keeper +package keeper_test import ( "testing" + abci "github.com/tendermint/tendermint/abci/types" + "github.com/stretchr/testify/require" - sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/x/gov/types" - "github.com/cosmos/cosmos-sdk/x/staking" ) func TestTallyNoOneVotes(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 5, 5}) + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + createValidators(ctx, app, []int64{5, 5, 5}) tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) proposalID := proposal.ProposalID proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) + app.GovKeeper.SetProposal(ctx, proposal) - proposal, ok := keeper.GetProposal(ctx, proposalID) + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) require.False(t, passes) require.True(t, burnDeposits) require.True(t, tallyResults.Equals(types.EmptyTallyResult())) } - -func TestTallyNoQuorum(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{2, 5, 0}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - err = keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionYes) - require.Nil(t, err) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, _ := keeper.Tally(ctx, proposal) - require.False(t, passes) - require.True(t, burnDeposits) -} - -func TestTallyOnlyValidatorsAllYes(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 5, 5}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyOnlyValidators51No(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 0}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, _ := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) -} - -func TestTallyOnlyValidators51Yes(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 0}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyOnlyValidatorsVetoed(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{6, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNoWithVeto)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.True(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) - -} - -func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{6, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{6, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyOnlyValidatorsNonVoter(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyDelgatorOverride(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(30) - val1, found := sk.GetValidator(ctx, valOpAddr1) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyDelgatorInherit(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(30) - val3, found := sk.GetValidator(ctx, valOpAddr3) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyDelgatorMultipleOverride(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(10) - val1, found := sk.GetValidator(ctx, valOpAddr1) - require.True(t, found) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true) - require.NoError(t, err) - _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyDelgatorMultipleInherit(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{25, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(10) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - val3, found := sk.GetValidator(ctx, valOpAddr3) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyJailedValidator(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{25, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(10) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - val3, found := sk.GetValidator(ctx, valOpAddr3) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - sk.Jail(ctx, sdk.ConsAddress(val2.GetConsPubKey().Address())) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - -func TestTallyValidatorMultipleDelegations(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{10, 10, 10}) - - delTokens := sdk.TokensFromConsensusPower(10) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - - _, err := sk.Delegate(ctx, valAccAddr1, delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - - expectedYes := sdk.TokensFromConsensusPower(30) - expectedAbstain := sdk.TokensFromConsensusPower(0) - expectedNo := sdk.TokensFromConsensusPower(10) - expectedNoWithVeto := sdk.TokensFromConsensusPower(0) - expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto) - - require.True(t, tallyResults.Equals(expectedTallyResult)) -} From e24734f72e313da7b560f40e5aba905aff3b4357 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:41:41 +0100 Subject: [PATCH 09/24] migrate TestTallyNoQuorum to use simapp --- x/gov/keeper/old_tally_test.go | 21 --------------------- x/gov/keeper/tally_test.go | 27 +++++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 21 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index e81e84874..2fe3b1f89 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,27 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyNoQuorum(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{2, 5, 0}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - err = keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionYes) - require.Nil(t, err) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, _ := keeper.Tally(ctx, proposal) - require.False(t, passes) - require.True(t, burnDeposits) -} - func TestTallyOnlyValidatorsAllYes(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{5, 5, 5}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index f86871b55..a72a3908e 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -3,6 +3,8 @@ package keeper_test import ( "testing" + sdk "github.com/cosmos/cosmos-sdk/types" + abci "github.com/tendermint/tendermint/abci/types" "github.com/stretchr/testify/require" @@ -32,3 +34,28 @@ func TestTallyNoOneVotes(t *testing.T) { require.True(t, burnDeposits) require.True(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyNoQuorum(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + createValidators(ctx, app, []int64{2, 5, 0}) + + addrs := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000000)) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + err = app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes) + require.Nil(t, err) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, _ := app.GovKeeper.Tally(ctx, proposal) + require.False(t, passes) + require.True(t, burnDeposits) +} From 88e3a22fc41288e6f9aec1610f3bf5a982881040 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:47:06 +0100 Subject: [PATCH 10/24] migrate TestTallyOnlyValidatorsAllYes to simapp --- x/gov/keeper/common_test.go | 4 +++- x/gov/keeper/old_tally_test.go | 24 ------------------------ x/gov/keeper/tally_test.go | 32 +++++++++++++++++++++++++++++--- 3 files changed, 32 insertions(+), 28 deletions(-) diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go index bf21f71c4..81b859973 100644 --- a/x/gov/keeper/common_test.go +++ b/x/gov/keeper/common_test.go @@ -23,7 +23,7 @@ func ProposalEqual(proposalA types.Proposal, proposalB types.Proposal) bool { types.ModuleCdc.MustMarshalBinaryBare(proposalB)) } -func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) { +func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress) { addrs := simapp.AddTestAddrsIncremental(app, ctx, 3, sdk.NewInt(10000000)) valAddrs := simapp.ConvertAddrsToValAddrs(addrs) pks := simapp.CreateTestPubKeys(3) @@ -56,4 +56,6 @@ func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) { _, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2]), sdk.Unbonded, val3, true) _ = staking.EndBlocker(ctx, app.StakingKeeper) + + return addrs, valAddrs } diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index 2fe3b1f89..05c043970 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,30 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyOnlyValidatorsAllYes(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 5, 5}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyOnlyValidators51No(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{5, 6, 0}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index a72a3908e..9f607df8d 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -3,13 +3,12 @@ package keeper_test import ( "testing" - sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" abci "github.com/tendermint/tendermint/abci/types" - "github.com/stretchr/testify/require" - "github.com/cosmos/cosmos-sdk/simapp" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/gov/types" ) @@ -59,3 +58,30 @@ func TestTallyNoQuorum(t *testing.T) { require.False(t, passes) require.True(t, burnDeposits) } + +func TestTallyOnlyValidatorsAllYes(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + addrs, _ := createValidators(ctx, app, []int64{5, 5, 5}) + valAccAddr1, valAccAddr2, valAccAddr3 := addrs[0], addrs[1], addrs[2] + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 1cf4a7e33048cd0d7350c493ed27e61d7681b972 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:50:39 +0100 Subject: [PATCH 11/24] migrate TestTallyOnlyValidators51No to use simapp --- x/gov/keeper/old_tally_test.go | 22 ---------------------- x/gov/keeper/tally_test.go | 33 ++++++++++++++++++++++++++++----- 2 files changed, 28 insertions(+), 27 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index 05c043970..6cfd0be78 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,28 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyOnlyValidators51No(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 0}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, _ := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) -} - func TestTallyOnlyValidators51Yes(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{5, 6, 0}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 9f607df8d..b29f13a1f 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -64,18 +64,17 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) { ctx := app.BaseApp.NewContext(false, abci.Header{}) addrs, _ := createValidators(ctx, app, []int64{5, 5, 5}) - valAccAddr1, valAccAddr2, valAccAddr3 := addrs[0], addrs[1], addrs[2] - tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) proposalID := proposal.ProposalID proposal.Status = types.StatusVotingPeriod app.GovKeeper.SetProposal(ctx, proposal) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[2], types.OptionYes)) proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) @@ -85,3 +84,27 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyOnlyValidators51No(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + valAccAddrs, _ := createValidators(ctx, app, []int64{5, 6, 0}) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[0], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[1], types.OptionNo)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, _ := app.GovKeeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) +} From 84b7fe5bfa30393613bcbe95e6a0ed00c4039f5f Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 16:53:06 +0100 Subject: [PATCH 12/24] migrate TestTallyOnlyValidators51Yes to use simapp --- x/gov/keeper/old_tally_test.go | 23 ----------------------- x/gov/keeper/tally_test.go | 26 ++++++++++++++++++++++++++ 2 files changed, 26 insertions(+), 23 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index 6cfd0be78..a30f9848f 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,29 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyOnlyValidators51Yes(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 0}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyOnlyValidatorsVetoed(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{6, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index b29f13a1f..eb5f7a962 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -108,3 +108,29 @@ func TestTallyOnlyValidators51No(t *testing.T) { require.False(t, passes) require.False(t, burnDeposits) } + +func TestTallyOnlyValidators51Yes(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + valAccAddrs, _ := createValidators(ctx, app, []int64{5, 6, 0}) + valAccAddr1, valAccAddr2 := valAccAddrs[0], valAccAddrs[1] + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From c3b18dfb2f544006b56101e83dffbe29a03d8a28 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 17:55:31 +0100 Subject: [PATCH 13/24] migrate TestTallyOnlyValidatorsVetoed test --- x/gov/keeper/old_tally_test.go | 25 ------------------------- x/gov/keeper/tally_test.go | 32 +++++++++++++++++++++++++++++--- 2 files changed, 29 insertions(+), 28 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index a30f9848f..79795c860 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,31 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyOnlyValidatorsVetoed(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{6, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNoWithVeto)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.True(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) - -} - func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{6, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index eb5f7a962..674d504ce 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -114,7 +114,6 @@ func TestTallyOnlyValidators51Yes(t *testing.T) { ctx := app.BaseApp.NewContext(false, abci.Header{}) valAccAddrs, _ := createValidators(ctx, app, []int64{5, 6, 0}) - valAccAddr1, valAccAddr2 := valAccAddrs[0], valAccAddrs[1] tp := TestProposal proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) @@ -123,8 +122,8 @@ func TestTallyOnlyValidators51Yes(t *testing.T) { proposal.Status = types.StatusVotingPeriod app.GovKeeper.SetProposal(ctx, proposal) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[0], types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[1], types.OptionYes)) proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) @@ -134,3 +133,30 @@ func TestTallyOnlyValidators51Yes(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyOnlyValidatorsVetoed(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7}) + valAccAddr1, valAccAddr2, valAccAddr3 := valAccAddrs[0], valAccAddrs[1], valAccAddrs[2] + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNoWithVeto)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.False(t, passes) + require.True(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From b83755fc1df09e865cfc228fc3cbf022d84a8bef Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 17:57:39 +0100 Subject: [PATCH 14/24] migrate TestTallyOnlyValidatorsAbstainPasses to simapp --- x/gov/keeper/old_tally_test.go | 24 ------------------------ x/gov/keeper/tally_test.go | 27 +++++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 24 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index 79795c860..16b2d4995 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,30 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{6, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{6, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 674d504ce..23c9f6b2b 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -160,3 +160,30 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) { require.True(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7}) + valAccAddr1, valAccAddr2, valAccAddr3 := valAccAddrs[0], valAccAddrs[1], valAccAddrs[2] + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 759181c2ccb85de91f34217855165e2ef3ef2a0d Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 17:59:24 +0100 Subject: [PATCH 15/24] migrate TestTallyOnlyValidatorsAbstainFails into simapp --- x/gov/keeper/old_tally_test.go | 24 --------------------- x/gov/keeper/tally_test.go | 39 ++++++++++++++++++++++++++++------ 2 files changed, 32 insertions(+), 31 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index 16b2d4995..e68f182a1 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,30 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{6, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyOnlyValidatorsNonVoter(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{5, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 23c9f6b2b..099659f22 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -139,7 +139,6 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) { ctx := app.BaseApp.NewContext(false, abci.Header{}) valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7}) - valAccAddr1, valAccAddr2, valAccAddr3 := valAccAddrs[0], valAccAddrs[1], valAccAddrs[2] tp := TestProposal proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) @@ -148,9 +147,9 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) { proposal.Status = types.StatusVotingPeriod app.GovKeeper.SetProposal(ctx, proposal) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNoWithVeto)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[0], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[1], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[2], types.OptionNoWithVeto)) proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) @@ -165,6 +164,32 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, abci.Header{}) + valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7}) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[0], types.OptionAbstain)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[1], types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[2], types.OptionYes)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} + +func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7}) valAccAddr1, valAccAddr2, valAccAddr3 := valAccAddrs[0], valAccAddrs[1], valAccAddrs[2] @@ -176,14 +201,14 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) { app.GovKeeper.SetProposal(ctx, proposal) require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) - require.True(t, passes) + require.False(t, passes) require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } From 46a70d58fab1ed5467d7761bccd80b26aa35ac4e Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 18:01:10 +0100 Subject: [PATCH 16/24] migrate TestTallyOnlyValidatorsNonVoter to simapp --- x/gov/keeper/old_tally_test.go | 23 ----------------------- x/gov/keeper/tally_test.go | 26 ++++++++++++++++++++++++++ 2 files changed, 26 insertions(+), 23 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index e68f182a1..ab324dfcb 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,29 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyOnlyValidatorsNonVoter(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyDelgatorOverride(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{5, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 099659f22..920f66c58 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -212,3 +212,29 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyOnlyValidatorsNonVoter(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + valAccAddrs, _ := createValidators(ctx, app, []int64{5, 6, 7}) + valAccAddr1, valAccAddr2 := valAccAddrs[0], valAccAddrs[1] + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 9f251885f1a5754b6048b24a0d773d5e76f77d55 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 18:08:40 +0100 Subject: [PATCH 17/24] migreate TestTallyDelgatorOverride to simapp --- x/gov/keeper/common_test.go | 4 +-- x/gov/keeper/old_tally_test.go | 34 ------------------------ x/gov/keeper/tally_test.go | 47 +++++++++++++++++++++++++++++++--- 3 files changed, 45 insertions(+), 40 deletions(-) diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go index 81b859973..379659612 100644 --- a/x/gov/keeper/common_test.go +++ b/x/gov/keeper/common_test.go @@ -24,9 +24,9 @@ func ProposalEqual(proposalA types.Proposal, proposalB types.Proposal) bool { } func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress) { - addrs := simapp.AddTestAddrsIncremental(app, ctx, 3, sdk.NewInt(10000000)) + addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.NewInt(30000000)) valAddrs := simapp.ConvertAddrsToValAddrs(addrs) - pks := simapp.CreateTestPubKeys(3) + pks := simapp.CreateTestPubKeys(5) appCodec := codec.NewAppCodec(app.Codec()) app.StakingKeeper = staking.NewKeeper( diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index ab324dfcb..f3b23eea6 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,40 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyDelgatorOverride(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(30) - val1, found := sk.GetValidator(ctx, valOpAddr1) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyDelgatorInherit(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{5, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 920f66c58..cee137b5b 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -3,6 +3,8 @@ package keeper_test import ( "testing" + "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/stretchr/testify/require" abci "github.com/tendermint/tendermint/abci/types" @@ -191,7 +193,6 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { ctx := app.BaseApp.NewContext(false, abci.Header{}) valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7}) - valAccAddr1, valAccAddr2, valAccAddr3 := valAccAddrs[0], valAccAddrs[1], valAccAddrs[2] tp := TestProposal proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) @@ -200,9 +201,9 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) { proposal.Status = types.StatusVotingPeriod app.GovKeeper.SetProposal(ctx, proposal) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionAbstain)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[0], types.OptionAbstain)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[1], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddrs[2], types.OptionNo)) proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) @@ -238,3 +239,41 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyDelgatorOverride(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + addrs, valAddrs := createValidators(ctx, app, []int64{5, 6, 7}) + valOpAddr1 := valAddrs[0] + valAccAddr1, valAccAddr2, valAccAddr3, valAccAddr4 := addrs[1], addrs[2], addrs[3], addrs[4] + + delTokens := sdk.TokensFromConsensusPower(30) + val1, found := app.StakingKeeper.GetValidator(ctx, valOpAddr1) + require.True(t, found) + + _, err := app.StakingKeeper.Delegate(ctx, valAccAddr4, delTokens, sdk.Unbonded, val1, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, app.StakingKeeper) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr4, types.OptionNo)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 73e1e3a354aba17b540277df082e2243b6b9f20f Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 18:49:14 +0100 Subject: [PATCH 18/24] refactor TestTallyDelgatorInherit to use simapp --- x/gov/keeper/old_tally_test.go | 33 ----------------------- x/gov/keeper/tally_test.go | 49 ++++++++++++++++++++++++++++------ 2 files changed, 41 insertions(+), 41 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index f3b23eea6..22ef47e8c 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,39 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyDelgatorInherit(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(30) - val3, found := sk.GetValidator(ctx, valOpAddr3) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyDelgatorMultipleOverride(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{5, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index cee137b5b..e7575d55f 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -245,14 +245,12 @@ func TestTallyDelgatorOverride(t *testing.T) { ctx := app.BaseApp.NewContext(false, abci.Header{}) addrs, valAddrs := createValidators(ctx, app, []int64{5, 6, 7}) - valOpAddr1 := valAddrs[0] - valAccAddr1, valAccAddr2, valAccAddr3, valAccAddr4 := addrs[1], addrs[2], addrs[3], addrs[4] delTokens := sdk.TokensFromConsensusPower(30) - val1, found := app.StakingKeeper.GetValidator(ctx, valOpAddr1) + val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0]) require.True(t, found) - _, err := app.StakingKeeper.Delegate(ctx, valAccAddr4, delTokens, sdk.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[4], delTokens, sdk.Unbonded, val1, true) require.NoError(t, err) _ = staking.EndBlocker(ctx, app.StakingKeeper) @@ -264,10 +262,10 @@ func TestTallyDelgatorOverride(t *testing.T) { proposal.Status = types.StatusVotingPeriod app.GovKeeper.SetProposal(ctx, proposal) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr4, types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[2], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[3], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[4], types.OptionNo)) proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) require.True(t, ok) @@ -277,3 +275,38 @@ func TestTallyDelgatorOverride(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyDelgatorInherit(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + addrs, vals := createValidators(ctx, app, []int64{5, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(30) + val3, found := app.StakingKeeper.GetValidator(ctx, vals[2]) + require.True(t, found) + + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, app.StakingKeeper) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[2], types.OptionYes)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 8d4d10d27f363a4f4a809fc8be28951925e985ed Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 18:52:45 +0100 Subject: [PATCH 19/24] refactor TestTallyDelgatorMultipleOverride to use simapp --- x/gov/keeper/old_tally_test.go | 38 -------------------------------- x/gov/keeper/tally_test.go | 40 ++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 38 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index 22ef47e8c..f7ce7c2f8 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,44 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyDelgatorMultipleOverride(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{5, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(10) - val1, found := sk.GetValidator(ctx, valOpAddr1) - require.True(t, found) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true) - require.NoError(t, err) - _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyDelgatorMultipleInherit(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{25, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index e7575d55f..69a5ca71c 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -310,3 +310,43 @@ func TestTallyDelgatorInherit(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyDelgatorMultipleOverride(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + addrs, vals := createValidators(ctx, app, []int64{5, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(10) + val1, found := app.StakingKeeper.GetValidator(ctx, vals[0]) + require.True(t, found) + val2, found := app.StakingKeeper.GetValidator(ctx, vals[1]) + require.True(t, found) + + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val1, true) + require.NoError(t, err) + _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, app.StakingKeeper) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[2], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[3], types.OptionNo)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 7d3430673ecdf7b57e81f5e01fb9b5b1cbd355bc Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 19:17:31 +0100 Subject: [PATCH 20/24] add tally test TestTallyDelgatorMultipleInherit --- x/gov/keeper/old_tally_test.go | 37 ------------------------------ x/gov/keeper/tally_test.go | 41 ++++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 37 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index f7ce7c2f8..b9ceb73b0 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -10,43 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyDelgatorMultipleInherit(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{25, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(10) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - val3, found := sk.GetValidator(ctx, valOpAddr3) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.False(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyJailedValidator(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{25, 6, 7}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 69a5ca71c..bc411019b 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -350,3 +350,44 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyDelgatorMultipleInherit(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + createValidators(ctx, app, []int64{25, 6, 7}) + + addrs, vals := createValidators(ctx, app, []int64{5, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(10) + val2, found := app.StakingKeeper.GetValidator(ctx, vals[1]) + require.True(t, found) + val3, found := app.StakingKeeper.GetValidator(ctx, vals[2]) + require.True(t, found) + + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, app.StakingKeeper) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[2], types.OptionNo)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.False(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 275b78f1c3d4e1dc95a71f1c202487c69bbd33e8 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 19:25:05 +0100 Subject: [PATCH 21/24] add TestTallyJailedValidator to simapp --- x/gov/keeper/old_tally_test.go | 40 --------------------------------- x/gov/keeper/tally_test.go | 41 ++++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 40 deletions(-) diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go index b9ceb73b0..9c08935e1 100644 --- a/x/gov/keeper/old_tally_test.go +++ b/x/gov/keeper/old_tally_test.go @@ -7,48 +7,8 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/gov/types" - "github.com/cosmos/cosmos-sdk/x/staking" ) -func TestTallyJailedValidator(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{25, 6, 7}) - - delTokens := sdk.TokensFromConsensusPower(10) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - val3, found := sk.GetValidator(ctx, valOpAddr3) - require.True(t, found) - - _, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - _, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true) - require.NoError(t, err) - - _ = staking.EndBlocker(ctx, sk) - - sk.Jail(ctx, sdk.ConsAddress(val2.GetConsPubKey().Address())) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionNo)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - require.False(t, tallyResults.Equals(types.EmptyTallyResult())) -} - func TestTallyValidatorMultipleDelegations(t *testing.T) { ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) createValidators(ctx, sk, []int64{10, 10, 10}) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index bc411019b..cab33140d 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -391,3 +391,44 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyJailedValidator(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + addrs, valAddrs := createValidators(ctx, app, []int64{25, 6, 7}) + + delTokens := sdk.TokensFromConsensusPower(10) + val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1]) + require.True(t, found) + val3, found := app.StakingKeeper.GetValidator(ctx, valAddrs[2]) + require.True(t, found) + + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true) + require.NoError(t, err) + + _ = staking.EndBlocker(ctx, app.StakingKeeper) + + app.StakingKeeper.Jail(ctx, sdk.ConsAddress(val2.GetConsPubKey().Address())) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[2], types.OptionNo)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + require.False(t, tallyResults.Equals(types.EmptyTallyResult())) +} From 894b2e58974fcdecb681d903582c2305f9e36d26 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 19:46:39 +0100 Subject: [PATCH 22/24] refactor old tally test --- x/gov/keeper/old_tally_test.go | 48 ---------------------------------- x/gov/keeper/tally_test.go | 40 ++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 48 deletions(-) delete mode 100644 x/gov/keeper/old_tally_test.go diff --git a/x/gov/keeper/old_tally_test.go b/x/gov/keeper/old_tally_test.go deleted file mode 100644 index 9c08935e1..000000000 --- a/x/gov/keeper/old_tally_test.go +++ /dev/null @@ -1,48 +0,0 @@ -package keeper - -import ( - "testing" - - "github.com/stretchr/testify/require" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/gov/types" -) - -func TestTallyValidatorMultipleDelegations(t *testing.T) { - ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100) - createValidators(ctx, sk, []int64{10, 10, 10}) - - delTokens := sdk.TokensFromConsensusPower(10) - val2, found := sk.GetValidator(ctx, valOpAddr2) - require.True(t, found) - - _, err := sk.Delegate(ctx, valAccAddr1, delTokens, sdk.Unbonded, val2, true) - require.NoError(t, err) - - tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) - require.NoError(t, err) - proposalID := proposal.ProposalID - proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) - - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo)) - require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr3, types.OptionYes)) - - proposal, ok := keeper.GetProposal(ctx, proposalID) - require.True(t, ok) - passes, burnDeposits, tallyResults := keeper.Tally(ctx, proposal) - - require.True(t, passes) - require.False(t, burnDeposits) - - expectedYes := sdk.TokensFromConsensusPower(30) - expectedAbstain := sdk.TokensFromConsensusPower(0) - expectedNo := sdk.TokensFromConsensusPower(10) - expectedNoWithVeto := sdk.TokensFromConsensusPower(0) - expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto) - - require.True(t, tallyResults.Equals(expectedTallyResult)) -} diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index cab33140d..3b7ff6958 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -432,3 +432,43 @@ func TestTallyJailedValidator(t *testing.T) { require.False(t, burnDeposits) require.False(t, tallyResults.Equals(types.EmptyTallyResult())) } + +func TestTallyValidatorMultipleDelegations(t *testing.T) { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + addrs, valAddrs := createValidators(ctx, app, []int64{10, 10, 10}) + + delTokens := sdk.TokensFromConsensusPower(10) + val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1]) + require.True(t, found) + + _, err := app.StakingKeeper.Delegate(ctx, addrs[0], delTokens, sdk.Unbonded, val2, true) + require.NoError(t, err) + + tp := TestProposal + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) + require.NoError(t, err) + proposalID := proposal.ProposalID + proposal.Status = types.StatusVotingPeriod + app.GovKeeper.SetProposal(ctx, proposal) + + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionNo)) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[2], types.OptionYes)) + + proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID) + require.True(t, ok) + passes, burnDeposits, tallyResults := app.GovKeeper.Tally(ctx, proposal) + + require.True(t, passes) + require.False(t, burnDeposits) + + expectedYes := sdk.TokensFromConsensusPower(30) + expectedAbstain := sdk.TokensFromConsensusPower(0) + expectedNo := sdk.TokensFromConsensusPower(10) + expectedNoWithVeto := sdk.TokensFromConsensusPower(0) + expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto) + + require.True(t, tallyResults.Equals(expectedTallyResult)) +} From e266c40ce12d45b851cb954e76761c78dbefe3ed Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 19:50:39 +0100 Subject: [PATCH 23/24] refactor vote test --- x/gov/keeper/vote_test.go | 49 ++++++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 21 deletions(-) diff --git a/x/gov/keeper/vote_test.go b/x/gov/keeper/vote_test.go index ae25c7fcc..8a87cdad6 100644 --- a/x/gov/keeper/vote_test.go +++ b/x/gov/keeper/vote_test.go @@ -1,64 +1,71 @@ -package keeper +package keeper_test import ( "testing" - "github.com/stretchr/testify/require" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/cosmos/cosmos-sdk/simapp" + abci "github.com/tendermint/tendermint/abci/types" "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/stretchr/testify/require" ) func TestVotes(t *testing.T) { - ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.NewInt(30000000)) tp := TestProposal - proposal, err := keeper.SubmitProposal(ctx, tp) + proposal, err := app.GovKeeper.SubmitProposal(ctx, tp) require.NoError(t, err) proposalID := proposal.ProposalID var invalidOption types.VoteOption = 0x10 - require.Error(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionYes), "proposal not on voting period") - require.Error(t, keeper.AddVote(ctx, 10, TestAddrs[0], types.OptionYes), "invalid proposal ID") + require.Error(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes), "proposal not on voting period") + require.Error(t, app.GovKeeper.AddVote(ctx, 10, addrs[0], types.OptionYes), "invalid proposal ID") proposal.Status = types.StatusVotingPeriod - keeper.SetProposal(ctx, proposal) + app.GovKeeper.SetProposal(ctx, proposal) - require.Error(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], invalidOption), "invalid option") + require.Error(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], invalidOption), "invalid option") // Test first vote - require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionAbstain)) - vote, found := keeper.GetVote(ctx, proposalID, TestAddrs[0]) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionAbstain)) + vote, found := app.GovKeeper.GetVote(ctx, proposalID, addrs[0]) require.True(t, found) - require.Equal(t, TestAddrs[0], vote.Voter) + require.Equal(t, addrs[0], vote.Voter) require.Equal(t, proposalID, vote.ProposalID) require.Equal(t, types.OptionAbstain, vote.Option) // Test change of vote - require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionYes)) - vote, found = keeper.GetVote(ctx, proposalID, TestAddrs[0]) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes)) + vote, found = app.GovKeeper.GetVote(ctx, proposalID, addrs[0]) require.True(t, found) - require.Equal(t, TestAddrs[0], vote.Voter) + require.Equal(t, addrs[0], vote.Voter) require.Equal(t, proposalID, vote.ProposalID) require.Equal(t, types.OptionYes, vote.Option) // Test second vote - require.NoError(t, keeper.AddVote(ctx, proposalID, TestAddrs[1], types.OptionNoWithVeto)) - vote, found = keeper.GetVote(ctx, proposalID, TestAddrs[1]) + require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, addrs[1], types.OptionNoWithVeto)) + vote, found = app.GovKeeper.GetVote(ctx, proposalID, addrs[1]) require.True(t, found) - require.Equal(t, TestAddrs[1], vote.Voter) + require.Equal(t, addrs[1], vote.Voter) require.Equal(t, proposalID, vote.ProposalID) require.Equal(t, types.OptionNoWithVeto, vote.Option) // Test vote iterator // NOTE order of deposits is determined by the addresses - votes := keeper.GetAllVotes(ctx) + votes := app.GovKeeper.GetAllVotes(ctx) require.Len(t, votes, 2) - require.Equal(t, votes, keeper.GetVotes(ctx, proposalID)) - require.Equal(t, TestAddrs[0], votes[0].Voter) + require.Equal(t, votes, app.GovKeeper.GetVotes(ctx, proposalID)) + require.Equal(t, addrs[0], votes[0].Voter) require.Equal(t, proposalID, votes[0].ProposalID) require.Equal(t, types.OptionYes, votes[0].Option) - require.Equal(t, TestAddrs[1], votes[1].Voter) + require.Equal(t, addrs[1], votes[1].Voter) require.Equal(t, proposalID, votes[1].ProposalID) require.Equal(t, types.OptionNoWithVeto, votes[1].Option) } From eba38af83d55da594cb89e3b02bb6f4bd02c96d9 Mon Sep 17 00:00:00 2001 From: Jonathan Gimeno Date: Mon, 2 Mar 2020 19:56:29 +0100 Subject: [PATCH 24/24] end of gov refactoring --- x/gov/abci_test.go | 7 +- x/gov/common_test.go | 15 ++- x/gov/genesis_test.go | 9 +- x/gov/keeper/old_test_common.go | 211 -------------------------------- 4 files changed, 19 insertions(+), 223 deletions(-) delete mode 100644 x/gov/keeper/old_test_common.go diff --git a/x/gov/abci_test.go b/x/gov/abci_test.go index 3e87d44e5..79db8f81a 100644 --- a/x/gov/abci_test.go +++ b/x/gov/abci_test.go @@ -10,7 +10,6 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/gov" - keep "github.com/cosmos/cosmos-sdk/x/gov/keeper" "github.com/cosmos/cosmos-sdk/x/staking" ) @@ -212,7 +211,7 @@ func TestTickPassedVotingPeriod(t *testing.T) { activeQueue.Close() proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5))} - newProposalMsg := gov.NewMsgSubmitProposal(keep.TestProposal, proposalCoins, addrs[0]) + newProposalMsg := gov.NewMsgSubmitProposal(TestProposal, proposalCoins, addrs[0]) res, err := govHandler(ctx, newProposalMsg) require.NoError(t, err) @@ -277,7 +276,7 @@ func TestProposalPassedEndblocker(t *testing.T) { require.NotNil(t, macc) initialModuleAccCoins := app.BankKeeper.GetAllBalances(ctx, macc.GetAddress()) - proposal, err := app.GovKeeper.SubmitProposal(ctx, keep.TestProposal) + proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal) require.NoError(t, err) proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10))} @@ -329,7 +328,7 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) { // Create a proposal where the handler will pass for the test proposal // because the value of contextKeyBadProposal is true. ctx = ctx.WithValue(contextKeyBadProposal, true) - proposal, err := app.GovKeeper.SubmitProposal(ctx, keep.TestProposal) + proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal) require.NoError(t, err) proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10))) diff --git a/x/gov/common_test.go b/x/gov/common_test.go index 79e927fd5..31d4dd168 100644 --- a/x/gov/common_test.go +++ b/x/gov/common_test.go @@ -11,12 +11,15 @@ import ( "github.com/tendermint/tendermint/crypto/ed25519" sdk "github.com/cosmos/cosmos-sdk/types" - keep "github.com/cosmos/cosmos-sdk/x/gov/keeper" + "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/staking" ) var ( - valTokens = sdk.TokensFromConsensusPower(42) + valTokens = sdk.TokensFromConsensusPower(42) + TestProposal = types.NewTextProposal("Test", "description") + TestDescription = staking.NewDescription("T", "E", "S", "T", "Z") + TestCommissionRates = staking.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()) ) // SortAddresses - Sorts Addresses @@ -83,7 +86,7 @@ func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context, valTokens := sdk.TokensFromConsensusPower(powerAmt[i]) valCreateMsg := staking.NewMsgCreateValidator( addrs[i], pubkeys[i], sdk.NewCoin(sdk.DefaultBondDenom, valTokens), - keep.TestDescription, keep.TestCommissionRates, sdk.OneInt(), + TestDescription, TestCommissionRates, sdk.OneInt(), ) res, err := stakingHandler(ctx, valCreateMsg) @@ -91,3 +94,9 @@ func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context, require.NotNil(t, res) } } + +// ProposalEqual checks if two proposals are equal (note: slow, for tests only) +func ProposalEqual(proposalA types.Proposal, proposalB types.Proposal) bool { + return bytes.Equal(types.ModuleCdc.MustMarshalBinaryBare(proposalA), + types.ModuleCdc.MustMarshalBinaryBare(proposalB)) +} diff --git a/x/gov/genesis_test.go b/x/gov/genesis_test.go index d9f8857b1..52ee0c0e1 100644 --- a/x/gov/genesis_test.go +++ b/x/gov/genesis_test.go @@ -12,7 +12,6 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/x/auth" "github.com/cosmos/cosmos-sdk/x/gov" - keep "github.com/cosmos/cosmos-sdk/x/gov/keeper" ) func TestImportExportQueues(t *testing.T) { @@ -28,7 +27,7 @@ func TestImportExportQueues(t *testing.T) { ctx = app.BaseApp.NewContext(false, abci.Header{}) // Create two proposals, put the second into the voting period - proposal := keep.TestProposal + proposal := TestProposal proposal1, err := app.GovKeeper.SubmitProposal(ctx, proposal) require.NoError(t, err) proposalID1 := proposal1.ProposalID @@ -116,7 +115,7 @@ func TestEqualProposals(t *testing.T) { app.BeginBlock(abci.RequestBeginBlock{Header: header}) // Submit two proposals - proposal := keep.TestProposal + proposal := TestProposal proposal1, err := app.GovKeeper.SubmitProposal(ctx, proposal) require.NoError(t, err) @@ -125,7 +124,7 @@ func TestEqualProposals(t *testing.T) { // They are similar but their IDs should be different require.NotEqual(t, proposal1, proposal2) - require.False(t, keep.ProposalEqual(proposal1, proposal2)) + require.False(t, ProposalEqual(proposal1, proposal2)) // Now create two genesis blocks state1 := gov.GenesisState{Proposals: []gov.Proposal{proposal1}} @@ -137,7 +136,7 @@ func TestEqualProposals(t *testing.T) { proposal1.ProposalID = 55 proposal2.ProposalID = 55 require.Equal(t, proposal1, proposal1) - require.True(t, keep.ProposalEqual(proposal1, proposal2)) + require.True(t, ProposalEqual(proposal1, proposal2)) // Reassign proposals into state state1.Proposals[0] = proposal1 diff --git a/x/gov/keeper/old_test_common.go b/x/gov/keeper/old_test_common.go deleted file mode 100644 index d8620b1a8..000000000 --- a/x/gov/keeper/old_test_common.go +++ /dev/null @@ -1,211 +0,0 @@ -package keeper - -// noalias -// nolint -// DONTCOVER - -import ( - "bytes" - "encoding/hex" - "testing" - - "github.com/stretchr/testify/require" - abci "github.com/tendermint/tendermint/abci/types" - "github.com/tendermint/tendermint/crypto" - "github.com/tendermint/tendermint/crypto/ed25519" - "github.com/tendermint/tendermint/libs/log" - tmtypes "github.com/tendermint/tendermint/types" - dbm "github.com/tendermint/tm-db" - - "github.com/cosmos/cosmos-sdk/codec" - simappcodec "github.com/cosmos/cosmos-sdk/simapp/codec" - "github.com/cosmos/cosmos-sdk/store" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/cosmos/cosmos-sdk/x/bank" - "github.com/cosmos/cosmos-sdk/x/gov/types" - "github.com/cosmos/cosmos-sdk/x/params/keeper" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" - "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/cosmos/cosmos-sdk/x/supply" -) - -// dummy addresses used for testing -var ( - delPk1 = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB51") - delPk2 = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB50") - delPk3 = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB52") - delAddr1 = sdk.AccAddress(delPk1.Address()) - delAddr2 = sdk.AccAddress(delPk2.Address()) - delAddr3 = sdk.AccAddress(delPk3.Address()) - - valOpPk1 = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB53") - valOpPk2 = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB54") - valOpPk3 = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB55") - valOpAddr1 = sdk.ValAddress(valOpPk1.Address()) - valOpAddr2 = sdk.ValAddress(valOpPk2.Address()) - valOpAddr3 = sdk.ValAddress(valOpPk3.Address()) - valAccAddr1 = sdk.AccAddress(valOpPk1.Address()) - valAccAddr2 = sdk.AccAddress(valOpPk2.Address()) - valAccAddr3 = sdk.AccAddress(valOpPk3.Address()) - - TestAddrs = []sdk.AccAddress{ - delAddr1, delAddr2, delAddr3, - valAccAddr1, valAccAddr2, valAccAddr3, - } - pubkeys = []crypto.PubKey{ - delPk1, delPk2, delPk3, valOpPk1, valOpPk2, valOpPk3, - } -) - -// TODO: remove dependency with staking -var ( - TestProposal = types.NewTextProposal("Test", "description") - TestDescription = staking.NewDescription("T", "E", "S", "T", "Z") - TestCommissionRates = staking.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()) -) - -// TODO move to common testing framework -func newPubKey(pk string) (res crypto.PubKey) { - pkBytes, err := hex.DecodeString(pk) - if err != nil { - panic(err) - } - var pkEd ed25519.PubKeyEd25519 - copy(pkEd[:], pkBytes) - return pkEd -} - -func makeTestCodec() *codec.Codec { - var cdc = codec.New() - auth.RegisterCodec(cdc) - types.RegisterCodec(cdc) - supply.RegisterCodec(cdc) - staking.RegisterCodec(cdc) - sdk.RegisterCodec(cdc) - codec.RegisterCrypto(cdc) - - return cdc -} - -func createTestInput( - t *testing.T, isCheckTx bool, initPower int64, -) (sdk.Context, auth.AccountKeeper, bank.Keeper, Keeper, staking.Keeper, types.SupplyKeeper, -) { - - initTokens := sdk.TokensFromConsensusPower(initPower) - keyAcc := sdk.NewKVStoreKey(auth.StoreKey) - keyBank := sdk.NewKVStoreKey(bank.StoreKey) - keyGov := sdk.NewKVStoreKey(types.StoreKey) - keyStaking := sdk.NewKVStoreKey(staking.StoreKey) - keySupply := sdk.NewKVStoreKey(supply.StoreKey) - keyParams := sdk.NewKVStoreKey(paramtypes.StoreKey) - tkeyParams := sdk.NewTransientStoreKey(paramtypes.TStoreKey) - - db := dbm.NewMemDB() - ms := store.NewCommitMultiStore(db) - - ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keyBank, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keyGov, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keyStaking, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) - require.Nil(t, ms.LoadLatestVersion()) - - ctx := sdk.NewContext(ms, abci.Header{ChainID: "gov-chain"}, isCheckTx, log.NewNopLogger()) - ctx = ctx.WithConsensusParams( - &abci.ConsensusParams{ - Validator: &abci.ValidatorParams{ - PubKeyTypes: []string{tmtypes.ABCIPubKeyTypeEd25519}, - }, - }, - ) - - cdc := makeTestCodec() - appCodec := simappcodec.NewAppCodec(cdc) - - maccPerms := map[string][]string{ - auth.FeeCollectorName: nil, - types.ModuleName: nil, - staking.NotBondedPoolName: {supply.Burner, supply.Staking}, - staking.BondedPoolName: {supply.Burner, supply.Staking}, - } - - // create module accounts - feeCollectorAcc := supply.NewEmptyModuleAccount(auth.FeeCollectorName) - govAcc := supply.NewEmptyModuleAccount(types.ModuleName, supply.Burner) - notBondedPool := supply.NewEmptyModuleAccount(staking.NotBondedPoolName, supply.Burner, supply.Staking) - bondPool := supply.NewEmptyModuleAccount(staking.BondedPoolName, supply.Burner, supply.Staking) - - blacklistedAddrs := make(map[string]bool) - blacklistedAddrs[feeCollectorAcc.GetAddress().String()] = true - blacklistedAddrs[govAcc.GetAddress().String()] = true - blacklistedAddrs[notBondedPool.GetAddress().String()] = true - blacklistedAddrs[bondPool.GetAddress().String()] = true - - pk := keeper.NewKeeper(appCodec, keyParams, tkeyParams) - accountKeeper := auth.NewAccountKeeper(appCodec, keyAcc, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount) - bankKeeper := bank.NewBaseKeeper(appCodec, keyBank, accountKeeper, pk.Subspace(bank.DefaultParamspace), blacklistedAddrs) - supplyKeeper := supply.NewKeeper(appCodec, keySupply, accountKeeper, bankKeeper, maccPerms) - - sk := staking.NewKeeper(staking.ModuleCdc, keyStaking, bankKeeper, supplyKeeper, pk.Subspace(staking.DefaultParamspace)) - sk.SetParams(ctx, staking.DefaultParams()) - - rtr := types.NewRouter(). - AddRoute(types.RouterKey, types.ProposalHandler) - - keeper := NewKeeper( - cdc, keyGov, pk.Subspace(types.DefaultParamspace).WithKeyTable(types.ParamKeyTable()), supplyKeeper, sk, rtr, - ) - - keeper.SetProposalID(ctx, types.DefaultStartingProposalID) - keeper.SetDepositParams(ctx, types.DefaultDepositParams()) - keeper.SetVotingParams(ctx, types.DefaultVotingParams()) - keeper.SetTallyParams(ctx, types.DefaultTallyParams()) - - initCoins := sdk.NewCoins(sdk.NewCoin(sk.BondDenom(ctx), initTokens)) - totalSupply := sdk.NewCoins(sdk.NewCoin(sk.BondDenom(ctx), initTokens.MulRaw(int64(len(TestAddrs))))) - supplyKeeper.SetSupply(ctx, supply.NewSupply(totalSupply)) - - for i, addr := range TestAddrs { - accountKeeper.SetAccount(ctx, auth.NewBaseAccount(addr, pubkeys[i], uint64(i), 0)) - require.NoError(t, bankKeeper.SetBalances(ctx, addr, initCoins)) - } - - keeper.supplyKeeper.SetModuleAccount(ctx, feeCollectorAcc) - keeper.supplyKeeper.SetModuleAccount(ctx, govAcc) - keeper.supplyKeeper.SetModuleAccount(ctx, bondPool) - keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) - - return ctx, accountKeeper, bankKeeper, keeper, sk, supplyKeeper -} - -// ProposalEqual checks if two proposals are equal (note: slow, for tests only) -func ProposalEqual(proposalA types.Proposal, proposalB types.Proposal) bool { - return bytes.Equal(types.ModuleCdc.MustMarshalBinaryBare(proposalA), - types.ModuleCdc.MustMarshalBinaryBare(proposalB)) -} - -func createValidators(ctx sdk.Context, sk staking.Keeper, powers []int64) { - val1 := staking.NewValidator(valOpAddr1, valOpPk1, staking.Description{}) - val2 := staking.NewValidator(valOpAddr2, valOpPk2, staking.Description{}) - val3 := staking.NewValidator(valOpAddr3, valOpPk3, staking.Description{}) - - sk.SetValidator(ctx, val1) - sk.SetValidator(ctx, val2) - sk.SetValidator(ctx, val3) - sk.SetValidatorByConsAddr(ctx, val1) - sk.SetValidatorByConsAddr(ctx, val2) - sk.SetValidatorByConsAddr(ctx, val3) - sk.SetNewValidatorByPowerIndex(ctx, val1) - sk.SetNewValidatorByPowerIndex(ctx, val2) - sk.SetNewValidatorByPowerIndex(ctx, val3) - - _, _ = sk.Delegate(ctx, valAccAddr1, sdk.TokensFromConsensusPower(powers[0]), sdk.Unbonded, val1, true) - _, _ = sk.Delegate(ctx, valAccAddr2, sdk.TokensFromConsensusPower(powers[1]), sdk.Unbonded, val2, true) - _, _ = sk.Delegate(ctx, valAccAddr3, sdk.TokensFromConsensusPower(powers[2]), sdk.Unbonded, val3, true) - - _ = staking.EndBlocker(ctx, sk) -}