Enhance the test checking cache speed

By using larger files (64kb instead of less than 1kb), making results with cache far faster.

Author: Alenar

mithril-common/src/digesters/cardano_immutable_digester.rs

@@ -410,14 +410,15 @@ mod tests {
     #[tokio::test]
     async fn hash_computation_is_quicker_with_a_full_cache() {
         let immutable_db = db_builder("hash_computation_is_quicker_with_a_full_cache")
-            .with_immutables(&(1..=300).collect::<Vec<ImmutableFileNumber>>())
+            .with_immutables(&(1..=50).collect::<Vec<ImmutableFileNumber>>())
             .append_immutable_trio()
+            .set_file_size(65536)
             .build();
         let cache = MemoryImmutableFileDigestCacheProvider::default();
         let logger = create_logger();
         let digester =
             CardanoImmutableDigester::new(immutable_db.dir, Some(Arc::new(cache)), logger.clone());
-        let beacon = Beacon::new("devnet".to_string(), 1, 300);
+        let beacon = Beacon::new("devnet".to_string(), 1, 50);
 
         let now = Instant::now();
         digester
@@ -433,9 +434,13 @@ mod tests {
             .expect("compute_digest must not fail");
         let elapsed_with_cache = now.elapsed();
 
+        // Note real performance doesn't matter here, the purpose is only to check that the computation
+        // time is faster with cache.
+        // We set the limit to 90% to avoid flakiness and ensure that the cache is useful (Note: Real
+        // performance is around ~100 times faster in debug).
         assert!(
             elapsed_with_cache < (elapsed_without_cache * 9 / 10),
-            "digest computation with full cache should be at least 10% faster than without cache,\
+            "digest computation with full cache should be faster than without cache,\
             time elapsed: with cache {:?}, without cache {:?}",
             elapsed_with_cache,
             elapsed_without_cache

mithril-common/src/digesters/dummy_immutable_db_builder.rs

@@ -11,6 +11,7 @@ pub struct DummyImmutablesDbBuilder {
     immutables_to_write: Vec<ImmutableFileNumber>,
     non_immutables_to_write: Vec<String>,
     append_uncompleted_trio: bool,
+    file_size: Option<u64>,
 }
 
 pub struct DummyImmutableDb {
@@ -28,6 +29,7 @@ impl DummyImmutablesDbBuilder {
             immutables_to_write: vec![],
             non_immutables_to_write: vec![],
             append_uncompleted_trio: false,
+            file_size: None,
         }
     }
 
@@ -41,14 +43,22 @@ impl DummyImmutablesDbBuilder {
         self
     }
 
-    /// Makes [Self::build] add another trio of immutables file, that won't be included
+    /// Makes [build][Self::build] add another trio of immutables file, that won't be included
     /// in its returned vec, to simulate the last 3 'uncompleted / wip' files that can be found in
     /// a cardano immutable db.
     pub fn append_immutable_trio(&mut self) -> &mut Self {
         self.append_uncompleted_trio = true;
         self
     }
 
+    /// Set the size of all files written by [build][Self::build] to the given `file_size` in bytes.
+    ///
+    /// Note: by default the size of the produced files is less than a 1kb.
+    pub fn set_file_size(&mut self, file_size: u64) -> &mut Self {
+        self.file_size = Some(file_size);
+        self
+    }
+
     pub fn build(&self) -> DummyImmutableDb {
         let mut non_immutables_files = vec![];
         let mut immutable_numbers = self.immutables_to_write.clone();
@@ -113,7 +123,14 @@ impl DummyImmutablesDbBuilder {
     fn write_dummy_file(&self, filename: &str) -> PathBuf {
         let file = self.dir.join(Path::new(filename));
         let mut source_file = File::create(&file).unwrap();
+
         write!(source_file, "This is a test file named '{}'", filename).unwrap();
+
+        if let Some(file_size) = self.file_size {
+            writeln!(source_file).unwrap();
+            source_file.set_len(file_size).unwrap();
+        }
+
         file
     }
 }