From 1cb76625d3be9dd25a630b164100436d5665024a Mon Sep 17 00:00:00 2001 From: Ethan Buchman Date: Thu, 18 Jan 2018 20:38:19 -0500 Subject: [PATCH] consensus: rename test funcs --- consensus/mempool_test.go | 10 +++++----- consensus/reactor_test.go | 21 +++++++-------------- consensus/state_test.go | 32 ++++++++++++++++---------------- consensus/wal_test.go | 2 +- 4 files changed, 29 insertions(+), 36 deletions(-) diff --git a/consensus/mempool_test.go b/consensus/mempool_test.go index 91acce65d..97bc050fa 100644 --- a/consensus/mempool_test.go +++ b/consensus/mempool_test.go @@ -19,7 +19,7 @@ func init() { config = ResetConfig("consensus_mempool_test") } -func TestNoProgressUntilTxsAvailable(t *testing.T) { +func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) { config := ResetConfig("consensus_mempool_txs_available_test") config.Consensus.CreateEmptyBlocks = false state, privVals := randGenesisState(1, false, 10) @@ -37,7 +37,7 @@ func TestNoProgressUntilTxsAvailable(t *testing.T) { ensureNoNewStep(newBlockCh) } -func TestProgressAfterCreateEmptyBlocksInterval(t *testing.T) { +func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) { config := ResetConfig("consensus_mempool_txs_available_test") config.Consensus.CreateEmptyBlocksInterval = int(ensureTimeout.Seconds()) state, privVals := randGenesisState(1, false, 10) @@ -52,7 +52,7 @@ func TestProgressAfterCreateEmptyBlocksInterval(t *testing.T) { 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.Consensus.CreateEmptyBlocks = false 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) cs := newConsensusState(state, privVals[0], NewCounterApplication()) 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) app := NewCounterApplication() cs := newConsensusState(state, privVals[0], app) diff --git a/consensus/reactor_test.go b/consensus/reactor_test.go index bcf97f94b..0fb348bd0 100644 --- a/consensus/reactor_test.go +++ b/consensus/reactor_test.go @@ -31,31 +31,24 @@ func startConsensusNet(t *testing.T, css []*ConsensusState, N int) ([]*Consensus reactors := make([]*ConsensusReactor, N) eventChans := make([]chan interface{}, N) eventBuses := make([]*types.EventBus, N) - logger := consensusLogger() 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)}*/ - thisLogger := logger - reactors[i] = NewConsensusReactor(css[i], true) // so we dont start the consensus states - reactors[i].conS.SetLogger(thisLogger.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) + reactors[i].SetLogger(css[i].Logger.With("validator", "i")) + // eventBus is already started with the cs + eventBuses[i] = css[i].eventBus reactors[i].SetEventBus(eventBuses[i]) 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) } // make connected switches and start all reactors p2p.MakeConnectedSwitches(config.P2P, N, func(i int, s *p2p.Switch) *p2p.Switch { 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 }, p2p.Connect2Switches) @@ -84,7 +77,7 @@ func stopConsensusNet(logger log.Logger, reactors []*ConsensusReactor, eventBuse } // Ensure a testnet makes blocks -func TestReactor(t *testing.T) { +func TestReactorBasic(t *testing.T) { N := 4 css := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter) reactors, eventChans, eventBuses := startConsensusNet(t, css, N) diff --git a/consensus/state_test.go b/consensus/state_test.go index 97562febd..e6b2a1354 100644 --- a/consensus/state_test.go +++ b/consensus/state_test.go @@ -55,7 +55,7 @@ x * TestHalt1 - if we see +2/3 precommits after timing out into new round, we sh //---------------------------------------------------------------------------------------------------- // ProposeSuite -func TestProposerSelection0(t *testing.T) { +func TestStateProposerSelection0(t *testing.T) { cs1, vss := randConsensusState(4) 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 -func TestProposerSelection2(t *testing.T) { +func TestStateProposerSelection2(t *testing.T) { cs1, vss := randConsensusState(4) // test needs more work for more than 3 validators newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound) @@ -118,7 +118,7 @@ func TestProposerSelection2(t *testing.T) { } // a non-validator should timeout into the prevote round -func TestEnterProposeNoPrivValidator(t *testing.T) { +func TestStateEnterProposeNoPrivValidator(t *testing.T) { cs, _ := randConsensusState(1) cs.SetPrivValidator(nil) 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!) -func TestEnterProposeYesPrivValidator(t *testing.T) { +func TestStateEnterProposeYesPrivValidator(t *testing.T) { cs, _ := randConsensusState(1) 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) height, round := cs1.Height, cs1.Round vs2 := vss[1] @@ -239,7 +239,7 @@ func TestBadProposal(t *testing.T) { // FullRoundSuite // propose, prevote, and precommit a block -func TestFullRound1(t *testing.T) { +func TestStateFullRound1(t *testing.T) { cs, vss := randConsensusState(1) height, round := cs.Height, cs.Round @@ -275,7 +275,7 @@ func TestFullRound1(t *testing.T) { } // nil is proposed, so prevote and precommit nil -func TestFullRoundNil(t *testing.T) { +func TestStateFullRoundNil(t *testing.T) { cs, vss := randConsensusState(1) height, round := cs.Height, cs.Round @@ -293,7 +293,7 @@ func TestFullRoundNil(t *testing.T) { // run through propose, prevote, precommit commit with two validators // 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) vs2 := vss[1] height, round := cs1.Height, cs1.Round @@ -334,7 +334,7 @@ func TestFullRound2(t *testing.T) { // two validators, 4 rounds. // 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) vs2 := vss[1] 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 -func TestLockPOLRelock(t *testing.T) { +func TestStateLockPOLRelock(t *testing.T) { cs1, vss := randConsensusState(4) 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 -func TestLockPOLUnlock(t *testing.T) { +func TestStateLockPOLUnlock(t *testing.T) { cs1, vss := randConsensusState(4) 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 // then a polka at round 2 that we lock on // 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) vs2, vs3, vs4 := vss[1], vss[2], vss[3] @@ -838,7 +838,7 @@ func TestLockPOLSafety1(t *testing.T) { // What we want: // 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) vs2, vs3, vs4 := vss[1], vss[2], vss[3] @@ -937,7 +937,7 @@ func TestLockPOLSafety2(t *testing.T) { // TODO: Slashing /* -func TestSlashingPrevotes(t *testing.T) { +func TestStateSlashingPrevotes(t *testing.T) { cs1, vss := randConsensusState(2) vs2 := vss[1] @@ -972,7 +972,7 @@ func TestSlashingPrevotes(t *testing.T) { // XXX: Check for existence of Dupeout info } -func TestSlashingPrecommits(t *testing.T) { +func TestStateSlashingPrecommits(t *testing.T) { cs1, vss := randConsensusState(2) vs2 := vss[1] @@ -1017,7 +1017,7 @@ func TestSlashingPrecommits(t *testing.T) { // 4 vals. // 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) vs2, vs3, vs4 := vss[1], vss[2], vss[3] diff --git a/consensus/wal_test.go b/consensus/wal_test.go index c7f087398..3553591c9 100644 --- a/consensus/wal_test.go +++ b/consensus/wal_test.go @@ -41,7 +41,7 @@ func TestWALEncoderDecoder(t *testing.T) { } } -func TestSearchForEndHeight(t *testing.T) { +func TestWALSearchForEndHeight(t *testing.T) { walBody, err := WALWithNBlocks(6) if err != nil { t.Fatal(err)