consensus: rename test funcs

This commit is contained in:
Ethan Buchman
2018-01-18 20:38:19 -05:00
parent ebeadfc57e
commit 1cb76625d3
4 changed files with 29 additions and 36 deletions

View File

@ -19,7 +19,7 @@ func init() {
config = ResetConfig("consensus_mempool_test") config = ResetConfig("consensus_mempool_test")
} }
func TestNoProgressUntilTxsAvailable(t *testing.T) { func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) {
config := ResetConfig("consensus_mempool_txs_available_test") config := ResetConfig("consensus_mempool_txs_available_test")
config.Consensus.CreateEmptyBlocks = false config.Consensus.CreateEmptyBlocks = false
state, privVals := randGenesisState(1, false, 10) state, privVals := randGenesisState(1, false, 10)
@ -37,7 +37,7 @@ func TestNoProgressUntilTxsAvailable(t *testing.T) {
ensureNoNewStep(newBlockCh) ensureNoNewStep(newBlockCh)
} }
func TestProgressAfterCreateEmptyBlocksInterval(t *testing.T) { func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
config := ResetConfig("consensus_mempool_txs_available_test") config := ResetConfig("consensus_mempool_txs_available_test")
config.Consensus.CreateEmptyBlocksInterval = int(ensureTimeout.Seconds()) config.Consensus.CreateEmptyBlocksInterval = int(ensureTimeout.Seconds())
state, privVals := randGenesisState(1, false, 10) state, privVals := randGenesisState(1, false, 10)
@ -52,7 +52,7 @@ func TestProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
ensureNewStep(newBlockCh) // until the CreateEmptyBlocksInterval has passed ensureNewStep(newBlockCh) // until the CreateEmptyBlocksInterval has passed
} }
func TestProgressInHigherRound(t *testing.T) { func TestMempoolProgressInHigherRound(t *testing.T) {
config := ResetConfig("consensus_mempool_txs_available_test") config := ResetConfig("consensus_mempool_txs_available_test")
config.Consensus.CreateEmptyBlocks = false config.Consensus.CreateEmptyBlocks = false
state, privVals := randGenesisState(1, false, 10) state, privVals := randGenesisState(1, false, 10)
@ -94,7 +94,7 @@ func deliverTxsRange(cs *ConsensusState, start, end int) {
} }
} }
func TestTxConcurrentWithCommit(t *testing.T) { func TestMempoolTxConcurrentWithCommit(t *testing.T) {
state, privVals := randGenesisState(1, false, 10) state, privVals := randGenesisState(1, false, 10)
cs := newConsensusState(state, privVals[0], NewCounterApplication()) cs := newConsensusState(state, privVals[0], NewCounterApplication())
height, round := cs.Height, cs.Round height, round := cs.Height, cs.Round
@ -116,7 +116,7 @@ func TestTxConcurrentWithCommit(t *testing.T) {
} }
} }
func TestRmBadTx(t *testing.T) { func TestMempoolRmBadTx(t *testing.T) {
state, privVals := randGenesisState(1, false, 10) state, privVals := randGenesisState(1, false, 10)
app := NewCounterApplication() app := NewCounterApplication()
cs := newConsensusState(state, privVals[0], app) cs := newConsensusState(state, privVals[0], app)

View File

@ -31,31 +31,24 @@ func startConsensusNet(t *testing.T, css []*ConsensusState, N int) ([]*Consensus
reactors := make([]*ConsensusReactor, N) reactors := make([]*ConsensusReactor, N)
eventChans := make([]chan interface{}, N) eventChans := make([]chan interface{}, N)
eventBuses := make([]*types.EventBus, N) eventBuses := make([]*types.EventBus, N)
logger := consensusLogger()
for i := 0; i < N; i++ { for i := 0; i < N; i++ {
/*thisLogger, err := tmflags.ParseLogLevel("consensus:info,*:error", logger, "info") /*logger, err := tmflags.ParseLogLevel("consensus:info,*:error", logger, "info")
if err != nil { t.Fatal(err)}*/ if err != nil { t.Fatal(err)}*/
thisLogger := logger
reactors[i] = NewConsensusReactor(css[i], true) // so we dont start the consensus states reactors[i] = NewConsensusReactor(css[i], true) // so we dont start the consensus states
reactors[i].conS.SetLogger(thisLogger.With("validator", i)) reactors[i].SetLogger(css[i].Logger.With("validator", "i"))
reactors[i].SetLogger(thisLogger.With("validator", i))
eventBuses[i] = types.NewEventBus()
eventBuses[i].SetLogger(thisLogger.With("module", "events", "validator", i))
err := eventBuses[i].Start()
require.NoError(t, err)
// eventBus is already started with the cs
eventBuses[i] = css[i].eventBus
reactors[i].SetEventBus(eventBuses[i]) reactors[i].SetEventBus(eventBuses[i])
eventChans[i] = make(chan interface{}, 1) eventChans[i] = make(chan interface{}, 1)
err = eventBuses[i].Subscribe(context.Background(), testSubscriber, types.EventQueryNewBlock, eventChans[i]) err := eventBuses[i].Subscribe(context.Background(), testSubscriber, types.EventQueryNewBlock, eventChans[i])
require.NoError(t, err) require.NoError(t, err)
} }
// make connected switches and start all reactors // make connected switches and start all reactors
p2p.MakeConnectedSwitches(config.P2P, N, func(i int, s *p2p.Switch) *p2p.Switch { p2p.MakeConnectedSwitches(config.P2P, N, func(i int, s *p2p.Switch) *p2p.Switch {
s.AddReactor("CONSENSUS", reactors[i]) s.AddReactor("CONSENSUS", reactors[i])
s.SetLogger(reactors[i].Logger.With("module", "p2p", "validator", i)) s.SetLogger(reactors[i].conS.Logger.With("module", "p2p"))
return s return s
}, p2p.Connect2Switches) }, p2p.Connect2Switches)
@ -84,7 +77,7 @@ func stopConsensusNet(logger log.Logger, reactors []*ConsensusReactor, eventBuse
} }
// Ensure a testnet makes blocks // Ensure a testnet makes blocks
func TestReactor(t *testing.T) { func TestReactorBasic(t *testing.T) {
N := 4 N := 4
css := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter) css := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter)
reactors, eventChans, eventBuses := startConsensusNet(t, css, N) reactors, eventChans, eventBuses := startConsensusNet(t, css, N)

View File

@ -55,7 +55,7 @@ x * TestHalt1 - if we see +2/3 precommits after timing out into new round, we sh
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
// ProposeSuite // ProposeSuite
func TestProposerSelection0(t *testing.T) { func TestStateProposerSelection0(t *testing.T) {
cs1, vss := randConsensusState(4) cs1, vss := randConsensusState(4)
height, round := cs1.Height, cs1.Round height, round := cs1.Height, cs1.Round
@ -89,7 +89,7 @@ func TestProposerSelection0(t *testing.T) {
} }
// Now let's do it all again, but starting from round 2 instead of 0 // Now let's do it all again, but starting from round 2 instead of 0
func TestProposerSelection2(t *testing.T) { func TestStateProposerSelection2(t *testing.T) {
cs1, vss := randConsensusState(4) // test needs more work for more than 3 validators cs1, vss := randConsensusState(4) // test needs more work for more than 3 validators
newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound) newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
@ -118,7 +118,7 @@ func TestProposerSelection2(t *testing.T) {
} }
// a non-validator should timeout into the prevote round // a non-validator should timeout into the prevote round
func TestEnterProposeNoPrivValidator(t *testing.T) { func TestStateEnterProposeNoPrivValidator(t *testing.T) {
cs, _ := randConsensusState(1) cs, _ := randConsensusState(1)
cs.SetPrivValidator(nil) cs.SetPrivValidator(nil)
height, round := cs.Height, cs.Round height, round := cs.Height, cs.Round
@ -143,7 +143,7 @@ func TestEnterProposeNoPrivValidator(t *testing.T) {
} }
// a validator should not timeout of the prevote round (TODO: unless the block is really big!) // a validator should not timeout of the prevote round (TODO: unless the block is really big!)
func TestEnterProposeYesPrivValidator(t *testing.T) { func TestStateEnterProposeYesPrivValidator(t *testing.T) {
cs, _ := randConsensusState(1) cs, _ := randConsensusState(1)
height, round := cs.Height, cs.Round height, round := cs.Height, cs.Round
@ -179,7 +179,7 @@ func TestEnterProposeYesPrivValidator(t *testing.T) {
} }
} }
func TestBadProposal(t *testing.T) { func TestStateBadProposal(t *testing.T) {
cs1, vss := randConsensusState(2) cs1, vss := randConsensusState(2)
height, round := cs1.Height, cs1.Round height, round := cs1.Height, cs1.Round
vs2 := vss[1] vs2 := vss[1]
@ -239,7 +239,7 @@ func TestBadProposal(t *testing.T) {
// FullRoundSuite // FullRoundSuite
// propose, prevote, and precommit a block // propose, prevote, and precommit a block
func TestFullRound1(t *testing.T) { func TestStateFullRound1(t *testing.T) {
cs, vss := randConsensusState(1) cs, vss := randConsensusState(1)
height, round := cs.Height, cs.Round height, round := cs.Height, cs.Round
@ -275,7 +275,7 @@ func TestFullRound1(t *testing.T) {
} }
// nil is proposed, so prevote and precommit nil // nil is proposed, so prevote and precommit nil
func TestFullRoundNil(t *testing.T) { func TestStateFullRoundNil(t *testing.T) {
cs, vss := randConsensusState(1) cs, vss := randConsensusState(1)
height, round := cs.Height, cs.Round height, round := cs.Height, cs.Round
@ -293,7 +293,7 @@ func TestFullRoundNil(t *testing.T) {
// run through propose, prevote, precommit commit with two validators // run through propose, prevote, precommit commit with two validators
// where the first validator has to wait for votes from the second // where the first validator has to wait for votes from the second
func TestFullRound2(t *testing.T) { func TestStateFullRound2(t *testing.T) {
cs1, vss := randConsensusState(2) cs1, vss := randConsensusState(2)
vs2 := vss[1] vs2 := vss[1]
height, round := cs1.Height, cs1.Round height, round := cs1.Height, cs1.Round
@ -334,7 +334,7 @@ func TestFullRound2(t *testing.T) {
// two validators, 4 rounds. // two validators, 4 rounds.
// two vals take turns proposing. val1 locks on first one, precommits nil on everything else // two vals take turns proposing. val1 locks on first one, precommits nil on everything else
func TestLockNoPOL(t *testing.T) { func TestStateLockNoPOL(t *testing.T) {
cs1, vss := randConsensusState(2) cs1, vss := randConsensusState(2)
vs2 := vss[1] vs2 := vss[1]
height := cs1.Height height := cs1.Height
@ -503,7 +503,7 @@ func TestLockNoPOL(t *testing.T) {
} }
// 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka // 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
func TestLockPOLRelock(t *testing.T) { func TestStateLockPOLRelock(t *testing.T) {
cs1, vss := randConsensusState(4) cs1, vss := randConsensusState(4)
vs2, vs3, vs4 := vss[1], vss[2], vss[3] vs2, vs3, vs4 := vss[1], vss[2], vss[3]
@ -618,7 +618,7 @@ func TestLockPOLRelock(t *testing.T) {
} }
// 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka // 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
func TestLockPOLUnlock(t *testing.T) { func TestStateLockPOLUnlock(t *testing.T) {
cs1, vss := randConsensusState(4) cs1, vss := randConsensusState(4)
vs2, vs3, vs4 := vss[1], vss[2], vss[3] vs2, vs3, vs4 := vss[1], vss[2], vss[3]
@ -715,7 +715,7 @@ func TestLockPOLUnlock(t *testing.T) {
// a polka at round 1 but we miss it // a polka at round 1 but we miss it
// then a polka at round 2 that we lock on // then a polka at round 2 that we lock on
// then we see the polka from round 1 but shouldn't unlock // then we see the polka from round 1 but shouldn't unlock
func TestLockPOLSafety1(t *testing.T) { func TestStateLockPOLSafety1(t *testing.T) {
cs1, vss := randConsensusState(4) cs1, vss := randConsensusState(4)
vs2, vs3, vs4 := vss[1], vss[2], vss[3] vs2, vs3, vs4 := vss[1], vss[2], vss[3]
@ -838,7 +838,7 @@ func TestLockPOLSafety1(t *testing.T) {
// What we want: // What we want:
// dont see P0, lock on P1 at R1, dont unlock using P0 at R2 // dont see P0, lock on P1 at R1, dont unlock using P0 at R2
func TestLockPOLSafety2(t *testing.T) { func TestStateLockPOLSafety2(t *testing.T) {
cs1, vss := randConsensusState(4) cs1, vss := randConsensusState(4)
vs2, vs3, vs4 := vss[1], vss[2], vss[3] vs2, vs3, vs4 := vss[1], vss[2], vss[3]
@ -937,7 +937,7 @@ func TestLockPOLSafety2(t *testing.T) {
// TODO: Slashing // TODO: Slashing
/* /*
func TestSlashingPrevotes(t *testing.T) { func TestStateSlashingPrevotes(t *testing.T) {
cs1, vss := randConsensusState(2) cs1, vss := randConsensusState(2)
vs2 := vss[1] vs2 := vss[1]
@ -972,7 +972,7 @@ func TestSlashingPrevotes(t *testing.T) {
// XXX: Check for existence of Dupeout info // XXX: Check for existence of Dupeout info
} }
func TestSlashingPrecommits(t *testing.T) { func TestStateSlashingPrecommits(t *testing.T) {
cs1, vss := randConsensusState(2) cs1, vss := randConsensusState(2)
vs2 := vss[1] vs2 := vss[1]
@ -1017,7 +1017,7 @@ func TestSlashingPrecommits(t *testing.T) {
// 4 vals. // 4 vals.
// we receive a final precommit after going into next round, but others might have gone to commit already! // we receive a final precommit after going into next round, but others might have gone to commit already!
func TestHalt1(t *testing.T) { func TestStateHalt1(t *testing.T) {
cs1, vss := randConsensusState(4) cs1, vss := randConsensusState(4)
vs2, vs3, vs4 := vss[1], vss[2], vss[3] vs2, vs3, vs4 := vss[1], vss[2], vss[3]

View File

@ -41,7 +41,7 @@ func TestWALEncoderDecoder(t *testing.T) {
} }
} }
func TestSearchForEndHeight(t *testing.T) { func TestWALSearchForEndHeight(t *testing.T) {
walBody, err := WALWithNBlocks(6) walBody, err := WALWithNBlocks(6)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)