Add OpenMessageObserver to aggregator integration tests

Author: Alenar

mithril-aggregator/tests/certificate_chain.rs

@@ -60,7 +60,11 @@ async fn certificate_chain() {
     cycle!(tester, "signing");
     tester.register_signers(&signers).await.unwrap();
     cycle_err!(tester, "signing");
-    let signed_entity_type = tester.retrieve_signed_entity_type().await;
+    let signed_entity_type = tester
+        .open_message_observer
+        .get_current_immutable_entity_type()
+        .await
+        .unwrap();
     tester
         .send_single_signatures(&signed_entity_type, &signers)
         .await
@@ -80,7 +84,11 @@ async fn certificate_chain() {
     tester.increase_immutable_number().await.unwrap();
     cycle!(tester, "ready");
     cycle!(tester, "signing");
-    let signed_entity_type = tester.retrieve_signed_entity_type().await;
+    let signed_entity_type = tester
+        .open_message_observer
+        .get_current_immutable_entity_type()
+        .await
+        .unwrap();
     tester
         .send_single_signatures(&signed_entity_type, &signers)
         .await
@@ -143,7 +151,11 @@ async fn certificate_chain() {
         "Signers register & send signatures, the new certificate should be link to the first of the previous epoch"
     );
     tester.register_signers(&new_signers).await.unwrap();
-    let signed_entity_type = tester.retrieve_signed_entity_type().await;
+    let signed_entity_type = tester
+        .open_message_observer
+        .get_current_immutable_entity_type()
+        .await
+        .unwrap();
     tester
         .send_single_signatures(&signed_entity_type, &signers)
         .await
@@ -183,7 +195,11 @@ async fn certificate_chain() {
     cycle!(tester, "ready");
     cycle!(tester, "signing");
 
-    let signed_entity_type = tester.retrieve_signed_entity_type().await;
+    let signed_entity_type = tester
+        .open_message_observer
+        .get_current_immutable_entity_type()
+        .await
+        .unwrap();
     tester
         .send_single_signatures(&signed_entity_type, &signers)
         .await
@@ -199,7 +215,11 @@ async fn certificate_chain() {
     tester.increase_immutable_number().await.unwrap();
     cycle!(tester, "ready");
     cycle!(tester, "signing");
-    let signed_entity_type = tester.retrieve_signed_entity_type().await;
+    let signed_entity_type = tester
+        .open_message_observer
+        .get_current_immutable_entity_type()
+        .await
+        .unwrap();
 
     tester
         .send_single_signatures(&signed_entity_type, &new_signers)

mithril-aggregator/tests/create_certificate.rs

@@ -67,7 +67,11 @@ async fn create_certificate() {
     cycle!(tester, "signing");
 
     comment!("signers send their single signature");
-    let signed_entity_type = tester.retrieve_signed_entity_type().await;
+    let signed_entity_type = tester
+        .open_message_observer
+        .get_current_immutable_entity_type()
+        .await
+        .unwrap();
     let signers_who_sign = &signers[0..=6];
     tester
         .send_single_signatures(&signed_entity_type, signers_who_sign)

mithril-aggregator/tests/test_extensions/mod.rs

@@ -6,6 +6,7 @@
 pub mod runtime_tester;
 #[macro_use]
 pub mod utilities;
+pub mod open_message_observer;
 
 //pub use dependency::initialize_dependencies;
 pub use runtime_tester::RuntimeTester;

mithril-aggregator/tests/test_extensions/open_message_observer.rs

@@ -0,0 +1,53 @@
+use mithril_aggregator::{
+    certifier_service::CertifierService, database::provider::OpenMessageWithSingleSignatures,
+};
+use mithril_common::{entities::SignedEntityType, BeaconProvider};
+use std::sync::Arc;
+
+// An observer that allow to inspect currently available open messages.
+pub struct OpenMessageObserver {
+    pub beacon_provider: Arc<dyn BeaconProvider>,
+    pub certifier_service: Arc<dyn CertifierService>,
+}
+
+impl OpenMessageObserver {
+    // [OpenMessageObserver] factory
+    pub fn new(
+        beacon_provider: Arc<dyn BeaconProvider>,
+        certifier_service: Arc<dyn CertifierService>,
+    ) -> Self {
+        Self {
+            beacon_provider,
+            certifier_service,
+        }
+    }
+
+    // Get the current [open message][OpenMessageWithSingleSignatures] for [cardano immutables][SignedEntityType::CardanoImmutableFilesFull]
+    pub async fn get_current_immutable_message(
+        &self,
+    ) -> Result<Option<OpenMessageWithSingleSignatures>, String> {
+        let immutable_signer_entity_type = SignedEntityType::CardanoImmutableFilesFull(
+            self.beacon_provider
+                .get_current_beacon()
+                .await
+                .map_err(|e| format!("Querying the current beacon should not fail: {e:?}"))?,
+        );
+
+        self.certifier_service
+            .get_open_message(&immutable_signer_entity_type)
+            .await
+            .map_err(|e| {
+                format!(
+                    "Requesting current open message of type CardanoImmutableFilesFull should be not fail: {e:?}"
+                )
+            })
+    }
+
+    // Get the [entity type][SignedEntityType::CardanoImmutableFilesFull] of the current current open message
+    pub async fn get_current_immutable_entity_type(&self) -> Result<SignedEntityType, String> {
+        match self.get_current_immutable_message().await? {
+            None => Err("An open message should be available for cardano immutables".to_string()),
+            Some(message) => Ok(message.signed_entity_type),
+        }
+    }
+}

mithril-aggregator/tests/test_extensions/runtime_tester.rs

@@ -6,10 +6,12 @@ use mithril_common::era::{EraMarker, EraReader, SupportedEra};
 use mithril_common::test_utils::{
     MithrilFixtureBuilder, SignerFixture, StakeDistributionGenerationMethod,
 };
+use semver::Op;
 use slog::Drain;
 use std::sync::Arc;
 use tokio::sync::mpsc::UnboundedReceiver;
 
+use crate::test_extensions::open_message_observer::OpenMessageObserver;
 use mithril_aggregator::{
     AggregatorRuntime, Configuration, DumbSnapshotUploader, DumbSnapshotter,
     ProtocolParametersStorer, SignerRegisterer,
@@ -52,6 +54,7 @@ pub struct RuntimeTester {
     pub runtime: AggregatorRuntime,
     pub receiver: UnboundedReceiver<EventMessage>,
     pub era_reader_adapter: Arc<EraReaderDummyAdapter>,
+    pub open_message_observer: OpenMessageObserver,
     _logs_guard: slog_scope::GlobalLoggerGuard,
 }
 
@@ -82,6 +85,10 @@ impl RuntimeTester {
         let drain = slog_async::Async::new(drain).build().fuse();
         let log = slog_scope::set_global_logger(slog::Logger::root(Arc::new(drain), slog::o!()));
         let receiver = deps_builder.get_event_transmitter_receiver().await.unwrap();
+        let open_message_observer = OpenMessageObserver::new(
+            deps_builder.get_beacon_provider().await.unwrap(),
+            deps_builder.get_certifier_service().await.unwrap(),
+        );
 
         Self {
             snapshot_uploader,
@@ -94,6 +101,7 @@ impl RuntimeTester {
             runtime,
             receiver,
             era_reader_adapter,
+            open_message_observer,
             _logs_guard: log,
         }
     }
@@ -390,26 +398,4 @@ impl RuntimeTester {
     pub async fn set_era_markers(&self, markers: Vec<EraMarker>) {
         self.era_reader_adapter.set_markers(markers)
     }
-
-    /// Retrieve signed entity type
-    pub async fn retrieve_signed_entity_type(&mut self) -> SignedEntityType {
-        let signer_entity_type_default = SignedEntityType::CardanoImmutableFilesFull(
-            self.deps_builder
-                .get_beacon_provider()
-                .await
-                .unwrap()
-                .get_current_beacon()
-                .await
-                .unwrap(),
-        );
-        self.deps_builder
-            .get_certifier_service()
-            .await
-            .unwrap()
-            .get_open_message(&signer_entity_type_default)
-            .await
-            .unwrap()
-            .map(|om| om.signed_entity_type)
-            .unwrap()
-    }
 }