Update Artifact builder service to trait

Author: jpraynaud

mithril-aggregator/src/artifact_builder/artifact_builder_service.rs

@@ -1,3 +1,5 @@
+use async_trait::async_trait;
+
 use std::sync::Arc;
 
 use mithril_common::{
@@ -10,14 +12,29 @@ use crate::artifact_builder::ArtifactBuilder;
 
 use super::MithrilStakeDistribution;
 
-/// ArtifactBuilder Service
-pub struct ArtifactBuilderService {
+#[cfg(test)]
+use mockall::automock;
+
+/// ArtifactBuilder Service trait
+#[cfg_attr(test, automock)]
+#[async_trait]
+pub trait ArtifactBuilderService: Send + Sync {
+    /// Compute artifact from signed entity type
+    async fn compute_artifact(
+        &self,
+        signed_entity_type: SignedEntityType,
+        certificate: &Certificate,
+    ) -> StdResult<Arc<dyn Artifact>>;
+}
+
+/// Mithril ArtifactBuilder Service
+pub struct MithrilArtifactBuilderService {
     mithril_stake_distribution_artifact_builder:
         Arc<dyn ArtifactBuilder<Epoch, MithrilStakeDistribution>>,
 }
 
-impl ArtifactBuilderService {
-    /// ArtifactBuilderService factory
+impl MithrilArtifactBuilderService {
+    /// MithrilArtifactBuilderService factory
     #[allow(dead_code)]
     pub fn new(
         mithril_stake_distribution_artifact_builder: Arc<
@@ -30,13 +47,14 @@ impl ArtifactBuilderService {
     }
 }
 
-impl ArtifactBuilderService {
+#[async_trait]
+impl ArtifactBuilderService for MithrilArtifactBuilderService {
     #[allow(dead_code)]
     async fn compute_artifact(
         &self,
         signed_entity_type: SignedEntityType,
         certificate: &Certificate,
-    ) -> StdResult<Arc<impl Artifact>> {
+    ) -> StdResult<Arc<dyn Artifact>> {
         let artifact = match signed_entity_type {
             SignedEntityType::MithrilStakeDistribution(e) => Arc::new(
                 self.mithril_stake_distribution_artifact_builder
@@ -70,18 +88,21 @@ mod tests {
             .once()
             .return_once(move |_, _| Ok(mithril_stake_distribution_clone));
 
-        let artifact_builder_service =
-            ArtifactBuilderService::new(Arc::new(mock_mithril_stake_distribution_artifact_builder));
+        let artifact_builder_service = MithrilArtifactBuilderService::new(Arc::new(
+            mock_mithril_stake_distribution_artifact_builder,
+        ));
         let certificate = Certificate::default();
 
         let signed_entity_type = SignedEntityType::MithrilStakeDistribution(Epoch(1));
         let artifact = artifact_builder_service
             .compute_artifact(signed_entity_type, &certificate)
             .await
             .unwrap();
+        let mithril_stake_distribution_computed: MithrilStakeDistribution =
+            serde_json::from_str(&serde_json::to_string(&artifact).unwrap()).unwrap();
         assert_eq!(
             serde_json::to_string(&mithril_stake_distribution_expected).unwrap(),
-            serde_json::to_string(&artifact).unwrap()
+            serde_json::to_string(&mithril_stake_distribution_computed).unwrap()
         );
     }
 }

mithril-aggregator/src/dependency.rs

@@ -115,7 +115,7 @@ pub struct DependencyManager {
     pub signable_builder_service: Arc<SignableBuilderService>,
 
     /// Artifact Builder Service
-    pub artifact_builder_service: Arc<ArtifactBuilderService>,
+    pub artifact_builder_service: Arc<dyn ArtifactBuilderService>,
 
     /// Certifier Service
     pub certifier_service: Arc<dyn CertifierService>,

mithril-aggregator/src/dependency_injection/builder.rs

@@ -33,7 +33,10 @@ use tokio::{
 use warp::Filter;
 
 use crate::{
-    artifact_builder::{ArtifactBuilderService, MithrilStakeDistributionArtifactBuilder},
+    artifact_builder::{
+        ArtifactBuilderService, MithrilArtifactBuilderService,
+        MithrilStakeDistributionArtifactBuilder,
+    },
     certifier_service::{CertifierService, MithrilCertifierService},
     configuration::{ExecutionEnvironment, LIST_SNAPSHOTS_MAX_ITEMS},
     database::provider::{
@@ -170,7 +173,7 @@ pub struct DependenciesBuilder {
     pub signable_builder_service: Option<Arc<SignableBuilderService>>,
 
     /// Artifact Builder Service
-    pub artifact_builder_service: Option<Arc<ArtifactBuilderService>>,
+    pub artifact_builder_service: Option<Arc<dyn ArtifactBuilderService>>,
 
     /// Certifier service
     pub certifier_service: Option<Arc<dyn CertifierService>>,
@@ -897,19 +900,21 @@ impl DependenciesBuilder {
         Ok(self.signable_builder_service.as_ref().cloned().unwrap())
     }
 
-    async fn build_artifact_builder_service(&mut self) -> Result<Arc<ArtifactBuilderService>> {
+    async fn build_artifact_builder_service(&mut self) -> Result<Arc<dyn ArtifactBuilderService>> {
         let multi_signer = self.get_multi_signer().await?;
         let mithril_stake_distribution_artifact_builder =
             Arc::new(MithrilStakeDistributionArtifactBuilder::new(multi_signer));
-        let artifact_builder_service = Arc::new(ArtifactBuilderService::new(
+        let artifact_builder_service = Arc::new(MithrilArtifactBuilderService::new(
             mithril_stake_distribution_artifact_builder,
         ));
 
         Ok(artifact_builder_service)
     }
 
     /// [ArtifactBuilderService] service
-    pub async fn get_artifact_builder_service(&mut self) -> Result<Arc<ArtifactBuilderService>> {
+    pub async fn get_artifact_builder_service(
+        &mut self,
+    ) -> Result<Arc<dyn ArtifactBuilderService>> {
         if self.artifact_builder_service.is_none() {
             self.artifact_builder_service = Some(self.build_artifact_builder_service().await?);
         }