certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge PR #5738: Migrate Gov module to Simapp

This commit is contained in:
Alexander Bezobchuk 2020-03-02 14:53:41 -05:00 committed by GitHub
parent 214cd2e648 c0fd5cbda0
commit e45feae647
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 430 additions and 500 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
x/gov/abci_test.go
View File

@ -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)))

15
x/gov/common_test.go
View File

@ -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))
}

9
x/gov/genesis_test.go
View File

@ -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

61
x/gov/keeper/common_test.go Normal file
View File

@ -0,0 +1,61 @@
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"
)
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))
}
func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress) {
addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.NewInt(30000000))
valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
pks := simapp.CreateTestPubKeys(5)
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)
return addrs, valAddrs
}

2
x/gov/keeper/deposit.go
View File

@ -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
}

60
x/gov/keeper/deposit_test.go
View File

@ -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]))
}

35
x/gov/keeper/keeper_test.go
View File

@ -1,51 +1,56 @@
package keeper
package keeper_test
import (
"testing"
"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 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
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
// create test proposals
tp := TestProposal
proposal, err := keeper.SubmitProposal(ctx, tp)
proposal, err := app.GovKeeper.SubmitProposal(ctx, tp)
require.NoError(t, err)
inactiveIterator := keeper.InactiveProposalQueueIterator(ctx, proposal.DepositEndTime)
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()
keeper.activateVotingPeriod(ctx, proposal)
app.GovKeeper.ActivateVotingPeriod(ctx, proposal)
proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID)
proposal, ok := app.GovKeeper.GetProposal(ctx, proposal.ProposalID)
require.True(t, ok)
activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime)
activeIterator := app.GovKeeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime)
require.True(t, activeIterator.Valid())
keeper.cdc.UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID)
app.Codec().UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID)
require.Equal(t, proposalID, proposal.ProposalID)
activeIterator.Close()
}

2
x/gov/keeper/proposal.go
View File

@ -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)

47
x/gov/keeper/proposal_test.go
View File

@ -1,4 +1,4 @@
package keeper
package keeper_test
import (
"errors"
@ -6,44 +6,50 @@ import (
"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"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/x/gov/types"
)
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
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)
require.True(t, proposal.VotingStartTime.Equal(time.Time{}))
keeper.activateVotingPeriod(ctx, proposal)
app.GovKeeper.ActivateVotingPeriod(ctx, proposal)
require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time))
proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID)
proposal, ok := app.GovKeeper.GetProposal(ctx, proposal.ProposalID)
require.True(t, ok)
activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime)
activeIterator := app.GovKeeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime)
require.True(t, activeIterator.Valid())
proposalID := types.GetProposalIDFromBytes(activeIterator.Value())
@ -97,9 +103,10 @@ func registerTestCodec(cdc *codec.Codec) {
}
func TestSubmitProposal(t *testing.T) {
ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
registerTestCodec(keeper.cdc)
registerTestCodec(app.Codec())
testCases := []struct {
content types.Content
@ -118,14 +125,16 @@ func TestSubmitProposal(t *testing.T) {
}
for i, tc := range testCases {
_, err := keeper.SubmitProposal(ctx, tc.content)
_, 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)
ctx, _, _, keeper, _, _ := createTestInput(t, false, 100) // nolint: dogsled
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
status := []types.ProposalStatus{types.StatusDepositPeriod, types.StatusVotingPeriod}
addr1 := sdk.AccAddress("foo")
@ -138,11 +147,11 @@ func TestGetProposalsFiltered(t *testing.T) {
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)
app.GovKeeper.SetDeposit(ctx, d)
app.GovKeeper.SetVote(ctx, v)
}
keeper.SetProposal(ctx, p)
app.GovKeeper.SetProposal(ctx, p)
proposalID++
}
}
@ -166,7 +175,7 @@ func TestGetProposalsFiltered(t *testing.T) {
}
for _, tc := range testCases {
proposals := keeper.GetProposalsFiltered(ctx, tc.params)
proposals := app.GovKeeper.GetProposalsFiltered(ctx, tc.params)
require.Len(t, proposals, tc.expectedNumResults)
for _, p := range proposals {

82
x/gov/keeper/querier_test.go
View File

@ -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])

350
x/gov/keeper/tally_test.go
View File

@ -1,29 +1,35 @@
package keeper
package keeper_test
import (
"testing"
"github.com/cosmos/cosmos-sdk/x/staking"
"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"
"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)
@ -31,44 +37,50 @@ func TestTallyNoOneVotes(t *testing.T) {
}
func TestTallyNoQuorum(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{2, 5, 0})
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 := 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)
err = keeper.AddVote(ctx, proposalID, TestAddrs[0], types.OptionYes)
err = app.GovKeeper.AddVote(ctx, proposalID, addrs[0], types.OptionYes)
require.Nil(t, err)
proposal, ok := keeper.GetProposal(ctx, proposalID)
proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID)
require.True(t, ok)
passes, burnDeposits, _ := keeper.Tally(ctx, proposal)
passes, burnDeposits, _ := app.GovKeeper.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})
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
addrs, _ := 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)
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, 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 := 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.True(t, passes)
require.False(t, burnDeposits)
@ -76,44 +88,48 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) {
}
func TestTallyOnlyValidators51No(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{5, 6, 0})
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
valAccAddrs, _ := createValidators(ctx, app, []int64{5, 6, 0})
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)
require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes))
require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo))
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 := keeper.GetProposal(ctx, proposalID)
proposal, ok := app.GovKeeper.GetProposal(ctx, proposalID)
require.True(t, ok)
passes, burnDeposits, _ := keeper.Tally(ctx, proposal)
passes, burnDeposits, _ := app.GovKeeper.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})
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
valAccAddrs, _ := createValidators(ctx, app, []int64{5, 6, 0})
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)
require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionNo))
require.NoError(t, keeper.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 := 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.True(t, passes)
require.False(t, burnDeposits)
@ -121,48 +137,51 @@ func TestTallyOnlyValidators51Yes(t *testing.T) {
}
func TestTallyOnlyValidatorsVetoed(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{6, 6, 7})
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7})
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)
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))
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 := 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.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})
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7})
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)
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))
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 := 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.True(t, passes)
require.False(t, burnDeposits)
@ -170,23 +189,25 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
}
func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{6, 6, 7})
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
valAccAddrs, _ := createValidators(ctx, app, []int64{6, 6, 7})
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)
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))
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 := 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.False(t, burnDeposits)
@ -194,22 +215,25 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
}
func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{5, 6, 7})
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 := 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)
require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes))
require.NoError(t, keeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo))
require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr1, types.OptionYes))
require.NoError(t, app.GovKeeper.AddVote(ctx, proposalID, valAccAddr2, types.OptionNo))
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.False(t, burnDeposits)
@ -217,33 +241,35 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
}
func TestTallyDelgatorOverride(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{5, 6, 7})
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
addrs, valAddrs := createValidators(ctx, app, []int64{5, 6, 7})
delTokens := sdk.TokensFromConsensusPower(30)
val1, found := sk.GetValidator(ctx, valOpAddr1)
val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0])
require.True(t, found)
_, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true)
_, err := app.StakingKeeper.Delegate(ctx, addrs[4], delTokens, sdk.Unbonded, val1, true)
require.NoError(t, err)
_ = staking.EndBlocker(ctx, sk)
_ = staking.EndBlocker(ctx, app.StakingKeeper)
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)
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))
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 := 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.False(t, burnDeposits)
@ -251,32 +277,34 @@ func TestTallyDelgatorOverride(t *testing.T) {
}
func TestTallyDelgatorInherit(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{5, 6, 7})
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 := sk.GetValidator(ctx, valOpAddr3)
val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
require.True(t, found)
_, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true)
_, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true)
require.NoError(t, err)
_ = staking.EndBlocker(ctx, sk)
_ = staking.EndBlocker(ctx, app.StakingKeeper)
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)
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))
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 := 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.True(t, passes)
require.False(t, burnDeposits)
@ -284,37 +312,39 @@ func TestTallyDelgatorInherit(t *testing.T) {
}
func TestTallyDelgatorMultipleOverride(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{5, 6, 7})
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 := sk.GetValidator(ctx, valOpAddr1)
val1, found := app.StakingKeeper.GetValidator(ctx, vals[0])
require.True(t, found)
val2, found := sk.GetValidator(ctx, valOpAddr2)
val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
require.True(t, found)
_, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val1, true)
_, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val1, true)
require.NoError(t, err)
_, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true)
_, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true)
require.NoError(t, err)
_ = staking.EndBlocker(ctx, sk)
_ = staking.EndBlocker(ctx, app.StakingKeeper)
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)
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))
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 := 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.False(t, burnDeposits)
@ -322,36 +352,40 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
}
func TestTallyDelgatorMultipleInherit(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{25, 6, 7})
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 := sk.GetValidator(ctx, valOpAddr2)
val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
require.True(t, found)
val3, found := sk.GetValidator(ctx, valOpAddr3)
val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
require.True(t, found)
_, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true)
_, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true)
require.NoError(t, err)
_, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true)
_, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true)
require.NoError(t, err)
_ = staking.EndBlocker(ctx, sk)
_ = staking.EndBlocker(ctx, app.StakingKeeper)
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)
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))
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 := 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.False(t, burnDeposits)
@ -359,38 +393,40 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
}
func TestTallyJailedValidator(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{25, 6, 7})
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 := sk.GetValidator(ctx, valOpAddr2)
val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
require.True(t, found)
val3, found := sk.GetValidator(ctx, valOpAddr3)
val3, found := app.StakingKeeper.GetValidator(ctx, valAddrs[2])
require.True(t, found)
_, err := sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val2, true)
_, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true)
require.NoError(t, err)
_, err = sk.Delegate(ctx, TestAddrs[0], delTokens, sdk.Unbonded, val3, true)
_, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true)
require.NoError(t, err)
_ = staking.EndBlocker(ctx, sk)
_ = staking.EndBlocker(ctx, app.StakingKeeper)
sk.Jail(ctx, sdk.ConsAddress(val2.GetConsPubKey().Address()))
app.StakingKeeper.Jail(ctx, sdk.ConsAddress(val2.GetConsPubKey().Address()))
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)
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))
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 := 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.True(t, passes)
require.False(t, burnDeposits)
@ -398,30 +434,32 @@ func TestTallyJailedValidator(t *testing.T) {
}
func TestTallyValidatorMultipleDelegations(t *testing.T) {
ctx, _, _, keeper, sk, _ := createTestInput(t, false, 100)
createValidators(ctx, sk, []int64{10, 10, 10})
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 := sk.GetValidator(ctx, valOpAddr2)
val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
require.True(t, found)
_, err := sk.Delegate(ctx, valAccAddr1, delTokens, sdk.Unbonded, val2, true)
_, err := app.StakingKeeper.Delegate(ctx, addrs[0], delTokens, sdk.Unbonded, val2, true)
require.NoError(t, err)
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)
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))
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 := 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.True(t, passes)
require.False(t, burnDeposits)

211
x/gov/keeper/test_common.go
View File

@ -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)
}

49
x/gov/keeper/vote_test.go
View File

@ -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)
}