adds missing input test

zebra-chain/src/transaction/arbitrary.rs

@@ -930,16 +930,7 @@ pub fn test_transactions(
         Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(),
     };
 
-    blocks.flat_map(|(&block_height, &block_bytes)| {
-        let block = block_bytes
-            .zcash_deserialize_into::<block::Block>()
-            .expect("block is structurally valid");
-
-        block
-            .transactions
-            .into_iter()
-            .map(move |transaction| (block::Height(block_height), transaction))
-    })
+    transactions_from_blocks(blocks)
 }
 
 /// Generate an iterator over fake V5 transactions.
@@ -950,18 +941,23 @@ pub fn fake_v5_transactions_for_network<'b>(
     network: Network,
     blocks: impl DoubleEndedIterator<Item = (&'b u32, &'b &'static [u8])> + 'b,
 ) -> impl DoubleEndedIterator<Item = Transaction> + 'b {
-    blocks.flat_map(move |(height, original_bytes)| {
-        let original_block = original_bytes
+    transactions_from_blocks(blocks)
+        .map(move |(height, transaction)| transaction_to_fake_v5(&transaction, network, height))
+}
+
+/// Generate an iterator over ([`block::Height`], [`Arc<Transaction>`]).
+pub fn transactions_from_blocks<'a>(
+    blocks: impl DoubleEndedIterator<Item = (&'a u32, &'a &'static [u8])> + 'a,
+) -> impl DoubleEndedIterator<Item = (block::Height, Arc<Transaction>)> + 'a {
+    blocks.flat_map(|(&block_height, &block_bytes)| {
+        let block = block_bytes
             .zcash_deserialize_into::<block::Block>()
             .expect("block is structurally valid");
 
-        original_block
+        block
             .transactions
             .into_iter()
-            .map(move |transaction| {
-                transaction_to_fake_v5(&transaction, network, block::Height(*height))
-            })
-            .map(Transaction::from)
+            .map(move |transaction| (block::Height(block_height), transaction))
     })
 }
 

zebra-consensus/src/transaction/tests.rs

@@ -19,12 +19,15 @@ use zebra_chain::{
     transaction::{
         arbitrary::{
             fake_v5_transactions_for_network, insert_fake_orchard_shielded_data, test_transactions,
+            transactions_from_blocks,
         },
         Hash, HashType, JoinSplitData, LockTime, Transaction,
     },
     transparent::{self, CoinbaseData},
 };
 
+use zebra_test::mock_service::MockService;
+
 use crate::error::TransactionError;
 
 use super::{check, Request, Verifier};
@@ -177,6 +180,38 @@ fn v5_transaction_with_no_inputs_fails_validation() {
     );
 }
 
+#[tokio::test]
+async fn mempool_request_with_missing_input_is_rejected() {
+    let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
+    let verifier = Verifier::new(Network::Mainnet, state.clone());
+
+    let (height, tx) = transactions_from_blocks(zebra_test::vectors::MAINNET_BLOCKS.iter())
+        .find(|(_, tx)| !(tx.is_coinbase() || tx.inputs().is_empty()))
+        .expect("At least one non-coinbase transaction with transparent inputs in test vectors");
+
+    let expected_state_request = zebra_state::Request::BestChainUtxo(match tx.inputs()[0] {
+        transparent::Input::PrevOut { outpoint, .. } => outpoint,
+        transparent::Input::Coinbase { .. } => panic!("requires a non-coinbase transaction"),
+    });
+
+    tokio::spawn(async move {
+        state
+            .expect_request(expected_state_request)
+            .await
+            .expect("verifier should call mock state service")
+            .respond(zebra_state::Response::BestChainUtxo(None));
+    });
+
+    let verifier_response = verifier
+        .oneshot(Request::Mempool {
+            transaction: tx.into(),
+            height,
+        })
+        .await;
+
+    assert_eq!(verifier_response, Err(TransactionError::InputNotFound));
+}
+
 #[test]
 fn v5_transaction_with_no_outputs_fails_validation() {
     let transaction = fake_v5_transactions_for_network(