test:enhance certificate chain builder and mock build

mithril-aggregator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.7.68"
+version = "0.7.69"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-aggregator/src/database/query/certificate/get_certificate.rs

@@ -71,28 +71,28 @@ mod tests {
 
     #[test]
     fn test_get_certificate_records_by_epoch() {
-        let (certificates, _) = setup_certificate_chain(20, 7);
+        let certificates = setup_certificate_chain(20, 7);
 
         let connection = main_db_connection().unwrap();
-        insert_certificate_records(&connection, certificates.clone());
+        insert_certificate_records(&connection, certificates.certificates_chained.clone());
 
         let certificate_records: Vec<CertificateRecord> = connection
             .fetch_collect(GetCertificateRecordQuery::by_epoch(Epoch(1)).unwrap())
             .unwrap();
         let expected_certificate_records: Vec<CertificateRecord> = certificates
-            .iter()
+            .reversed_chain()
+            .into_iter()
             .filter_map(|c| (c.epoch == Epoch(1)).then_some(c.to_owned().into()))
-            .rev()
             .collect();
         assert_eq!(expected_certificate_records, certificate_records);
 
         let certificate_records: Vec<CertificateRecord> = connection
             .fetch_collect(GetCertificateRecordQuery::by_epoch(Epoch(3)).unwrap())
             .unwrap();
         let expected_certificate_records: Vec<CertificateRecord> = certificates
-            .iter()
+            .reversed_chain()
+            .into_iter()
             .filter_map(|c| (c.epoch == Epoch(3)).then_some(c.to_owned().into()))
-            .rev()
             .collect();
         assert_eq!(expected_certificate_records, certificate_records);
 
@@ -104,15 +104,15 @@ mod tests {
 
     #[test]
     fn test_get_all_certificate_records() {
-        let (certificates, _) = setup_certificate_chain(5, 2);
+        let certificates = setup_certificate_chain(5, 2);
         let expected_certificate_records: Vec<CertificateRecord> = certificates
-            .iter()
-            .map(|c| c.to_owned().into())
-            .rev()
+            .reversed_chain()
+            .into_iter()
+            .map(Into::into)
             .collect();
 
         let connection = main_db_connection().unwrap();
-        insert_certificate_records(&connection, certificates.clone());
+        insert_certificate_records(&connection, certificates.certificates_chained.clone());
 
         let certificate_records: Vec<CertificateRecord> = connection
             .fetch_collect(GetCertificateRecordQuery::all())
@@ -123,26 +123,30 @@ mod tests {
     #[test]
     fn test_get_all_genesis_certificate_records() {
         // Two chains with different protocol parameters so generated certificates are different.
-        let (first_certificates_chain, _) = CertificateChainBuilder::new()
+        let first_certificates_chain = CertificateChainBuilder::new()
             .with_total_certificates(2)
             .with_protocol_parameters(ProtocolParameters {
                 m: 90,
                 k: 4,
                 phi_f: 0.65,
             })
             .build();
-        let first_chain_genesis: CertificateRecord =
-            first_certificates_chain.last().unwrap().clone().into();
-        let (second_certificates_chain, _) = CertificateChainBuilder::new()
+        let first_chain_genesis: CertificateRecord = first_certificates_chain
+            .genesis_certificate()
+            .clone()
+            .into();
+        let second_certificates_chain = CertificateChainBuilder::new()
             .with_total_certificates(2)
             .with_protocol_parameters(ProtocolParameters {
                 m: 100,
                 k: 5,
                 phi_f: 0.65,
             })
             .build();
-        let second_chain_genesis: CertificateRecord =
-            second_certificates_chain.last().unwrap().clone().into();
+        let second_chain_genesis: CertificateRecord = second_certificates_chain
+            .genesis_certificate()
+            .clone()
+            .into();
         assert_ne!(first_chain_genesis, second_chain_genesis);
 
         let connection = main_db_connection().unwrap();
@@ -151,14 +155,14 @@ mod tests {
             .unwrap();
         assert_eq!(Vec::<CertificateRecord>::new(), certificate_records);
 
-        insert_certificate_records(&connection, first_certificates_chain);
+        insert_certificate_records(&connection, first_certificates_chain.certificates_chained);
 
         let certificate_records: Vec<CertificateRecord> = connection
             .fetch_collect(GetCertificateRecordQuery::all_genesis())
             .unwrap();
         assert_eq!(vec![first_chain_genesis.to_owned()], certificate_records);
 
-        insert_certificate_records(&connection, second_certificates_chain);
+        insert_certificate_records(&connection, second_certificates_chain.certificates_chained);
 
         let certificate_records: Vec<CertificateRecord> = connection
             .fetch_collect(GetCertificateRecordQuery::all_genesis())

mithril-aggregator/src/database/query/certificate/insert_certificate.rs

@@ -111,11 +111,11 @@ mod tests {
 
     #[test]
     fn test_insert_certificate_record() {
-        let (certificates, _) = setup_certificate_chain(5, 2);
+        let certificates = setup_certificate_chain(5, 2);
 
         let connection = main_db_connection().unwrap();
 
-        for certificate in certificates {
+        for certificate in certificates.certificates_chained {
             let certificate_record: CertificateRecord = certificate.into();
             let certificate_record_saved = connection
                 .fetch_first(InsertCertificateRecordQuery::one(
@@ -128,9 +128,8 @@ mod tests {
 
     #[test]
     fn test_insert_many_certificates_records() {
-        let (certificates, _) = setup_certificate_chain(5, 2);
-        let certificates_records: Vec<CertificateRecord> =
-            certificates.into_iter().map(|cert| cert.into()).collect();
+        let certificates = setup_certificate_chain(5, 2);
+        let certificates_records: Vec<CertificateRecord> = certificates.into();
 
         let connection = main_db_connection().unwrap();
 

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

@@ -390,16 +390,16 @@ mod tests {
 
     #[test]
     fn test_convert_certificates() {
-        let (certificates, _) = setup_certificate_chain(20, 3);
+        let certificates = setup_certificate_chain(20, 3);
         let mut certificate_records: Vec<CertificateRecord> = Vec::new();
-        for certificate in certificates.clone() {
+        for certificate in certificates.certificates_chained.clone() {
             certificate_records.push(certificate.into());
         }
         let mut certificates_new: Vec<Certificate> = Vec::new();
         for certificate_record in certificate_records {
             certificates_new.push(certificate_record.into());
         }
-        assert_eq!(certificates, certificates_new);
+        assert_eq!(certificates.certificates_chained, certificates_new);
     }
 
     #[test]

mithril-aggregator/src/database/repository/certificate_repository.rs

@@ -245,10 +245,10 @@ mod tests {
 
     #[tokio::test]
     async fn repository_get_certificate() {
-        let (certificates, _) = setup_certificate_chain(5, 2);
+        let certificates = setup_certificate_chain(5, 2);
         let expected_hash = certificates[0].hash.clone();
         let connection = Arc::new(main_db_connection().unwrap());
-        insert_certificate_records(&connection, certificates.clone());
+        insert_certificate_records(&connection, certificates.certificates_chained.clone());
 
         let repository: CertificateRepository = CertificateRepository::new(connection);
         let certificate = repository
@@ -268,29 +268,28 @@ mod tests {
 
     #[tokio::test]
     async fn repository_get_latest_certificates() {
-        let (certificates, _) = setup_certificate_chain(5, 2);
+        let certificates = setup_certificate_chain(5, 2);
         let connection = Arc::new(main_db_connection().unwrap());
-        insert_certificate_records(&connection, certificates.clone());
+        insert_certificate_records(&connection, certificates.certificates_chained.clone());
 
         let repository = CertificateRepository::new(connection);
         let latest_certificates = repository
             .get_latest_certificates(certificates.len())
             .await
             .unwrap();
-        let expected: Vec<Certificate> = certificates.into_iter().rev().collect();
 
-        assert_eq!(expected, latest_certificates);
+        assert_eq!(certificates.reversed_chain(), latest_certificates);
     }
 
     #[tokio::test]
     async fn repository_get_latest_genesis_certificate() {
-        let (certificates, _) = setup_certificate_chain(5, 2);
+        let certificates = setup_certificate_chain(5, 2);
         let connection = Arc::new(main_db_connection().unwrap());
-        insert_certificate_records(&connection, certificates.clone());
+        insert_certificate_records(&connection, certificates.certificates_chained.clone());
 
         let repository = CertificateRepository::new(connection);
         let latest_certificates = repository.get_latest_genesis_certificate().await.unwrap();
-        let expected = Some(certificates.last().unwrap().clone());
+        let expected = Some(certificates.genesis_certificate().clone());
 
         assert_eq!(expected, latest_certificates);
     }
@@ -509,11 +508,11 @@ mod tests {
 
     #[tokio::test]
     async fn get_master_certificate_for_epoch() {
-        let (certificates, _) = setup_certificate_chain(3, 1);
+        let certificates = setup_certificate_chain(3, 1);
         let expected_certificate_id = &certificates[2].hash;
         let epoch = &certificates[2].epoch;
         let connection = Arc::new(main_db_connection().unwrap());
-        insert_certificate_records(&connection, certificates.clone());
+        insert_certificate_records(&connection, certificates.certificates_chained.clone());
 
         let repository: CertificateRepository = CertificateRepository::new(connection);
         let certificate = repository
@@ -527,7 +526,7 @@ mod tests {
 
     #[tokio::test]
     async fn save_certificate() {
-        let (certificates, _) = setup_certificate_chain(5, 3);
+        let certificates = setup_certificate_chain(5, 3);
         let connection = Arc::new(main_db_connection().unwrap());
         let repository: CertificateRepository = CertificateRepository::new(connection.clone());
         let certificate = repository

mithril-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-client"
-version = "0.12.17"
+version = "0.12.18"
 description = "Mithril client library"
 authors = { workspace = true }
 edition = { workspace = true }