Switch to a builder to generate dummy immutables

Author: Alenar

mithril-common/src/digesters/cardano_immutable_digester.rs

@@ -166,112 +166,34 @@ impl std::fmt::Display for Progress {
 #[cfg(test)]
 mod tests {
     use super::Progress;
-    use crate::digesters::cache::{
-        ImmutableDigesterCacheGetError, ImmutableDigesterCacheProviderError,
-        ImmutableDigesterCacheStoreError,
-    };
     use crate::{
         digesters::{
             cache::{
-                ImmutableFileDigestCacheProvider, MemoryImmutableFileDigestCacheProvider,
-                MockImmutableFileDigestCacheProvider,
+                ImmutableDigesterCacheGetError, ImmutableDigesterCacheProviderError,
+                ImmutableDigesterCacheStoreError, ImmutableFileDigestCacheProvider,
+                MemoryImmutableFileDigestCacheProvider, MockImmutableFileDigestCacheProvider,
             },
-            CardanoImmutableDigester, ImmutableDigester, ImmutableDigesterError, ImmutableFile,
+            CardanoImmutableDigester, DummyImmutablesDbBuilder, ImmutableDigester,
+            ImmutableDigesterError,
         },
         entities::{Beacon, ImmutableFileNumber},
     };
     use sha2::Sha256;
     use slog::Drain;
-    use std::{
-        collections::BTreeMap,
-        fs,
-        fs::File,
-        io,
-        io::prelude::*,
-        path::{Path, PathBuf},
-        sync::Arc,
-    };
+    use std::{collections::BTreeMap, io, sync::Arc};
     use tokio::time::Instant;
 
-    fn get_test_dir(subdir_name: &str) -> PathBuf {
-        let parent_dir = std::env::temp_dir()
-            .join("mithril_test")
-            .join("cardano_immutable_digester")
-            .join(subdir_name);
-
-        if parent_dir.exists() {
-            fs::remove_dir_all(&parent_dir)
-                .unwrap_or_else(|e| panic!("Could not remove dir {:?}: {}", parent_dir, e));
-        }
-        fs::create_dir_all(&parent_dir)
-            .unwrap_or_else(|e| panic!("Could not create dir {:?}: {}", parent_dir, e));
-
-        parent_dir
-    }
-
-    fn write_immutable_trio(
-        parent_dir: &Path,
-        immutable: ImmutableFileNumber,
-    ) -> Vec<ImmutableFile> {
-        let mut result = vec![];
-        for filename in [
-            format!("{}.chunk", immutable),
-            format!("{}.primary", immutable),
-            format!("{}.secondary", immutable),
-        ] {
-            let file = write_dummy_file(parent_dir, &filename);
-            result.push(ImmutableFile {
-                number: immutable.to_owned(),
-                path: file,
-                filename: filename.to_string(),
-            });
-        }
-        result
-    }
-
-    /// Create a chunk/primary/secondary trio for each given [ImmutableFileNumber].
-    ///
-    /// If `append_uncompleted_trio` is true it will add another trio of file, that won't be included
-    /// in the returned vec, to simulate the last 3 'uncompleted / wip' files that can be found in
-    /// a cardano immutable db.
-    fn create_fake_immutables(
-        parent_dir: &Path,
-        immutable_numbers: &[ImmutableFileNumber],
-        append_uncompleted_trio: bool,
-    ) -> Vec<ImmutableFile> {
-        if immutable_numbers.is_empty() {
-            panic!("At least one immutable numbers must be given");
-        }
-
-        let mut immutable_numbers = immutable_numbers.to_vec();
-        immutable_numbers.sort();
-
-        if append_uncompleted_trio {
-            write_immutable_trio(parent_dir, immutable_numbers.last().unwrap() + 1);
-        }
-
-        immutable_numbers
-            .into_iter()
-            .flat_map(|ifn| write_immutable_trio(parent_dir, ifn))
-            .collect::<Vec<_>>()
-    }
-
-    /// Create a file with the given name in the given dir, write some text to it, and then
-    /// return its path.
-    fn write_dummy_file(parent_dir: &Path, filename: &str) -> PathBuf {
-        let file = parent_dir.join(Path::new(filename));
-        let mut source_file = File::create(&file).unwrap();
-        write!(source_file, "This is a test file named '{}'", filename).unwrap();
-        file
-    }
-
     fn create_logger() -> slog::Logger {
         let decorator = slog_term::PlainDecorator::new(slog_term::TestStdoutWriter);
         let drain = slog_term::CompactFormat::new(decorator).build().fuse();
         let drain = slog_async::Async::new(drain).build().fuse();
         slog::Logger::root(Arc::new(drain), slog::o!())
     }
 
+    fn db_builder(dir_name: &str) -> DummyImmutablesDbBuilder {
+        DummyImmutablesDbBuilder::new(&format!("cardano_immutable_digester/{}", dir_name))
+    }
+
     #[test]
     fn reports_progress_every_5_percent() {
         let mut progress = Progress {
@@ -300,8 +222,8 @@ mod tests {
 
     #[tokio::test]
     async fn fail_if_no_file_in_folder() {
-        let dir = get_test_dir("fail_if_no_file_in_folder/immutable");
-        let digester = CardanoImmutableDigester::new(dir, None, create_logger());
+        let immutable_db = db_builder("fail_if_no_file_in_folder").build();
+        let digester = CardanoImmutableDigester::new(immutable_db.dir, None, create_logger());
         let beacon = Beacon::new("devnet".to_string(), 1, 1);
 
         let result = digester
@@ -323,19 +245,21 @@ mod tests {
 
     #[tokio::test]
     async fn fail_if_a_invalid_file_is_in_immutable_folder() {
-        let dir = get_test_dir("fail_if_no_immutable_exist/immutable");
-        write_dummy_file(&dir, "not_immutable");
-        let digester = CardanoImmutableDigester::new(dir, None, create_logger());
+        let immutable_db = db_builder("fail_if_no_immutable_exist")
+            .with_non_immutables(&["not_immutable"])
+            .build();
+        let digester = CardanoImmutableDigester::new(immutable_db.dir, None, create_logger());
         let beacon = Beacon::new("devnet".to_string(), 1, 1);
 
         assert!(digester.compute_digest(&beacon).await.is_err());
     }
 
     #[tokio::test]
     async fn fail_if_theres_only_the_uncompleted_immutable_trio() {
-        let dir = get_test_dir("fail_if_theres_only_the_uncompleted_immutable_trio/immutable");
-        write_immutable_trio(&dir, 1);
-        let digester = CardanoImmutableDigester::new(dir, None, create_logger());
+        let immutable_db = db_builder("fail_if_theres_only_the_uncompleted_immutable_trio")
+            .append_immutable_trio()
+            .build();
+        let digester = CardanoImmutableDigester::new(immutable_db.dir, None, create_logger());
         let beacon = Beacon::new("devnet".to_string(), 1, 1);
 
         let result = digester
@@ -357,9 +281,11 @@ mod tests {
 
     #[tokio::test]
     async fn fail_if_less_immutable_than_what_required_in_beacon() {
-        let dir = get_test_dir("fail_if_less_immutable_than_what_required_in_beacon/immutable");
-        create_fake_immutables(&dir, &[1, 2, 3, 4, 5], true);
-        let digester = CardanoImmutableDigester::new(dir, None, create_logger());
+        let immutable_db = db_builder("fail_if_less_immutable_than_what_required_in_beacon")
+            .with_immutables(&[1, 2, 3, 4, 5])
+            .append_immutable_trio()
+            .build();
+        let digester = CardanoImmutableDigester::new(immutable_db.dir, None, create_logger());
         let beacon = Beacon::new("devnet".to_string(), 1, 10);
 
         let result = digester
@@ -381,11 +307,13 @@ mod tests {
 
     #[tokio::test]
     async fn can_compute_hash_of_a_hundred_immutable_file_trio() {
-        let dir = get_test_dir("can_compute_hash_of_a_hundred_immutable_file_trio/immutable");
-        create_fake_immutables(&dir, &(1..=100).collect::<Vec<ImmutableFileNumber>>(), true);
+        let immutable_db = db_builder("can_compute_hash_of_a_hundred_immutable_file_trio")
+            .with_immutables(&(1..=100).collect::<Vec<ImmutableFileNumber>>())
+            .append_immutable_trio()
+            .build();
         let logger = create_logger();
         let digester = CardanoImmutableDigester::new(
-            dir,
+            immutable_db.dir,
             Some(Arc::new(MemoryImmutableFileDigestCacheProvider::default())),
             logger.clone(),
         );
@@ -397,18 +325,22 @@ mod tests {
             .expect("compute_digest must not fail");
 
         assert_eq!(
-            "3c91666ce10b79456041d8d031a625c376138203445bec80bbfce4a5098acf54".to_string(),
+            "a27fd67e495c2c77e4b6b0af9925b2b0bc39656c56adfad4aaab9f20fae49122".to_string(),
             result
         )
     }
 
     #[tokio::test]
     async fn digests_are_stored_into_cache_provider() {
-        let dir = get_test_dir("digests_are_stored_into_cache_provider/immutable");
-        let immutables = create_fake_immutables(&dir, &[1, 2], true);
+        let immutable_db = db_builder("digests_are_stored_into_cache_provider")
+            .with_immutables(&[1, 2])
+            .append_immutable_trio()
+            .build();
+        let immutables = immutable_db.immutables_files;
         let cache = Arc::new(MemoryImmutableFileDigestCacheProvider::default());
         let logger = create_logger();
-        let digester = CardanoImmutableDigester::new(dir, Some(cache.clone()), logger.clone());
+        let digester =
+            CardanoImmutableDigester::new(immutable_db.dir, Some(cache.clone()), logger.clone());
         let beacon = Beacon::new("devnet".to_string(), 1, 2);
 
         digester
@@ -433,12 +365,17 @@ mod tests {
 
     #[tokio::test]
     async fn computed_digest_with_cold_or_hot_or_without_any_cache_are_equals() {
-        let dir = get_test_dir("computed_digest_with_or_without_cache_are_equals/immutable");
-        create_fake_immutables(&dir, &[1, 2, 3], true);
+        let immutable_db = DummyImmutablesDbBuilder::new(
+            "computed_digest_with_cold_or_hot_or_without_any_cache_are_equals",
+        )
+        .with_immutables(&[1, 2, 3])
+        .append_immutable_trio()
+        .build();
         let logger = create_logger();
-        let no_cache_digester = CardanoImmutableDigester::new(dir.clone(), None, logger.clone());
+        let no_cache_digester =
+            CardanoImmutableDigester::new(immutable_db.dir.clone(), None, logger.clone());
         let cache_digester = CardanoImmutableDigester::new(
-            dir,
+            immutable_db.dir,
             Some(Arc::new(MemoryImmutableFileDigestCacheProvider::default())),
             logger.clone(),
         );
@@ -472,11 +409,14 @@ mod tests {
 
     #[tokio::test]
     async fn hash_computation_is_quicker_with_a_full_cache() {
-        let dir = get_test_dir("hash_computation_is_quicker_with_a_full_cache/immutable");
-        create_fake_immutables(&dir, &(1..=300).collect::<Vec<ImmutableFileNumber>>(), true);
+        let immutable_db = db_builder("hash_computation_is_quicker_with_a_full_cache")
+            .with_immutables(&(1..=300).collect::<Vec<ImmutableFileNumber>>())
+            .append_immutable_trio()
+            .build();
         let cache = MemoryImmutableFileDigestCacheProvider::default();
         let logger = create_logger();
-        let digester = CardanoImmutableDigester::new(dir, Some(Arc::new(cache)), logger.clone());
+        let digester =
+            CardanoImmutableDigester::new(immutable_db.dir, Some(Arc::new(cache)), logger.clone());
         let beacon = Beacon::new("devnet".to_string(), 1, 300);
 
         let now = Instant::now();
@@ -504,8 +444,10 @@ mod tests {
 
     #[tokio::test]
     async fn cache_read_failure_dont_block_computation() {
-        let dir = get_test_dir("cache_read_failure_dont_block_computation/immutable");
-        create_fake_immutables(&dir, &[1, 2, 3], true);
+        let immutable_db = db_builder("cache_read_failure_dont_block_computation")
+            .with_immutables(&[1, 2, 3])
+            .append_immutable_trio()
+            .build();
         let mut cache = MockImmutableFileDigestCacheProvider::new();
         cache.expect_get().returning(|_| Ok(BTreeMap::new()));
         cache.expect_store().returning(|_| {
@@ -514,7 +456,8 @@ mod tests {
             ))
         });
         let logger = create_logger();
-        let digester = CardanoImmutableDigester::new(dir, Some(Arc::new(cache)), logger.clone());
+        let digester =
+            CardanoImmutableDigester::new(immutable_db.dir, Some(Arc::new(cache)), logger.clone());
         let beacon = Beacon::new("devnet".to_string(), 1, 3);
 
         digester
@@ -525,8 +468,10 @@ mod tests {
 
     #[tokio::test]
     async fn cache_write_failure_dont_block_computation() {
-        let dir = get_test_dir("cache_write_failure_dont_block_computation/immutable");
-        create_fake_immutables(&dir, &[1, 2, 3], true);
+        let immutable_db = db_builder("cache_write_failure_dont_block_computation")
+            .with_immutables(&[1, 2, 3])
+            .append_immutable_trio()
+            .build();
         let mut cache = MockImmutableFileDigestCacheProvider::new();
         cache.expect_get().returning(|_| {
             Err(ImmutableDigesterCacheProviderError::Get(
@@ -535,7 +480,8 @@ mod tests {
         });
         cache.expect_store().returning(|_| Ok(()));
         let logger = create_logger();
-        let digester = CardanoImmutableDigester::new(dir, Some(Arc::new(cache)), logger.clone());
+        let digester =
+            CardanoImmutableDigester::new(immutable_db.dir, Some(Arc::new(cache)), logger.clone());
         let beacon = Beacon::new("devnet".to_string(), 1, 3);
 
         digester