Check all artifact types are produced in end to end test

Author: jpraynaud

mithril-test-lab/mithril-end-to-end/src/end_to_end_spec.rs

@@ -3,6 +3,9 @@ use crate::{attempt, Aggregator, Client, ClientCommand, Devnet, MithrilInfrastru
 use mithril_common::chain_observer::{CardanoCliChainObserver, ChainObserver};
 use mithril_common::digesters::ImmutableFile;
 use mithril_common::entities::{Certificate, Epoch, EpochSettings, ProtocolParameters, Snapshot};
+use mithril_common::messages::{
+    MithrilStakeDistributionListMessage, MithrilStakeDistributionMessage,
+};
 use reqwest::StatusCode;
 use slog_scope::{info, warn};
 use std::error::Error;
@@ -70,6 +73,22 @@ impl Spec {
         )
         .await?;
 
+        // Verify that mithril stake distribution artifacts are produced and signed correctly
+        let hash = assert_node_producing_mithril_stake_distribution(&aggregator_endpoint).await?;
+        let certificate_hash = assert_signer_is_signing_mithril_stake_distribution(
+            &aggregator_endpoint,
+            &hash,
+            target_epoch - 2,
+        )
+        .await?;
+        assert_is_creating_certificate_with_enough_signers(
+            &aggregator_endpoint,
+            &certificate_hash,
+            self.infrastructure.signers().len(),
+        )
+        .await?;
+
+        // Verify that snapshot artifacts are produced and signed correctly
         let digest = assert_node_producing_snapshot(&aggregator_endpoint).await?;
         let certificate_hash =
             assert_signer_is_signing_snapshot(&aggregator_endpoint, &digest, target_epoch - 2)
@@ -240,6 +259,79 @@ async fn update_protocol_parameters(aggregator: &mut Aggregator) -> Result<(), S
     Ok(())
 }
 
+async fn assert_node_producing_mithril_stake_distribution(
+    aggregator_endpoint: &str,
+) -> Result<String, String> {
+    let url = format!("{aggregator_endpoint}/artifact/mithril-stake-distributions");
+    info!("Waiting for the aggregator to produce a mithril stake distribution");
+
+    // todo: reduce the number of attempts if we can reduce the delay between two immutables
+    match attempt!(45, Duration::from_millis(2000), {
+        match reqwest::get(url.clone()).await {
+            Ok(response) => match response.status() {
+                StatusCode::OK => match response.json::<MithrilStakeDistributionListMessage>().await.as_deref() {
+                    Ok([stake_distribution, ..]) => Ok(Some(stake_distribution.hash.clone())),
+                    Ok(&[]) => Ok(None),
+                    Err(err) => Err(format!("Invalid mithril stake distribution body : {err}",)),
+                },
+                s => Err(format!("Unexpected status code from Aggregator: {s}")),
+            },
+            Err(err) => Err(format!("Request to `{url}` failed: {err}")),
+        }
+    }) {
+        AttemptResult::Ok(hash) => {
+            info!("Aggregator produced a mithril stake distribution"; "hash" => &hash);
+            Ok(hash)
+        }
+        AttemptResult::Err(error) => Err(error),
+        AttemptResult::Timeout() => Err(format!(
+            "Timeout exhausted assert_node_producing_mithril_stake_distribution, no response from `{url}`"
+        )),
+    }
+}
+
+async fn assert_signer_is_signing_mithril_stake_distribution(
+    aggregator_endpoint: &str,
+    hash: &str,
+    expected_epoch_min: Epoch,
+) -> Result<String, String> {
+    let url = format!("{aggregator_endpoint}/artifact/mithril-stake-distribution/{hash}");
+    info!(
+        "Asserting the aggregator is signing the mithril stake distribution message `{}` with an expected min epoch of `{}`",
+        hash,
+        expected_epoch_min
+    );
+
+    match attempt!(10, Duration::from_millis(1000), {
+        match reqwest::get(url.clone()).await {
+            Ok(response) => match response.status() {
+                StatusCode::OK => match response.json::<MithrilStakeDistributionMessage>().await {
+                    Ok(stake_distribution) => match stake_distribution.epoch {
+                        epoch if epoch >= expected_epoch_min => Ok(Some(stake_distribution)),
+                        epoch => Err(format!(
+                            "Minimum expected mithril stake distribution epoch not reached : {epoch} < {expected_epoch_min}"
+                        )),
+                    },
+                    Err(err) => Err(format!("Invalid mithril stake distribution body : {err}",)),
+                },
+                StatusCode::NOT_FOUND => Ok(None),
+                s => Err(format!("Unexpected status code from Aggregator: {s}")),
+            },
+            Err(err) => Err(format!("Request to `{url}` failed: {err}")),
+        }
+    }) {
+        AttemptResult::Ok(stake_distribution) => {
+            // todo: assert that the mithril stake distribution is really signed
+            info!("Signer signed a mithril stake distribution"; "certificate_hash" => &stake_distribution.certificate_hash);
+            Ok(stake_distribution.certificate_hash)
+        }
+        AttemptResult::Err(error) => Err(error),
+        AttemptResult::Timeout() => Err(format!(
+            "Timeout exhausted assert_signer_is_signing_mithril_stake_distribution, no response from `{url}`"
+        )),
+    }
+}
+
 async fn assert_node_producing_snapshot(aggregator_endpoint: &str) -> Result<String, String> {
     let url = format!("{aggregator_endpoint}/artifact/snapshots");
     info!("Waiting for the aggregator to produce a snapshot");