@Test public void shouldAddATransaction() { transactions.addRemoteTransaction(transaction1); assertThat(transactions.size()).isEqualTo(1); transactions.addRemoteTransaction(transaction2); assertThat(transactions.size()).isEqualTo(2); }
@Test public void shouldReturnEmptyOptionalAsMaximumNonceWhenLastTransactionForSenderRemoved() { final Transaction transaction = transactionWithNonceAndSender(1, KEYS1); transactions.addRemoteTransaction(transaction); transactions.removeTransaction(transaction); assertThat(transactions.getNextNonceForSender(SENDER1)).isEmpty(); }
@Test public void shouldReturnEmptyOptionalWhenNoTransactionWithGivenHashExists() { assertThat(transactions.getTransactionByHash(Hash.EMPTY_TRIE_HASH)).isEmpty(); }
@Test public void selectTransactionsUntilPendingIsEmpty() { transactions.addRemoteTransaction(transaction1); transactions.addRemoteTransaction(transaction2); final List<Transaction> parsedTransactions = Lists.newArrayList(); transactions.selectTransactions( transaction -> { parsedTransactions.add(transaction); return TransactionSelectionResult.CONTINUE; }); assertThat(parsedTransactions.size()).isEqualTo(2); assertThat(parsedTransactions.get(0)).isEqualTo(transaction2); assertThat(parsedTransactions.get(1)).isEqualTo(transaction1); }
@Test public void invalidTransactionsTransactionProcessingAreSkippedButBlockStillFills() { final PendingTransactions pendingTransactions = new PendingTransactions(5); final Transaction tx = createTransaction(i); transactionsToInject.add(tx); pendingTransactions.addRemoteTransaction(tx);
@Test public void createMainnetBlock1() throws IOException { final EthHashSolver solver = new EthHashSolver(Lists.newArrayList(BLOCK_1_NONCE), new Light()); final EthHashBlockCreator blockCreator = new EthHashBlockCreator( BLOCK_1_COINBASE, parent -> BLOCK_1_EXTRA_DATA, new PendingTransactions(1), executionContextTestFixture.getProtocolContext(), executionContextTestFixture.getProtocolSchedule(), gasLimit -> gasLimit, solver, Wei.ZERO, executionContextTestFixture.getBlockchain().getChainHeadHeader()); // A Hashrate should not exist in the block creator prior to creating a block Assertions.assertThat(blockCreator.getHashesPerSecond().isPresent()).isFalse(); final Block actualBlock = blockCreator.createBlock(BLOCK_1_TIMESTAMP); final Block expectedBlock = ValidationTestUtils.readBlock(1); Assertions.assertThat(actualBlock).isEqualTo(expectedBlock); Assertions.assertThat(blockCreator.getHashesPerSecond().isPresent()).isTrue(); } }
@Test public void transactionOfferingGasPriceLessThanMinimumIsIdentifiedAndRemovedFromPending() { final PendingTransactions pendingTransactions = new PendingTransactions(5); pendingTransactions.addRemoteTransaction(tx); assertThat(pendingTransactions.size()).isEqualTo(0);
@Test public void shouldDiscardTransactionsThatFailValidation() { final PendingTransactions pendingTransactions = new PendingTransactions(10); final TransactionProcessor transactionProcessor = mock(TransactionProcessor.class); final Blockchain blockchain = new TestBlockchain(); txTestFixture.nonce(2).gasLimit(2).createTransaction(keyPair); pendingTransactions.addRemoteTransaction(validTransaction); pendingTransactions.addRemoteTransaction(invalidTransaction); assertThat(pendingTransactions.getTransactionByHash(validTransaction.hash())).isPresent(); assertThat(pendingTransactions.getTransactionByHash(invalidTransaction.hash())).isNotPresent();
@Test public void invalidTransactionIsDeletedFromPendingTransactions() { transactions.addRemoteTransaction(transaction1); transactions.addRemoteTransaction(transaction2); final List<Transaction> parsedTransactions = Lists.newArrayList(); transactions.selectTransactions( transaction -> { parsedTransactions.add(transaction); return TransactionSelectionResult.DELETE_TRANSACTION_AND_CONTINUE; }); assertThat(parsedTransactions.size()).isEqualTo(2); assertThat(parsedTransactions.get(0)).isEqualTo(transaction2); assertThat(parsedTransactions.get(1)).isEqualTo(transaction1); assertThat(transactions.size()).isZero(); }
@Test public void shouldNotReplaceTransactionWithSameSenderAndNonceWhenGasPriceIsLower() { final Transaction transaction1 = transactionWithNonceSenderAndGasPrice(1, KEYS1, 2); final Transaction transaction1b = transactionWithNonceSenderAndGasPrice(1, KEYS1, 1); assertThat(transactions.addRemoteTransaction(transaction1)).isTrue(); transactions.addTransactionListener(listener); assertThat(transactions.addRemoteTransaction(transaction1b)).isFalse(); assertTransactionNotPending(transaction1b); assertTransactionPending(transaction1); assertThat(transactions.size()).isEqualTo(1); verifyZeroInteractions(listener); }
@Test public void shouldPrioritizeLocalTransaction() { final Transaction localTransaction = createTransaction(0); transactions.addLocalTransaction(localTransaction); for (int i = 1; i <= MAX_TRANSACTIONS; i++) { transactions.addRemoteTransaction(createTransaction(i)); } assertThat(transactions.size()).isEqualTo(MAX_TRANSACTIONS); assertTransactionPending(localTransaction); }
@Test public void shouldStartDroppingLocalTransactionsWhenPoolIsFullOfLocalTransactions() { final Transaction firstLocalTransaction = createTransaction(0); transactions.addLocalTransaction(firstLocalTransaction); for (int i = 1; i <= MAX_TRANSACTIONS; i++) { transactions.addLocalTransaction(createTransaction(i)); } assertThat(transactions.size()).isEqualTo(MAX_TRANSACTIONS); assertTransactionNotPending(firstLocalTransaction); }
@Test public void shouldGetTransactionByHash() { transactions.addRemoteTransaction(transaction1); assertTransactionPending(transaction1); }
@Test public void shouldNotifyListenerWhenRemoteTransactionAdded() { transactions.addTransactionListener(listener); transactions.addRemoteTransaction(transaction1); verify(listener).onTransactionAdded(transaction1); }
public int getPendingTransactionCount() { return transactionPool.getPendingTransactions().size(); } }
private void assertMaximumNonceForSender(final Address sender1, final int i) { assertThat(transactions.getNextNonceForSender(sender1)).isEqualTo(OptionalLong.of(i)); }
@Test public void shouldNotForceNonceOrderWhenSendersDiffer() { final Transaction transaction1 = transactionWithNonceAndSender(0, KEYS1); final Transaction transaction2 = transactionWithNonceAndSender(1, KEYS2); transactions.addLocalTransaction(transaction1); transactions.addLocalTransaction(transaction2); final List<Transaction> iterationOrder = new ArrayList<>(); transactions.selectTransactions( transaction -> { iterationOrder.add(transaction); return TransactionSelectionResult.CONTINUE; }); assertThat(iterationOrder).containsExactly(transaction2, transaction1); }
@Test public void shouldNotifyListenerWhenLocalTransactionAdded() { transactions.addTransactionListener(listener); transactions.addLocalTransaction(transaction1); verify(listener).onTransactionAdded(transaction1); }
@Test public void subsetOfPendingTransactionsIncludedWhenBlockGasLimitHit() { final PendingTransactions pendingTransactions = new PendingTransactions(5); final Transaction tx = createTransaction(i); transactionsToInject.add(tx); pendingTransactions.addRemoteTransaction(tx);
@Test public void settingCoinbaseToNullThrowsException() { final MiningParameters miningParameters = new MiningParametersTestBuilder().build(); final EthHashMinerExecutor executor = new EthHashMinerExecutor( null, Executors.newCachedThreadPool(), null, new PendingTransactions(1), miningParameters, new DefaultBlockScheduler(1, 10, Clock.systemUTC())); assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> executor.setCoinbase(null)) .withMessageContaining("Coinbase cannot be unset."); } }