[ETCM-927] enhance BlockchainTests/ValidBlocks/bcMultiChainTest/ChainAtoChainB_difficultyB test

Author: strauss-m

src/main/scala/io/iohk/ethereum/jsonrpc/EthBlocksService.scala

@@ -70,8 +70,8 @@ class EthBlocksService(val blockchain: Blockchain, val ledger: Ledger) extends R
     */
   def getByBlockHash(request: BlockByBlockHashRequest): ServiceResponse[BlockByBlockHashResponse] = Task {
     val BlockByBlockHashRequest(blockHash, fullTxs) = request
-    val blockOpt = blockchain.getBlockByHash(blockHash)
-    val weight = blockchain.getChainWeightByHash(blockHash)
+    val blockOpt = ledger.getBlockByHash(blockHash)
+    val weight = ledger.getChainWeightByHash(blockHash)
 
     val blockResponseOpt = blockOpt.map(block => BlockResponse(block, weight, fullTxs = fullTxs))
     Right(BlockByBlockHashResponse(blockResponseOpt))

src/main/scala/io/iohk/ethereum/jsonrpc/TestService.scala

@@ -134,6 +134,10 @@ class TestService(
   def setChainParams(request: SetChainParamsRequest): ServiceResponse[SetChainParamsResponse] = {
     currentConfig = buildNewConfig(request.chainParams.blockchainParams)
 
+    // clear ledger's cache on test start
+    // setChainParams is expected to be the first remote call for each test
+    testModeComponentsProvider.clearState()
+
     val genesisData = GenesisData(
       nonce = request.chainParams.genesis.nonce,
       mixHash = Some(request.chainParams.genesis.mixHash),
@@ -272,15 +276,20 @@ class TestService(
         testModeComponentsProvider
           .ledger(currentConfig, sealEngine)
           .importBlock(value)
-          .flatMap(handleResult)
+          .flatMap(handleResult(value))
     }
   }
 
-  private def handleResult(blockImportResult: BlockImportResult): ServiceResponse[ImportRawBlockResponse] = {
+  private def handleResult(
+      block: Block
+  )(blockImportResult: BlockImportResult): ServiceResponse[ImportRawBlockResponse] = {
     blockImportResult match {
       case BlockImportedToTop(blockImportData) =>
         val blockHash = s"0x${ByteStringUtils.hash2string(blockImportData.head.block.header.hash)}"
         ImportRawBlockResponse(blockHash).rightNow
+      case BlockEnqueued =>
+        val blockHash = s"0x${ByteStringUtils.hash2string(block.hash)}"
+        ImportRawBlockResponse(blockHash).rightNow
       case e =>
         log.warn("Block import failed with {}", e)
         Task.now(Left(JsonRpcError(-1, "block validation failed!", None)))

src/main/scala/io/iohk/ethereum/ledger/BlockQueue.scala

@@ -76,12 +76,28 @@ class BlockQueue(blockchain: Blockchain, val maxQueuedBlockNumberAhead: Int, val
     }
   }
 
+  /**
+    * Remove all blocks currently queued
+    */
+  def clear(): Unit = {
+    blocks.clear()
+    parentToChildren.clear()
+  }
+
   def getBlockByHash(hash: ByteString): Option[Block] =
     blocks.get(hash).map(_.block)
 
   def isQueued(hash: ByteString): Boolean =
     blocks.contains(hash)
 
+  /**
+    * Returns the weight of the block corresponding to the hash, or None if not found
+    * @param hash the block's hash to get the weight from
+    * @return the weight of the block corresponding to the hash, or None if not found
+    */
+  def getChainWeightByHash(hash: ByteString): Option[ChainWeight] =
+    blocks.get(hash).flatMap(_.weight)
+
   /**
     * Takes a branch going from descendant block upwards to the oldest ancestor
     * @param descendant the youngest block to be removed

src/main/scala/io/iohk/ethereum/ledger/Ledger.scala

@@ -28,6 +28,13 @@ trait Ledger {
     */
   def getBlockByHash(hash: ByteString): Option[Block]
 
+  /**
+    * Returns the chain weight if the block represented by its hash is either stored in the blockchain or enqueued
+    * @param hash the hash of the block to retrieve the chain weight
+    * @return the chain weight if the block represented by its hash is either stored in the blockchain or enqueued
+    */
+  def getChainWeightByHash(hash: ByteString): Option[ChainWeight]
+
   /** Tries to import the block as the new best block in the chain or enqueue it for later processing.
     *
     * The implementation uses [[io.iohk.ethereum.consensus.Consensus]] in order to apply
@@ -117,6 +124,9 @@ class LedgerImpl(
   override def getBlockByHash(hash: ByteString): Option[Block] =
     blockchain.getBlockByHash(hash) orElse blockQueue.getBlockByHash(hash)
 
+  override def getChainWeightByHash(hash: ByteString): Option[ChainWeight] =
+    blockchain.getChainWeightByHash(hash) orElse blockQueue.getChainWeightByHash(hash)
+
   override def importBlock(
       block: Block
   )(implicit blockExecutionScheduler: Scheduler): Task[BlockImportResult] =

src/main/scala/io/iohk/ethereum/testmode/TestEthBlockServiceWrapper.scala

@@ -6,6 +6,7 @@ import io.iohk.ethereum.jsonrpc.{
   BaseBlockResponse,
   BaseTransactionResponse,
   EthBlocksService,
+  JsonRpcError,
   ServiceResponse,
   TransactionData
 }
@@ -30,9 +31,18 @@ class TestEthBlockServiceWrapper(blockchain: Blockchain, ledger: Ledger, consens
     .getByBlockHash(request)
     .map(
       _.map(blockByBlockResponse => {
-        val fullBlock = blockchain.getBlockByNumber(blockByBlockResponse.blockResponse.get.number).get
-        BlockByBlockHashResponse(blockByBlockResponse.blockResponse.map(response => toEthResponse(fullBlock, response)))
-      })
+        blockByBlockResponse.blockResponse
+          .toRight("missing block response")
+          .flatMap(baseBlockResponse => baseBlockResponse.hash.toRight(s"missing hash for block $baseBlockResponse"))
+          .flatMap(hash => ledger.getBlockByHash(hash).toRight(s"unable to find block for hash=$hash"))
+          .map(fullBlock =>
+            BlockByBlockHashResponse(
+              blockByBlockResponse.blockResponse.map(response => toEthResponse(fullBlock, response))
+            )
+          )
+          .left
+          .map(errorMessage => JsonRpcError.LogicError(errorMessage))
+      }).flatten
     )
 
   /**
@@ -120,9 +130,9 @@ final case class EthTransactionResponse(
     gasPrice: BigInt,
     gas: BigInt,
     input: ByteString,
-    r: ByteString,
-    s: ByteString,
-    v: ByteString
+    r: BigInt,
+    s: BigInt,
+    v: BigInt
 ) extends BaseTransactionResponse
 
 object EthTransactionResponse {
@@ -147,8 +157,8 @@ object EthTransactionResponse {
       gasPrice = stx.tx.gasPrice,
       gas = stx.tx.gasLimit,
       input = stx.tx.payload,
-      r = UInt256(stx.signature.r).bytes,
-      s = UInt256(stx.signature.s).bytes,
-      v = ByteString(stx.signature.v)
+      r = stx.signature.r,
+      s = stx.signature.s,
+      v = stx.signature.v
     )
 }

src/main/scala/io/iohk/ethereum/testmode/TestModeComponentsProvider.scala

@@ -1,14 +1,16 @@
 package io.iohk.ethereum.testmode
 
 import io.iohk.ethereum.consensus.difficulty.DifficultyCalculator
-import io.iohk.ethereum.consensus.{Consensus, ConsensusConfig}
+import io.iohk.ethereum.consensus.ConsensusConfig
 import io.iohk.ethereum.domain.BlockchainImpl
 import io.iohk.ethereum.ledger.Ledger.VMImpl
-import io.iohk.ethereum.ledger.{Ledger, LedgerImpl, StxLedger}
+import io.iohk.ethereum.ledger.{BlockQueue, Ledger, LedgerImpl, StxLedger}
 import io.iohk.ethereum.utils.BlockchainConfig
 import io.iohk.ethereum.utils.Config.SyncConfig
 import monix.execution.Scheduler
 
+import scala.collection.immutable.HashMap
+
 /** Provides a ledger or consensus instances with modifiable blockchain config (used in test mode). */
 class TestModeComponentsProvider(
     blockchain: BlockchainImpl,
@@ -19,14 +21,42 @@ class TestModeComponentsProvider(
     vm: VMImpl
 ) {
 
-  def ledger(blockchainConfig: BlockchainConfig, sealEngine: SealEngineType): Ledger =
-    new LedgerImpl(
-      blockchain,
-      blockchainConfig,
-      syncConfig,
-      consensus(blockchainConfig, sealEngine),
-      validationExecutionContext
+  private var cache = HashMap.empty[(BlockchainConfig, SealEngineType), Ledger]
+  private var blockQueue = BlockQueue(blockchain, syncConfig)
+
+  /**
+    * Clear the internal builder state
+    */
+  def clearState(): Unit = {
+    blockQueue = BlockQueue(blockchain, syncConfig)
+    cache = cache.empty
+  }
+
+  /**
+    * Create a ledger depending on parameters.
+    * The same instance is returned for multiple calls with the same parameters.
+    * @see [[io.iohk.ethereum.testmode.TestModeComponentsProvider#clearState]] to clear the cache
+    * @param blockchainConfig
+    * @param sealEngine
+    * @return a ledger instance
+    */
+  def ledger(blockchainConfig: BlockchainConfig, sealEngine: SealEngineType): Ledger = {
+    cache.getOrElse(
+      (blockchainConfig, sealEngine), {
+        val newLedger: Ledger = new LedgerImpl(
+          blockchain,
+          blockQueue,
+          blockchainConfig,
+          consensus(blockchainConfig, sealEngine),
+          validationExecutionContext
+        )
+        cache += (blockchainConfig, sealEngine) -> newLedger
+        newLedger
+      }
     )
+
+  }
+
   def stxLedger(blockchainConfig: BlockchainConfig, sealEngine: SealEngineType): StxLedger =
     new StxLedger(blockchain, blockchainConfig, consensus(blockchainConfig, sealEngine).blockPreparator)
   def consensus(

src/main/scala/io/iohk/ethereum/testmode/TestModeServiceBuilder.scala

@@ -42,9 +42,18 @@ trait TestModeServiceBuilder extends LedgerBuilder {
     ): Task[BlockImportResult] = testLedger.importBlock(block)
     override def resolveBranch(headers: NonEmptyList[BlockHeader]): BranchResolutionResult =
       testLedger.resolveBranch(headers)
+
+    /**
+      * Returns the chain weight if the block represented by its hash is either stored in the blockchain or enqueued
+      *
+      * @param hash the hash of the block to retrieve the chain weight
+      * @return
+      */
+    override def getChainWeightByHash(hash: ByteString): Option[ChainWeight] = testLedger.getChainWeightByHash(hash)
   }
 
   override lazy val ledger: Ledger = new TestLedgerProxy
+//  override lazy val ledger: Ledger = testModeComponentsProvider.ledger(blockchainConfig, SealEngineType.NoReward)
   override lazy val stxLedger: StxLedger =
     testModeComponentsProvider.stxLedger(blockchainConfig, SealEngineType.NoReward)
 }

src/test/scala/io/iohk/ethereum/Mocks.scala

@@ -28,6 +28,8 @@ object Mocks {
 
     override def getBlockByHash(hash: ByteString): Option[Block] = ???
 
+    override def getChainWeightByHash(hash: ByteString): Option[ChainWeight] = ???
+
     override def importBlock(block: Block)(implicit blockExecutionContext: Scheduler): Task[BlockImportResult] = ???
 
     override def resolveBranch(headers: NonEmptyList[BlockHeader]): BranchResolutionResult = ???

src/test/scala/io/iohk/ethereum/jsonrpc/EthBlocksServiceSpec.scala

@@ -411,7 +411,18 @@ class EthBlocksServiceSpec
   class TestSetup(implicit system: ActorSystem) extends MockFactory with EphemBlockchainTestSetup {
     val blockGenerator = mock[PoWBlockGenerator]
     val appStateStorage = mock[AppStateStorage]
-    override lazy val ledger = mock[Ledger]
+    override lazy val ledger = {
+      val ledgerMock = mock[Ledger]
+      // properly mock the getBlockByHash and getChainWeightByHash
+      // they are needed for handling the json rpc getBlockByHash request
+      (ledgerMock.getBlockByHash _).expects(*).onCall {
+        blockchain.getBlockByHash _
+      }
+      (ledgerMock.getChainWeightByHash _).expects(*).onCall {
+        blockchain.getChainWeightByHash _
+      }
+      ledgerMock
+    }
     override lazy val consensus: TestConsensus = buildTestConsensus().withBlockGenerator(blockGenerator)
     override lazy val consensusConfig = ConsensusConfigs.consensusConfig
 

src/test/scala/io/iohk/ethereum/jsonrpc/JsonRpcControllerFixture.scala

@@ -44,7 +44,18 @@ class JsonRpcControllerFixture(implicit system: ActorSystem)
   val blockGenerator = mock[PoWBlockGenerator]
 
   val syncingController = TestProbe()
-  override lazy val ledger = mock[Ledger]
+  override lazy val ledger = {
+    val ledgerMock = mock[Ledger]
+    // properly mock the getBlockByHash and getChainWeightByHash
+    // they are needed for handling the json rpc getBlockByHash request
+    (ledgerMock.getBlockByHash _).expects(*).onCall {
+      blockchain.getBlockByHash _
+    }
+    (ledgerMock.getChainWeightByHash _).expects(*).onCall {
+      blockchain.getChainWeightByHash _
+    }
+    ledgerMock
+  }
   override lazy val stxLedger = mock[StxLedger]
   override lazy val validators = mock[ValidatorsExecutor]
   override lazy val consensus: TestConsensus = buildTestConsensus()