test(aggregator): update create_certificate_follower integration test

Author: Alenar

mithril-aggregator/tests/create_certificate_follower.rs

@@ -5,9 +5,8 @@ use std::{collections::HashMap, ops::Range};
 use mithril_aggregator::ServeCommandConfiguration;
 use mithril_common::{
     entities::{
-        BlockNumber, CardanoTransactionsSigningConfig, ChainPoint, Epoch, ProtocolParameters,
-        SignedEntityType, SignedEntityTypeDiscriminants, SlotNumber, StakeDistributionParty,
-        TimePoint,
+        BlockNumber, ChainPoint, Epoch, ProtocolParameters, SignedEntityType,
+        SignedEntityTypeDiscriminants, SlotNumber, StakeDistributionParty, TimePoint,
     },
     temp_dir,
     test_utils::{
@@ -86,7 +85,7 @@ async fn create_certificate_follower() {
         phi_f: 0.95,
     };
     let fixtures =
-        EpochFixturesMapBuilder::build_fixtures_sequence(1..10, protocol_parameters.clone());
+        EpochFixturesMapBuilder::build_fixtures_sequence(1..6, protocol_parameters.clone());
     let epoch_fixtures_map = EpochFixturesMapBuilder::build_epoch_fixtures_map(&fixtures);
     let start_time_point = TimePoint {
         epoch: Epoch(1),
@@ -100,11 +99,9 @@ async fn create_certificate_follower() {
     let leader_configuration = ServeCommandConfiguration {
         protocol_parameters: protocol_parameters.clone(),
         data_stores_directory: get_test_dir("create_certificate_leader"),
-        cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
-            security_parameter: BlockNumber(0),
-            step: BlockNumber(30),
-        },
-        signed_entity_types: Some(SignedEntityTypeDiscriminants::CardanoDatabase.to_string()),
+        signed_entity_types: Some(
+            SignedEntityTypeDiscriminants::CardanoStakeDistribution.to_string(),
+        ),
         ..ServeCommandConfiguration::new_sample(temp_dir!())
     };
     let mut leader_tester =
@@ -127,6 +124,7 @@ async fn create_certificate_follower() {
         "Epoch 1:
     - the leader aggregator registers the first signers
     - the leader aggregator can't transition from 'Idle' to 'Ready'
+    - the follower can't synchronise its chain with the leader aggregator
     - the follower aggregator can't transition from 'Idle' to 'Ready'
     "
     );
@@ -211,7 +209,8 @@ async fn create_certificate_follower() {
         "Epoch 3:
     - the leader aggregator produces a new certificate
     - the follower aggregator synchronizes signers from the leader aggregator
-    - the follower aggregator can't transition from 'Idle' to 'Ready'
+    - the follower synchronise its chain with the leader aggregator
+    - the follower aggregator can transition from 'Idle' to 'Ready'
     "
     );
     let epoch_fixture = &epoch_fixtures_map[&Epoch(3)];
@@ -233,10 +232,6 @@ async fn create_certificate_follower() {
     cycle!(leader_tester, "ready");
     cycle!(leader_tester, "signing");
 
-    comment!("Follower: change the epoch after leader");
-    follower_tester.increase_epoch().await.unwrap();
-    cycle_err!(follower_tester, "idle");
-
     comment!("Leader: register signers");
     leader_tester
         .register_signers(&epoch_fixture.registering.signers_fixture())
@@ -256,27 +251,36 @@ async fn create_certificate_follower() {
     comment!("Leader: state machine should issue a certificate for the MithrilStakeDistribution");
     cycle!(leader_tester, "signing");
 
-    assert_last_certificate_eq!(
-        leader_tester,
-        ExpectedCertificate::new(
-            Epoch(3),
-            StakeDistributionParty::from_signers(
-                epoch_fixture.current_signing.unwrap().signers_with_stake()
-            )
-            .as_slice(),
-            epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
-            SignedEntityType::MithrilStakeDistribution(Epoch(3)),
-            ExpectedCertificate::genesis_identifier(Epoch(2)),
+    let expected_certificate_on_both_aggregator = ExpectedCertificate::new(
+        Epoch(3),
+        StakeDistributionParty::from_signers(
+            epoch_fixture.current_signing.unwrap().signers_with_stake(),
         )
+        .as_slice(),
+        epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
+        SignedEntityType::MithrilStakeDistribution(Epoch(3)),
+        ExpectedCertificate::genesis_identifier(Epoch(2)),
+    );
+    assert_last_certificate_eq!(leader_tester, expected_certificate_on_both_aggregator);
+    cycle_err!(leader_tester, "signing");
+
+    comment!(
+        "Follower: change the epoch after leader made a certificate and synchronise certificate chain"
+    );
+    follower_tester.increase_epoch().await.unwrap();
+    cycle_err!(follower_tester, "idle");
+    assert_last_certificate_eq!(
+        follower_tester, synchronised_from_leader => expected_certificate_on_both_aggregator
     );
+    cycle!(follower_tester, "ready");
     cycle_err!(leader_tester, "signing");
 
     comment!(
         "Epoch 4:
     - the leader aggregator produces a new certificate
     - the follower aggregator synchronizes signers from the leader aggregator
-    - the follower aggregator bootstraps its genesis certificate
-    - the follower aggregator can't transition from 'Idle' to 'Ready'"
+    - the follower aggregator produces a new certificate
+    - the follower aggregator new certificate uses the same avk as the leader aggregator's new certificate"
     );
     let epoch_fixture = &epoch_fixtures_map[&Epoch(4)];
 
@@ -299,13 +303,8 @@ async fn create_certificate_follower() {
 
     comment!("Follower: change the epoch after leader");
     follower_tester.increase_epoch().await.unwrap();
-    cycle_err!(follower_tester, "idle");
-
-    comment!("Follower: bootstrap the genesis certificate");
-    follower_tester
-        .register_genesis_certificate(epoch_fixture.next_signing.unwrap())
-        .await
-        .unwrap();
+    cycle!(follower_tester, "idle");
+    cycle!(follower_tester, "ready");
 
     comment!("Leader: register signers");
     leader_tester
@@ -326,69 +325,19 @@ async fn create_certificate_follower() {
     comment!("Leader: state machine should issue a certificate for the MithrilStakeDistribution");
     cycle!(leader_tester, "ready");
 
-    assert_last_certificate_eq!(
-        leader_tester,
-        ExpectedCertificate::new(
-            Epoch(4),
-            StakeDistributionParty::from_signers(
-                epoch_fixture.current_signing.unwrap().signers_with_stake()
-            )
-            .as_slice(),
-            epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
-            SignedEntityType::MithrilStakeDistribution(Epoch(4)),
-            ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(3))),
+    let leader_expected_certificate = ExpectedCertificate::new(
+        Epoch(4),
+        StakeDistributionParty::from_signers(
+            epoch_fixture.current_signing.unwrap().signers_with_stake(),
         )
+        .as_slice(),
+        epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
+        SignedEntityType::MithrilStakeDistribution(Epoch(4)),
+        ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(3))),
     );
+    assert_last_certificate_eq!(leader_tester, leader_expected_certificate);
     cycle!(leader_tester, "signing");
 
-    comment!(
-        "Epoch 5:
-    - the leader aggregator produces a new certificate
-    - the follower aggregator produces a new certificate
-    - the follower aggregator new certificate uses the same avk as the leader aggregator's new certificate
-    ");
-    let epoch_fixture = &epoch_fixtures_map[&Epoch(5)];
-
-    comment!("Leader: update stake distribution source");
-    leader_tester
-        .update_stake_distribution(epoch_fixture.registering.stake_distribution())
-        .await
-        .unwrap();
-
-    comment!("Follower: update stake distribution source");
-    follower_tester
-        .update_stake_distribution(epoch_fixture.registering.stake_distribution())
-        .await
-        .unwrap();
-
-    comment!("Follower: change the epoch before leader");
-    follower_tester.increase_epoch().await.unwrap();
-    cycle!(follower_tester, "idle");
-
-    comment!("Leader: change the epoch");
-    leader_tester.increase_epoch().await.unwrap();
-    cycle!(leader_tester, "idle");
-    cycle!(leader_tester, "ready");
-
-    comment!("Follower: change the epoch after leader");
-    cycle!(follower_tester, "ready");
-
-    comment!("Leader: register signers");
-    leader_tester
-        .register_signers(&epoch_fixture.registering.signers_fixture())
-        .await
-        .unwrap();
-    cycle!(leader_tester, "signing");
-
-    comment!("Leader: signers send their single signature");
-    leader_tester
-        .send_single_signatures(
-            SignedEntityTypeDiscriminants::MithrilStakeDistribution,
-            &epoch_fixture.current_signing.unwrap().signers_fixture(),
-        )
-        .await
-        .unwrap();
-
     comment!("Follower: signers send their single signature");
     cycle!(follower_tester, "signing");
     follower_tester
@@ -399,31 +348,17 @@ async fn create_certificate_follower() {
         .await
         .unwrap();
 
-    comment!("Leader: state machine should issue a certificate for the MithrilStakeDistribution");
-    cycle!(leader_tester, "ready");
-    let leader_expected_certificate = ExpectedCertificate::new(
-        Epoch(5),
-        StakeDistributionParty::from_signers(
-            epoch_fixture.current_signing.unwrap().signers_with_stake(),
-        )
-        .as_slice(),
-        epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
-        SignedEntityType::MithrilStakeDistribution(Epoch(5)),
-        ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(4))),
-    );
-    assert_last_certificate_eq!(leader_tester, leader_expected_certificate);
-
     comment!("Follower: state machine should issue a certificate for the MithrilStakeDistribution");
     cycle!(follower_tester, "ready");
     let follower_expected_certificate = ExpectedCertificate::new(
-        Epoch(5),
+        Epoch(4),
         StakeDistributionParty::from_signers(
             epoch_fixture.current_signing.unwrap().signers_with_stake(),
         )
         .as_slice(),
         epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
-        SignedEntityType::MithrilStakeDistribution(Epoch(5)),
-        ExpectedCertificate::genesis_identifier(Epoch(4)),
+        SignedEntityType::MithrilStakeDistribution(Epoch(4)),
+        ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(3))),
     );
     assert_last_certificate_eq!(follower_tester, follower_expected_certificate);
     let expected_avk = epoch_fixture
@@ -435,12 +370,12 @@ async fn create_certificate_follower() {
     assert_eq!(expected_avk, follower_expected_certificate.avk());
 
     comment!(
-        "Epoch 6:
+        "Epoch 5:
     - the leader aggregator produces a new certificate
     - the follower aggregator produces a new certificate
     - the follower aggregator new certificate uses the same avk as the leader aggregator's new certificate
     ");
-    let epoch_fixture = &epoch_fixtures_map[&Epoch(6)];
+    let epoch_fixture = &epoch_fixtures_map[&Epoch(5)];
 
     comment!("Leader: update stake distribution source");
     leader_tester
@@ -493,28 +428,28 @@ async fn create_certificate_follower() {
     comment!("Leader: state machine should issue a certificate for the MithrilStakeDistribution");
     cycle!(leader_tester, "ready");
     let leader_expected_certificate = ExpectedCertificate::new(
-        Epoch(6),
+        Epoch(5),
         StakeDistributionParty::from_signers(
             epoch_fixture.current_signing.unwrap().signers_with_stake(),
         )
         .as_slice(),
         epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
-        SignedEntityType::MithrilStakeDistribution(Epoch(6)),
-        ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(5))),
+        SignedEntityType::MithrilStakeDistribution(Epoch(5)),
+        ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(4))),
     );
     assert_last_certificate_eq!(leader_tester, leader_expected_certificate);
 
     comment!("Follower: state machine should issue a certificate for the MithrilStakeDistribution");
     cycle!(follower_tester, "ready");
     let follower_expected_certificate = ExpectedCertificate::new(
-        Epoch(6),
+        Epoch(5),
         StakeDistributionParty::from_signers(
             epoch_fixture.current_signing.unwrap().signers_with_stake(),
         )
         .as_slice(),
         epoch_fixture.current_signing.unwrap().compute_and_encode_avk(),
-        SignedEntityType::MithrilStakeDistribution(Epoch(6)),
-        ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(5))),
+        SignedEntityType::MithrilStakeDistribution(Epoch(5)),
+        ExpectedCertificate::identifier(&SignedEntityType::MithrilStakeDistribution(Epoch(4))),
     );
     assert_last_certificate_eq!(follower_tester, follower_expected_certificate);
     let expected_avk = epoch_fixture

mithril-aggregator/tests/test_extensions/leader_aggregator_http_server.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use axum::{
     Json, Router,
-    extract::State,
+    extract::{Path, State},
     http::StatusCode,
     response::{IntoResponse, Response},
     routing::get,
@@ -30,6 +30,9 @@ impl LeaderAggregatorHttpServer {
         };
         let router = Router::new()
             .route("/epoch-settings", get(epoch_settings))
+            .route("/certificates", get(certificates_list))
+            .route("/certificate/genesis", get(certificate_last_genesis))
+            .route("/certificate/{hash}", get(certificate_by_hash))
             .with_state(state);
 
         let server = TestServer::builder().http_transport().build(router)?;
@@ -66,3 +69,32 @@ async fn epoch_settings(state: State<LeaderAggregatorRoutesState>) -> Response {
         Err(err) => internal_server_error(err).into_response(),
     }
 }
+
+async fn certificates_list(state: State<LeaderAggregatorRoutesState>) -> Response {
+    slog::debug!(state.logger, "/certificates");
+    match state.message_service.get_certificate_list_message(5).await {
+        Ok(message) => (StatusCode::OK, Json(message)).into_response(),
+        Err(err) => internal_server_error(err).into_response(),
+    }
+}
+
+async fn certificate_last_genesis(state: State<LeaderAggregatorRoutesState>) -> Response {
+    slog::debug!(state.logger, "/certificate/genesis");
+    match state.message_service.get_latest_genesis_certificate_message().await {
+        Ok(Some(message)) => (StatusCode::OK, Json(message)).into_response(),
+        Ok(None) => StatusCode::NOT_FOUND.into_response(),
+        Err(err) => internal_server_error(err).into_response(),
+    }
+}
+
+async fn certificate_by_hash(
+    Path(hash): Path<String>,
+    state: State<LeaderAggregatorRoutesState>,
+) -> Response {
+    slog::debug!(state.logger, "/certificate/{hash}");
+    match state.message_service.get_certificate_message(&hash).await {
+        Ok(Some(message)) => (StatusCode::OK, Json(message)).into_response(),
+        Ok(None) => StatusCode::NOT_FOUND.into_response(),
+        Err(err) => internal_server_error(err).into_response(),
+    }
+}