Use MithrilFixtureBuilder in signer tests

Author: Alenar

mithril-signer/src/runtime/runner.rs

@@ -436,20 +436,21 @@ impl Runner for SignerRunner {
 
 #[cfg(test)]
 mod tests {
-    use mithril_common::chain_observer::ChainObserver;
-    use mockall::mock;
-    use std::{path::PathBuf, sync::Arc};
-
-    use mithril_common::crypto_helper::tests_setup::{setup_protocol_parameters, setup_signers};
-    use mithril_common::crypto_helper::ProtocolInitializer;
-    use mithril_common::digesters::{DumbImmutableDigester, DumbImmutableFileObserver};
-    use mithril_common::entities::{Epoch, StakeDistribution};
-    use mithril_common::store::adapter::{DumbStoreAdapter, MemoryAdapter};
-    use mithril_common::store::{StakeStore, StakeStorer};
     use mithril_common::{
-        chain_observer::FakeObserver, BeaconProvider, BeaconProviderError, BeaconProviderImpl,
+        chain_observer::{ChainObserver, FakeObserver},
+        crypto_helper::ProtocolInitializer,
+        digesters::{DumbImmutableDigester, DumbImmutableFileObserver},
+        entities::{Epoch, StakeDistribution},
+        fake_data,
+        store::{
+            adapter::{DumbStoreAdapter, MemoryAdapter},
+            StakeStore, StakeStorer,
+        },
+        test_utils::MithrilFixtureBuilder,
+        BeaconProvider, BeaconProviderError, BeaconProviderImpl, CardanoNetwork,
     };
-    use mithril_common::{fake_data, CardanoNetwork};
+    use mockall::mock;
+    use std::{path::PathBuf, sync::Arc};
 
     use crate::{
         CertificateHandler, DumbCertificateHandler, MithrilSingleSigner, MockCertificateHandler,
@@ -693,8 +694,9 @@ mod tests {
             .get_current_beacon()
             .await
             .expect("get_current_beacon should not fail");
-        let signers = setup_signers(5, &setup_protocol_parameters());
-        let (signer_with_stake, _, protocol_initializer) = signers.first().unwrap();
+        let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
+        let signer_with_stake = fixture.signers_fixture()[0].signer_with_stake.clone();
+        let protocol_initializer = fixture.signers_fixture()[0].protocol_initializer.clone();
         let single_signer = Arc::new(MithrilSingleSigner::new(
             signer_with_stake.party_id.to_owned(),
         ));
@@ -708,18 +710,15 @@ mod tests {
             .await
             .expect("save_protocol_initializer should not fail");
 
-        let next_signers = signers
-            .iter()
-            .map(|(signer_with_stake, _, _)| signer_with_stake.to_owned())
-            .collect::<Vec<_>>();
+        let next_signers = fixture.signers_with_stake();
         let mut expected = ProtocolMessage::new();
         expected.set_message_part(
             ProtocolMessagePartKey::SnapshotDigest,
             DIGESTER_RESULT.to_string(),
         );
         let avk = services
             .single_signer
-            .compute_aggregate_verification_key(&next_signers, protocol_initializer)
+            .compute_aggregate_verification_key(&next_signers, &protocol_initializer)
             .expect("compute_aggregate_verification_key should not fail")
             .expect("an avk should have been computed");
         expected.set_message_part(ProtocolMessagePartKey::NextAggregateVerificationKey, avk);
@@ -741,8 +740,9 @@ mod tests {
             .get_current_beacon()
             .await
             .expect("get_current_beacon should not fail");
-        let signers = setup_signers(5, &setup_protocol_parameters());
-        let (signer_with_stake, _, protocol_initializer) = signers.first().unwrap();
+        let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
+        let signer_with_stake = fixture.signers_fixture()[0].signer_with_stake.clone();
+        let protocol_initializer = fixture.signers_fixture()[0].protocol_initializer.clone();
         let single_signer = Arc::new(MithrilSingleSigner::new(
             signer_with_stake.party_id.to_string(),
         ));
@@ -758,10 +758,7 @@ mod tests {
             )
             .await
             .expect("save_protocol_initializer should not fail");
-        let signers = signers
-            .iter()
-            .map(|(signer_with_stake, _, _)| signer_with_stake.to_owned())
-            .collect::<Vec<_>>();
+        let signers = fixture.signers_with_stake();
 
         let mut message = ProtocolMessage::new();
         message.set_message_part(
@@ -774,7 +771,7 @@ mod tests {
         );
 
         let expected = single_signer
-            .compute_single_signatures(&message, &signers, protocol_initializer)
+            .compute_single_signatures(&message, &signers, &protocol_initializer)
             .expect("compute_single_signatures should not fail");
 
         let runner = init_runner(Some(services), None);

mithril-signer/src/single_signer.rs

@@ -237,34 +237,33 @@ impl SingleSigner for MithrilSingleSigner {
 mod tests {
     use super::*;
 
-    use mithril_common::crypto_helper::tests_setup::*;
-    use mithril_common::crypto_helper::{key_decode_hex, ProtocolClerk, ProtocolSingleSignature};
-    use mithril_common::entities::ProtocolMessagePartKey;
+    use mithril_common::{
+        crypto_helper::{key_decode_hex, tests_setup::*, ProtocolClerk, ProtocolSingleSignature},
+        entities::ProtocolMessagePartKey,
+        test_utils::MithrilFixtureBuilder,
+    };
 
     #[test]
     fn compute_single_signature_success() {
         let snapshot_digest = "digest".to_string();
         let protocol_parameters = setup_protocol_parameters();
-        let signers = setup_signers(5, &protocol_parameters);
-        let signers_with_stake = signers
-            .iter()
-            .map(
-                |(signer_with_stake, _protocol_signer, _protocol_initializer)| {
-                    signer_with_stake.to_owned()
-                },
-            )
-            .collect::<Vec<SignerWithStake>>();
-        let current_signer = &signers[0];
-        let single_signer = MithrilSingleSigner::new(current_signer.0.party_id.to_owned());
-        let protocol_signer = &current_signer.1;
-        let clerk = ProtocolClerk::from_signer(protocol_signer);
+        let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
+        let signers_with_stake = fixture.signers_with_stake();
+        let current_signer = &fixture.signers_fixture()[0];
+        let single_signer =
+            MithrilSingleSigner::new(current_signer.signer_with_stake.party_id.to_owned());
+        let clerk = ProtocolClerk::from_signer(&current_signer.protocol_signer);
         let avk = clerk.compute_avk();
         let mut protocol_message = ProtocolMessage::new();
         protocol_message.set_message_part(ProtocolMessagePartKey::SnapshotDigest, snapshot_digest);
         let expected_message = protocol_message.compute_hash().as_bytes().to_vec();
 
         let sign_result = single_signer
-            .compute_single_signatures(&protocol_message, &signers_with_stake, &current_signer.2)
+            .compute_single_signatures(
+                &protocol_message,
+                &signers_with_stake,
+                &current_signer.protocol_initializer,
+            )
             .expect("single signer should not fail")
             .expect("single signer should produce a signature here");
 
@@ -273,34 +272,31 @@ mod tests {
             decoded_sig
                 .verify(
                     &protocol_parameters,
-                    &protocol_signer.verification_key(),
-                    &protocol_signer.get_stake(),
+                    &current_signer.protocol_signer.verification_key(),
+                    &current_signer.protocol_signer.get_stake(),
                     &avk,
                     &expected_message
                 )
                 .is_ok(),
             "produced single signature should be valid"
         );
         //TODO: decoded_sig.pk should probably be a StmVerificationKeyPoP, uncomment once fixed
-        //assert_eq!(current_signer.2, decoded_sig.pk);
+        //assert_eq!(current_signer.protocol_initializer, decoded_sig.pk);
     }
 
     #[test]
     fn compute_aggregate_verification_key_success() {
-        let signers = setup_signers(5, &setup_protocol_parameters());
-        let signers_with_stake = signers
-            .iter()
-            .map(
-                |(signer_with_stake, _protocol_signer, _protocol_initializer)| {
-                    signer_with_stake.to_owned()
-                },
-            )
-            .collect::<Vec<SignerWithStake>>();
-        let current_signer = &signers[0];
-        let single_signer = MithrilSingleSigner::new(current_signer.0.party_id.to_owned());
-        let protocol_initializer = &current_signer.2;
+        let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
+        let signers_with_stake = fixture.signers_with_stake();
+        let current_signer = &fixture.signers_fixture()[0];
+        let single_signer =
+            MithrilSingleSigner::new(current_signer.signer_with_stake.party_id.to_owned());
+
         single_signer
-            .compute_aggregate_verification_key(&signers_with_stake, protocol_initializer)
+            .compute_aggregate_verification_key(
+                &signers_with_stake,
+                &current_signer.protocol_initializer,
+            )
             .expect("compute aggregate verification signature should not fail")
             .expect("aggregate verification signature should not be empty");
     }

mithril-signer/tests/state_machine.rs

@@ -1,8 +1,7 @@
 mod test_extensions;
 
 use mithril_common::{
-    crypto_helper::tests_setup,
-    entities::{Epoch, SignerWithStake},
+    crypto_helper::tests_setup, entities::Epoch, test_utils::MithrilFixtureBuilder,
 };
 
 use test_extensions::StateMachineTester;
@@ -12,8 +11,8 @@ use test_extensions::StateMachineTester;
 async fn test_create_single_signature() {
 
     let protocol_parameters = tests_setup::setup_protocol_parameters();
-    let signers = tests_setup::setup_signers(10, &protocol_parameters);
-    let signers_with_stake = signers.iter().map(|(signer_with_stake, _, _)| signer_with_stake.to_owned()).collect::<Vec<SignerWithStake>>();
+    let fixture = MithrilFixtureBuilder::default().with_signers(10).with_protocol_parameters(protocol_parameters.into()).build();
+    let signers_with_stake = fixture.signers_with_stake();
     let mut tester = StateMachineTester::init(&signers_with_stake).await.expect("state machine tester init should not fail");
 
     tester