From 5fcee2c34571f89ed70c18d8cbb899834598321e Mon Sep 17 00:00:00 2001 From: Sergio Mena Date: Thu, 22 Dec 2022 19:55:53 +0100 Subject: [PATCH] Thread contexts to the concerned test cases --- consensus/byzantine_test.go | 17 +++++++--- consensus/common_test.go | 3 +- consensus/reactor_test.go | 5 ++- consensus/replay_test.go | 11 ++++--- consensus/state_test.go | 64 +++++++++++++++++++++++++++++-------- node/node_test.go | 10 ++++-- state/execution_test.go | 27 ++++++++++++---- 7 files changed, 103 insertions(+), 34 deletions(-) diff --git a/consensus/byzantine_test.go b/consensus/byzantine_test.go index b31355334..41619e602 100644 --- a/consensus/byzantine_test.go +++ b/consensus/byzantine_test.go @@ -39,6 +39,9 @@ import ( // Byzantine node sends two different prevotes (nil and blockID) to the same validator func TestByzantinePrevoteEquivocation(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + const nValidators = 4 const byzantineNode = 0 const prevoteHeight = int64(2) @@ -223,7 +226,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) { proposerAddr := lazyProposer.privValidatorPubKey.Address() block, err := lazyProposer.blockExec.CreateProposalBlock( - context.TODO() /**/, lazyProposer.Height, lazyProposer.state, extCommit, proposerAddr) + ctx, lazyProposer.Height, lazyProposer.state, extCommit, proposerAddr) require.NoError(t, err) blockParts, err := block.MakePartSet(types.BlockPartSizeBytes) require.NoError(t, err) @@ -312,6 +315,10 @@ func TestByzantinePrevoteEquivocation(t *testing.T) { func TestByzantineConflictingProposalsWithPartition(t *testing.T) { N := 4 logger := consensusLogger().With("test", "byzantine") + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + app := newKVStore css, cleanup := randConsensusNet(t, N, "consensus_byzantine_test", newMockTickerFunc(false), app) defer cleanup() @@ -347,7 +354,7 @@ func TestByzantineConflictingProposalsWithPartition(t *testing.T) { css[i].privValidator.(types.MockPV).DisableChecks() css[i].decideProposal = func(j int32) func(int64, int32) { return func(height int64, round int32) { - byzantineDecideProposalFunc(t, height, round, css[j], switches[j]) + byzantineDecideProposalFunc(t, ctx, height, round, css[j], switches[j]) } }(int32(i)) // We are setting the prevote function to do nothing because the prevoting @@ -466,12 +473,12 @@ func TestByzantineConflictingProposalsWithPartition(t *testing.T) { //------------------------------- // byzantine consensus functions -func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *State, sw *p2p.Switch) { +func byzantineDecideProposalFunc(t *testing.T, ctx context.Context, height int64, round int32, cs *State, sw *p2p.Switch) { // byzantine user should create two proposals and try to split the vote. // Avoid sending on internalMsgQueue and running consensus state. // Create a new proposal block from state/txs from the mempool. - block1, err := cs.createProposalBlock(context.TODO() /**/) + block1, err := cs.createProposalBlock(ctx) require.NoError(t, err) blockParts1, err := block1.MakePartSet(types.BlockPartSizeBytes) require.NoError(t, err) @@ -488,7 +495,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St deliverTxsRange(t, cs, 0, 1) // Create a new proposal block from state/txs from the mempool. - block2, err := cs.createProposalBlock(context.TODO() /**/) + block2, err := cs.createProposalBlock(ctx) require.NoError(t, err) blockParts2, err := block2.MakePartSet(types.BlockPartSizeBytes) require.NoError(t, err) diff --git a/consensus/common_test.go b/consensus/common_test.go index fe27e4d1c..ad3a9f1f4 100644 --- a/consensus/common_test.go +++ b/consensus/common_test.go @@ -213,13 +213,14 @@ func startTestRound(cs *State, height int64, round int32) { // Create proposal block from cs1 but sign it with vs. func decideProposal( t *testing.T, + ctx context.Context, cs1 *State, vs *validatorStub, height int64, round int32, ) (proposal *types.Proposal, block *types.Block) { cs1.mtx.Lock() - block, err := cs1.createProposalBlock(context.TODO() /**/) + block, err := cs1.createProposalBlock(ctx) require.NoError(t, err) blockParts, err := block.MakePartSet(types.BlockPartSizeBytes) require.NoError(t, err) diff --git a/consensus/reactor_test.go b/consensus/reactor_test.go index c83a2159b..5a36e7d51 100644 --- a/consensus/reactor_test.go +++ b/consensus/reactor_test.go @@ -356,6 +356,9 @@ func TestSwitchToConsensusVoteExtensions(t *testing.T) { }, } { t.Run(testCase.name, func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs, vs := randState(1) validator := vs[0] validator.Height = testCase.storedHeight @@ -364,7 +367,7 @@ func TestSwitchToConsensusVoteExtensions(t *testing.T) { cs.state.LastValidators = cs.state.Validators.Copy() cs.state.ConsensusParams.ABCI.VoteExtensionsEnableHeight = testCase.initialRequiredHeight - propBlock, err := cs.createProposalBlock(context.TODO() /**/) + propBlock, err := cs.createProposalBlock(ctx) require.NoError(t, err) // Consensus is preparing to do the next height after the stored height. diff --git a/consensus/replay_test.go b/consensus/replay_test.go index c5dfd565c..0e1786a1f 100644 --- a/consensus/replay_test.go +++ b/consensus/replay_test.go @@ -313,6 +313,9 @@ var modes = []uint{0, 1, 2, 3} // This is actually not a test, it's for storing validator change tx data for testHandshakeReplay func setupChainWithChangingValidators(t *testing.T, name string, nBlocks int) (*cfg.Config, []*types.Block, []*types.ExtendedCommit, sm.State) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + nPeers := 7 nVals := 4 css, genDoc, config, cleanup := randConsensusNetWithPeers( @@ -358,7 +361,7 @@ func setupChainWithChangingValidators(t *testing.T, name string, nBlocks int) (* newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower) err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx1, nil, mempool.TxInfo{}) assert.NoError(t, err) - propBlock, err := css[0].createProposalBlock(context.TODO() /**/) // changeProposer(t, cs1, vs2) + propBlock, err := css[0].createProposalBlock(ctx) // changeProposer(t, cs1, vs2) require.NoError(t, err) propBlockParts, err := propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -390,7 +393,7 @@ func setupChainWithChangingValidators(t *testing.T, name string, nBlocks int) (* updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25) err = assertMempool(css[0].txNotifier).CheckTx(updateValidatorTx1, nil, mempool.TxInfo{}) assert.NoError(t, err) - propBlock, err = css[0].createProposalBlock(context.TODO() /**/) // changeProposer(t, cs1, vs2) + propBlock, err = css[0].createProposalBlock(ctx) // changeProposer(t, cs1, vs2) require.NoError(t, err) propBlockParts, err = propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -429,7 +432,7 @@ func setupChainWithChangingValidators(t *testing.T, name string, nBlocks int) (* newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower) err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx3, nil, mempool.TxInfo{}) assert.NoError(t, err) - propBlock, err = css[0].createProposalBlock(context.TODO() /**/) // changeProposer(t, cs1, vs2) + propBlock, err = css[0].createProposalBlock(ctx) // changeProposer(t, cs1, vs2) require.NoError(t, err) propBlockParts, err = propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -506,7 +509,7 @@ func setupChainWithChangingValidators(t *testing.T, name string, nBlocks int) (* removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0) err = assertMempool(css[0].txNotifier).CheckTx(removeValidatorTx3, nil, mempool.TxInfo{}) assert.NoError(t, err) - propBlock, err = css[0].createProposalBlock(context.TODO() /**/) // changeProposer(t, cs1, vs2) + propBlock, err = css[0].createProposalBlock(ctx) // changeProposer(t, cs1, vs2) require.NoError(t, err) propBlockParts, err = propBlock.MakePartSet(partSize) require.NoError(t, err) diff --git a/consensus/state_test.go b/consensus/state_test.go index 4bf7eb7cd..a3370b49b 100644 --- a/consensus/state_test.go +++ b/consensus/state_test.go @@ -186,6 +186,9 @@ func TestStateEnterProposeYesPrivValidator(t *testing.T) { } func TestStateBadProposal(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(2) height, round := cs1.Height, cs1.Round vs2 := vss[1] @@ -195,7 +198,7 @@ func TestStateBadProposal(t *testing.T) { proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal) voteCh := subscribe(cs1.eventBus, types.EventQueryVote) - propBlock, err := cs1.createProposalBlock(context.TODO() /**/) // changeProposer(t, cs1, vs2) + propBlock, err := cs1.createProposalBlock(ctx) // changeProposer(t, cs1, vs2) require.NoError(t, err) // make the second validator the proposer by incrementing round @@ -252,6 +255,9 @@ func TestStateBadProposal(t *testing.T) { } func TestStateOversizedBlock(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(2) cs1.state.ConsensusParams.Block.MaxBytes = 2000 height, round := cs1.Height, cs1.Round @@ -262,7 +268,7 @@ func TestStateOversizedBlock(t *testing.T) { timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose) voteCh := subscribe(cs1.eventBus, types.EventQueryVote) - propBlock, err := cs1.createProposalBlock(context.TODO() /**/) + propBlock, err := cs1.createProposalBlock(ctx) require.NoError(t, err) propBlock.Data.Txs = []types.Tx{tmrand.Bytes(2001)} propBlock.Header.DataHash = propBlock.Data.Hash() @@ -418,6 +424,9 @@ func TestStateFullRound2(t *testing.T) { // two validators, 4 rounds. // two vals take turns proposing. val1 locks on first one, precommits nil on everything else func TestStateLockNoPOL(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(2) vs2 := vss[1] height, round := cs1.Height, cs1.Round @@ -564,7 +573,7 @@ func TestStateLockNoPOL(t *testing.T) { cs2, _ := randState(2) // needed so generated block is different than locked block // before we time out into new round, set next proposal block - prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(t, ctx, cs2, vs2, vs2.Height, vs2.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } @@ -618,6 +627,9 @@ func TestStateLockNoPOL(t *testing.T) { // in round two: v1 prevotes the same block that the node is locked on // the others prevote a new block hence v1 changes lock and precommits the new block with the others func TestStateLockPOLRelock(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, cs1.Round @@ -663,7 +675,7 @@ func TestStateLockPOLRelock(t *testing.T) { // before we timeout to the new round set the new proposal cs2 := newState(cs1.state, vs2, kvstore.NewInMemoryApplication()) - prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(t, ctx, cs2, vs2, vs2.Height, vs2.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } @@ -717,6 +729,9 @@ func TestStateLockPOLRelock(t *testing.T) { // 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka func TestStateLockPOLUnlock(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, cs1.Round @@ -762,7 +777,7 @@ func TestStateLockPOLUnlock(t *testing.T) { signAddVotes(cs1, tmproto.PrecommitType, theBlockHash, theBlockParts, vs3) // before we time out into new round, set next proposal block - prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(t, ctx, cs1, vs2, vs2.Height, vs2.Round+1) propBlockParts, err := propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -810,6 +825,9 @@ func TestStateLockPOLUnlock(t *testing.T) { // v1 should unlock and precommit nil. In the third round another block is proposed, all vals // prevote and now v1 can lock onto the third block and precommit that func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, cs1.Round @@ -851,7 +869,7 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) { // before we timeout to the new round set the new proposal cs2 := newState(cs1.state, vs2, kvstore.NewInMemoryApplication()) - prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(t, ctx, cs2, vs2, vs2.Height, vs2.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } @@ -897,7 +915,7 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) { // before we timeout to the new round set the new proposal cs3 := newState(cs1.state, vs3, kvstore.NewInMemoryApplication()) - prop, propBlock = decideProposal(t, cs3, vs3, vs3.Height, vs3.Round+1) + prop, propBlock = decideProposal(t, ctx, cs3, vs3, vs3.Height, vs3.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } @@ -939,6 +957,9 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) { // then a polka at round 2 that we lock on // then we see the polka from round 1 but shouldn't unlock func TestStateLockPOLSafety1(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, cs1.Round @@ -982,7 +1003,7 @@ func TestStateLockPOLSafety1(t *testing.T) { t.Log("### ONTO ROUND 1") - prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(t, ctx, cs1, vs2, vs2.Height, vs2.Round+1) propBlockHash := propBlock.Hash() propBlockParts, err := propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -1062,6 +1083,9 @@ func TestStateLockPOLSafety1(t *testing.T) { // What we want: // dont see P0, lock on P1 at R1, dont unlock using P0 at R2 func TestStateLockPOLSafety2(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, cs1.Round @@ -1079,7 +1103,7 @@ func TestStateLockPOLSafety2(t *testing.T) { // the block for R0: gets polkad but we miss it // (even though we signed it, shhh) - _, propBlock0 := decideProposal(t, cs1, vss[0], height, round) + _, propBlock0 := decideProposal(t, ctx, cs1, vss[0], height, round) propBlockHash0 := propBlock0.Hash() propBlockParts0, err := propBlock0.MakePartSet(partSize) require.NoError(t, err) @@ -1089,7 +1113,7 @@ func TestStateLockPOLSafety2(t *testing.T) { prevotes := signVotes(tmproto.PrevoteType, propBlockHash0, propBlockParts0.Header(), vs2, vs3, vs4) // the block for round 1 - prop1, propBlock1 := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1) + prop1, propBlock1 := decideProposal(t, ctx, cs1, vs2, vs2.Height, vs2.Round+1) propBlockHash1 := propBlock1.Hash() propBlockParts1, err := propBlock1.MakePartSet(partSize) require.NoError(t, err) @@ -1316,6 +1340,9 @@ func TestSetValidBlockOnDelayedPrevote(t *testing.T) { // P0 miss to lock B as Proposal Block is missing, but set valid block to B after // receiving delayed Block Proposal. func TestSetValidBlockOnDelayedProposal(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, cs1.Round @@ -1343,7 +1370,7 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) { ensurePrevote(voteCh, height, round) validatePrevote(t, cs1, round, vss[0], nil) - prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(t, ctx, cs1, vs2, vs2.Height, vs2.Round+1) propBlockHash := propBlock.Hash() propBlockParts, err := propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -1984,6 +2011,9 @@ func TestWaitTimeoutProposeOnNilPolkaForTheCurrentRound(t *testing.T) { // What we want: // P0 emit NewValidBlock event upon receiving 2/3+ Precommit for B but hasn't received block B yet func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, int32(1) @@ -1995,7 +2025,7 @@ func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) { newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound) validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock) - _, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round) + _, propBlock := decideProposal(t, ctx, cs1, vs2, vs2.Height, vs2.Round) propBlockHash := propBlock.Hash() propBlockParts, err := propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -2019,6 +2049,9 @@ func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) { // P0 receives 2/3+ Precommit for B for round 0, while being in round 1. It emits NewValidBlock event. // After receiving block, it executes block and moves to the next height. func TestCommitFromPreviousRound(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + cs1, vss := randState(4) vs2, vs3, vs4 := vss[1], vss[2], vss[3] height, round := cs1.Height, int32(1) @@ -2029,7 +2062,7 @@ func TestCommitFromPreviousRound(t *testing.T) { validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock) proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal) - prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round) + prop, propBlock := decideProposal(t, ctx, cs1, vs2, vs2.Height, vs2.Round) propBlockHash := propBlock.Hash() propBlockParts, err := propBlock.MakePartSet(partSize) require.NoError(t, err) @@ -2134,6 +2167,9 @@ func TestStartNextHeightCorrectlyAfterTimeout(t *testing.T) { } func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + config.Consensus.SkipTimeoutCommit = false cs1, vss := randState(4) @@ -2175,7 +2211,7 @@ func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) { ensureNewBlockHeader(newBlockHeader, height, theBlockHash) - prop, propBlock := decideProposal(t, cs1, vs2, height+1, 0) + prop, propBlock := decideProposal(t, ctx, cs1, vs2, height+1, 0) propBlockParts, err := propBlock.MakePartSet(partSize) require.NoError(t, err) diff --git a/node/node_test.go b/node/node_test.go index 204ad50d5..fa51c9158 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -248,6 +248,9 @@ func testFreeAddr(t *testing.T) string { // create a proposal block using real and full // mempool and evidence pool and validate it. func TestCreateProposalBlock(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + config := test.ResetTestRoot("node_create_proposal") defer os.RemoveAll(config.RootDir) cc := proxy.NewLocalClientCreator(kvstore.NewInMemoryApplication()) @@ -335,7 +338,7 @@ func TestCreateProposalBlock(t *testing.T) { extCommit := &types.ExtendedCommit{Height: height - 1} block, err := blockExec.CreateProposalBlock( - context.TODO(), /**/ + ctx, height, state, extCommit, @@ -361,6 +364,9 @@ func TestCreateProposalBlock(t *testing.T) { } func TestMaxProposalBlockSize(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + config := test.ResetTestRoot("node_create_proposal") defer os.RemoveAll(config.RootDir) cc := proxy.NewLocalClientCreator(kvstore.NewInMemoryApplication()) @@ -422,7 +428,7 @@ func TestMaxProposalBlockSize(t *testing.T) { extCommit := &types.ExtendedCommit{Height: height - 1} block, err := blockExec.CreateProposalBlock( - context.TODO(), /**/ + ctx, height, state, extCommit, diff --git a/state/execution_test.go b/state/execution_test.go index b83e027f0..87f65d3e5 100644 --- a/state/execution_test.go +++ b/state/execution_test.go @@ -696,6 +696,8 @@ func TestFinalizeBlockValidatorUpdatesResultingInEmptySet(t *testing.T) { func TestEmptyPrepareProposal(t *testing.T) { const height = 2 + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() app := &abci.BaseApplication{} cc := proxy.NewLocalClientCreator(app) @@ -733,7 +735,7 @@ func TestEmptyPrepareProposal(t *testing.T) { pa, _ := state.Validators.GetByIndex(0) commit, _, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals) require.NoError(t, err) - _, err = blockExec.CreateProposalBlock(context.TODO() /**/, height, state, commit, pa) + _, err = blockExec.CreateProposalBlock(ctx, height, state, commit, pa) require.NoError(t, err) } @@ -741,6 +743,8 @@ func TestEmptyPrepareProposal(t *testing.T) { // the prepare proposal response are included in the block. func TestPrepareProposalTxsAllIncluded(t *testing.T) { const height = 2 + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() state, stateDB, privVals := makeState(1, height) stateStore := sm.NewStore(stateDB, sm.StoreOptions{ @@ -776,7 +780,7 @@ func TestPrepareProposalTxsAllIncluded(t *testing.T) { pa, _ := state.Validators.GetByIndex(0) commit, _, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals) require.NoError(t, err) - block, err := blockExec.CreateProposalBlock(context.TODO() /**/, height, state, commit, pa) + block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa) require.NoError(t, err) for i, tx := range block.Data.Txs { @@ -790,6 +794,8 @@ func TestPrepareProposalTxsAllIncluded(t *testing.T) { // in the order matching the order they are returned from PrepareProposal. func TestPrepareProposalReorderTxs(t *testing.T) { const height = 2 + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() state, stateDB, privVals := makeState(1, height) stateStore := sm.NewStore(stateDB, sm.StoreOptions{ @@ -829,7 +835,7 @@ func TestPrepareProposalReorderTxs(t *testing.T) { pa, _ := state.Validators.GetByIndex(0) commit, _, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals) require.NoError(t, err) - block, err := blockExec.CreateProposalBlock(context.TODO() /**/, height, state, commit, pa) + block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa) require.NoError(t, err) for i, tx := range block.Data.Txs { require.Equal(t, txs[i], tx) @@ -843,6 +849,8 @@ func TestPrepareProposalReorderTxs(t *testing.T) { // an error if the ResponsePrepareProposal returned from the application is invalid. func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) { const height = 2 + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() state, stateDB, privVals := makeState(1, height) // limit max block size @@ -884,7 +892,7 @@ func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) { pa, _ := state.Validators.GetByIndex(0) commit, _, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals) require.NoError(t, err) - block, err := blockExec.CreateProposalBlock(context.TODO() /**/, height, state, commit, pa) + block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa) require.Nil(t, block) require.ErrorContains(t, err, "transaction data size exceeds maximum") @@ -895,6 +903,8 @@ func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) { // upon calling PrepareProposal on it. func TestPrepareProposalErrorOnPrepareProposalError(t *testing.T) { const height = 2 + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() state, stateDB, privVals := makeState(1, height) stateStore := sm.NewStore(stateDB, sm.StoreOptions{ @@ -933,7 +943,7 @@ func TestPrepareProposalErrorOnPrepareProposalError(t *testing.T) { pa, _ := state.Validators.GetByIndex(0) commit, _, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals) require.NoError(t, err) - block, err := blockExec.CreateProposalBlock(context.TODO() /**/, height, state, commit, pa) + block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa) require.Nil(t, block) require.ErrorContains(t, err, "an injected error") @@ -980,6 +990,9 @@ func TestCreateProposalAbsentVoteExtensions(t *testing.T) { }, } { t.Run(testCase.name, func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + app := abcimocks.NewApplication(t) if !testCase.expectPanic { app.On("PrepareProposal", mock.Anything, mock.Anything).Return(&abci.ResponsePrepareProposal{}, nil) @@ -1026,10 +1039,10 @@ func TestCreateProposalAbsentVoteExtensions(t *testing.T) { stripSignatures(lastCommit) if testCase.expectPanic { require.Panics(t, func() { - blockExec.CreateProposalBlock(context.TODO() /**/, testCase.height, state, lastCommit, pa) //nolint:errcheck + blockExec.CreateProposalBlock(ctx, testCase.height, state, lastCommit, pa) //nolint:errcheck }) } else { - _, err = blockExec.CreateProposalBlock(context.TODO() /**/, testCase.height, state, lastCommit, pa) + _, err = blockExec.CreateProposalBlock(ctx, testCase.height, state, lastCommit, pa) require.NoError(t, err) } })