Merge pull request input-output-hk#1703 from input-output-hk/ensemble…

…/1667/create-test-ctx-builder

Create a test Cardano transactions builder

internal/mithril-persistence/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-persistence"
-version = "0.1.12"
+version = "0.1.13"
 description = "Common types, interfaces, and utilities to persist data for Mithril nodes."
 authors = { workspace = true }
 edition = { workspace = true }

internal/mithril-persistence/src/database/repository/cardano_transaction_repository.rs

@@ -68,15 +68,19 @@ impl CardanoTransactionRepository {
     ) -> StdResult<Vec<CardanoTransactionRecord>> {
         // Get the highest block number for the given immutable number.
         // This is a temporary fix that will be removed when the retrieval is based on block number instead of immutable number.
-        let block_number = self
+
+        if let Some(block_number) = self
             .get_highest_block_number_for_immutable_number(beacon)
             .await?
-            .unwrap_or(0);
-        let provider = GetCardanoTransactionProvider::new(&self.connection);
-        let filters = provider.get_transaction_between_blocks_condition(0..block_number + 1);
-        let transactions = provider.find(filters)?;
+        {
+            let provider = GetCardanoTransactionProvider::new(&self.connection);
+            let filters = provider.get_transaction_between_blocks_condition(0..block_number + 1);
+            let transactions = provider.find(filters)?;
 
-        Ok(transactions.collect())
+            Ok(transactions.collect())
+        } else {
+            Ok(vec![])
+        }
     }
 
     /// Return the [CardanoTransactionRecord] for the given transaction hash.
@@ -324,6 +328,8 @@ impl BlockRangeRootRetriever for CardanoTransactionRepository {
 
 #[cfg(test)]
 mod tests {
+    use mithril_common::test_utils::CardanoTransactionsBuilder;
+
     use crate::database::provider::GetBlockRangeRootProvider;
     use crate::database::test_helper::cardano_tx_db_connection;
     use crate::sqlite::GetAllProvider;
@@ -470,23 +476,20 @@ mod tests {
         let connection = Arc::new(cardano_tx_db_connection().unwrap());
         let repository = CardanoTransactionRepository::new(connection);
 
-        // Build transactions with block numbers from 20 to 40 and immutable file numbers from 12 to 14
-        let cardano_transactions: Vec<CardanoTransactionRecord> = (20..=40)
-            .map(|i| CardanoTransactionRecord {
-                transaction_hash: format!("tx-hash-{i}"),
-                block_number: i,
-                slot_number: i * 100,
-                block_hash: format!("block-hash-{i}"),
-                immutable_file_number: i / 10 + 10,
-            })
+        let cardano_transactions: Vec<CardanoTransactionRecord> = CardanoTransactionsBuilder::new()
+            .max_transactions_per_immutable_file(10)
+            .first_immutable_file(120)
+            .build_transactions(40)
+            .into_iter()
+            .map(CardanoTransactionRecord::from)
             .collect();
 
         repository
             .create_transactions(cardano_transactions.clone())
             .await
             .unwrap();
 
-        let transaction_result = repository.get_transactions_up_to(12).await.unwrap();
+        let transaction_result = repository.get_transactions_up_to(120).await.unwrap();
         let transaction_up_to_immutable_file_number_12 = cardano_transactions[0..10].to_vec();
         assert_eq!(
             transaction_up_to_immutable_file_number_12,
@@ -497,7 +500,28 @@ mod tests {
         let transaction_all = cardano_transactions[..].to_vec();
         assert_eq!(transaction_all, transaction_result);
 
-        let transaction_result = repository.get_transactions_up_to(9).await.unwrap();
+        let transaction_result = repository.get_transactions_up_to(90).await.unwrap();
+        assert_eq!(Vec::<CardanoTransactionRecord>::new(), transaction_result);
+    }
+
+    #[tokio::test]
+    async fn get_transactions_up_to_return_empty_list_when_no_record_found_with_provided_immutable_file_number(
+    ) {
+        let connection = Arc::new(cardano_tx_db_connection().unwrap());
+        let repository = CardanoTransactionRepository::new(connection);
+
+        repository
+            .create_transactions(vec![CardanoTransaction::new(
+                "tx-hash-123".to_string(),
+                0,
+                50,
+                "block-hash-0",
+                99,
+            )])
+            .await
+            .unwrap();
+
+        let transaction_result = repository.get_transactions_up_to(90).await.unwrap();
         assert_eq!(Vec::<CardanoTransactionRecord>::new(), transaction_result);
     }
 
@@ -525,7 +549,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn repository_store_transactions_with_existing_hash_doesnt_erase_existing_data() {
+    async fn repository_store_transactions_doesnt_erase_existing_data() {
         let connection = Arc::new(cardano_tx_db_connection().unwrap());
         let repository = CardanoTransactionRepository::new(connection);
 
@@ -871,21 +895,18 @@ mod tests {
         let connection = Arc::new(cardano_tx_db_connection().unwrap());
         let repository = CardanoTransactionRepository::new(connection);
 
-        // Build transactions with block numbers from 20 to 50
-        let cardano_transactions: Vec<CardanoTransactionRecord> = (20..=50)
-            .map(|i| CardanoTransactionRecord {
-                transaction_hash: format!("tx-hash-{i}"),
-                block_number: i,
-                slot_number: i * 100,
-                block_hash: format!("block-hash-{i}"),
-                immutable_file_number: 1,
-            })
+        let cardano_transactions: Vec<CardanoTransactionRecord> = CardanoTransactionsBuilder::new()
+            .blocks_per_block_range(15)
+            .build_transactions(53)
+            .into_iter()
+            .map(CardanoTransactionRecord::from)
             .collect();
 
         repository
             .create_transactions(cardano_transactions.clone())
             .await
             .unwrap();
+        // Use by 'prune_transaction' to get the block_range of the highest block number
         repository
             .create_block_range_roots(vec![(
                 BlockRange::from_block_number(45),
@@ -911,6 +932,12 @@ mod tests {
             .await
             .unwrap();
         assert_eq!(Vec::<CardanoTransactionRecord>::new(), transaction_result);
+
+        let transaction_result = repository
+            .get_transactions_in_range_blocks(25..1000)
+            .await
+            .unwrap();
+        assert_eq!(28, transaction_result.len());
     }
 
     #[tokio::test]

mithril-aggregator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.5.8"
+version = "0.5.9"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-aggregator/src/services/prover.rs

@@ -153,11 +153,10 @@ impl ProverService for MithrilProverService {
 
 #[cfg(test)]
 mod tests {
-    use std::cmp::max;
-
     use anyhow::anyhow;
     use mithril_common::crypto_helper::{MKMap, MKMapNode, MKTreeNode};
     use mithril_common::entities::{CardanoTransaction, ImmutableFileNumber};
+    use mithril_common::test_utils::CardanoTransactionsBuilder;
     use mockall::mock;
     use mockall::predicate::eq;
 
@@ -183,43 +182,6 @@ mod tests {
     mod test_data {
         use super::*;
 
-        // Generate transactions for 'total_block_ranges' consecutive block ranges,
-        // with 'total_transactions_per_block_range' transactions per block range
-        pub fn generate_transactions(
-            total_block_ranges: usize,
-            total_transactions_per_block_range: usize,
-        ) -> Vec<CardanoTransaction> {
-            let block_range_length = BlockRange::LENGTH as usize;
-            let max_transaction_per_block_number =
-                max(1, total_transactions_per_block_range / block_range_length);
-            let mut transactions = vec![];
-
-            for i in 0..total_block_ranges {
-                let block_range = BlockRange::from_block_number((i * block_range_length) as u64);
-                for j in 0..total_transactions_per_block_range {
-                    let transaction_index = i * total_transactions_per_block_range + j;
-                    let block_number =
-                        block_range.start + (j / max_transaction_per_block_number) as u64;
-                    let slot_number = 100 * block_number;
-                    let immutable_file_number = block_number / 5;
-                    let tx_hash = format!(
-                        "tx-br-{}..{}-{}-idx-{}",
-                        block_range.start, block_range.end, j, transaction_index
-                    );
-                    let block_hash = format!("block_hash-{block_number}");
-                    transactions.push(CardanoTransaction::new(
-                        &tx_hash,
-                        block_number,
-                        slot_number,
-                        block_hash,
-                        immutable_file_number,
-                    ));
-                }
-            }
-
-            transactions
-        }
-
         pub fn filter_transactions_for_indices(
             indices: &[usize],
             transactions: &[CardanoTransaction],
@@ -232,7 +194,7 @@ mod tests {
                 .collect()
         }
 
-        pub fn compute_transaction_hashes_from_transactions(
+        pub fn map_to_transaction_hashes(
             transactions: &[CardanoTransaction],
         ) -> Vec<TransactionHash> {
             transactions
@@ -241,7 +203,7 @@ mod tests {
                 .collect()
         }
 
-        pub fn compute_block_ranges_map_from_transactions(
+        pub fn transactions_group_by_block_range(
             transactions: &[CardanoTransaction],
         ) -> BTreeMap<BlockRange, Vec<CardanoTransaction>> {
             let mut block_ranges_map = BTreeMap::new();
@@ -309,11 +271,10 @@ mod tests {
             transactions_to_prove: &[CardanoTransaction],
             transactions: &[CardanoTransaction],
         ) -> TestData {
-            let transaction_hashes_to_prove =
-                compute_transaction_hashes_from_transactions(transactions_to_prove);
-            let block_ranges_map = compute_block_ranges_map_from_transactions(transactions);
+            let transaction_hashes_to_prove = map_to_transaction_hashes(transactions_to_prove);
+            let block_ranges_map = transactions_group_by_block_range(transactions);
             let block_ranges_map_to_prove =
-                compute_block_ranges_map_from_transactions(transactions_to_prove);
+                transactions_group_by_block_range(transactions_to_prove);
             let block_ranges_to_prove = block_ranges_map_to_prove
                 .keys()
                 .cloned()
@@ -355,10 +316,10 @@ mod tests {
     async fn compute_proof_for_one_set_of_three_known_transactions() {
         let total_block_ranges = 5;
         let total_transactions_per_block_range = 3;
-        let transactions = test_data::generate_transactions(
-            total_block_ranges,
-            total_transactions_per_block_range,
-        );
+        let transactions = CardanoTransactionsBuilder::new()
+            .max_transactions_per_block(1)
+            .blocks_per_block_range(total_transactions_per_block_range)
+            .build_block_ranges(total_block_ranges);
         let transactions_to_prove =
             test_data::filter_transactions_for_indices(&[1, 2, 4], &transactions);
         let test_data = test_data::build_test_data(&transactions_to_prove, &transactions);
@@ -408,10 +369,10 @@ mod tests {
     async fn cant_compute_proof_for_unknown_transaction() {
         let total_block_ranges = 5;
         let total_transactions_per_block_range = 3;
-        let transactions = test_data::generate_transactions(
-            total_block_ranges,
-            total_transactions_per_block_range,
-        );
+        let transactions = CardanoTransactionsBuilder::new()
+            .max_transactions_per_block(1)
+            .blocks_per_block_range(total_transactions_per_block_range)
+            .build_block_ranges(total_block_ranges);
         let transactions_to_prove = test_data::filter_transactions_for_indices(&[], &transactions);
         let mut test_data = test_data::build_test_data(&transactions_to_prove, &transactions);
         test_data.transaction_hashes_to_prove = vec!["tx-unknown-123".to_string()];
@@ -456,10 +417,10 @@ mod tests {
     async fn compute_proof_for_one_set_of_three_known_transactions_and_two_unknowns() {
         let total_block_ranges = 5;
         let total_transactions_per_block_range = 3;
-        let transactions = test_data::generate_transactions(
-            total_block_ranges,
-            total_transactions_per_block_range,
-        );
+        let transactions = CardanoTransactionsBuilder::new()
+            .max_transactions_per_block(1)
+            .blocks_per_block_range(total_transactions_per_block_range)
+            .build_block_ranges(total_block_ranges);
         let transactions_to_prove =
             test_data::filter_transactions_for_indices(&[1, 2, 4], &transactions);
         let transaction_hashes_unknown =
@@ -517,10 +478,10 @@ mod tests {
     async fn cant_compute_proof_if_transaction_retriever_fails() {
         let total_block_ranges = 5;
         let total_transactions_per_block_range = 3;
-        let transactions = test_data::generate_transactions(
-            total_block_ranges,
-            total_transactions_per_block_range,
-        );
+        let transactions = CardanoTransactionsBuilder::new()
+            .max_transactions_per_block(1)
+            .blocks_per_block_range(total_transactions_per_block_range)
+            .build_block_ranges(total_block_ranges);
         let transactions_to_prove =
             test_data::filter_transactions_for_indices(&[1, 2, 4], &transactions);
         let test_data = test_data::build_test_data(&transactions_to_prove, &transactions);
@@ -547,10 +508,10 @@ mod tests {
     async fn cant_compute_proof_if_block_range_root_retriever_fails() {
         let total_block_ranges = 5;
         let total_transactions_per_block_range = 3;
-        let transactions = test_data::generate_transactions(
-            total_block_ranges,
-            total_transactions_per_block_range,
-        );
+        let transactions = CardanoTransactionsBuilder::new()
+            .max_transactions_per_block(1)
+            .blocks_per_block_range(total_transactions_per_block_range)
+            .build_block_ranges(total_block_ranges);
         let transactions_to_prove =
             test_data::filter_transactions_for_indices(&[1, 2, 4], &transactions);
         let test_data = test_data::build_test_data(&transactions_to_prove, &transactions);

mithril-common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.4.6"
+version = "0.4.7"
 description = "Common types, interfaces, and utilities for Mithril nodes."
 authors = { workspace = true }
 edition = { workspace = true }

mithril-common/src/signable_builder/cardano_transactions.rs

@@ -109,7 +109,10 @@ impl SignableBuilder<CardanoDbBeacon> for CardanoTransactionsSignableBuilder {
 #[cfg(test)]
 mod tests {
 
-    use crate::{entities::CardanoTransaction, test_utils::TestLogger};
+    use crate::{
+        entities::CardanoTransaction,
+        test_utils::{CardanoTransactionsBuilder, TestLogger},
+    };
 
     use super::*;
 
@@ -132,11 +135,7 @@ mod tests {
             immutable_file_number: 14,
             ..CardanoDbBeacon::default()
         };
-        let transactions = vec![
-            CardanoTransaction::new("tx-hash-123", 10, 1, "block_hash-", 11),
-            CardanoTransaction::new("tx-hash-456", 20, 2, "block_hash", 12),
-            CardanoTransaction::new("tx-hash-789", 30, 3, "block_hash", 13),
-        ];
+        let transactions = CardanoTransactionsBuilder::new().build_transactions(3);
         let mk_map = compute_mk_map_from_transactions(transactions.clone());
         let mut transaction_importer = MockTransactionsImporter::new();
         transaction_importer