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

bring back old keeper_test

This commit is contained in:
rigelrozanski 2018-05-10 19:20:16 -04:00
parent ee9fe541f4
commit 0ad2cc0dc7
1 changed files with 315 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

589
x/stake/keeper_test.go
View File

@ -23,128 +23,128 @@ var (
} }
) )
// This function tests GetValidator, GetValidators, setValidator, removeValidator // This function tests GetCandidate, GetCandidates, setCandidate, removeCandidate
func TestValidator(t *testing.T) { func TestCandidate(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0) ctx, _, keeper := createTestInput(t, false, 0)
//construct the validators //construct the candidates
var validators [3]Validator var candidates [3]Candidate
amts := []int64{9, 8, 7} amts := []int64{9, 8, 7}
for i, amt := range amts { for i, amt := range amts {
validators[i] = NewValidator(addrVals[i], pks[i], Description{}) candidates[i] = NewCandidate(addrVals[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt) candidates[i].BondedShares = sdk.NewRat(amt)
validators[i].DelegatorShares = sdk.NewRat(amt) candidates[i].DelegatorShares = sdk.NewRat(amt)
} }
// check the empty keeper first // check the empty keeper first
_, found := keeper.GetValidator(ctx, addrVals[0]) _, found := keeper.GetCandidate(ctx, addrVals[0])
assert.False(t, found) assert.False(t, found)
resCands := keeper.GetValidators(ctx, 100) resCands := keeper.GetCandidates(ctx, 100)
assert.Zero(t, len(resCands)) assert.Zero(t, len(resCands))
// set and retrieve a record // set and retrieve a record
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
resCand, found := keeper.GetValidator(ctx, addrVals[0]) resCand, found := keeper.GetCandidate(ctx, addrVals[0])
require.True(t, found) require.True(t, found)
assert.True(t, validators[0].equal(resCand), "%v \n %v", resCand, validators[0]) assert.True(t, candidates[0].equal(resCand), "%v \n %v", resCand, candidates[0])
// modify a records, save, and retrieve // modify a records, save, and retrieve
validators[0].DelegatorShares = sdk.NewRat(99) candidates[0].DelegatorShares = sdk.NewRat(99)
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
resCand, found = keeper.GetValidator(ctx, addrVals[0]) resCand, found = keeper.GetCandidate(ctx, addrVals[0])
require.True(t, found) require.True(t, found)
assert.True(t, validators[0].equal(resCand)) assert.True(t, candidates[0].equal(resCand))
// also test that the address has been added to address list // also test that the address has been added to address list
resCands = keeper.GetValidators(ctx, 100) resCands = keeper.GetCandidates(ctx, 100)
require.Equal(t, 1, len(resCands)) require.Equal(t, 1, len(resCands))
assert.Equal(t, addrVals[0], resCands[0].Address) assert.Equal(t, addrVals[0], resCands[0].Address)
// add other validators // add other candidates
keeper.setValidator(ctx, validators[1]) keeper.setCandidate(ctx, candidates[1])
keeper.setValidator(ctx, validators[2]) keeper.setCandidate(ctx, candidates[2])
resCand, found = keeper.GetValidator(ctx, addrVals[1]) resCand, found = keeper.GetCandidate(ctx, addrVals[1])
require.True(t, found) require.True(t, found)
assert.True(t, validators[1].equal(resCand), "%v \n %v", resCand, validators[1]) assert.True(t, candidates[1].equal(resCand), "%v \n %v", resCand, candidates[1])
resCand, found = keeper.GetValidator(ctx, addrVals[2]) resCand, found = keeper.GetCandidate(ctx, addrVals[2])
require.True(t, found) require.True(t, found)
assert.True(t, validators[2].equal(resCand), "%v \n %v", resCand, validators[2]) assert.True(t, candidates[2].equal(resCand), "%v \n %v", resCand, candidates[2])
resCands = keeper.GetValidators(ctx, 100) resCands = keeper.GetCandidates(ctx, 100)
require.Equal(t, 3, len(resCands)) require.Equal(t, 3, len(resCands))
assert.True(t, validators[0].equal(resCands[0]), "%v \n %v", resCands[0], validators[0]) assert.True(t, candidates[0].equal(resCands[0]), "%v \n %v", resCands[0], candidates[0])
assert.True(t, validators[1].equal(resCands[1]), "%v \n %v", resCands[1], validators[1]) assert.True(t, candidates[1].equal(resCands[1]), "%v \n %v", resCands[1], candidates[1])
assert.True(t, validators[2].equal(resCands[2]), "%v \n %v", resCands[2], validators[2]) assert.True(t, candidates[2].equal(resCands[2]), "%v \n %v", resCands[2], candidates[2])
// remove a record // remove a record
keeper.removeValidator(ctx, validators[1].Address) keeper.removeCandidate(ctx, candidates[1].Address)
_, found = keeper.GetValidator(ctx, addrVals[1]) _, found = keeper.GetCandidate(ctx, addrVals[1])
assert.False(t, found) assert.False(t, found)
} }
// tests GetDelegation, GetDelegations, SetDelegation, removeDelegation, GetBonds // tests GetDelegatorBond, GetDelegatorBonds, SetDelegatorBond, removeDelegatorBond, GetBonds
func TestBond(t *testing.T) { func TestBond(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0) ctx, _, keeper := createTestInput(t, false, 0)
//construct the validators //construct the candidates
amts := []int64{9, 8, 7} amts := []int64{9, 8, 7}
var validators [3]Validator var candidates [3]Candidate
for i, amt := range amts { for i, amt := range amts {
validators[i] = NewValidator(addrVals[i], pks[i], Description{}) candidates[i] = NewCandidate(addrVals[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt) candidates[i].BondedShares = sdk.NewRat(amt)
validators[i].DelegatorShares = sdk.NewRat(amt) candidates[i].DelegatorShares = sdk.NewRat(amt)
} }
// first add a validators[0] to delegate too // first add a candidates[0] to delegate too
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
bond1to1 := Delegation{ bond1to1 := DelegatorBond{
DelegatorAddr: addrDels[0], DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0], CandidateAddr: addrVals[0],
Shares: sdk.NewRat(9), Shares: sdk.NewRat(9),
} }
// check the empty keeper first // check the empty keeper first
_, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0]) _, found := keeper.GetDelegatorBond(ctx, addrDels[0], addrVals[0])
assert.False(t, found) assert.False(t, found)
// set and retrieve a record // set and retrieve a record
keeper.setDelegation(ctx, bond1to1) keeper.setDelegatorBond(ctx, bond1to1)
resBond, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0]) resBond, found := keeper.GetDelegatorBond(ctx, addrDels[0], addrVals[0])
assert.True(t, found) assert.True(t, found)
assert.True(t, bond1to1.equal(resBond)) assert.True(t, bond1to1.equal(resBond))
// modify a records, save, and retrieve // modify a records, save, and retrieve
bond1to1.Shares = sdk.NewRat(99) bond1to1.Shares = sdk.NewRat(99)
keeper.setDelegation(ctx, bond1to1) keeper.setDelegatorBond(ctx, bond1to1)
resBond, found = keeper.GetDelegation(ctx, addrDels[0], addrVals[0]) resBond, found = keeper.GetDelegatorBond(ctx, addrDels[0], addrVals[0])
assert.True(t, found) assert.True(t, found)
assert.True(t, bond1to1.equal(resBond)) assert.True(t, bond1to1.equal(resBond))
// add some more records // add some more records
keeper.setValidator(ctx, validators[1]) keeper.setCandidate(ctx, candidates[1])
keeper.setValidator(ctx, validators[2]) keeper.setCandidate(ctx, candidates[2])
bond1to2 := Delegation{addrDels[0], addrVals[1], sdk.NewRat(9), 0} bond1to2 := DelegatorBond{addrDels[0], addrVals[1], sdk.NewRat(9), 0}
bond1to3 := Delegation{addrDels[0], addrVals[2], sdk.NewRat(9), 1} bond1to3 := DelegatorBond{addrDels[0], addrVals[2], sdk.NewRat(9), 1}
bond2to1 := Delegation{addrDels[1], addrVals[0], sdk.NewRat(9), 2} bond2to1 := DelegatorBond{addrDels[1], addrVals[0], sdk.NewRat(9), 2}
bond2to2 := Delegation{addrDels[1], addrVals[1], sdk.NewRat(9), 3} bond2to2 := DelegatorBond{addrDels[1], addrVals[1], sdk.NewRat(9), 3}
bond2to3 := Delegation{addrDels[1], addrVals[2], sdk.NewRat(9), 4} bond2to3 := DelegatorBond{addrDels[1], addrVals[2], sdk.NewRat(9), 4}
keeper.setDelegation(ctx, bond1to2) keeper.setDelegatorBond(ctx, bond1to2)
keeper.setDelegation(ctx, bond1to3) keeper.setDelegatorBond(ctx, bond1to3)
keeper.setDelegation(ctx, bond2to1) keeper.setDelegatorBond(ctx, bond2to1)
keeper.setDelegation(ctx, bond2to2) keeper.setDelegatorBond(ctx, bond2to2)
keeper.setDelegation(ctx, bond2to3) keeper.setDelegatorBond(ctx, bond2to3)
// test all bond retrieve capabilities // test all bond retrieve capabilities
resBonds := keeper.GetDelegations(ctx, addrDels[0], 5) resBonds := keeper.GetDelegatorBonds(ctx, addrDels[0], 5)
require.Equal(t, 3, len(resBonds)) require.Equal(t, 3, len(resBonds))
assert.True(t, bond1to1.equal(resBonds[0])) assert.True(t, bond1to1.equal(resBonds[0]))
assert.True(t, bond1to2.equal(resBonds[1])) assert.True(t, bond1to2.equal(resBonds[1]))
assert.True(t, bond1to3.equal(resBonds[2])) assert.True(t, bond1to3.equal(resBonds[2]))
resBonds = keeper.GetDelegations(ctx, addrDels[0], 3) resBonds = keeper.GetDelegatorBonds(ctx, addrDels[0], 3)
require.Equal(t, 3, len(resBonds)) require.Equal(t, 3, len(resBonds))
resBonds = keeper.GetDelegations(ctx, addrDels[0], 2) resBonds = keeper.GetDelegatorBonds(ctx, addrDels[0], 2)
require.Equal(t, 2, len(resBonds)) require.Equal(t, 2, len(resBonds))
resBonds = keeper.GetDelegations(ctx, addrDels[1], 5) resBonds = keeper.GetDelegatorBonds(ctx, addrDels[1], 5)
require.Equal(t, 3, len(resBonds)) require.Equal(t, 3, len(resBonds))
assert.True(t, bond2to1.equal(resBonds[0])) assert.True(t, bond2to1.equal(resBonds[0]))
assert.True(t, bond2to2.equal(resBonds[1])) assert.True(t, bond2to2.equal(resBonds[1]))
@ -159,76 +159,76 @@ func TestBond(t *testing.T) {
assert.True(t, bond2to3.equal(allBonds[5])) assert.True(t, bond2to3.equal(allBonds[5]))
// delete a record // delete a record
keeper.removeDelegation(ctx, bond2to3) keeper.removeDelegatorBond(ctx, bond2to3)
_, found = keeper.GetDelegation(ctx, addrDels[1], addrVals[2]) _, found = keeper.GetDelegatorBond(ctx, addrDels[1], addrVals[2])
assert.False(t, found) assert.False(t, found)
resBonds = keeper.GetDelegations(ctx, addrDels[1], 5) resBonds = keeper.GetDelegatorBonds(ctx, addrDels[1], 5)
require.Equal(t, 2, len(resBonds)) require.Equal(t, 2, len(resBonds))
assert.True(t, bond2to1.equal(resBonds[0])) assert.True(t, bond2to1.equal(resBonds[0]))
assert.True(t, bond2to2.equal(resBonds[1])) assert.True(t, bond2to2.equal(resBonds[1]))
// delete all the records from delegator 2 // delete all the records from delegator 2
keeper.removeDelegation(ctx, bond2to1) keeper.removeDelegatorBond(ctx, bond2to1)
keeper.removeDelegation(ctx, bond2to2) keeper.removeDelegatorBond(ctx, bond2to2)
_, found = keeper.GetDelegation(ctx, addrDels[1], addrVals[0]) _, found = keeper.GetDelegatorBond(ctx, addrDels[1], addrVals[0])
assert.False(t, found) assert.False(t, found)
_, found = keeper.GetDelegation(ctx, addrDels[1], addrVals[1]) _, found = keeper.GetDelegatorBond(ctx, addrDels[1], addrVals[1])
assert.False(t, found) assert.False(t, found)
resBonds = keeper.GetDelegations(ctx, addrDels[1], 5) resBonds = keeper.GetDelegatorBonds(ctx, addrDels[1], 5)
require.Equal(t, 0, len(resBonds)) require.Equal(t, 0, len(resBonds))
} }
// TODO seperate out into multiple tests // TODO seperate out into multiple tests
func TestGetValidatorsBonded(t *testing.T) { func TestGetValidators(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0) ctx, _, keeper := createTestInput(t, false, 0)
// initialize some validators into the state // initialize some candidates into the state
amts := []int64{0, 100, 1, 400, 200} amts := []int64{0, 100, 1, 400, 200}
n := len(amts) n := len(amts)
var validators [5]Validator var candidates [5]Candidate
for i, amt := range amts { for i, amt := range amts {
validators[i] = NewValidator(addrs[i], pks[i], Description{}) candidates[i] = NewCandidate(addrs[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt) candidates[i].BondedShares = sdk.NewRat(amt)
validators[i].DelegatorShares = sdk.NewRat(amt) candidates[i].DelegatorShares = sdk.NewRat(amt)
keeper.setValidator(ctx, validators[i]) keeper.setCandidate(ctx, candidates[i])
} }
// first make sure everything made it in to the validator group // first make sure everything made it in to the validator group
validators := keeper.GetValidatorsBondedByPower(ctx) validators := keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
assert.Equal(t, sdk.NewRat(400), validators[0].Power, "%v", validators) assert.Equal(t, sdk.NewRat(400), validators[0].Power, "%v", validators)
assert.Equal(t, sdk.NewRat(200), validators[1].Power, "%v", validators) assert.Equal(t, sdk.NewRat(200), validators[1].Power, "%v", validators)
assert.Equal(t, sdk.NewRat(100), validators[2].Power, "%v", validators) assert.Equal(t, sdk.NewRat(100), validators[2].Power, "%v", validators)
assert.Equal(t, sdk.NewRat(1), validators[3].Power, "%v", validators) assert.Equal(t, sdk.NewRat(1), validators[3].Power, "%v", validators)
assert.Equal(t, sdk.NewRat(0), validators[4].Power, "%v", validators) assert.Equal(t, sdk.NewRat(0), validators[4].Power, "%v", validators)
assert.Equal(t, validators[3].Address, validators[0].Address, "%v", validators) assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators)
assert.Equal(t, validators[4].Address, validators[1].Address, "%v", validators) assert.Equal(t, candidates[4].Address, validators[1].Address, "%v", validators)
assert.Equal(t, validators[1].Address, validators[2].Address, "%v", validators) assert.Equal(t, candidates[1].Address, validators[2].Address, "%v", validators)
assert.Equal(t, validators[2].Address, validators[3].Address, "%v", validators) assert.Equal(t, candidates[2].Address, validators[3].Address, "%v", validators)
assert.Equal(t, validators[0].Address, validators[4].Address, "%v", validators) assert.Equal(t, candidates[0].Address, validators[4].Address, "%v", validators)
// test a basic increase in voting power // test a basic increase in voting power
validators[3].BondedShares = sdk.NewRat(500) candidates[3].BondedShares = sdk.NewRat(500)
keeper.setValidator(ctx, validators[3]) keeper.setCandidate(ctx, candidates[3])
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
assert.Equal(t, sdk.NewRat(500), validators[0].Power, "%v", validators) assert.Equal(t, sdk.NewRat(500), validators[0].Power, "%v", validators)
assert.Equal(t, validators[3].Address, validators[0].Address, "%v", validators) assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators)
// test a decrease in voting power // test a decrease in voting power
validators[3].BondedShares = sdk.NewRat(300) candidates[3].BondedShares = sdk.NewRat(300)
keeper.setValidator(ctx, validators[3]) keeper.setCandidate(ctx, candidates[3])
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
assert.Equal(t, sdk.NewRat(300), validators[0].Power, "%v", validators) assert.Equal(t, sdk.NewRat(300), validators[0].Power, "%v", validators)
assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators) assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators)
assert.Equal(t, candidates[4].Address, validators[1].Address, "%v", validators) assert.Equal(t, candidates[4].Address, validators[1].Address, "%v", validators)
// test equal voting power, different age // test equal voting power, different age
validators[3].BondedShares = sdk.NewRat(200) candidates[3].BondedShares = sdk.NewRat(200)
ctx = ctx.WithBlockHeight(10) ctx = ctx.WithBlockHeight(10)
keeper.setValidator(ctx, validators[3]) keeper.setCandidate(ctx, candidates[3])
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
assert.Equal(t, sdk.NewRat(200), validators[0].Power, "%v", validators) assert.Equal(t, sdk.NewRat(200), validators[0].Power, "%v", validators)
assert.Equal(t, sdk.NewRat(200), validators[1].Power, "%v", validators) assert.Equal(t, sdk.NewRat(200), validators[1].Power, "%v", validators)
@ -239,8 +239,8 @@ func TestGetValidatorsBonded(t *testing.T) {
// no change in voting power - no change in sort // no change in voting power - no change in sort
ctx = ctx.WithBlockHeight(20) ctx = ctx.WithBlockHeight(20)
keeper.setValidator(ctx, validators[4]) keeper.setCandidate(ctx, candidates[4])
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators) assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators)
assert.Equal(t, candidates[4].Address, validators[1].Address, "%v", validators) assert.Equal(t, candidates[4].Address, validators[1].Address, "%v", validators)
@ -252,8 +252,8 @@ func TestGetValidatorsBonded(t *testing.T) {
validators = keeper.getValidatorsOrdered(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
ctx = ctx.WithBlockHeight(30) ctx = ctx.WithBlockHeight(30)
keeper.setValidator(ctx, validators[4]) keeper.setCandidate(ctx, candidates[4])
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n, "%v", validators) require.Equal(t, len(validators), n, "%v", validators)
assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators) assert.Equal(t, candidates[3].Address, validators[0].Address, "%v", validators)
assert.Equal(t, candidates[4].Address, validators[1].Address, "%v", validators) assert.Equal(t, candidates[4].Address, validators[1].Address, "%v", validators)
@ -271,17 +271,17 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
// initialize some candidates into the state // initialize some candidates into the state
amts := []int64{0, 100, 400, 400, 200} amts := []int64{0, 100, 400, 400, 200}
n := len(amts) n := len(amts)
var validators [5]Validator var candidates [5]Candidate
for i, amt := range amts { for i, amt := range amts {
validators[i] = NewValidator(addrs[i], pks[i], Description{}) candidates[i] = NewCandidate(addrs[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt) candidates[i].BondedShares = sdk.NewRat(amt)
validators[i].DelegatorShares = sdk.NewRat(amt) candidates[i].DelegatorShares = sdk.NewRat(amt)
keeper.setValidator(ctx, validators[i]) keeper.setCandidate(ctx, candidates[i])
} }
validators[0].BondedShares = sdk.NewRat(500) candidates[0].BondedShares = sdk.NewRat(500)
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
validators := keeper.GetValidatorsBondedByPower(ctx) validators := keeper.getValidatorsOrdered(ctx)
require.Equal(t, uint16(len(validators)), params.MaxValidators) require.Equal(t, uint16(len(validators)), params.MaxValidators)
require.Equal(t, candidates[0].Address, validators[0].Address, "%v", validators) require.Equal(t, candidates[0].Address, validators[0].Address, "%v", validators)
// candidate 3 was set before candidate 4 // candidate 3 was set before candidate 4
@ -314,7 +314,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
require.Equal(t, candidates[2].Address, validators[1].Address, "%v", validators) require.Equal(t, candidates[2].Address, validators[1].Address, "%v", validators)
candidate, exists := keeper.GetCandidate(ctx, candidates[3].Address) candidate, exists := keeper.GetCandidate(ctx, candidates[3].Address)
require.Equal(t, exists, true) require.Equal(t, exists, true)
require.Equal(t, validator.BondHeight, int64(40)) require.Equal(t, candidate.ValidatorBondHeight, int64(40))
// If two candidates both increase to the same voting power in the same block, // If two candidates both increase to the same voting power in the same block,
// the one with the first transaction should take precedence (become a validator). // the one with the first transaction should take precedence (become a validator).
@ -327,299 +327,339 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
keeper.setCandidate(ctx, candidates[2]) keeper.setCandidate(ctx, candidates[2])
validators = keeper.getValidatorsOrdered(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, uint16(len(validators)), params.MaxValidators) require.Equal(t, uint16(len(validators)), params.MaxValidators)
require.Equal(t, validators[0].Address, validators[0].Address, "%v", validators) require.Equal(t, candidates[0].Address, validators[0].Address, "%v", validators)
require.Equal(t, validators[1].Address, validators[1].Address, "%v", validators) require.Equal(t, candidates[1].Address, validators[1].Address, "%v", validators)
validators[1].BondedShares = sdk.NewRat(1100) candidates[1].BondedShares = sdk.NewRat(1100)
validators[2].BondedShares = sdk.NewRat(1100) candidates[2].BondedShares = sdk.NewRat(1100)
keeper.setValidator(ctx, validators[2]) keeper.setCandidate(ctx, candidates[2])
keeper.setValidator(ctx, validators[1]) keeper.setCandidate(ctx, candidates[1])
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, uint16(len(validators)), params.MaxValidators) require.Equal(t, uint16(len(validators)), params.MaxValidators)
require.Equal(t, validators[0].Address, validators[0].Address, "%v", validators) require.Equal(t, candidates[0].Address, validators[0].Address, "%v", validators)
require.Equal(t, validators[2].Address, validators[1].Address, "%v", validators) require.Equal(t, candidates[2].Address, validators[1].Address, "%v", validators)
// reset assets / heights // reset assets / heights
params.MaxValidators = 100 params.MaxValidators = 100
keeper.setParams(ctx, params) keeper.setParams(ctx, params)
validators[0].BondedShares = sdk.NewRat(0) candidates[0].BondedShares = sdk.NewRat(0)
validators[1].BondedShares = sdk.NewRat(100) candidates[1].BondedShares = sdk.NewRat(100)
validators[2].BondedShares = sdk.NewRat(1) candidates[2].BondedShares = sdk.NewRat(1)
validators[3].BondedShares = sdk.NewRat(300) candidates[3].BondedShares = sdk.NewRat(300)
validators[4].BondedShares = sdk.NewRat(200) candidates[4].BondedShares = sdk.NewRat(200)
ctx = ctx.WithBlockHeight(0) ctx = ctx.WithBlockHeight(0)
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
keeper.setValidator(ctx, validators[1]) keeper.setCandidate(ctx, candidates[1])
keeper.setValidator(ctx, validators[2]) keeper.setCandidate(ctx, candidates[2])
keeper.setValidator(ctx, validators[3]) keeper.setCandidate(ctx, candidates[3])
keeper.setValidator(ctx, validators[4]) keeper.setCandidate(ctx, candidates[4])
// test a swap in voting power // test a swap in voting power
validators[0].BondedShares = sdk.NewRat(600) candidates[0].BondedShares = sdk.NewRat(600)
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
assert.Equal(t, sdk.NewRat(600), validators[0].Power, "%v", validators) assert.Equal(t, sdk.NewRat(600), validators[0].Power, "%v", validators)
assert.Equal(t, validators[0].Address, validators[0].Address, "%v", validators) assert.Equal(t, candidates[0].Address, validators[0].Address, "%v", validators)
assert.Equal(t, sdk.NewRat(300), validators[1].Power, "%v", validators) assert.Equal(t, sdk.NewRat(300), validators[1].Power, "%v", validators)
assert.Equal(t, validators[3].Address, validators[1].Address, "%v", validators) assert.Equal(t, candidates[3].Address, validators[1].Address, "%v", validators)
// test the max validators term // test the max validators term
params = keeper.GetParams(ctx) params = keeper.GetParams(ctx)
n = 2 n = 2
params.MaxValidators = uint16(n) params.MaxValidators = uint16(n)
keeper.setParams(ctx, params) keeper.setParams(ctx, params)
validators = keeper.GetValidatorsBondedByPower(ctx) validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, len(validators), n) require.Equal(t, len(validators), n)
assert.Equal(t, sdk.NewRat(600), validators[0].Power, "%v", validators) assert.Equal(t, sdk.NewRat(600), validators[0].Power, "%v", validators)
assert.Equal(t, validators[0].Address, validators[0].Address, "%v", validators) assert.Equal(t, candidates[0].Address, validators[0].Address, "%v", validators)
assert.Equal(t, sdk.NewRat(300), validators[1].Power, "%v", validators) assert.Equal(t, sdk.NewRat(300), validators[1].Power, "%v", validators)
assert.Equal(t, validators[3].Address, validators[1].Address, "%v", validators) assert.Equal(t, candidates[3].Address, validators[1].Address, "%v", validators)
} }
// clear the tracked changes to the validator set // clear the tracked changes to the validator set
func TestClearValidatorsTendermintUpdates(t *testing.T) { func TestClearAccUpdateValidators(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0) ctx, _, keeper := createTestInput(t, false, 0)
amts := []int64{100, 400, 200} amts := []int64{100, 400, 200}
validators := make([]Validator, len(amts)) candidates := make([]Candidate, len(amts))
for i, amt := range amts { for i, amt := range amts {
validators[i] = NewValidator(addrs[i], pks[i], Description{}) candidates[i] = NewCandidate(addrs[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt) candidates[i].BondedShares = sdk.NewRat(amt)
validators[i].DelegatorShares = sdk.NewRat(amt) candidates[i].DelegatorShares = sdk.NewRat(amt)
keeper.setValidator(ctx, validators[i]) keeper.setCandidate(ctx, candidates[i])
} }
acc := keeper.getValidatorsTendermintUpdates(ctx) acc := keeper.getAccUpdateValidators(ctx)
assert.Equal(t, len(amts), len(acc)) assert.Equal(t, len(amts), len(acc))
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
acc = keeper.getValidatorsTendermintUpdates(ctx) acc = keeper.getAccUpdateValidators(ctx)
assert.Equal(t, 0, len(acc)) assert.Equal(t, 0, len(acc))
} }
// test the mechanism which keeps track of a validator set change // test the mechanism which keeps track of a validator set change
func TestGetValidatorsTendermintUpdates(t *testing.T) { func TestGetAccUpdateValidators(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0) ctx, _, keeper := createTestInput(t, false, 0)
params := defaultParams() params := defaultParams()
params.MaxValidators = 4 params.MaxValidators = 4
keeper.setParams(ctx, params) keeper.setParams(ctx, params)
// TODO eliminate use of validatorsIn here // TODO eliminate use of candidatesIn here
// tests could be clearer if they just // tests could be clearer if they just
// created the validator at time of use // created the candidate at time of use
// and were labelled by power in the comments // and were labelled by power in the comments
// outlining in each test // outlining in each test
amts := []int64{10, 11, 12, 13, 1} amts := []int64{10, 11, 12, 13, 1}
var validatorsIn [5]Validator var candidatesIn [5]Candidate
for i, amt := range amts { for i, amt := range amts {
validatorsIn[i] = NewValidator(addrs[i], pks[i], Description{}) candidatesIn[i] = NewCandidate(addrs[i], pks[i], Description{})
validatorsIn[i].BondedShares = sdk.NewRat(amt) candidatesIn[i].BondedShares = sdk.NewRat(amt)
validatorsIn[i].DelegatorShares = sdk.NewRat(amt) candidatesIn[i].DelegatorShares = sdk.NewRat(amt)
} }
// test from nothing to something // test from nothing to something
// validator set: {} -> {c1, c3} // candidate set: {} -> {c1, c3}
// validator set: {} -> {c1, c3} // validator set: {} -> {c1, c3}
// accUpdate set: {} -> {c1, c3} // accUpdate set: {} -> {c1, c3}
assert.Equal(t, 0, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 0, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 0, len(keeper.GetValidatorsBonded(ctx))) assert.Equal(t, 0, len(keeper.GetValidators(ctx)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
keeper.setValidator(ctx, validatorsIn[1]) keeper.setCandidate(ctx, candidatesIn[1])
keeper.setValidator(ctx, validatorsIn[3]) keeper.setCandidate(ctx, candidatesIn[3])
vals := keeper.GetValidatorsBondedByPower(ctx) // to init recent validator set vals := keeper.getValidatorsOrdered(ctx) // to init recent validator set
require.Equal(t, 2, len(vals)) require.Equal(t, 2, len(vals))
acc := keeper.getValidatorsTendermintUpdates(ctx) acc := keeper.getAccUpdateValidators(ctx)
require.Equal(t, 2, len(acc)) require.Equal(t, 2, len(acc))
validators := keeper.GetValidators(ctx, 5) candidates := keeper.GetCandidates(ctx, 5)
require.Equal(t, 2, len(validators)) require.Equal(t, 2, len(candidates))
assert.Equal(t, validators[0].validator().abciValidator(keeper.cdc), acc[0]) assert.Equal(t, candidates[0].validator().abciValidator(keeper.cdc), acc[0])
assert.Equal(t, validators[1].validator().abciValidator(keeper.cdc), acc[1]) assert.Equal(t, candidates[1].validator().abciValidator(keeper.cdc), acc[1])
assert.True(t, validators[0].validator().equal(vals[1])) assert.True(t, candidates[0].validator().equal(vals[1]))
assert.True(t, validators[1].validator().equal(vals[0])) assert.True(t, candidates[1].validator().equal(vals[0]))
// test identical, // test identical,
// validator set: {c1, c3} -> {c1, c3} // candidate set: {c1, c3} -> {c1, c3}
// accUpdate set: {} -> {} // accUpdate set: {} -> {}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 2, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 2, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
keeper.setValidator(ctx, validators[1]) keeper.setCandidate(ctx, candidates[1])
require.Equal(t, 2, len(keeper.GetValidators(ctx, 5))) require.Equal(t, 2, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
// test single value change // test single value change
// validator set: {c1, c3} -> {c1', c3} // candidate set: {c1, c3} -> {c1', c3}
// accUpdate set: {} -> {c1'} // accUpdate set: {} -> {c1'}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 2, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 2, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
validators[0].BondedShares = sdk.NewRat(600) candidates[0].BondedShares = sdk.NewRat(600)
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
validators = keeper.GetValidators(ctx, 5) candidates = keeper.GetCandidates(ctx, 5)
require.Equal(t, 2, len(validators)) require.Equal(t, 2, len(candidates))
assert.True(t, validators[0].BondedShares.Equal(sdk.NewRat(600))) assert.True(t, candidates[0].BondedShares.Equal(sdk.NewRat(600)))
acc = keeper.getValidatorsTendermintUpdates(ctx) acc = keeper.getAccUpdateValidators(ctx)
require.Equal(t, 1, len(acc)) require.Equal(t, 1, len(acc))
assert.Equal(t, validators[0].validator().abciValidator(keeper.cdc), acc[0]) assert.Equal(t, candidates[0].validator().abciValidator(keeper.cdc), acc[0])
// test multiple value change // test multiple value change
// validator set: {c1, c3} -> {c1', c3'} // candidate set: {c1, c3} -> {c1', c3'}
// accUpdate set: {c1, c3} -> {c1', c3'} // accUpdate set: {c1, c3} -> {c1', c3'}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 2, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 2, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
validators[0].BondedShares = sdk.NewRat(200) candidates[0].BondedShares = sdk.NewRat(200)
validators[1].BondedShares = sdk.NewRat(100) candidates[1].BondedShares = sdk.NewRat(100)
keeper.setValidator(ctx, validators[0]) keeper.setCandidate(ctx, candidates[0])
keeper.setValidator(ctx, validators[1]) keeper.setCandidate(ctx, candidates[1])
acc = keeper.getValidatorsTendermintUpdates(ctx) acc = keeper.getAccUpdateValidators(ctx)
require.Equal(t, 2, len(acc)) require.Equal(t, 2, len(acc))
validators = keeper.GetValidators(ctx, 5) candidates = keeper.GetCandidates(ctx, 5)
require.Equal(t, 2, len(validators)) require.Equal(t, 2, len(candidates))
require.Equal(t, validators[0].validator().abciValidator(keeper.cdc), acc[0]) require.Equal(t, candidates[0].validator().abciValidator(keeper.cdc), acc[0])
require.Equal(t, validators[1].validator().abciValidator(keeper.cdc), acc[1]) require.Equal(t, candidates[1].validator().abciValidator(keeper.cdc), acc[1])
// test validtor added at the beginning // test validtor added at the beginning
// validator set: {c1, c3} -> {c0, c1, c3} // candidate set: {c1, c3} -> {c0, c1, c3}
// accUpdate set: {} -> {c0} // accUpdate set: {} -> {c0}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 2, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 2, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
keeper.setValidator(ctx, validatorsIn[0]) keeper.setCandidate(ctx, candidatesIn[0])
acc = keeper.getValidatorsTendermintUpdates(ctx) acc = keeper.getAccUpdateValidators(ctx)
require.Equal(t, 1, len(acc)) require.Equal(t, 1, len(acc))
validators = keeper.GetValidators(ctx, 5) candidates = keeper.GetCandidates(ctx, 5)
require.Equal(t, 3, len(validators)) require.Equal(t, 3, len(candidates))
assert.Equal(t, validators[0].validator().abciValidator(keeper.cdc), acc[0]) assert.Equal(t, candidates[0].validator().abciValidator(keeper.cdc), acc[0])
// test validator added at the middle // test validator added at the middle
// validator set: {c0, c1, c3} -> {c0, c1, c2, c3} // candidate set: {c0, c1, c3} -> {c0, c1, c2, c3]
// accUpdate set: {} -> {c2} // accUpdate set: {} -> {c2}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 3, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 3, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
keeper.setValidator(ctx, validatorsIn[2]) keeper.setCandidate(ctx, candidatesIn[2])
acc = keeper.getValidatorsTendermintUpdates(ctx) acc = keeper.getAccUpdateValidators(ctx)
require.Equal(t, 1, len(acc)) require.Equal(t, 1, len(acc))
validators = keeper.GetValidators(ctx, 5) candidates = keeper.GetCandidates(ctx, 5)
require.Equal(t, 4, len(validators)) require.Equal(t, 4, len(candidates))
assert.Equal(t, validators[2].validator().abciValidator(keeper.cdc), acc[0]) assert.Equal(t, candidates[2].validator().abciValidator(keeper.cdc), acc[0])
// test validator added at the end but not inserted in the valset // test candidate added at the end but not inserted in the valset
// validator set: {c0, c1, c2, c3} -> {c0, c1, c2, c3, c4} // candidate set: {c0, c1, c2, c3} -> {c0, c1, c2, c3, c4}
// validator set: {c0, c1, c2, c3} -> {c0, c1, c2, c3} // validator set: {c0, c1, c2, c3} -> {c0, c1, c2, c3}
// accUpdate set: {} -> {} // accUpdate set: {} -> {}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 4, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 4, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx))) assert.Equal(t, 4, len(keeper.GetValidators(ctx)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
keeper.setValidator(ctx, validatorsIn[4]) keeper.setCandidate(ctx, candidatesIn[4])
assert.Equal(t, 5, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 5, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx))) assert.Equal(t, 4, len(keeper.GetValidators(ctx)))
require.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) // max validator number is 4 require.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx))) // max validator number is 4
// test validator change its power but still not in the valset // test candidate change its power but still not in the valset
// validator set: {c0, c1, c2, c3, c4} -> {c0, c1, c2, c3, c4} // candidate set: {c0, c1, c2, c3, c4} -> {c0, c1, c2, c3, c4}
// validator set: {c0, c1, c2, c3} -> {c0, c1, c2, c3} // validator set: {c0, c1, c2, c3} -> {c0, c1, c2, c3}
// accUpdate set: {} -> {} // accUpdate set: {} -> {}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 5, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 5, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx))) assert.Equal(t, 4, len(keeper.GetValidators(ctx)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
validatorsIn[4].BondedShares = sdk.NewRat(1) candidatesIn[4].BondedShares = sdk.NewRat(1)
keeper.setValidator(ctx, validatorsIn[4]) keeper.setCandidate(ctx, candidatesIn[4])
assert.Equal(t, 5, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 5, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx))) assert.Equal(t, 4, len(keeper.GetValidators(ctx)))
require.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) // max validator number is 4 require.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx))) // max validator number is 4
// test validator change its power and become a validator (pushing out an existing) // test candidate change its power and become a validator (pushing out an existing)
// validator set: {c0, c1, c2, c3, c4} -> {c0, c1, c2, c3, c4} // candidate set: {c0, c1, c2, c3, c4} -> {c0, c1, c2, c3, c4}
// validator set: {c0, c1, c2, c3} -> {c1, c2, c3, c4} // validator set: {c0, c1, c2, c3} -> {c1, c2, c3, c4}
// accUpdate set: {} -> {c0, c4} // accUpdate set: {} -> {c0, c4}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 5, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 5, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx))) assert.Equal(t, 4, len(keeper.GetValidators(ctx)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
validatorsIn[4].BondedShares = sdk.NewRat(1000) candidatesIn[4].BondedShares = sdk.NewRat(1000)
keeper.setValidator(ctx, validatorsIn[4]) keeper.setCandidate(ctx, candidatesIn[4])
validators = keeper.GetValidators(ctx, 5) candidates = keeper.GetCandidates(ctx, 5)
require.Equal(t, 5, len(validators)) require.Equal(t, 5, len(candidates))
vals = keeper.GetValidatorsBondedByPower(ctx) vals = keeper.getValidatorsOrdered(ctx)
require.Equal(t, 4, len(vals)) require.Equal(t, 4, len(vals))
assert.Equal(t, validatorsIn[1].Address, vals[1].Address) assert.Equal(t, candidatesIn[1].Address, vals[1].Address)
assert.Equal(t, validatorsIn[2].Address, vals[3].Address) assert.Equal(t, candidatesIn[2].Address, vals[3].Address)
assert.Equal(t, validatorsIn[3].Address, vals[2].Address) assert.Equal(t, candidatesIn[3].Address, vals[2].Address)
assert.Equal(t, validatorsIn[4].Address, vals[0].Address) assert.Equal(t, candidatesIn[4].Address, vals[0].Address)
acc = keeper.getValidatorsTendermintUpdates(ctx) acc = keeper.getAccUpdateValidators(ctx)
require.Equal(t, 2, len(acc), "%v", acc) require.Equal(t, 2, len(acc), "%v", acc)
assert.Equal(t, validatorsIn[0].PubKey.Bytes(), acc[0].PubKey) assert.Equal(t, candidatesIn[0].PubKey.Bytes(), acc[0].PubKey)
assert.Equal(t, int64(0), acc[0].Power) assert.Equal(t, int64(0), acc[0].Power)
assert.Equal(t, vals[0].abciValidator(keeper.cdc), acc[1]) assert.Equal(t, vals[0].abciValidator(keeper.cdc), acc[1])
// test from something to nothing // test from something to nothing
// validator set: {c0, c1, c2, c3, c4} -> {} // candidate set: {c0, c1, c2, c3, c4} -> {}
// validator set: {c1, c2, c3, c4} -> {} // validator set: {c1, c2, c3, c4} -> {}
// accUpdate set: {} -> {c1, c2, c3, c4} // accUpdate set: {} -> {c1, c2, c3, c4}
keeper.clearValidatorsTendermintUpdates(ctx) keeper.clearAccUpdateValidators(ctx)
assert.Equal(t, 5, len(keeper.GetValidators(ctx, 5))) assert.Equal(t, 5, len(keeper.GetCandidates(ctx, 5)))
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx))) assert.Equal(t, 4, len(keeper.GetValidators(ctx)))
assert.Equal(t, 0, len(keeper.getValidatorsTendermintUpdates(ctx))) assert.Equal(t, 0, len(keeper.getAccUpdateValidators(ctx)))
keeper.removeValidator(ctx, validatorsIn[0].Address) keeper.removeCandidate(ctx, candidatesIn[0].Address)
keeper.removeValidator(ctx, validatorsIn[1].Address) keeper.removeCandidate(ctx, candidatesIn[1].Address)
keeper.removeValidator(ctx, validatorsIn[2].Address) keeper.removeCandidate(ctx, candidatesIn[2].Address)
keeper.removeValidator(ctx, validatorsIn[3].Address) keeper.removeCandidate(ctx, candidatesIn[3].Address)
keeper.removeValidator(ctx, validatorsIn[4].Address) keeper.removeCandidate(ctx, candidatesIn[4].Address)
vals = keeper.GetValidatorsBondedByPower(ctx) vals = keeper.getValidatorsOrdered(ctx)
assert.Equal(t, 0, len(vals), "%v", vals) assert.Equal(t, 0, len(vals), "%v", vals)
validators = keeper.GetValidators(ctx, 5) candidates = keeper.GetCandidates(ctx, 5)
require.Equal(t, 0, len(validators)) require.Equal(t, 0, len(candidates))
acc = keeper.getValidatorsTendermintUpdates(ctx) acc = keeper.getAccUpdateValidators(ctx)
require.Equal(t, 4, len(acc)) require.Equal(t, 4, len(acc))
assert.Equal(t, validatorsIn[1].PubKey.Bytes(), acc[0].PubKey) assert.Equal(t, candidatesIn[1].PubKey.Bytes(), acc[0].PubKey)
assert.Equal(t, validatorsIn[2].PubKey.Bytes(), acc[1].PubKey) assert.Equal(t, candidatesIn[2].PubKey.Bytes(), acc[1].PubKey)
assert.Equal(t, validatorsIn[3].PubKey.Bytes(), acc[2].PubKey) assert.Equal(t, candidatesIn[3].PubKey.Bytes(), acc[2].PubKey)
assert.Equal(t, validatorsIn[4].PubKey.Bytes(), acc[3].PubKey) assert.Equal(t, candidatesIn[4].PubKey.Bytes(), acc[3].PubKey)
assert.Equal(t, int64(0), acc[0].Power) assert.Equal(t, int64(0), acc[0].Power)
assert.Equal(t, int64(0), acc[1].Power) assert.Equal(t, int64(0), acc[1].Power)
assert.Equal(t, int64(0), acc[2].Power) assert.Equal(t, int64(0), acc[2].Power)
assert.Equal(t, int64(0), acc[3].Power) assert.Equal(t, int64(0), acc[3].Power)
} }
// test if is a validator from the last update
func TestIsValidator(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0)
amts := []int64{9, 8, 7, 10, 6}
var candidatesIn [5]Candidate
for i, amt := range amts {
candidatesIn[i] = NewCandidate(addrVals[i], pks[i], Description{})
candidatesIn[i].BondedShares = sdk.NewRat(amt)
candidatesIn[i].DelegatorShares = sdk.NewRat(amt)
}
// test that an empty validator set doesn't have any validators
validators := keeper.getValidatorsOrdered(ctx)
assert.Equal(t, 0, len(validators))
// get the validators for the first time
keeper.setCandidate(ctx, candidatesIn[0])
keeper.setCandidate(ctx, candidatesIn[1])
validators = keeper.getValidatorsOrdered(ctx)
require.Equal(t, 2, len(validators))
assert.True(t, candidatesIn[0].validator().equal(validators[0]))
c1ValWithCounter := candidatesIn[1].validator()
c1ValWithCounter.Counter = int16(1)
assert.True(t, c1ValWithCounter.equal(validators[1]))
// test a basic retrieve of something that should be a recent validator
assert.True(t, keeper.IsValidator(ctx, candidatesIn[0].PubKey))
assert.True(t, keeper.IsValidator(ctx, candidatesIn[1].PubKey))
// test a basic retrieve of something that should not be a recent validator
assert.False(t, keeper.IsValidator(ctx, candidatesIn[2].PubKey))
// remove that validator, but don't retrieve the recent validator group
keeper.removeCandidate(ctx, candidatesIn[0].Address)
// test that removed validator is not considered a recent validator
assert.False(t, keeper.IsValidator(ctx, candidatesIn[0].PubKey))
}
// test if is a validator from the last update // test if is a validator from the last update
func TestGetTotalPrecommitVotingPower(t *testing.T) { func TestGetTotalPrecommitVotingPower(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0) ctx, _, keeper := createTestInput(t, false, 0)
amts := []int64{10000, 1000, 100, 10, 1} amts := []int64{10000, 1000, 100, 10, 1}
var validatorsIn [5]Validator var candidatesIn [5]Candidate
for i, amt := range amts { for i, amt := range amts {
validatorsIn[i] = NewValidator(addrVals[i], pks[i], Description{}) candidatesIn[i] = NewCandidate(addrVals[i], pks[i], Description{})
validatorsIn[i].BondedShares = sdk.NewRat(amt) candidatesIn[i].BondedShares = sdk.NewRat(amt)
validatorsIn[i].DelegatorShares = sdk.NewRat(amt) candidatesIn[i].DelegatorShares = sdk.NewRat(amt)
keeper.setValidator(ctx, validatorsIn[i]) keeper.setCandidate(ctx, candidatesIn[i])
} }
// test that an empty validator set doesn't have any validators // test that an empty validator set doesn't have any validators
validators := keeper.GetValidatorsBonded(ctx) validators := keeper.GetValidators(ctx)
assert.Equal(t, 5, len(validators)) assert.Equal(t, 5, len(validators))
totPow := keeper.GetTotalPrecommitVotingPower(ctx) totPow := keeper.GetTotalPrecommitVotingPower(ctx)
@ -664,6 +704,7 @@ func TestPool(t *testing.T) {
resPool = keeper.GetPool(ctx) resPool = keeper.GetPool(ctx)
assert.True(t, expPool.equal(resPool)) assert.True(t, expPool.equal(resPool))
} }
<<<<<<< HEAD
func TestValidatorsetKeeper(t *testing.T) { func TestValidatorsetKeeper(t *testing.T) {
ctx, _, keeper := createTestInput(t, false, 0) ctx, _, keeper := createTestInput(t, false, 0)