private BlockHeader block(final long blockNumber) { return otherBlockchain.getBlockHeader(blockNumber).get(); } }
@Override protected List<BlockHeader> generateDataToBeRequested() { return singletonList(blockchain.getBlockHeader(PIVOT_BLOCK_NUMBER).get()); }
@Override protected List<BlockHeader> generateDataToBeRequested() { final List<BlockHeader> requestedHeaders = new ArrayList<>(); for (long i = 0; i < 3; i++) { final long blockNumber = 10 + i; final BlockHeader header = blockchain.getBlockHeader(blockNumber).get(); requestedHeaders.add(header); } return requestedHeaders; }
@Override protected List<BlockHeader> generateDataToBeRequested() { final int count = 3; final List<BlockHeader> requestedHeaders = new ArrayList<>(count); for (long i = 0; i < count; i++) { requestedHeaders.add(blockchain.getBlockHeader(5 + i).get()); } return requestedHeaders; }
private void mockBlockchainForBlockHeader(final Hash stateRoot, final long blockNumber) { final BlockHeader blockHeader = mock(BlockHeader.class); when(blockHeader.getStateRoot()).thenReturn(stateRoot); when(blockHeader.getNumber()).thenReturn(blockNumber); when(blockchain.getBlockHeader(blockNumber)).thenReturn(Optional.of(blockHeader)); }
@Override protected EthTask<List<BlockHeader>> createTask(final List<BlockHeader> requestedData) { final BlockHeader lastHeader = requestedData.get(requestedData.size() - 1); final BlockHeader referenceHeader = blockchain.getBlockHeader(lastHeader.getNumber() + 1).get(); return DownloadHeaderSequenceTask.endingAtHeader( protocolSchedule, protocolContext, ethContext, referenceHeader, requestedData.size(), maxRetries, ethTasksTimer); }
@Override protected Map<BlockHeader, List<TransactionReceipt>> generateDataToBeRequested() { final Map<BlockHeader, List<TransactionReceipt>> expectedData = new HashMap<>(); for (long i = 0; i < 3; i++) { final BlockHeader header = blockchain.getBlockHeader(10 + i).get(); final List<TransactionReceipt> transactionReceipts = blockchain.getTxReceipts(header.getHash()).get(); expectedData.put(header, transactionReceipts); } return expectedData; }
@Test public void traceTransactionShouldReturnEmptyResultWhenTransactionNotInCurrentBlock() { when(blockchain.getBlockHeader(blockHash)).thenReturn(Optional.of(blockHeader)); when(blockchain.getBlockHeader(previousBlockHash)).thenReturn(Optional.of(previousBlockHeader)); when(blockBody.getTransactions()).thenReturn(Collections.singletonList(otherTransaction)); when(blockchain.getBlockBody(blockHash)).thenReturn(Optional.of(blockBody)); final Optional<TransactionTrace> transactionTrace = transactionTracer.traceTransaction(blockHash, transactionHash, tracer); assertEquals(Optional.empty(), transactionTrace); }
@Test public void shouldReturnEmptyWhenBlockDoesNotExist() { when(blockchain.getBlockHeader(eq(1L))).thenReturn(Optional.empty()); final Optional<TransientTransactionProcessingResult> result = transientTransactionProcessor.process(callParameter(), 1L); assertThat(result.isPresent()).isFalse(); }
@Test public void traceTransactionShouldReturnTraceFramesFromExecutionTracer() { when(blockchain.getBlockHeader(blockHash)).thenReturn(Optional.of(blockHeader)); when(blockchain.getBlockHeader(previousBlockHash)).thenReturn(Optional.of(previousBlockHeader)); when(blockBody.getTransactions()).thenReturn(Collections.singletonList(transaction)); when(blockchain.getBlockBody(blockHash)).thenReturn(Optional.of(blockBody)); final List<TraceFrame> traceFrames = Collections.singletonList(mock(TraceFrame.class)); when(tracer.getTraceFrames()).thenReturn(traceFrames); final Optional<TransactionTrace> transactionTrace = transactionTracer.traceTransaction(blockHash, transactionHash, tracer); assertEquals(traceFrames, transactionTrace.get().getTraceFrames()); }
@After public void verifyBlocksNeverLookedUpByNumber() { // Looking up the block by number is incorrect because it always uses the canonical chain even // if the block being imported is on a fork. verify(blockchain, never()).getBlockHeader(anyLong()); }
@Test public void traceTransactionShouldReturnEmptyResultWhenBlockIsNotAvailable() { when(blockchain.getBlockHeader(blockHash)).thenReturn(Optional.of(blockHeader)); when(blockchain.getBlockBody(blockHash)).thenReturn(Optional.empty()); final Optional<TransactionTrace> transactionTrace = transactionTracer.traceTransaction(blockHash, transactionHash, tracer); assertEquals(Optional.empty(), transactionTrace); } }
@Test public void shouldCacheBlockHashesWhileIteratingBackToPreviousHeader() { assertHashForBlockNumber(CURRENT_BLOCK_NUMBER - 4); assertHashForBlockNumber(CURRENT_BLOCK_NUMBER - 1); verify(blockchain).getBlockHeader(headers[CURRENT_BLOCK_NUMBER - 1].getHash()); verify(blockchain).getBlockHeader(headers[CURRENT_BLOCK_NUMBER - 2].getHash()); verify(blockchain).getBlockHeader(headers[CURRENT_BLOCK_NUMBER - 3].getHash()); verifyNoMoreInteractions(blockchain); }
@Override protected List<Block> generateDataToBeRequested() { final List<Block> requestedBlocks = new ArrayList<>(); for (long i = 0; i < 3; i++) { final BlockHeader header = blockchain.getBlockHeader(10 + i).get(); final BlockBody body = blockchain.getBlockBody(header.getHash()).get(); requestedBlocks.add(new Block(header, body)); } return requestedBlocks; }
@Test public void shouldReturnListOfValidatorsFromBlock() { when(blockchain.getBlockHeader(Hash.ZERO)).thenReturn(Optional.of(blockHeader)); final List<Address> addresses = Collections.singletonList(Address.ID); final List<String> expectedOutput = Collections.singletonList(Address.ID.toString()); when(ibftBlockInterface.validatorsInBlock(blockHeader)).thenReturn(addresses); request = requestWithParams(ZERO_HASH); JsonRpcSuccessResponse response = (JsonRpcSuccessResponse) method.response(request); Assertions.assertThat(response.getResult()).isEqualTo(expectedOutput); }
@Override protected Block generateDataToBeRequested() { final BlockHeader header = blockchain.getBlockHeader(5).get(); final BlockBody body = blockchain.getBlockBody(header.getHash()).get(); return new Block(header, body); }
@Before public void setUp() { when(blockchainQueries.headBlockNumber()).thenReturn(1L); when(blockchainQueries.getBlockchain()).thenReturn(blockchain); when(blockchain.getBlockHeader(eq(1L))).thenReturn(Optional.of(blockHeader)); when(blockHeader.getGasLimit()).thenReturn(Long.MAX_VALUE); when(blockHeader.getNumber()).thenReturn(1L); method = new EthEstimateGas( blockchainQueries, transientTransactionProcessor, new JsonRpcParameter()); }
private Responder responderForFakeBlock() { final Blockchain mockBlockchain = mock(Blockchain.class); when(mockBlockchain.getBlockHeader(PIVOT_BLOCK_NUMBER)) .thenReturn( Optional.of( new BlockHeaderTestFixture() .number(PIVOT_BLOCK_NUMBER) .extraData(BytesValue.of(1)) .buildHeader())); return RespondingEthPeer.blockchainResponder(mockBlockchain); } }
@Test public void disconnectOnFailureToSendStatusMessage() { try (final EthProtocolManager ethManager = new EthProtocolManager(blockchain, protocolContext.getWorldStateArchive(), 1, true, 1, 1)) { final MessageData messageData = BlockHeadersMessage.create(Collections.singletonList(blockchain.getBlockHeader(1).get())); final MockPeerConnection peer = setupPeerWithoutStatusExchange(ethManager, (cap, msg, conn) -> {}); ethManager.processMessage(EthProtocol.ETH63, new DefaultMessage(peer, messageData)); assertThat(peer.isDisconnected()).isTrue(); } }
@Test public void disconnectOnUnsolicitedMessage() { try (final EthProtocolManager ethManager = new EthProtocolManager(blockchain, protocolContext.getWorldStateArchive(), 1, true, 1, 1)) { final MessageData messageData = BlockHeadersMessage.create(Collections.singletonList(blockchain.getBlockHeader(1).get())); final MockPeerConnection peer = setupPeer(ethManager, (cap, msg, conn) -> {}); ethManager.processMessage(EthProtocol.ETH63, new DefaultMessage(peer, messageData)); assertThat(peer.isDisconnected()).isTrue(); } }