minor test cleanup:

* renaming a few variable to prevent variable shadowing
• removed unnecessary white spaces
• removed duplicated instantiation of Lock Manager in testing suite's Setup method plus individual tests.

Author: AlexHentschel

cmd/util/cmd/execution-state-extract/execution_state_extract_test.go

@@ -37,7 +37,6 @@ func TestExtractExecutionState(t *testing.T) {
 	metr := &metrics.NoopCollector{}
 
 	t.Run("missing block->state commitment mapping", func(t *testing.T) {
-
 		withDirs(t, func(datadir, execdir, outdir string) {
 			// Initialize a proper Badger database instead of using empty directory
 			db := unittest.PebbleDB(t, datadir)
@@ -96,7 +95,6 @@ func TestExtractExecutionState(t *testing.T) {
 		lockManager := storage.NewTestingLockManager()
 
 		withDirs(t, func(datadir, execdir, _ string) {
-
 			const (
 				checkpointDistance = math.MaxInt // A large number to prevent checkpoint creation.
 				checkpointsToKeep  = 1

engine/access/access_test.go

@@ -636,7 +636,6 @@ func (suite *Suite) TestGetExecutionResultByBlockID() {
 // TestGetSealedTransaction tests that transactions status of transaction that belongs to a sealed block
 // is reported as sealed
 func (suite *Suite) TestGetSealedTransaction() {
-	lockManager := storage.NewTestingLockManager()
 	unittest.RunWithBadgerDB(suite.T(), func(db *badger.DB) {
 		all := bstorage.InitAll(metrics.NewNoopCollector(), db)
 		en := util.ExecutionStorageLayer(suite.T(), db)
@@ -772,11 +771,11 @@ func (suite *Suite) TestGetSealedTransaction() {
 		lctx.Release()
 
 		fctx := suite.lockManager.NewContext()
-		defer fctx.Release()
 		require.NoError(suite.T(), fctx.AcquireLock(storage.LockFinalizeBlock))
 		require.NoError(suite.T(), bdb.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 			return operation.IndexFinalizedBlockByHeight(fctx, rw, block.Height, block.ID())
 		}))
+		fctx.Release()
 
 		suite.sealedBlock = block.ToHeader()
 
@@ -798,7 +797,7 @@ func (suite *Suite) TestGetSealedTransaction() {
 		suite.request.On("EntityByID", collection.ID(), mock.Anything).Return()
 		// 4. Indexer IndexCollection receives the requested collection and all the execution receipts
 		// Create a lock context for indexing
-		indexLctx := lockManager.NewContext()
+		indexLctx := suite.lockManager.NewContext()
 		lockErr := indexLctx.AcquireLock(storage.LockInsertCollection)
 		require.NoError(suite.T(), lockErr)
 		defer indexLctx.Release()
@@ -1149,7 +1148,6 @@ func (suite *Suite) TestGetTransactionResult() {
 // TestExecuteScript tests the three execute Script related calls to make sure that the execution api is called with
 // the correct block id
 func (suite *Suite) TestExecuteScript() {
-	lockManager := storage.NewTestingLockManager()
 	unittest.RunWithBadgerDB(suite.T(), func(badgerdb *badger.DB) {
 		db := badgerimpl.ToDB(badgerdb)
 		all := bstorage.InitAll(metrics.NewNoopCollector(), badgerdb)
@@ -1237,7 +1235,7 @@ func (suite *Suite) TestExecuteScript() {
 			all.Collections,
 			all.Transactions,
 			lastFullBlockHeight,
-			lockManager,
+			suite.lockManager,
 		)
 
 		ingestEng, err := ingestion.New(
@@ -1260,15 +1258,15 @@ func (suite *Suite) TestExecuteScript() {
 
 		// create a block and a seal pointing to that block
 		lastBlock := unittest.BlockWithParentFixture(prevBlock.ToHeader())
-		lctx := lockManager.NewContext()
+		lctx := suite.lockManager.NewContext()
 		require.NoError(suite.T(), lctx.AcquireLock(storage.LockInsertBlock))
 		require.NoError(suite.T(), db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 			return all.Blocks.BatchStore(lctx, rw, unittest.ProposalFromBlock(lastBlock))
 		}))
 		lctx.Release()
 		require.NoError(suite.T(), err)
 
-		fctx := lockManager.NewContext()
+		fctx := suite.lockManager.NewContext()
 		require.NoError(suite.T(), fctx.AcquireLock(storage.LockFinalizeBlock))
 		require.NoError(suite.T(), db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 			return operation.IndexFinalizedBlockByHeight(fctx, rw, lastBlock.Height, lastBlock.ID())
@@ -1285,7 +1283,7 @@ func (suite *Suite) TestExecuteScript() {
 			require.NoError(suite.T(), err)
 		}
 
-		fctx2 := lockManager.NewContext()
+		fctx2 := suite.lockManager.NewContext()
 		require.NoError(suite.T(), fctx2.AcquireLock(storage.LockInsertBlock))
 		require.NoError(suite.T(), fctx2.AcquireLock(storage.LockFinalizeBlock))
 		require.NoError(suite.T(), db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {

engine/execution/pruner/core_test.go

@@ -49,31 +49,31 @@ func TestLoopPruneExecutionDataFromRootToLatestSealed(t *testing.T) {
 			// indexed by height
 			chunks := make([]*verification.VerifiableChunkData, lastFinalizedHeight+2)
 			parentID := genesis.ID()
-			lctx := lockManager.NewContext()
-			require.NoError(t, lctx.AcquireLock(storage.LockInsertBlock))
+			lctxGenesis := lockManager.NewContext()
+			require.NoError(t, lctxGenesis.AcquireLock(storage.LockInsertBlock))
 			require.NoError(t, db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
-				return blockstore.BatchStore(lctx, rw, &flow.Proposal{Block: *genesis, ProposerSigData: nil})
+				return blockstore.BatchStore(lctxGenesis, rw, &flow.Proposal{Block: *genesis, ProposerSigData: nil})
 			}))
-			lctx.Release()
+			lctxGenesis.Release()
 
 			for i := 1; i <= lastFinalizedHeight; i++ {
 				chunk, block := unittest.VerifiableChunkDataFixture(0, func(headerBody *flow.HeaderBody) {
 					headerBody.Height = uint64(i)
 					headerBody.ParentID = parentID
 				})
 				chunks[i] = chunk // index by height
-				lctx := lockManager.NewContext()
-				require.NoError(t, lctx.AcquireLock(storage.LockInsertBlock))
+				lctxBlock := lockManager.NewContext()
+				require.NoError(t, lctxBlock.AcquireLock(storage.LockInsertBlock))
 				require.NoError(t, db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
-					return blockstore.BatchStore(lctx, rw, unittest.ProposalFromBlock(block))
+					return blockstore.BatchStore(lctxBlock, rw, unittest.ProposalFromBlock(block))
 				}))
-				lctx.Release()
-				lctx = lockManager.NewContext()
-				require.NoError(t, lctx.AcquireLock(storage.LockFinalizeBlock))
+				lctxBlock.Release()
+				lctxFinality := lockManager.NewContext()
+				require.NoError(t, lctxFinality.AcquireLock(storage.LockFinalizeBlock))
 				require.NoError(t, db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
-					return operation.IndexFinalizedBlockByHeight(lctx, rw, chunk.Header.Height, chunk.Header.ID())
+					return operation.IndexFinalizedBlockByHeight(lctxFinality, rw, chunk.Header.Height, chunk.Header.ID())
 				}))
-				lctx.Release()
+				lctxFinality.Release()
 				require.NoError(t, results.Store(chunk.Result))
 				require.NoError(t, results.Index(chunk.Result.BlockID, chunk.Result.ID()))
 				require.NoError(t, chunkDataPacks.Store([]*flow.ChunkDataPack{chunk.ChunkDataPack}))