Make SignableBuilderService a trait

Author: jpraynaud

mithril-aggregator/src/dependency.rs

@@ -112,7 +112,7 @@ pub struct DependencyManager {
     pub signer_recorder: Arc<dyn SignerRecorder>,
 
     /// Signable Builder Service
-    pub signable_builder_service: Arc<SignableBuilderService>,
+    pub signable_builder_service: Arc<dyn SignableBuilderService>,
 
     /// Artifact Builder Service
     pub artifact_builder_service: Arc<dyn ArtifactBuilderService>,

mithril-aggregator/src/dependency_injection/builder.rs

@@ -48,7 +48,7 @@ use crate::{
     },
     event_store::{EventMessage, EventStore, TransmitterService},
     http_server::routes::router,
-    signable_builder::SignableBuilderService,
+    signable_builder::{MithrilSignableBuilderService, SignableBuilderService},
     signer_registerer::SignerRecorder,
     stake_distribution_service::{MithrilStakeDistributionService, StakeDistributionService},
     ticker_service::{MithrilTickerService, TickerService},
@@ -172,7 +172,7 @@ pub struct DependenciesBuilder {
     pub signer_recorder: Option<Arc<dyn SignerRecorder>>,
 
     /// Signable Builder Service
-    pub signable_builder_service: Option<Arc<SignableBuilderService>>,
+    pub signable_builder_service: Option<Arc<dyn SignableBuilderService>>,
 
     /// Artifact Builder Service
     pub artifact_builder_service: Option<Arc<dyn ArtifactBuilderService>>,
@@ -877,13 +877,14 @@ impl DependenciesBuilder {
         Ok(self.signer_recorder.as_ref().cloned().unwrap())
     }
 
-    async fn build_signable_builder_service(&mut self) -> Result<Arc<SignableBuilderService>> {
-        let mithril_stake_distribution_builder = MithrilStakeDistributionSignableBuilder::default();
-        let immutable_signable_builder = CardanoImmutableFilesFullSignableBuilder::new(
+    async fn build_signable_builder_service(&mut self) -> Result<Arc<dyn SignableBuilderService>> {
+        let mithril_stake_distribution_builder =
+            Arc::new(MithrilStakeDistributionSignableBuilder::default());
+        let immutable_signable_builder = Arc::new(CardanoImmutableFilesFullSignableBuilder::new(
             self.get_immutable_digester().await?,
             self.get_logger().await?,
-        );
-        let signable_builder_service = Arc::new(SignableBuilderService::new(
+        ));
+        let signable_builder_service = Arc::new(MithrilSignableBuilderService::new(
             mithril_stake_distribution_builder,
             immutable_signable_builder,
         ));
@@ -892,7 +893,9 @@ impl DependenciesBuilder {
     }
 
     /// [SignableBuilderService] service
-    pub async fn get_signable_builder_service(&mut self) -> Result<Arc<SignableBuilderService>> {
+    pub async fn get_signable_builder_service(
+        &mut self,
+    ) -> Result<Arc<dyn SignableBuilderService>> {
         if self.signable_builder_service.is_none() {
             self.signable_builder_service = Some(self.build_signable_builder_service().await?);
         }

mithril-aggregator/src/signable_builder/signable_builder_service.rs

@@ -1,25 +1,37 @@
+use async_trait::async_trait;
 use std::sync::Arc;
 
 use mithril_common::{
-    entities::SignedEntityType,
-    signable_builder::{
-        CardanoImmutableFilesFullSignableBuilder, MithrilStakeDistributionSignableBuilder,
-        Signable, SignableBuilder,
-    },
+    entities::{Beacon, Epoch, ProtocolMessage, SignedEntityType},
+    signable_builder::{Signable, SignableBuilder},
     StdResult,
 };
 
-/// SignableBuilder Service
-pub struct SignableBuilderService {
-    mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
-    immutable_signable_builder: CardanoImmutableFilesFullSignableBuilder,
+#[cfg(test)]
+use mockall::automock;
+
+/// ArtifactBuilder Service trait
+#[cfg_attr(test, automock)]
+#[async_trait]
+pub trait SignableBuilderService: Send + Sync {
+    /// Compute signable from signed entity type
+    async fn compute_signable(
+        &self,
+        signed_entity_type: SignedEntityType,
+    ) -> StdResult<Arc<dyn Signable>>;
+}
+
+/// Mithril Signable Builder Service
+pub struct MithrilSignableBuilderService {
+    mithril_stake_distribution_builder: Arc<dyn SignableBuilder<Epoch, ProtocolMessage>>,
+    immutable_signable_builder: Arc<dyn SignableBuilder<Beacon, ProtocolMessage>>,
 }
 
-impl SignableBuilderService {
-    /// SignableBuilderService factory
+impl MithrilSignableBuilderService {
+    /// MithrilSignableBuilderService factory
     pub fn new(
-        mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
-        immutable_signable_builder: CardanoImmutableFilesFullSignableBuilder,
+        mithril_stake_distribution_builder: Arc<dyn SignableBuilder<Epoch, ProtocolMessage>>,
+        immutable_signable_builder: Arc<dyn SignableBuilder<Beacon, ProtocolMessage>>,
     ) -> Self {
         Self {
             mithril_stake_distribution_builder,
@@ -28,7 +40,8 @@ impl SignableBuilderService {
     }
 }
 
-impl SignableBuilderService {
+#[async_trait]
+impl SignableBuilderService for MithrilSignableBuilderService {
     #[allow(dead_code)]
     async fn compute_signable(
         &self,
@@ -53,4 +66,80 @@ impl SignableBuilderService {
 }
 
 #[cfg(test)]
-mod tests {}
+mod tests {
+    use super::*;
+
+    use mithril_common::{
+        entities::{Epoch, ProtocolMessage},
+        signable_builder::{Beacon as Beaconnable, Signable, SignableBuilder},
+        StdResult,
+    };
+
+    use async_trait::async_trait;
+    use mockall::mock;
+
+    mock! {
+        SignableBuilderImpl<U, V> { }
+
+        #[async_trait]
+        impl<U, V> SignableBuilder<U, V> for SignableBuilderImpl<U, V> where
+        U: Beaconnable,
+        V: Signable,{
+
+            async fn compute_signable(&self, beacon: U) -> StdResult<V>;
+        }
+    }
+
+    #[tokio::test]
+    async fn build_mithril_stake_distribution_signable_when_given_mithril_stake_distribution_entity_type(
+    ) {
+        let protocol_message = ProtocolMessage::new();
+        let protocol_message_clone = protocol_message.clone();
+        let mut mock_mithril_stake_distribution_signable_builder =
+            MockSignableBuilderImpl::<Epoch, ProtocolMessage>::new();
+        mock_mithril_stake_distribution_signable_builder
+            .expect_compute_signable()
+            .once()
+            .return_once(move |_| Ok(protocol_message_clone));
+
+        let mock_cardano_immutable_files_full_signable_builder =
+            MockSignableBuilderImpl::<Beacon, ProtocolMessage>::new();
+
+        let signable_builder_service = MithrilSignableBuilderService::new(
+            Arc::new(mock_mithril_stake_distribution_signable_builder),
+            Arc::new(mock_cardano_immutable_files_full_signable_builder),
+        );
+
+        let signed_entity_type = SignedEntityType::MithrilStakeDistribution(Epoch(1));
+        signable_builder_service
+            .compute_signable(signed_entity_type)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test]
+    async fn build_snapshot_signable_when_given_cardano_immutable_files_full_entity_type() {
+        let protocol_message = ProtocolMessage::new();
+        let protocol_message_clone = protocol_message.clone();
+        let mock_mithril_stake_distribution_signable_builder =
+            MockSignableBuilderImpl::<Epoch, ProtocolMessage>::new();
+
+        let mut mock_cardano_immutable_files_full_signable_builder =
+            MockSignableBuilderImpl::<Beacon, ProtocolMessage>::new();
+        mock_cardano_immutable_files_full_signable_builder
+            .expect_compute_signable()
+            .once()
+            .return_once(move |_| Ok(protocol_message_clone));
+
+        let signable_builder_service = MithrilSignableBuilderService::new(
+            Arc::new(mock_mithril_stake_distribution_signable_builder),
+            Arc::new(mock_cardano_immutable_files_full_signable_builder),
+        );
+
+        let signed_entity_type = SignedEntityType::CardanoImmutableFilesFull(Beacon::default());
+        signable_builder_service
+            .compute_signable(signed_entity_type)
+            .await
+            .unwrap();
+    }
+}

mithril-common/src/signable_builder/interface.rs

@@ -3,6 +3,9 @@ use std::fmt::Debug;
 
 use crate::{entities::ProtocolMessage, StdResult};
 
+#[cfg(test)]
+use mockall::automock;
+
 /// Beacon trait
 pub trait Beacon: Send + Sync {}
 
@@ -17,8 +20,9 @@ pub trait Signable: Send + Sync {
 pub trait Artifact: Debug + Send + Sync {}
 
 /// SignableBuilder is trait for building a signable for a beacon
+#[cfg_attr(test, automock)]
 #[async_trait]
-pub trait SignableBuilder<U, V>
+pub trait SignableBuilder<U, V>: Send + Sync
 where
     U: Beacon,
     V: Signable,