test(aggregator): update tooling to check cert have associated signed entity only if not synchronized

Has synchronised certificate are created without a signed entity,
previouysly it was only the case for genesis certificates.

Author: Alenar

mithril-aggregator/tests/test_extensions/runtime_tester.rs

@@ -36,7 +36,7 @@ use mithril_common::{
 use mithril_era::{EraMarker, EraReader, adapters::EraReaderDummyAdapter};
 
 use crate::test_extensions::leader_aggregator_http_server::LeaderAggregatorHttpServer;
-use crate::test_extensions::utilities::tx_hash;
+use crate::test_extensions::utilities::{async_wait, tx_hash};
 use crate::test_extensions::{AggregatorObserver, ExpectedCertificate, MetricsVerifier};
 
 #[macro_export]
@@ -67,9 +67,10 @@ macro_rules! cycle_err {
         let (runtime_cycle_success, runtime_cycle_total) =
             $tester.get_runtime_cycle_success_and_total_since_startup_metrics();
 
-        RuntimeTester::cycle(&mut $tester)
+        let err = RuntimeTester::cycle(&mut $tester)
             .await
             .expect_err("cycle tick should have returned an error");
+        slog_scope::info!("cycle_err result: {err:?}");
         assert_eq!($expected_state, $tester.runtime.get_state());
 
         assert_metrics_eq!(
@@ -85,12 +86,30 @@ macro_rules! cycle_err {
 macro_rules! assert_last_certificate_eq {
     ( $tester:expr, $expected_certificate:expr ) => {{
         if let Some(signed_type) = $expected_certificate.get_signed_type() {
-            $tester.wait_until_signed_entity(&signed_type).await.unwrap();
+            RuntimeTester::wait_until_signed_entity(&$tester, &signed_type)
+                .await
+                .unwrap();
         }
 
-        let last_certificate = RuntimeTester::get_last_expected_certificate(&mut $tester)
-            .await
-            .unwrap();
+        let is_synchronized_from_leader = false;
+        let last_certificate =
+            RuntimeTester::get_last_expected_certificate(&mut $tester, is_synchronized_from_leader)
+                .await
+                .unwrap();
+        assert_eq!($expected_certificate, last_certificate);
+    }};
+    ( $tester:expr, synchronised_from_leader => $expected_certificate:expr ) => {{
+        if let Some(signed_type) = $expected_certificate.get_signed_type() {
+            RuntimeTester::wait_until_certificate(&$tester, &signed_type)
+                .await
+                .unwrap();
+        }
+
+        let is_synchronized_from_leader = true;
+        let last_certificate =
+            RuntimeTester::get_last_expected_certificate(&mut $tester, is_synchronized_from_leader)
+                .await
+                .unwrap();
         assert_eq!($expected_certificate, last_certificate);
     }};
 }
@@ -538,12 +557,11 @@ impl RuntimeTester {
         Ok(())
     }
 
-    /// Get the last produced certificate with its signed entity if it's not a genesis certificate
-    pub async fn get_last_certificate_with_signed_entity(
+    /// Get the last produced signed entity
+    async fn get_last_signed_entity(
         &mut self,
-    ) -> StdResult<(Certificate, Option<SignedEntityRecord>)> {
-        let certificate = self.observer.get_last_certificate().await?;
-
+        certificate: &Certificate,
+    ) -> StdResult<Option<SignedEntityRecord>> {
         let signed_entity = match &certificate.signature {
             CertificateSignature::GenesisSignature(..) => None,
             CertificateSignature::MultiSignature(..) => {
@@ -560,37 +578,40 @@ impl RuntimeTester {
             }
         };
 
-        Ok((certificate, signed_entity))
+        Ok(signed_entity)
     }
 
     /// Get the last produced certificate and transform it to a [ExpectedCertificate]
-    pub async fn get_last_expected_certificate(&mut self) -> StdResult<ExpectedCertificate> {
-        let (certificate, signed_entity_record) =
-            self.get_last_certificate_with_signed_entity().await?;
+    pub async fn get_last_expected_certificate(
+        &mut self,
+        is_synchronized_from_leader: bool,
+    ) -> StdResult<ExpectedCertificate> {
+        let certificate = self.observer.get_last_certificate().await?;
 
-        let expected_certificate = match signed_entity_record {
-            None if certificate.is_genesis() => ExpectedCertificate::new_genesis(
+        let expected_certificate = if certificate.is_genesis() {
+            ExpectedCertificate::new_genesis(
                 certificate.epoch,
                 certificate.aggregate_verification_key.try_into().unwrap(),
-            ),
-            None => {
-                panic!(
+            )
+        } else {
+            let signed_entity_type = certificate.signed_entity_type();
+            let previous_cert_identifier = self
+                .get_expected_certificate_identifier(&certificate.previous_hash)
+                .await?;
+
+            if !is_synchronized_from_leader && !certificate.is_genesis() {
+                self.get_last_signed_entity(&certificate).await?.ok_or(anyhow!(
                     "A certificate should always have a SignedEntity if it's not a genesis certificate"
-                );
-            }
-            Some(record) => {
-                let previous_cert_identifier = self
-                    .get_expected_certificate_identifier(&certificate.previous_hash)
-                    .await?;
-
-                ExpectedCertificate::new(
-                    certificate.epoch,
-                    certificate.metadata.signers.as_slice(),
-                    certificate.aggregate_verification_key.try_into().unwrap(),
-                    record.signed_entity_type,
-                    previous_cert_identifier,
-                )
+                ))?;
             }
+
+            ExpectedCertificate::new(
+                certificate.epoch,
+                certificate.metadata.signers.as_slice(),
+                certificate.aggregate_verification_key.try_into().unwrap(),
+                signed_entity_type,
+                previous_cert_identifier,
+            )
         };
 
         Ok(expected_certificate)
@@ -601,30 +622,22 @@ impl RuntimeTester {
         &mut self,
         certificate_hash: &str,
     ) -> StdResult<String> {
-        let cert_identifier = match self
+        let certificate = self
             .dependencies
-            .signed_entity_storer
-            .get_signed_entity_by_certificate_id(certificate_hash)
+            .certificate_repository
+            .get_certificate::<Certificate>(certificate_hash)
             .await
-            .with_context(|| "Querying signed entity should not fail")?
-        {
-            Some(record) => ExpectedCertificate::identifier(&record.signed_entity_type),
-            None => {
-                // Certificate is a genesis certificate
-                let genesis_certificate = self
-                    .dependencies
-                    .certifier_service
-                    .get_certificate_by_hash(certificate_hash)
-                    .await
-                    .with_context(|| "Querying genesis certificate should not fail")?
-                    .ok_or(anyhow!(
-                        "A genesis certificate should exist with hash {}",
-                        certificate_hash
-                    ))?;
-                ExpectedCertificate::genesis_identifier(genesis_certificate.epoch)
-            }
-        };
+            .with_context(|| format!("Failed to query certificate with hash {certificate_hash}"))?
+            .ok_or(anyhow!(
+                "A certificate should exist with hash {}",
+                certificate_hash
+            ))?;
 
+        let cert_identifier = if certificate.is_genesis() {
+            ExpectedCertificate::genesis_identifier(certificate.epoch)
+        } else {
+            ExpectedCertificate::identifier(&certificate.signed_entity_type())
+        };
         Ok(cert_identifier)
     }
 
@@ -634,22 +647,25 @@ impl RuntimeTester {
         &self,
         signed_entity_type_expected: &SignedEntityType,
     ) -> StdResult<()> {
-        let mut max_iteration = 100;
-        while !self
-            .observer
-            .is_last_signed_entity(signed_entity_type_expected)
-            .await?
-        {
-            max_iteration -= 1;
-            if max_iteration <= 0 {
-                return Err(anyhow!(
-                    "Signed entity not found: {signed_entity_type_expected}"
-                ));
-            }
-            tokio::time::sleep(Duration::from_millis(1)).await;
-        }
+        async_wait!(
+            max_iter:100, sleep_ms:1,
+            condition: !self.observer.is_last_signed_entity(signed_entity_type_expected).await?,
+            error_msg: "Signed entity not found: {signed_entity_type_expected}"
+        )
+    }
 
-        Ok(())
+    /// Wait until the last stored certificate of the given signed entity type
+    /// corresponds to the expected signed entity type
+    pub async fn wait_until_certificate(
+        &self,
+        certificate_signed_entity_type: &SignedEntityType,
+    ) -> StdResult<()> {
+        async_wait!(
+            max_iter:100, sleep_ms:1,
+            condition: self.observer.get_last_certificate().await?.signed_entity_type()
+                != *certificate_signed_entity_type,
+            error_msg: "Certificate not found for signed entity: {certificate_signed_entity_type}"
+        )
     }
 
     /// Returns the runtime cycle success and total metrics since startup

mithril-aggregator/tests/test_extensions/utilities.rs

@@ -29,3 +29,21 @@ macro_rules! comment {
         test_extensions::utilities::comment(format!($($comment)*));
     }};
 }
+
+#[macro_export]
+macro_rules! async_wait {
+    ( max_iter:$max_iter:expr, sleep_ms:$sleep_ms:expr, condition:$condition:expr, error_msg:$($error_msg:tt)*
+    ) => {{
+        let mut max_iteration: usize = $max_iter;
+        while $condition {
+            max_iteration -= 1;
+            if max_iteration == 0 {
+                return Err(anyhow::anyhow!($($error_msg)*));
+            }
+            tokio::time::sleep(Duration::from_millis($sleep_ms)).await;
+        }
+
+        Ok(())
+    }};
+}
+pub use async_wait;