fix tests

ghubertpalo · ghubertpalo · commit 3314ff609bff · 2023-03-29T10:33:56.000+02:00
diff --git a/mithril-aggregator/src/configuration.rs b/mithril-aggregator/src/configuration.rs
@@ -18,7 +18,7 @@ pub const LIST_SNAPSHOTS_MAX_ITEMS: usize = 20;
 const SQLITE_FILE: &str = "aggregator.sqlite3";
 
 /// Different kinds of execution environments
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub enum ExecutionEnvironment {
     /// Test environment, maximum logging, memory stores etc.
     Test,
@@ -133,7 +133,7 @@ impl Default for Configuration {
             cardano_cli_path: PathBuf::new(),
             cardano_node_socket_path: PathBuf::new(),
             network_magic: Some(42),
-            network: "whatever".to_string(),
+            network: "devnet".to_string(),
             protocol_parameters: ProtocolParameters {
                 k: 5,
                 m: 100,
diff --git a/mithril-aggregator/src/dependency.rs b/mithril-aggregator/src/dependency.rs
@@ -283,153 +283,15 @@ impl DependencyManager {
 #[cfg(test)]
 pub mod tests {
     use crate::{
-        configuration::ExecutionEnvironment, database::provider::StakePoolStore,
-        event_store::TransmitterService,
-        stake_distribution_service::MithrilStakeDistributionService, AggregatorConfig,
-        CertificatePendingStore, CertificateStore, Configuration, DependencyManager,
-        DumbSnapshotUploader, DumbSnapshotter, LocalSnapshotStore, MithrilSignerRegisterer,
-        MultiSignerImpl, ProtocolParametersStore, SingleSignatureStore, SnapshotUploaderType,
-        VerificationKeyStore,
-    };
-    use mithril_common::{
-        api_version::APIVersionProvider,
-        certificate_chain::MithrilCertificateVerifier,
-        chain_observer::FakeObserver,
-        crypto_helper::{key_encode_hex, ProtocolGenesisSigner},
-        digesters::{DumbImmutableDigester, DumbImmutableFileObserver},
-        era::{
-            adapters::{EraReaderAdapterType, EraReaderBootstrapAdapter},
-            EraChecker, EraReader,
-        },
-        store::adapter::MemoryAdapter,
-        test_utils::fake_data,
-        BeaconProvider, BeaconProviderImpl, CardanoNetwork,
-    };
-    use sqlite::Connection;
-    use std::{path::PathBuf, sync::Arc};
-    use tokio::sync::{
-        mpsc::{self},
-        Mutex, RwLock,
+        dependency_injection::DependenciesBuilder, AggregatorConfig, Configuration,
+        DependencyManager,
     };
+    use mithril_common::CardanoNetwork;
 
     pub async fn initialize_dependencies() -> (DependencyManager, AggregatorConfig) {
-        let genesis_signer = ProtocolGenesisSigner::create_deterministic_genesis_signer();
-        let genesis_verifier = Arc::new(genesis_signer.create_genesis_verifier());
-        let genesis_verification_key = genesis_verifier.to_verification_key();
-        let config = Configuration {
-            environment: ExecutionEnvironment::Test,
-            cardano_cli_path: PathBuf::new(),
-            cardano_node_socket_path: PathBuf::new(),
-            network_magic: Some(42),
-            network: "whatever".to_string(),
-            protocol_parameters: fake_data::protocol_parameters(),
-            url_snapshot_manifest: "https://storage.googleapis.com/cardano-testnet/snapshots.json"
-                .to_string(),
-            snapshot_uploader_type: SnapshotUploaderType::Local,
-            snapshot_bucket_name: None,
-            server_ip: "0.0.0.0".to_string(),
-            server_port: 8000,
-            run_interval: 5000,
-            db_directory: PathBuf::new(),
-            snapshot_directory: PathBuf::new(),
-            data_stores_directory: PathBuf::new(),
-            genesis_verification_key: key_encode_hex(genesis_verification_key).unwrap(),
-            store_retention_limit: None,
-            era_reader_adapter_type: EraReaderAdapterType::Bootstrap,
-            era_reader_adapter_params: None,
-            reset_digests_cache: Some(true),
-        };
-        let connection = Arc::new(Mutex::new(Connection::open(":memory:").unwrap()));
-        let snapshot_store = Arc::new(LocalSnapshotStore::new(
-            Box::new(MemoryAdapter::new(None).unwrap()),
-            20,
-        ));
-        let snapshot_uploader = Arc::new(DumbSnapshotUploader::new());
-        let certificate_pending_store = Arc::new(CertificatePendingStore::new(Box::new(
-            MemoryAdapter::new(None).unwrap(),
-        )));
-        let certificate_store = Arc::new(CertificateStore::new(Box::new(
-            MemoryAdapter::new(None).unwrap(),
-        )));
-        let verification_key_store = Arc::new(VerificationKeyStore::new(
-            Box::new(MemoryAdapter::new(None).unwrap()),
-            config.store_retention_limit,
-        ));
-        let single_signature_store = Arc::new(SingleSignatureStore::new(
-            Box::new(MemoryAdapter::new(None).unwrap()),
-            config.store_retention_limit,
-        ));
-        let protocol_parameters_store = Arc::new(ProtocolParametersStore::new(
-            Box::new(MemoryAdapter::new(None).unwrap()),
-            None,
-        ));
-        let stake_pool_store = Arc::new(StakePoolStore::new(connection.clone()));
-        let multi_signer = MultiSignerImpl::new(
-            verification_key_store.clone(),
-            stake_pool_store.clone(),
-            single_signature_store.clone(),
-            protocol_parameters_store.clone(),
-        );
-        let multi_signer = Arc::new(RwLock::new(multi_signer));
-        let immutable_file_observer = Arc::new(DumbImmutableFileObserver::default());
-        let chain_observer = Arc::new(FakeObserver::default());
-        let beacon_provider = Arc::new(BeaconProviderImpl::new(
-            chain_observer.clone(),
-            immutable_file_observer.clone(),
-            CardanoNetwork::TestNet(42),
-        ));
-        let stake_distribution_service = Arc::new(MithrilStakeDistributionService::new(
-            stake_pool_store.clone(),
-            chain_observer.clone(),
-        ));
-        let certificate_verifier = Arc::new(MithrilCertificateVerifier::new(slog_scope::logger()));
-        let signer_registerer = Arc::new(MithrilSignerRegisterer::new(
-            chain_observer.clone(),
-            verification_key_store.clone(),
-        ));
-        let era_reader = Arc::new(EraReader::new(Arc::new(EraReaderBootstrapAdapter)));
-        let era_epoch_token = era_reader
-            .read_era_epoch_token(beacon_provider.get_current_beacon().await.unwrap().epoch)
-            .await
-            .unwrap();
-        let era_checker = Arc::new(EraChecker::new(
-            era_epoch_token.get_current_supported_era().unwrap(),
-            era_epoch_token.get_current_epoch(),
-        ));
-        let event_transmitter = {
-            let (tx, mut _rx) = mpsc::unbounded_channel();
-            Arc::new(TransmitterService::new(tx))
-        };
-
-        let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
-
-        let dependency_manager = DependencyManager {
-            sqlite_connection: connection,
-            stake_store: stake_pool_store,
-            config,
-            snapshot_store,
-            snapshot_uploader,
-            multi_signer,
-            certificate_pending_store,
-            certificate_store,
-            verification_key_store,
-            single_signature_store,
-            protocol_parameters_store,
-            chain_observer,
-            beacon_provider,
-            immutable_file_observer,
-            digester: Arc::new(DumbImmutableDigester::new("digest", true)),
-            snapshotter: Arc::new(DumbSnapshotter::new()),
-            certificate_verifier,
-            genesis_verifier,
-            signer_registerer: signer_registerer.clone(),
-            signer_registration_round_opener: signer_registerer,
-            era_checker,
-            era_reader,
-            event_transmitter,
-            api_version_provider,
-            stake_distribution_service,
-        };
+        let config = Configuration::default();
+        let mut builder = DependenciesBuilder::new(config);
+        let dependency_manager = builder.build_dependency_container().await.unwrap();
 
         let config = AggregatorConfig::new(
             dependency_manager.config.run_interval,
diff --git a/mithril-aggregator/src/dependency_injection/builder.rs b/mithril-aggregator/src/dependency_injection/builder.rs
@@ -42,11 +42,11 @@ use crate::{
     stake_distribution_service::{MithrilStakeDistributionService, StakeDistributionService},
     tools::{GcpFileUploader, GenesisToolsDependency},
     AggregatorConfig, AggregatorRunner, AggregatorRuntime, CertificatePendingStore,
-    CertificateStore, Configuration, DependencyManager, DumbSnapshotter, GzipSnapshotter,
-    LocalSnapshotStore, LocalSnapshotUploader, MithrilSignerRegisterer, MultiSigner,
-    MultiSignerImpl, ProtocolParametersStore, ProtocolParametersStorer, RemoteSnapshotUploader,
-    SingleSignatureStore, SnapshotStore, SnapshotUploader, SnapshotUploaderType, Snapshotter,
-    VerificationKeyStore,
+    CertificateStore, Configuration, DependencyManager, DumbSnapshotUploader, DumbSnapshotter,
+    GzipSnapshotter, LocalSnapshotStore, LocalSnapshotUploader, MithrilSignerRegisterer,
+    MultiSigner, MultiSignerImpl, ProtocolParametersStore, ProtocolParametersStorer,
+    RemoteSnapshotUploader, SingleSignatureStore, SnapshotStore, SnapshotUploader,
+    SnapshotUploaderType, Snapshotter, VerificationKeyStore,
 };
 
 use super::{DependenciesBuilderError, Result};
@@ -123,6 +123,9 @@ pub struct DependenciesBuilder {
     /// Era checker service
     pub era_checker: Option<Arc<EraChecker>>,
 
+    /// Adapter for [EraReader]
+    pub era_reader_adapter: Option<Arc<dyn EraReaderAdapter>>,
+
     /// Era reader service
     pub era_reader: Option<Arc<EraReader>>,
 
@@ -168,6 +171,7 @@ impl DependenciesBuilder {
             certificate_verifier: None,
             genesis_verifier: None,
             mithril_registerer: None,
+            era_reader_adapter: None,
             era_checker: None,
             era_reader: None,
             event_transmitter: None,
@@ -270,27 +274,31 @@ impl DependenciesBuilder {
     }
 
     async fn build_snapshot_uploader(&mut self) -> Result<Arc<dyn SnapshotUploader>> {
-        match self.configuration.snapshot_uploader_type {
-            SnapshotUploaderType::Gcp => {
-                let bucket = self
-                    .configuration
-                    .snapshot_bucket_name
-                    .to_owned()
-                    .ok_or_else(|| {
-                        DependenciesBuilderError::MissingConfiguration(
-                            "snapshot_bucket_name".to_string(),
-                        )
-                    })?;
+        if self.configuration.environment == ExecutionEnvironment::Production {
+            match self.configuration.snapshot_uploader_type {
+                SnapshotUploaderType::Gcp => {
+                    let bucket = self
+                        .configuration
+                        .snapshot_bucket_name
+                        .to_owned()
+                        .ok_or_else(|| {
+                            DependenciesBuilderError::MissingConfiguration(
+                                "snapshot_bucket_name".to_string(),
+                            )
+                        })?;
 
-                Ok(Arc::new(RemoteSnapshotUploader::new(
-                    Box::new(GcpFileUploader::new(bucket.clone())),
-                    bucket,
-                )))
+                    Ok(Arc::new(RemoteSnapshotUploader::new(
+                        Box::new(GcpFileUploader::new(bucket.clone())),
+                        bucket,
+                    )))
+                }
+                SnapshotUploaderType::Local => Ok(Arc::new(LocalSnapshotUploader::new(
+                    self.configuration.get_server_url(),
+                    &self.configuration.snapshot_directory,
+                ))),
             }
-            SnapshotUploaderType::Local => Ok(Arc::new(LocalSnapshotUploader::new(
-                self.configuration.get_server_url(),
-                &self.configuration.snapshot_directory,
-            ))),
+        } else {
+            Ok(Arc::new(DumbSnapshotUploader::new()))
         }
     }
 
@@ -591,7 +599,7 @@ impl DependenciesBuilder {
                 ExecutionEnvironment::Production => Arc::new(ImmutableFileSystemObserver::new(
                     &self.configuration.db_directory,
                 )),
-                _ => Arc::new(DumbImmutableFileObserver::new()),
+                _ => Arc::new(DumbImmutableFileObserver::default()),
             };
 
         Ok(immutable_file_observer)
@@ -937,7 +945,8 @@ impl DependenciesBuilder {
         Ok(self.stake_distribution_service.as_ref().cloned().unwrap())
     }
 
-    async fn build_dependency_container(&mut self) -> Result<DependencyManager> {
+    /// Return an unconfigured [DependencyManager]
+    pub async fn build_dependency_container(&mut self) -> Result<DependencyManager> {
         let dependency_manager = DependencyManager {
             config: self.configuration.clone(),
             sqlite_connection: self.get_sqlite_connection().await?,
@@ -979,20 +988,21 @@ impl DependenciesBuilder {
     pub async fn create_aggregator_runner(&mut self) -> Result<AggregatorRuntime> {
         // initialize ProtocolParameters store if needed
         {
-            let (work_epoch, epoch_to_sign, next_epoch_to_sign) = match self
+            let current_epoch = self
                 .get_chain_observer()
                 .await?
                 .get_current_epoch()
                 .await
                 .map_err(|e| DependenciesBuilderError::Initialization {
-                    message: "cannot create aggrgator runner".to_string(),
+                    message: "cannot create aggregator runner".to_string(),
                     error: Some(e.into()),
                 })?
                 .ok_or(DependenciesBuilderError::Initialization {
                     message: "cannot build aggrgator runner: impossible to retrieve current epoch"
                         .to_string(),
                     error: None,
-                })? {
+                })?;
+            let (work_epoch, epoch_to_sign, next_epoch_to_sign) = match current_epoch {
                 Epoch(0) => (Epoch(0), Epoch(1), Epoch(2)),
                 epoch => (
                     epoch.offset_to_signer_retrieval_epoch().unwrap(),
@@ -1001,6 +1011,7 @@ impl DependenciesBuilder {
                 ),
             };
             let protocol_parameters_store = self.get_protocol_parameters_store().await?;
+
             if protocol_parameters_store
                 .get_protocol_parameters(work_epoch)
                 .await
diff --git a/mithril-aggregator/src/stake_distribution_service.rs b/mithril-aggregator/src/stake_distribution_service.rs
@@ -238,7 +238,7 @@ mod tests {
             Arc::new(chain_observer),
         );
         let query =
-            format!("insert into stake_pool (stake_pool_id, epoch, stake) values (?1, ?2, ?3)");
+            "insert into stake_pool (stake_pool_id, epoch, stake) values (?1, ?2, ?3)".to_string();
         let stake_distribution: &[(&str, i64, i64); 9] = &[
             ("pool1", 1, 1000),
             ("pool2", 1, 1100),
diff --git a/mithril-aggregator/tests/certificate_chain.rs b/mithril-aggregator/tests/certificate_chain.rs
@@ -27,7 +27,10 @@ async fn certificate_chain() {
         .set_signers(signers_with_stake.clone())
         .await;
     tester
-        .deps
+        .deps_builder
+        .build_dependency_container()
+        .await
+        .unwrap()
         .prepare_for_genesis(
             signers_with_stake.clone(),
             signers_with_stake.clone(),
@@ -111,8 +114,10 @@ async fn certificate_chain() {
         "Checking that no signers are registered for the next epoch since they did not register"
     );
     let next_epoch_verification_keys = tester
-        .deps
-        .verification_key_store
+        .deps_builder
+        .get_verification_key_store()
+        .await
+        .unwrap()
         .get_verification_keys(new_epoch + 1)
         .await
         .expect("get_verification_keys should not fail");
diff --git a/mithril-aggregator/tests/create_certificate.rs b/mithril-aggregator/tests/create_certificate.rs
@@ -29,7 +29,10 @@ async fn create_certificate() {
         .set_signers(signers_with_stake.clone())
         .await;
     tester
-        .deps
+        .deps_builder
+        .build_dependency_container()
+        .await
+        .unwrap()
         .prepare_for_genesis(
             signers_with_stake.clone(),
             signers_with_stake,
diff --git a/mithril-aggregator/tests/era_checker.rs b/mithril-aggregator/tests/era_checker.rs
@@ -58,7 +58,10 @@ async fn testing_eras() {
         .set_signers(signers_with_stake.clone())
         .await;
     tester
-        .deps
+        .deps_builder
+        .build_dependency_container()
+        .await
+        .unwrap()
         .prepare_for_genesis(
             signers_with_stake.clone(),
             signers_with_stake.clone(),
diff --git a/mithril-aggregator/tests/simple.rs b/mithril-aggregator/tests/simple.rs
@@ -27,7 +27,10 @@ async fn simple_scenario() {
         .set_signers(signers_with_stake.clone())
         .await;
     tester
-        .deps
+        .deps_builder
+        .build_dependency_container()
+        .await
+        .unwrap()
         .prepare_for_genesis(
             signers_with_stake.clone(),
             signers_with_stake.clone(),
diff --git a/mithril-aggregator/tests/test_extensions/dependency.rs b/mithril-aggregator/tests/test_extensions/dependency.rs
diff --git a/mithril-aggregator/tests/test_extensions/runtime_tester.rs b/mithril-aggregator/tests/test_extensions/runtime_tester.rs
