refactor: enhance test tooling for ImmutableDigester

Co-authored-by: DJO <[email protected]>

Author: dlachaume

mithril-common/src/digesters/dumb_immutable_digester.rs

@@ -0,0 +1,88 @@
+use std::path::Path;
+
+use crate::{
+    crypto_helper::{MKTree, MKTreeStoreInMemory},
+    digesters::{ImmutableDigester, ImmutableDigesterError},
+    entities::CardanoDbBeacon,
+};
+use async_trait::async_trait;
+use tokio::sync::RwLock;
+
+/// A [ImmutableDigester] returning configurable result for testing purpose.
+pub struct DumbImmutableDigester {
+    digest: RwLock<String>,
+    mktree_leaves: RwLock<Vec<String>>,
+    is_success: bool,
+}
+
+impl DumbImmutableDigester {
+    /// Set the digest returned by [compute_digest][DumbImmutableDigester::compute_digest]
+    pub fn with_digest(mut self, new_digest: &str) -> Self {
+        self.digest = RwLock::new(new_digest.to_string());
+        self
+    }
+
+    /// Set the leaves used to construct the merkle tree returned by [compute_merkle_tree][DumbImmutableDigester::compute_merkle_tree]
+    pub fn with_merkle_tree(mut self, leaves: Vec<String>) -> Self {
+        self.mktree_leaves = RwLock::new(leaves);
+        self
+    }
+
+    /// Update digest returned by [compute_digest][DumbImmutableDigester::compute_digest]
+    pub async fn update_digest(&self, new_digest: String) {
+        let mut digest = self.digest.write().await;
+        *digest = new_digest;
+    }
+
+    /// Update the leaves used to construct the merkle tree returned by [compute_merkle_tree][DumbImmutableDigester::compute_merkle_tree]
+    pub async fn update_merkle_tree(&self, leaves: Vec<String>) {
+        let mut mktree_leaves = self.mktree_leaves.write().await;
+        *mktree_leaves = leaves;
+    }
+}
+
+impl Default for DumbImmutableDigester {
+    fn default() -> Self {
+        Self {
+            digest: RwLock::new(String::from("1234")),
+            mktree_leaves: RwLock::new(vec!["1".to_string(), "2".to_string(), "3".to_string()]),
+            is_success: true,
+        }
+    }
+}
+
+#[async_trait]
+impl ImmutableDigester for DumbImmutableDigester {
+    async fn compute_digest(
+        &self,
+        dirpath: &Path,
+        beacon: &CardanoDbBeacon,
+    ) -> Result<String, ImmutableDigesterError> {
+        if self.is_success {
+            Ok(self.digest.read().await.clone())
+        } else {
+            Err(ImmutableDigesterError::NotEnoughImmutable {
+                expected_number: beacon.immutable_file_number,
+                found_number: None,
+                db_dir: dirpath.to_owned(),
+            })
+        }
+    }
+
+    async fn compute_merkle_tree(
+        &self,
+        dirpath: &Path,
+        beacon: &CardanoDbBeacon,
+    ) -> Result<MKTree<MKTreeStoreInMemory>, ImmutableDigesterError> {
+        if self.is_success {
+            let leaves = self.mktree_leaves.read().await;
+            Ok(MKTree::new(&leaves).unwrap())
+        } else {
+            Err(ImmutableDigesterError::NotEnoughImmutable {
+                expected_number: beacon.immutable_file_number,
+                found_number: None,
+                db_dir: dirpath.to_owned(),
+            })
+        }
+    }
+}

mithril-common/src/digesters/dumb_immutable_observer.rs

@@ -2,7 +2,7 @@
 
 pub mod cache;
 mod cardano_immutable_digester;
-mod dumb_immutable_observer;
+mod dumb_immutable_digester;
 mod immutable_digester;
 mod immutable_file;
 mod immutable_file_observer;
@@ -15,7 +15,7 @@ pub use immutable_file_observer::{
     ImmutableFileSystemObserver,
 };
 
-pub use dumb_immutable_observer::DumbImmutableDigester;
+pub use dumb_immutable_digester::DumbImmutableDigester;
 
 cfg_test_tools! {
     mod dummy_immutable_db_builder;

mithril-common/src/digesters/mod.rs

@@ -72,47 +72,17 @@ mod tests {
 
     use crate::{
         crypto_helper::{MKTree, MKTreeStoreInMemory},
-        digesters::ImmutableDigesterError,
+        digesters::DumbImmutableDigester,
         entities::{CardanoDbBeacon, ProtocolMessagePartKey},
         test_utils::TestLogger,
     };
 
     use super::*;
 
-    #[derive(Default)]
-    pub struct ImmutableDigesterImpl {
-        digests: Vec<String>,
-    }
-
-    impl ImmutableDigesterImpl {
-        pub fn new(digests: Vec<String>) -> Self {
-            Self { digests }
-        }
-    }
-
-    #[async_trait]
-    impl ImmutableDigester for ImmutableDigesterImpl {
-        async fn compute_digest(
-            &self,
-            _dirpath: &Path,
-            _beacon: &CardanoDbBeacon,
-        ) -> Result<String, ImmutableDigesterError> {
-            Ok("whatever".to_string())
-        }
-
-        async fn compute_merkle_tree(
-            &self,
-            _dirpath: &Path,
-            _beacon: &CardanoDbBeacon,
-        ) -> Result<MKTree<MKTreeStoreInMemory>, ImmutableDigesterError> {
-            Ok(MKTree::new(&self.digests).unwrap())
-        }
-    }
-
     #[tokio::test]
     async fn compute_signable() {
         let digests = vec!["digest-1".to_string(), "digest-2".to_string()];
-        let digester = ImmutableDigesterImpl::new(digests.clone());
+        let digester = DumbImmutableDigester::default().with_merkle_tree(digests.clone());
         let signable_builder = CardanoDatabaseSignableBuilder::new(
             Arc::new(digester),
             Path::new(""),

mithril-common/src/signable_builder/cardano_database.rs

@@ -62,41 +62,17 @@ impl SignableBuilder<CardanoDbBeacon> for CardanoImmutableFilesFullSignableBuild
 
 #[cfg(test)]
 mod tests {
-    use async_trait::async_trait;
     use std::path::Path;
 
-    use crate::crypto_helper::{MKTree, MKTreeStoreInMemory};
-    use crate::digesters::{ImmutableDigester, ImmutableDigesterError};
+    use crate::digesters::DumbImmutableDigester;
     use crate::entities::CardanoDbBeacon;
     use crate::test_utils::TestLogger;
 
     use super::*;
 
-    #[derive(Default)]
-    pub struct ImmutableDigesterImpl;
-
-    #[async_trait]
-    impl ImmutableDigester for ImmutableDigesterImpl {
-        async fn compute_digest(
-            &self,
-            _dirpath: &Path,
-            beacon: &CardanoDbBeacon,
-        ) -> Result<String, ImmutableDigesterError> {
-            Ok(format!("immutable {}", beacon.immutable_file_number))
-        }
-
-        async fn compute_merkle_tree(
-            &self,
-            _dirpath: &Path,
-            _beacon: &CardanoDbBeacon,
-        ) -> Result<MKTree<MKTreeStoreInMemory>, ImmutableDigesterError> {
-            unimplemented!()
-        }
-    }
-
     #[tokio::test]
     async fn compute_signable() {
-        let digester = ImmutableDigesterImpl;
+        let digester = DumbImmutableDigester::default().with_digest("immutable 0");
         let signable_builder = CardanoImmutableFilesFullSignableBuilder::new(
             Arc::new(digester),
             Path::new(""),

mithril-common/src/signable_builder/cardano_immutable_full_signable_builder.rs

@@ -423,7 +423,7 @@ mod tests {
         ));
 
         let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
-        let digester = Arc::new(DumbImmutableDigester::new(DIGESTER_RESULT, true));
+        let digester = Arc::new(DumbImmutableDigester::default().with_digest(DIGESTER_RESULT));
         let cardano_immutable_signable_builder =
             Arc::new(CardanoImmutableFilesFullSignableBuilder::new(
                 digester.clone(),

mithril-signer/src/runtime/runner.rs

@@ -158,7 +158,7 @@ impl StateMachineTester {
             },
             ticker_service.clone(),
         ));
-        let digester = Arc::new(DumbImmutableDigester::new("DIGEST", true));
+        let digester = Arc::new(DumbImmutableDigester::default().with_digest("DIGEST"));
         let protocol_initializer_store = Arc::new(ProtocolInitializerRepository::new(
             sqlite_connection.clone(),
             config.store_retention_limit.map(|limit| limit as u64),