refactor(common): transform test only methods on entities into extension traits

This allow a clean split between the production and test code even when
using thoses methods as to do so you will now need to import a trait
located in the `mithril_common::test` module.

one caveat: in order to transform `Blockrange::new` into a extension
trait method, its `inner_range` property had to be made `pub(crate)`.

Author: Alenar

mithril-aggregator/src/database/record/buffered_single_signature_record.rs

@@ -3,7 +3,10 @@ use chrono::{DateTime, Utc};
 use mithril_common::entities::{
     HexEncodedSingleSignature, LotteryIndex, SignedEntityTypeDiscriminants, SingleSignature,
 };
+#[cfg(test)]
+use mithril_common::test::entities_extensions::SingleSignatureTestExtension;
 use mithril_common::{StdError, StdResult};
+
 use mithril_persistence::sqlite::{HydrationError, Projection, SqLiteEntity};
 
 /// `BufferedSingleSignatureRecord` record is the representation of a buffered single_signature

mithril-aggregator/src/services/certifier/buffered_certifier.rs

@@ -192,6 +192,7 @@ mod tests {
     };
     use mithril_common::entities::SingleSignatureAuthenticationStatus;
     use mithril_common::test::double::{Dummy, fake_data};
+    use mithril_common::test::entities_extensions::SingleSignatureTestExtension;
 
     use crate::database::repository::BufferedSingleSignatureRepository;
     use crate::database::test_helper::main_db_connection;

mithril-aggregator/src/tools/single_signature_authenticator.rs

@@ -112,6 +112,8 @@ impl SingleSignatureAuthenticator {
 mod tests {
     use anyhow::anyhow;
 
+    use mithril_common::test::entities_extensions::SingleSignatureTestExtension;
+
     use crate::multi_signer::MockMultiSigner;
     use crate::test::TestLogger;
 

mithril-common/src/crypto_helper/merkle_map.rs

@@ -468,6 +468,7 @@ mod tests {
     use crate::{
         crypto_helper::MKTreeStoreInMemory,
         entities::{BlockNumber, BlockRange},
+        test::entities_extensions::BlockRangeTestExtension,
     };
 
     use super::*;

mithril-common/src/entities/block_range.rs

@@ -19,41 +19,14 @@ pub type BlockRangeLength = BlockNumber;
 /// BlockRange for the Cardano chain
 #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug, Hash)]
 pub struct BlockRange {
-    inner_range: Range<BlockNumber>,
+    pub(crate) inner_range: Range<BlockNumber>,
 }
 
 impl BlockRange {
     /// The length of the block range
     /// Important: this value should be updated with extreme care (probably with an era change) in order to avoid signing disruptions.
     pub const LENGTH: BlockRangeLength = BlockNumber(15);
 
-    cfg_test_tools! {
-        /// BlockRange factory
-        pub fn new(start: u64, end: u64) -> Self {
-            Self {
-                inner_range: BlockNumber(start)..BlockNumber(end),
-            }
-        }
-
-        /// Try to add two BlockRanges
-        pub fn try_add(&self, other: &BlockRange) -> StdResult<BlockRange> {
-            if self.inner_range.end.max(other.inner_range.end)
-                < self.inner_range.start.min(other.inner_range.start)
-            {
-                return Err(anyhow!(
-                    "BlockRange cannot be added as they don't strictly overlap"
-                ));
-            }
-
-            Ok(Self {
-                inner_range: Range {
-                    start: self.inner_range.start.min(other.inner_range.start),
-                    end: self.inner_range.end.max(other.inner_range.end),
-                },
-            })
-        }
-    }
-
     /// Get the start of the block range that contains the given block number
     pub fn start(number: BlockNumber) -> BlockNumber {
         Self::start_with_length(number, Self::LENGTH)
@@ -232,6 +205,8 @@ impl ExactSizeIterator for BlockRangesSequence {
 mod tests {
     use std::ops::Not;
 
+    use crate::test::entities_extensions::BlockRangeTestExtension;
+
     use super::*;
 
     #[test]
@@ -259,22 +234,6 @@ mod tests {
         assert!(BlockRange::new(1, 11) < BlockRange::new(2, 10));
     }
 
-    #[test]
-    fn test_block_range_try_add() {
-        assert_eq!(
-            BlockRange::new(1, 10).try_add(&BlockRange::new(1, 10)).unwrap(),
-            BlockRange::new(1, 10)
-        );
-        assert_eq!(
-            BlockRange::new(1, 10).try_add(&BlockRange::new(1, 11)).unwrap(),
-            BlockRange::new(1, 11)
-        );
-        assert_eq!(
-            BlockRange::new(1, 10).try_add(&BlockRange::new(2, 10)).unwrap(),
-            BlockRange::new(1, 10)
-        );
-    }
-
     #[test]
     fn test_block_range_start() {
         assert_eq!(BlockRange::start(BlockNumber(0)), 0);

mithril-common/src/entities/cardano_transactions_set_proof.rs

@@ -4,12 +4,6 @@ use crate::entities::TransactionHash;
 
 use super::BlockRange;
 
-cfg_test_tools! {
-    use crate::crypto_helper::{MKMap, MKTree, MKTreeNode, MKMapNode, MKTreeStorer, MKTreeStoreInMemory};
-    use crate::entities::BlockNumber;
-    use std::collections::HashMap;
-}
-
 /// A cryptographic proof of a set of Cardano transactions is included in the global Cardano transactions set
 #[derive(Clone, Debug, PartialEq)]
 pub struct CardanoTransactionsSetProof {
@@ -51,46 +45,14 @@ impl CardanoTransactionsSetProof {
 
         Ok(())
     }
-
-    cfg_test_tools! {
-        /// Helper to create a proof from a list of leaves
-        pub fn from_leaves<S: MKTreeStorer>(leaves: &[(BlockNumber, TransactionHash)]) -> StdResult<Self> {
-            let transactions_hashes: Vec<TransactionHash> =
-                leaves.iter().map(|(_, t)| t.into()).collect();
-            let mut transactions_by_block_ranges: HashMap<BlockRange, Vec<TransactionHash>> =
-                HashMap::new();
-            for (block_number, transaction_hash) in leaves {
-                let block_range = BlockRange::from_block_number(*block_number);
-                transactions_by_block_ranges
-                    .entry(block_range)
-                    .or_default()
-                    .push(transaction_hash.to_owned());
-            }
-            let mk_map = MKMap::<_, _, MKTreeStoreInMemory>::new(
-                transactions_by_block_ranges
-                    .into_iter()
-                    .try_fold(
-                        vec![],
-                        |mut acc, (block_range, transactions)| -> StdResult<Vec<(_, MKMapNode<_,S>)>> {
-                            acc.push((block_range, MKTree::<S>::new(&transactions)?.into()));
-                            Ok(acc)
-                        },
-                    )?
-                    .as_slice(),
-            )?;
-            let mk_leaves: Vec<MKTreeNode> = transactions_hashes
-                .iter()
-                .map(|h| h.to_owned().into())
-                .collect();
-            let mk_proof = mk_map.compute_proof(&mk_leaves)?;
-            Ok(Self::new(transactions_hashes, mk_proof))
-        }
-
-    }
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::crypto_helper::MKTreeStoreInMemory;
+    use crate::entities::BlockNumber;
+    use crate::test::entities_extensions::CardanoTransactionsSetProofTestExtension;
+
     use super::*;
 
     #[test]

mithril-common/src/entities/signed_entity_config.rs

@@ -120,7 +120,6 @@ impl CardanoTransactionsSigningConfig {
                 step,
             }
         }
-
     }
 
     /// Compute the block number to be signed based on the chain tip block number.

mithril-common/src/entities/single_signature.rs

@@ -62,34 +62,6 @@ impl SingleSignature {
     }
 }
 
-cfg_test_tools! {
-impl SingleSignature {
-    /// Create a fake [SingleSignature] with valid cryptographic data for testing purposes.
-    pub fn fake<TPartyId: Into<String>, TMessage: Into<String>>(party_id: TPartyId, message: TMessage) -> Self {
-        use crate::entities::{ProtocolParameters};
-        use crate::test::builder::{MithrilFixtureBuilder, StakeDistributionGenerationMethod};
-
-        let party_id = party_id.into();
-        let message = message.into();
-
-        let fixture = MithrilFixtureBuilder::default()
-            .with_stake_distribution(StakeDistributionGenerationMethod::Custom(
-                std::collections::BTreeMap::from([(party_id.to_string(), 100)]),
-            ))
-            .with_protocol_parameters(ProtocolParameters::new(1, 1, 1.0))
-            .build();
-        let signature = fixture.signers_fixture()[0].sign(&message).unwrap();
-
-        Self {
-            party_id,
-            signature: signature.signature,
-            won_indexes: vec![10, 15],
-            authentication_status: SingleSignatureAuthenticationStatus::Unauthenticated,
-        }
-    }
-}
-}
-
 impl Debug for SingleSignature {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let is_pretty_printing = f.alternate();

mithril-common/src/messages/cardano_transactions_proof.rs

@@ -191,6 +191,7 @@ mod tests {
     };
     use crate::test::crypto_helper::MKProofTestExtension;
     use crate::test::double::Dummy;
+    use crate::test::entities_extensions::CardanoTransactionsSetProofTestExtension;
 
     use super::*;
 

mithril-common/src/test/double/dummies.rs

@@ -5,6 +5,7 @@ use crate::test::double::{Dummy, fake_data, fake_keys};
 mod entities {
     use crate::crypto_helper::MKTreeStoreInMemory;
     use crate::entities::*;
+    use crate::test::entities_extensions::CardanoTransactionsSetProofTestExtension;
 
     use super::*;