Replace context.Background with testing.TB.Context where possible (#15416)

* Replace context.Background with testing.TB.Context where possible * Fix failing tests
2026-01-09 13:28:01 -05:00 · 2025-06-16 17:09:18 -05:00
parent 6a13ba9125
commit 62fec4d1f3
409 changed files with 3175 additions and 3456 deletions
--- a/beacon-chain/execution/block_reader_test.go
+++ b/beacon-chain/execution/block_reader_test.go
@@ -35,7 +35,7 @@ func TestLatestMainchainInfo_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -77,7 +77,7 @@ func TestBlockHashByHeight_ReturnsHash(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -85,7 +85,7 @@ func TestBlockHashByHeight_ReturnsHash(t *testing.T) {

 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{}
-	ctx := context.Background()
+	ctx := t.Context()

 	header := &gethTypes.Header{
 		Number: big.NewInt(15),
@@ -110,7 +110,7 @@ func TestBlockHashByHeight_ReturnsError_WhenNoEth1Client(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -118,7 +118,7 @@ func TestBlockHashByHeight_ReturnsError_WhenNoEth1Client(t *testing.T) {

 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = nil
-	ctx := context.Background()
+	ctx := t.Context()

 	_, err = web3Service.BlockHashByHeight(ctx, big.NewInt(0))
 	require.ErrorContains(t, "nil rpc client", err)
@@ -133,7 +133,7 @@ func TestBlockExists_ValidHash(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -142,10 +142,10 @@ func TestBlockExists_ValidHash(t *testing.T) {
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	testAcc.Backend.Commit()
-	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), big.NewInt(0))
+	block, err := testAcc.Backend.Client().BlockByNumber(t.Context(), big.NewInt(0))
 	assert.NoError(t, err)

-	exists, height, err := web3Service.BlockExists(context.Background(), block.Hash())
+	exists, height, err := web3Service.BlockExists(t.Context(), block.Hash())
 	require.NoError(t, err, "Could not get block hash with given height")
 	require.Equal(t, true, exists)
 	require.Equal(t, 0, height.Cmp(block.Number()))
@@ -163,7 +163,7 @@ func TestBlockExists_InvalidHash(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -171,7 +171,7 @@ func TestBlockExists_InvalidHash(t *testing.T) {

 	web3Service = setDefaultMocks(web3Service)

-	_, _, err = web3Service.BlockExists(context.Background(), common.BytesToHash([]byte{0}))
+	_, _, err = web3Service.BlockExists(t.Context(), common.BytesToHash([]byte{0}))
 	require.NotNil(t, err, "Expected BlockExists to error with invalid hash")
 }

@@ -182,7 +182,7 @@ func TestBlockExists_UsesCachedBlockInfo(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -195,14 +195,14 @@ func TestBlockExists_UsesCachedBlockInfo(t *testing.T) {
 	err = web3Service.headerCache.AddHeader(header)
 	require.NoError(t, err)

-	exists, height, err := web3Service.BlockExists(context.Background(), header.Hash)
+	exists, height, err := web3Service.BlockExists(t.Context(), header.Hash)
 	require.NoError(t, err, "Could not get block hash with given height")
 	require.Equal(t, true, exists)
 	require.Equal(t, 0, height.Cmp(header.Number))
 }

 func TestService_BlockNumberByTimestamp(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	beaconDB := dbutil.SetupDB(t)
 	testAcc, err := mock.Setup()

@@ -212,7 +212,7 @@ func TestService_BlockNumberByTimestamp(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -250,7 +250,7 @@ func TestService_BlockNumberByTimestampLessTargetTime(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -261,7 +261,7 @@ func TestService_BlockNumberByTimestampLessTargetTime(t *testing.T) {
 	for i := 0; i < 200; i++ {
 		testAcc.Backend.Commit()
 	}
-	ctx := context.Background()
+	ctx := t.Context()
 	hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockTime = hd.Time
@@ -274,7 +274,7 @@ func TestService_BlockNumberByTimestampLessTargetTime(t *testing.T) {
 	require.ErrorContains(t, context.DeadlineExceeded.Error(), err)

 	// Provide an attainable target time
-	blk, err := web3Service.findMaxTargetEth1Block(context.Background(), hd.Number, hd.Time-5)
+	blk, err := web3Service.findMaxTargetEth1Block(t.Context(), hd.Number, hd.Time-5)
 	require.NoError(t, err)
 	require.NotEqual(t, hd.Number.Uint64(), blk.Number.Uint64(), "retrieved block is not less than the head")
 }
@@ -288,7 +288,7 @@ func TestService_BlockNumberByTimestampMoreTargetTime(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -299,7 +299,7 @@ func TestService_BlockNumberByTimestampMoreTargetTime(t *testing.T) {
 	for i := 0; i < 200; i++ {
 		testAcc.Backend.Commit()
 	}
-	ctx := context.Background()
+	ctx := t.Context()
 	hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockTime = hd.Time
@@ -312,7 +312,7 @@ func TestService_BlockNumberByTimestampMoreTargetTime(t *testing.T) {
 	require.ErrorContains(t, context.DeadlineExceeded.Error(), err)

 	// Provide an attainable target time with respect to head
-	blk, err := web3Service.findMinTargetEth1Block(context.Background(), big.NewInt(0).Sub(hd.Number, big.NewInt(5)), hd.Time)
+	blk, err := web3Service.findMinTargetEth1Block(t.Context(), big.NewInt(0).Sub(hd.Number, big.NewInt(5)), hd.Time)
 	require.NoError(t, err)
 	require.Equal(t, hd.Number.Uint64(), blk.Number.Uint64(), "retrieved block is not equal to the head")
 }
@@ -324,7 +324,7 @@ func TestService_BlockTimeByHeight_ReturnsError_WhenNoEth1Client(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -332,7 +332,7 @@ func TestService_BlockTimeByHeight_ReturnsError_WhenNoEth1Client(t *testing.T) {

 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = nil
-	ctx := context.Background()
+	ctx := t.Context()

 	_, err = web3Service.BlockTimeByHeight(ctx, big.NewInt(0))
 	require.ErrorContains(t, "nil rpc client", err)
--- a/beacon-chain/execution/deposit_test.go
+++ b/beacon-chain/execution/deposit_test.go
@@ -1,7 +1,6 @@
 package execution

 import (
-	"context"
 	"fmt"
 	"testing"

@@ -58,7 +57,7 @@ func TestProcessDeposit_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -72,10 +71,10 @@ func TestProcessDeposit_OK(t *testing.T) {
 	eth1Data, err := util.DeterministicEth1Data(len(deposits))
 	require.NoError(t, err)

-	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
+	err = web3Service.processDeposit(t.Context(), eth1Data, deposits[0])
 	require.NoError(t, err, "could not process deposit")

-	valcount, err := helpers.ActiveValidatorCount(context.Background(), web3Service.preGenesisState, 0)
+	valcount, err := helpers.ActiveValidatorCount(t.Context(), web3Service.preGenesisState, 0)
 	require.NoError(t, err)
 	require.Equal(t, 1, int(valcount), "Did not get correct active validator count")
 }
@@ -87,7 +86,7 @@ func TestProcessDeposit_InvalidMerkleBranch(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -102,7 +101,7 @@ func TestProcessDeposit_InvalidMerkleBranch(t *testing.T) {

 	deposits[0].Proof = [][]byte{{'f', 'a', 'k', 'e'}}

-	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
+	err = web3Service.processDeposit(t.Context(), eth1Data, deposits[0])
 	require.NotNil(t, err, "No errors, when an error was expected")

 	want := "deposit merkle branch of deposit root did not verify for root"
@@ -118,7 +117,7 @@ func TestProcessDeposit_InvalidPublicKey(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -146,7 +145,7 @@ func TestProcessDeposit_InvalidPublicKey(t *testing.T) {
 		DepositRoot:  root[:],
 	}

-	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
+	err = web3Service.processDeposit(t.Context(), eth1Data, deposits[0])
 	require.NoError(t, err)

 	require.LogsContain(t, hook, pubKeyErr)
@@ -160,7 +159,7 @@ func TestProcessDeposit_InvalidSignature(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -187,7 +186,7 @@ func TestProcessDeposit_InvalidSignature(t *testing.T) {
 		DepositRoot:  root[:],
 	}

-	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
+	err = web3Service.processDeposit(t.Context(), eth1Data, deposits[0])
 	require.NoError(t, err)

 	require.LogsContain(t, hook, "could not verify deposit data signature")
@@ -202,7 +201,7 @@ func TestProcessDeposit_UnableToVerify(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -225,7 +224,7 @@ func TestProcessDeposit_UnableToVerify(t *testing.T) {
 	proof, err := generatedTrie.MerkleProof(0)
 	require.NoError(t, err)
 	deposits[0].Proof = proof
-	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
+	err = web3Service.processDeposit(t.Context(), eth1Data, deposits[0])
 	require.NoError(t, err)
 	want := "signature did not verify"

@@ -240,7 +239,7 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -293,10 +292,10 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) {

 		deposit.Proof, err = generatedTrie.MerkleProof(i)
 		require.NoError(t, err)
-		err = web3Service.processDeposit(context.Background(), eth1Data, deposit)
+		err = web3Service.processDeposit(t.Context(), eth1Data, deposit)
 		require.NoError(t, err, fmt.Sprintf("Could not process deposit at %d", i))

-		valcount, err := helpers.ActiveValidatorCount(context.Background(), web3Service.preGenesisState, 0)
+		valcount, err := helpers.ActiveValidatorCount(t.Context(), web3Service.preGenesisState, 0)
 		require.NoError(t, err)
 		require.Equal(t, 0, int(valcount), "Did not get correct active validator count")
 	}
@@ -309,7 +308,7 @@ func TestProcessDeposit_AllDepositedSuccessfully(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -323,10 +322,10 @@ func TestProcessDeposit_AllDepositedSuccessfully(t *testing.T) {

 	for i := range keys {
 		eth1Data.DepositCount = uint64(i + 1)
-		err = web3Service.processDeposit(context.Background(), eth1Data, deposits[i])
+		err = web3Service.processDeposit(t.Context(), eth1Data, deposits[i])
 		require.NoError(t, err, fmt.Sprintf("Could not process deposit at %d", i))

-		valCount, err := helpers.ActiveValidatorCount(context.Background(), web3Service.preGenesisState, 0)
+		valCount, err := helpers.ActiveValidatorCount(t.Context(), web3Service.preGenesisState, 0)
 		require.NoError(t, err)
 		require.Equal(t, uint64(i+1), valCount, "Did not get correct active validator count")

--- a/beacon-chain/execution/engine_client_test.go
+++ b/beacon-chain/execution/engine_client_test.go
@@ -66,7 +66,7 @@ func TestClient_IPC(t *testing.T) {
 	defer rpcClient.Close()
 	srv := &Service{}
 	srv.rpcClient = rpcClient
-	ctx := context.Background()
+	ctx := t.Context()
 	fix := fixtures()

 	params.SetupTestConfigCleanup(t)
@@ -159,7 +159,7 @@ func TestClient_IPC(t *testing.T) {
 }

 func TestClient_HTTP(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	fix := fixtures()

 	params.SetupTestConfigCleanup(t)
@@ -954,7 +954,7 @@ func TestClient_HTTP(t *testing.T) {
 }

 func TestReconstructFullBellatrixBlock(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	t.Run("nil block", func(t *testing.T) {
 		service := &Service{}

@@ -1046,7 +1046,7 @@ func TestReconstructFullBellatrixBlock(t *testing.T) {
 }

 func TestReconstructFullBellatrixBlockBatch(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	t.Run("nil block", func(t *testing.T) {
 		service := &Service{}

@@ -1374,7 +1374,7 @@ func TestServer_getPowBlockHashAtTerminalTotalDifficulty(t *testing.T) {
 				ExecutionBlock:     tt.currentPowBlock,
 				BlockByHashMap:     m,
 			}
-			b, e, err := client.GetTerminalBlockHash(context.Background(), 1)
+			b, e, err := client.GetTerminalBlockHash(t.Context(), 1)
 			if tt.errString != "" {
 				require.ErrorContains(t, tt.errString, err)
 			} else {
@@ -1908,7 +1908,7 @@ func TestHeaderByHash_NotFound(t *testing.T) {
 	srv := &Service{}
 	srv.rpcClient = RPCClientBad{}

-	_, err := srv.HeaderByHash(context.Background(), [32]byte{})
+	_, err := srv.HeaderByHash(t.Context(), [32]byte{})
 	assert.Equal(t, ethereum.NotFound, err)
 }

@@ -1916,7 +1916,7 @@ func TestHeaderByNumber_NotFound(t *testing.T) {
 	srv := &Service{}
 	srv.rpcClient = RPCClientBad{}

-	_, err := srv.HeaderByNumber(context.Background(), big.NewInt(100))
+	_, err := srv.HeaderByNumber(t.Context(), big.NewInt(100))
 	assert.Equal(t, ethereum.NotFound, err)
 }

@@ -2300,7 +2300,7 @@ func newPayloadV4Setup(t *testing.T, status *pb.PayloadStatus, payload *pb.Execu

 func TestReconstructBlindedBlockBatch(t *testing.T) {
 	t.Run("empty response works", func(t *testing.T) {
-		ctx := context.Background()
+		ctx := t.Context()
 		cli, srv := newMockEngine(t)
 		srv.registerDefault(func(*jsonrpcMessage, http.ResponseWriter, *http.Request) {

@@ -2311,7 +2311,7 @@ func TestReconstructBlindedBlockBatch(t *testing.T) {
 		require.Equal(t, 0, len(results))
 	})
 	t.Run("expected error for nil response", func(t *testing.T) {
-		ctx := context.Background()
+		ctx := t.Context()
 		slot, err := slots.EpochStart(params.BeaconConfig().DenebForkEpoch)
 		require.NoError(t, err)
 		blk, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, 0)
@@ -2345,7 +2345,7 @@ func Test_ExchangeCapabilities(t *testing.T) {
 			err := json.NewEncoder(w).Encode(resp)
 			require.NoError(t, err)
 		}))
-		ctx := context.Background()
+		ctx := t.Context()
 		logHook := logTest.NewGlobal()

 		rpcClient, err := rpc.DialHTTP(srv.URL)
@@ -2378,7 +2378,7 @@ func Test_ExchangeCapabilities(t *testing.T) {
 			err := json.NewEncoder(w).Encode(resp)
 			require.NoError(t, err)
 		}))
-		ctx := context.Background()
+		ctx := t.Context()

 		rpcClient, err := rpc.DialHTTP(srv.URL)
 		require.NoError(t, err)
@@ -2413,7 +2413,7 @@ func TestReconstructBlobSidecars(t *testing.T) {
 	sb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)

-	ctx := context.Background()
+	ctx := t.Context()
 	t.Run("all seen", func(t *testing.T) {
 		hi := mockSummary(t, []bool{true, true, true, true, true, true})
 		verifiedBlobs, err := client.ReconstructBlobSidecars(ctx, sb, r, hi)
--- a/beacon-chain/execution/log_processing_test.go
+++ b/beacon-chain/execution/log_processing_test.go
@@ -1,7 +1,6 @@
 package execution

 import (
-	"context"
 	"encoding/binary"
 	"math/big"
 	"testing"
@@ -39,7 +38,7 @@ func TestProcessDepositLog_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -79,7 +78,7 @@ func TestProcessDepositLog_OK(t *testing.T) {
 		t.Fatal("no logs")
 	}

-	err = web3Service.ProcessLog(context.Background(), &logs[0])
+	err = web3Service.ProcessLog(t.Context(), &logs[0])
 	require.NoError(t, err)

 	require.LogsDoNotContain(t, hook, "Could not unpack log")
@@ -108,7 +107,7 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
 		server.Stop()
 	})

-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -149,12 +148,12 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {

 	web3Service.chainStartData.Chainstarted = true

-	err = web3Service.ProcessDepositLog(context.Background(), &logs[0])
+	err = web3Service.ProcessDepositLog(t.Context(), &logs[0])
 	require.NoError(t, err)
-	err = web3Service.ProcessDepositLog(context.Background(), &logs[1])
+	err = web3Service.ProcessDepositLog(t.Context(), &logs[1])
 	require.NoError(t, err)

-	pendingDeposits := web3Service.cfg.depositCache.PendingDeposits(context.Background(), nil /*blockNum*/)
+	pendingDeposits := web3Service.cfg.depositCache.PendingDeposits(t.Context(), nil /*blockNum*/)
 	require.Equal(t, 2, len(pendingDeposits), "Unexpected number of deposits")

 	hook.Reset()
@@ -169,7 +168,7 @@ func TestUnpackDepositLogData_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -224,7 +223,7 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
 		server.Stop()
 	})

-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -273,7 +272,7 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
 	require.NoError(t, err, "Unable to retrieve logs")

 	for i := range logs {
-		err = web3Service.ProcessLog(context.Background(), &logs[i])
+		err = web3Service.ProcessLog(t.Context(), &logs[i])
 		require.NoError(t, err)
 	}
 	assert.Equal(t, false, web3Service.chainStartData.Chainstarted, "Genesis has been triggered despite being 8 duplicate keys")
@@ -299,7 +298,7 @@ func TestProcessETH2GenesisLog(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -352,11 +351,11 @@ func TestProcessETH2GenesisLog(t *testing.T) {
 	defer stateSub.Unsubscribe()

 	for i := range logs {
-		err = web3Service.ProcessLog(context.Background(), &logs[i])
+		err = web3Service.ProcessLog(t.Context(), &logs[i])
 		require.NoError(t, err)
 	}

-	err = web3Service.ProcessETH1Block(context.Background(), big.NewInt(int64(logs[len(logs)-1].BlockNumber)))
+	err = web3Service.ProcessETH1Block(t.Context(), big.NewInt(int64(logs[len(logs)-1].BlockNumber)))
 	require.NoError(t, err)

 	cachedDeposits := web3Service.chainStartData.ChainstartDeposits
@@ -392,7 +391,7 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 		server.Stop()
 	})

-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(kvStore),
@@ -405,7 +404,7 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	web3Service.httpLogger = testAcc.Backend.Client()
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	block, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
 	web3Service.latestEth1Data.BlockTime = block.Time()
@@ -446,7 +445,7 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	b, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
 	web3Service.latestEth1Data.BlockTime = b.Time()
@@ -456,7 +455,7 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	stateSub := web3Service.cfg.stateNotifier.StateFeed().Subscribe(stateChannel)
 	defer stateSub.Unsubscribe()

-	err = web3Service.processPastLogs(context.Background())
+	err = web3Service.processPastLogs(t.Context())
 	require.NoError(t, err)

 	cachedDeposits := web3Service.chainStartData.ChainstartDeposits
@@ -493,7 +492,7 @@ func TestProcessLogs_DepositRequestsStarted(t *testing.T) {
 		server.Stop()
 	})

-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(kvStore),
@@ -506,7 +505,7 @@ func TestProcessLogs_DepositRequestsStarted(t *testing.T) {
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	web3Service.httpLogger = testAcc.Backend.Client()
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	block, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
 	web3Service.latestEth1Data.BlockTime = block.Time()
@@ -547,7 +546,7 @@ func TestProcessLogs_DepositRequestsStarted(t *testing.T) {
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	b, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
 	web3Service.latestEth1Data.BlockTime = b.Time()
@@ -580,7 +579,7 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 		server.Stop()
 	})

-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(kvStore),
@@ -593,7 +592,7 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	web3Service.httpLogger = testAcc.Backend.Client()
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	b, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
 	web3Service.latestEth1Data.BlockTime = b.Time()
@@ -633,7 +632,7 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	for i := uint64(0); i < 1500; i++ {
 		testAcc.Backend.Commit()
 	}
-	genesisBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	genesisBlock, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)

 	wantedGenesisTime := genesisBlock.Time()
@@ -642,7 +641,7 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	currBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	currBlock, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockHeight = currBlock.NumberU64()
 	web3Service.latestEth1Data.BlockTime = currBlock.Time()
@@ -658,7 +657,7 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	stateSub := web3Service.cfg.stateNotifier.StateFeed().Subscribe(stateChannel)
 	defer stateSub.Unsubscribe()

-	err = web3Service.processPastLogs(context.Background())
+	err = web3Service.processPastLogs(t.Context())
 	require.NoError(t, err)

 	cachedDeposits := web3Service.chainStartData.ChainstartDeposits
@@ -686,7 +685,7 @@ func TestCheckForChainstart_NoValidator(t *testing.T) {
 	require.NoError(t, err, "Unable to set up simulated backend")
 	beaconDB := testDB.SetupDB(t)
 	s := newPowchainService(t, testAcc, beaconDB)
-	s.processChainStartIfReady(context.Background(), [32]byte{}, nil, 0)
+	s.processChainStartIfReady(t.Context(), [32]byte{}, nil, 0)
 	require.LogsDoNotContain(t, hook, "Could not determine active validator count from pre genesis state")
 }

@@ -698,7 +697,7 @@ func newPowchainService(t *testing.T, eth1Backend *mock.TestAccount, beaconDB db
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(eth1Backend.ContractAddr),
 		WithDatabase(beaconDB),
--- a/beacon-chain/execution/mock_test.go
+++ b/beacon-chain/execution/mock_test.go
@@ -1,7 +1,6 @@
 package execution

 import (
-	"context"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
@@ -117,7 +116,7 @@ func mockWriteResult(t *testing.T, w http.ResponseWriter, req *jsonrpcMessage, r
 }

 func TestParseRequest(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	cases := []struct {
 		method   string
 		hexArgs  []string // uint64 as hex
@@ -197,7 +196,7 @@ func TestCallCount(t *testing.T) {
 				mockWriteResult(t, w, msg, nil)
 			})
 			for i := 0; i < c.count; i++ {
-				require.NoError(t, cli.CallContext(context.Background(), nil, c.method))
+				require.NoError(t, cli.CallContext(t.Context(), nil, c.method))
 			}
 			for _, m := range methods {
 				if m == c.method {
--- a/beacon-chain/execution/payload_body_test.go
+++ b/beacon-chain/execution/payload_body_test.go
@@ -1,7 +1,6 @@
 package execution

 import (
-	"context"
 	"net/http"
 	"testing"

@@ -125,7 +124,7 @@ func TestPayloadBodiesViaUnblinder(t *testing.T) {
 			}
 			mockWriteResult(t, w, msg, executionPayloadBodies)
 		})
-		ctx := context.Background()
+		ctx := t.Context()

 		toUnblind := []interfaces.ReadOnlySignedBeaconBlock{
 			fx.denebBlock.blinded.block,
@@ -255,7 +254,7 @@ func TestComputeRanges(t *testing.T) {

 func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
 	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
-	ctx := context.Background()
+	ctx := t.Context()
 	t.Run("fallback fails", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
 		fx := testBlindedBlockFixtures(t)
@@ -353,7 +352,7 @@ func TestReconstructBlindedBlockBatchDenebAndBeyond(t *testing.T) {
 			fx.electra.blinded.block,
 			fx.fulu.blinded.block,
 		}
-		unblinded, err := reconstructBlindedBlockBatch(context.Background(), cli, blinded)
+		unblinded, err := reconstructBlindedBlockBatch(t.Context(), cli, blinded)
 		require.NoError(t, err)
 		require.Equal(t, len(blinded), len(unblinded))
 		for i := range unblinded {
--- a/beacon-chain/execution/prometheus_test.go
+++ b/beacon-chain/execution/prometheus_test.go
@@ -13,7 +13,7 @@ import (
 // also tests the interchangeability of the explicit prometheus Register/Unregister
 // and the implicit methods within the collector implementation
 func TestCleanup(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	pc, err := NewPowchainCollector(ctx)
 	assert.NoError(t, err, "Unexpected error calling NewPowchainCollector")
 	unregistered := pc.unregister()
@@ -37,7 +37,7 @@ func TestCleanup(t *testing.T) {
 // does come at the cost of an extra channel cluttering up
 // PowchainCollector, just for this test.
 func TestCancellation(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	pc, err := NewPowchainCollector(ctx)
 	assert.NoError(t, err, "Unexpected error calling NewPowchainCollector")
 	ticker := time.NewTicker(10 * time.Second)
--- a/beacon-chain/execution/service_test.go
+++ b/beacon-chain/execution/service_test.go
@@ -100,7 +100,7 @@ func TestStart_OK(t *testing.T) {
 	waiter := verification.NewInitializerWaiter(
 		c, forkchoice.NewROForkChoice(nil), nil)

-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -130,7 +130,7 @@ func TestStart_NoHttpEndpointDefinedFails_WithoutChainStarted(t *testing.T) {
 	beaconDB := dbutil.SetupDB(t)
 	testAcc, err := mock.Setup()
 	require.NoError(t, err, "Unable to set up simulated backend")
-	_, err = NewService(context.Background(),
+	_, err = NewService(t.Context(),
 		WithHttpEndpoint(""),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -149,7 +149,7 @@ func TestStop_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -179,7 +179,7 @@ func TestService_Eth1Synced(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -189,7 +189,7 @@ func TestService_Eth1Synced(t *testing.T) {
 	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)

-	header, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
+	header, err := testAcc.Backend.Client().HeaderByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	currTime := header.Time
 	now := time.Now()
@@ -206,7 +206,7 @@ func TestFollowBlock_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -221,7 +221,7 @@ func TestFollowBlock_OK(t *testing.T) {

 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	block, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	baseHeight := block.NumberU64()
 	// process follow_distance blocks
@@ -229,16 +229,16 @@ func TestFollowBlock_OK(t *testing.T) {
 	for i := 0; i < int(params.BeaconConfig().Eth1FollowDistance); i++ {
 		lastHash = testAcc.Backend.Commit()
 	}
-	lb, err := testAcc.Backend.Client().BlockByHash(context.Background(), lastHash)
+	lb, err := testAcc.Backend.Client().BlockByHash(t.Context(), lastHash)
 	require.NoError(t, err)
 	log.Println(lb.NumberU64())
 	// set current height
-	block, err = testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	block, err = testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
 	web3Service.latestEth1Data.BlockTime = block.Time()

-	h, err := web3Service.followedBlockHeight(context.Background())
+	h, err := web3Service.followedBlockHeight(t.Context())
 	require.NoError(t, err)
 	assert.Equal(t, baseHeight, h, "Unexpected block height")
 	numToForward := uint64(2)
@@ -248,13 +248,13 @@ func TestFollowBlock_OK(t *testing.T) {
 		testAcc.Backend.Commit()
 	}

-	newBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	newBlock, err := testAcc.Backend.Client().BlockByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	// set current height
 	web3Service.latestEth1Data.BlockHeight = newBlock.NumberU64()
 	web3Service.latestEth1Data.BlockTime = newBlock.Time()

-	h, err = web3Service.followedBlockHeight(context.Background())
+	h, err = web3Service.followedBlockHeight(t.Context())
 	require.NoError(t, err)
 	assert.Equal(t, expectedHeight, h, "Unexpected block height")
 }
@@ -294,7 +294,7 @@ func TestHandlePanic_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 	)
@@ -331,7 +331,7 @@ func TestLogTillGenesis_OK(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -371,19 +371,19 @@ func TestInitDepositCache_OK(t *testing.T) {
 	var err error
 	s.cfg.depositCache, err = depositsnapshot.New()
 	require.NoError(t, err)
-	require.NoError(t, s.initDepositCaches(context.Background(), ctrs))
+	require.NoError(t, s.initDepositCaches(t.Context(), ctrs))

-	require.Equal(t, 0, len(s.cfg.depositCache.PendingContainers(context.Background(), nil)))
+	require.Equal(t, 0, len(s.cfg.depositCache.PendingContainers(t.Context(), nil)))

 	blockRootA := [32]byte{'a'}

 	emptyState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.cfg.beaconDB.SaveGenesisBlockRoot(context.Background(), blockRootA))
-	require.NoError(t, s.cfg.beaconDB.SaveState(context.Background(), emptyState, blockRootA))
+	require.NoError(t, s.cfg.beaconDB.SaveGenesisBlockRoot(t.Context(), blockRootA))
+	require.NoError(t, s.cfg.beaconDB.SaveState(t.Context(), emptyState, blockRootA))
 	s.chainStartData.Chainstarted = true
-	require.NoError(t, s.initDepositCaches(context.Background(), ctrs))
-	require.Equal(t, 3, len(s.cfg.depositCache.PendingContainers(context.Background(), nil)))
+	require.NoError(t, s.initDepositCaches(t.Context(), ctrs))
+	require.Equal(t, 3, len(s.cfg.depositCache.PendingContainers(t.Context(), nil)))
 }

 func TestInitDepositCacheWithFinalization_OK(t *testing.T) {
@@ -432,9 +432,9 @@ func TestInitDepositCacheWithFinalization_OK(t *testing.T) {
 	var err error
 	s.cfg.depositCache, err = depositsnapshot.New()
 	require.NoError(t, err)
-	require.NoError(t, s.initDepositCaches(context.Background(), ctrs))
+	require.NoError(t, s.initDepositCaches(t.Context(), ctrs))

-	require.Equal(t, 0, len(s.cfg.depositCache.PendingContainers(context.Background(), nil)))
+	require.Equal(t, 0, len(s.cfg.depositCache.PendingContainers(t.Context(), nil)))

 	headBlock := util.NewBeaconBlock()
 	headRoot, err := headBlock.Block.HashTreeRoot()
@@ -443,21 +443,21 @@ func TestInitDepositCacheWithFinalization_OK(t *testing.T) {

 	emptyState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.cfg.beaconDB.SaveGenesisBlockRoot(context.Background(), headRoot))
-	require.NoError(t, s.cfg.beaconDB.SaveState(context.Background(), emptyState, headRoot))
-	require.NoError(t, stateGen.SaveState(context.Background(), headRoot, emptyState))
+	require.NoError(t, s.cfg.beaconDB.SaveGenesisBlockRoot(t.Context(), headRoot))
+	require.NoError(t, s.cfg.beaconDB.SaveState(t.Context(), emptyState, headRoot))
+	require.NoError(t, stateGen.SaveState(t.Context(), headRoot, emptyState))
 	s.cfg.stateGen = stateGen
 	require.NoError(t, emptyState.SetEth1DepositIndex(3))

-	ctx := context.Background()
+	ctx := t.Context()
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(0), Root: headRoot[:]}))
 	s.cfg.finalizedStateAtStartup = emptyState

 	s.chainStartData.Chainstarted = true
-	require.NoError(t, s.initDepositCaches(context.Background(), ctrs))
+	require.NoError(t, s.initDepositCaches(t.Context(), ctrs))
 	fDeposits, err := s.cfg.depositCache.FinalizedDeposits(ctx)
 	require.NoError(t, err)
-	deps := s.cfg.depositCache.NonFinalizedDeposits(context.Background(), fDeposits.MerkleTrieIndex(), nil)
+	deps := s.cfg.depositCache.NonFinalizedDeposits(t.Context(), fDeposits.MerkleTrieIndex(), nil)
 	assert.Equal(t, 0, len(deps))
 }

@@ -470,7 +470,7 @@ func TestNewService_EarliestVotingBlock(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	web3Service, err := NewService(context.Background(),
+	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -486,7 +486,7 @@ func TestNewService_EarliestVotingBlock(t *testing.T) {

 	// Genesis not set
 	followBlock := uint64(2000)
-	blk, err := web3Service.determineEarliestVotingBlock(context.Background(), followBlock)
+	blk, err := web3Service.determineEarliestVotingBlock(t.Context(), followBlock)
 	require.NoError(t, err)
 	assert.Equal(t, followBlock-conf.Eth1FollowDistance, blk, "unexpected earliest voting block")

@@ -497,14 +497,14 @@ func TestNewService_EarliestVotingBlock(t *testing.T) {
 	for i := 0; i < numToForward; i++ {
 		testAcc.Backend.Commit()
 	}
-	currHeader, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
+	currHeader, err := testAcc.Backend.Client().HeaderByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	currTime := currHeader.Time
 	now := time.Now()
 	err = testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0)))
 	require.NoError(t, err)
 	testAcc.Backend.Commit()
-	currHeader, err = testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
+	currHeader, err = testAcc.Backend.Client().HeaderByNumber(t.Context(), nil)
 	require.NoError(t, err)
 	currTime = currHeader.Time
 	web3Service.latestEth1Data.BlockHeight = currHeader.Number.Uint64()
@@ -512,7 +512,7 @@ func TestNewService_EarliestVotingBlock(t *testing.T) {
 	web3Service.chainStartData.GenesisTime = currTime

 	// With a current slot of zero, only request follow_blocks behind.
-	blk, err = web3Service.determineEarliestVotingBlock(context.Background(), followBlock)
+	blk, err = web3Service.determineEarliestVotingBlock(t.Context(), followBlock)
 	require.NoError(t, err)
 	assert.Equal(t, followBlock-conf.Eth1FollowDistance, blk, "unexpected earliest voting block")

@@ -528,14 +528,14 @@ func TestNewService_Eth1HeaderRequLimit(t *testing.T) {
 	t.Cleanup(func() {
 		server.Stop()
 	})
-	s1, err := NewService(context.Background(),
+	s1, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	assert.Equal(t, defaultEth1HeaderReqLimit, s1.cfg.eth1HeaderReqLimit, "default eth1 header request limit not set")
-	s2, err := NewService(context.Background(),
+	s2, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -584,7 +584,7 @@ func TestService_EnsureConsistentPowchainData(t *testing.T) {
 	t.Cleanup(func() {
 		srv.Stop()
 	})
-	s1, err := NewService(context.Background(),
+	s1, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 		WithDepositCache(cache),
@@ -594,11 +594,11 @@ func TestService_EnsureConsistentPowchainData(t *testing.T) {
 	require.NoError(t, err)
 	assert.NoError(t, genState.SetSlot(1000))

-	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(context.Background(), genState))
-	_, err = s1.validPowchainData(context.Background())
+	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(t.Context(), genState))
+	_, err = s1.validPowchainData(t.Context())
 	require.NoError(t, err)

-	eth1Data, err := s1.cfg.beaconDB.ExecutionChainData(context.Background())
+	eth1Data, err := s1.cfg.beaconDB.ExecutionChainData(t.Context())
 	assert.NoError(t, err)

 	assert.NotNil(t, eth1Data)
@@ -615,7 +615,7 @@ func TestService_InitializeCorrectly(t *testing.T) {
 	t.Cleanup(func() {
 		srv.Stop()
 	})
-	s1, err := NewService(context.Background(),
+	s1, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 		WithDepositCache(cache),
@@ -625,14 +625,14 @@ func TestService_InitializeCorrectly(t *testing.T) {
 	require.NoError(t, err)
 	assert.NoError(t, genState.SetSlot(1000))

-	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(context.Background(), genState))
-	_, err = s1.validPowchainData(context.Background())
+	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(t.Context(), genState))
+	_, err = s1.validPowchainData(t.Context())
 	require.NoError(t, err)

-	eth1Data, err := s1.cfg.beaconDB.ExecutionChainData(context.Background())
+	eth1Data, err := s1.cfg.beaconDB.ExecutionChainData(t.Context())
 	assert.NoError(t, err)

-	assert.NoError(t, s1.initializeEth1Data(context.Background(), eth1Data))
+	assert.NoError(t, s1.initializeEth1Data(t.Context(), eth1Data))
 	assert.Equal(t, int64(-1), s1.lastReceivedMerkleIndex, "received incorrect last received merkle index")
 }

@@ -645,7 +645,7 @@ func TestService_EnsureValidPowchainData(t *testing.T) {
 	t.Cleanup(func() {
 		srv.Stop()
 	})
-	s1, err := NewService(context.Background(),
+	s1, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 		WithDepositCache(cache),
@@ -655,17 +655,17 @@ func TestService_EnsureValidPowchainData(t *testing.T) {
 	require.NoError(t, err)
 	assert.NoError(t, genState.SetSlot(1000))

-	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(context.Background(), genState))
+	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(t.Context(), genState))

-	err = s1.cfg.beaconDB.SaveExecutionChainData(context.Background(), &ethpb.ETH1ChainData{
+	err = s1.cfg.beaconDB.SaveExecutionChainData(t.Context(), &ethpb.ETH1ChainData{
 		ChainstartData:    &ethpb.ChainStartData{Chainstarted: true},
 		DepositContainers: []*ethpb.DepositContainer{{Index: 1}},
 	})
 	require.NoError(t, err)
-	_, err = s1.validPowchainData(context.Background())
+	_, err = s1.validPowchainData(t.Context())
 	require.NoError(t, err)

-	eth1Data, err := s1.cfg.beaconDB.ExecutionChainData(context.Background())
+	eth1Data, err := s1.cfg.beaconDB.ExecutionChainData(t.Context())
 	assert.NoError(t, err)

 	assert.NotNil(t, eth1Data)
@@ -741,7 +741,7 @@ func TestETH1Endpoints(t *testing.T) {
 	beaconDB := dbutil.SetupDB(t)

 	mbs := &mockBSUpdater{}
-	s1, err := NewService(context.Background(),
+	s1, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoints[0]),
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
@@ -796,7 +796,7 @@ func TestService_FollowBlock(t *testing.T) {
 		headerCache:    newHeaderCache(),
 		latestEth1Data: &ethpb.LatestETH1Data{BlockTime: (3000 * 40) + followTime, BlockHeight: 3000},
 	}
-	h, err := s.followedBlockHeight(context.Background())
+	h, err := s.followedBlockHeight(t.Context())
 	assert.NoError(t, err)
 	// With a much higher blocktime, the follow height is respectively shortened.
 	assert.Equal(t, uint64(2283), h)
@@ -841,7 +841,7 @@ func TestService_migrateOldDepositTree(t *testing.T) {
 	t.Cleanup(func() {
 		srv.Stop()
 	})
-	s, err := NewService(context.Background(),
+	s, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),
 		WithDatabase(beaconDB),
 		WithDepositCache(cache),