Add missing open message tests

Author: jpraynaud

mithril-aggregator/src/database/provider/mod.rs

@@ -7,6 +7,8 @@ mod signer;
 mod signer_registration;
 mod single_signature;
 mod stake_pool;
+#[cfg(test)]
+mod test_helper;
 
 pub use certificate::*;
 pub use epoch_setting::*;
@@ -16,3 +18,5 @@ pub use signer::*;
 pub use signer_registration::*;
 pub use single_signature::*;
 pub use stake_pool::*;
+#[cfg(test)]
+pub use test_helper::*;

mithril-aggregator/src/database/provider/open_message.rs

@@ -330,89 +330,6 @@ impl<'client> Provider<'client> for DeleteOpenMessageProvider<'client> {
     }
 }
 
-/// ## Open message repository
-///
-/// This is a business oriented layer to perform actions on the database through
-/// providers.
-pub struct OpenMessageRepository {
-    connection: Arc<Mutex<Connection>>,
-}
-
-impl OpenMessageRepository {
-    /// Instanciate service
-    pub fn new(connection: Arc<Mutex<Connection>>) -> Self {
-        Self { connection }
-    }
-
-    /// Return the latest [OpenMessage] for the given Epoch and [SignedEntityType].
-    pub async fn get_open_message(
-        &self,
-        signed_entity_type: &SignedEntityType,
-    ) -> StdResult<Option<OpenMessage>> {
-        let lock = self.connection.lock().await;
-        let provider = OpenMessageProvider::new(&lock);
-        let filters = provider
-            .get_epoch_condition(signed_entity_type.get_epoch())
-            .and_where(provider.get_signed_entity_type_condition(signed_entity_type));
-        let mut messages = provider.find(filters)?;
-
-        Ok(messages.next())
-    }
-
-    /// Create a new [OpenMessage] in the database.
-    pub async fn create_open_message(
-        &self,
-        epoch: Epoch,
-        signed_entity_type: &SignedEntityType,
-        protocol_message: &ProtocolMessage,
-    ) -> StdResult<OpenMessage> {
-        let lock = self.connection.lock().await;
-        let provider = InsertOpenMessageProvider::new(&lock);
-        let filters = provider.get_insert_condition(epoch, signed_entity_type, protocol_message)?;
-        let mut cursor = provider.find(filters)?;
-
-        cursor
-            .next()
-            .ok_or_else(|| panic!("Inserting an open_message should not return nothing."))
-    }
-
-    /// Updates an [OpenMessage] in the database.
-    pub async fn update_open_message(&self, open_message: &OpenMessage) -> StdResult<OpenMessage> {
-        let lock = self.connection.lock().await;
-        let provider = UpdateOpenMessageProvider::new(&lock);
-        let filters = provider.get_update_condition(open_message)?;
-        let mut cursor = provider.find(filters)?;
-
-        cursor
-            .next()
-            .ok_or_else(|| panic!("Updating an open_message should not return nothing."))
-    }
-
-    /// Remove all the [OpenMessage] for the given Epoch in the database.
-    /// It returns the number of messages removed.
-    pub async fn clean_epoch(&self, epoch: Epoch) -> StdResult<usize> {
-        let lock = self.connection.lock().await;
-        let provider = DeleteOpenMessageProvider::new(&lock);
-        let filters = provider.get_epoch_condition(epoch);
-        let cursor = provider.find(filters)?;
-
-        Ok(cursor.count())
-    }
-
-    /// Return an open message with its associated single signatures if any.
-    pub async fn get_open_message_with_single_signatures(
-        &self,
-        signed_entity_type: &SignedEntityType,
-    ) -> StdResult<Option<OpenMessageWithSingleSignatures>> {
-        let lock = self.connection.lock().await;
-        let provider = OpenMessageWithSingleSignaturesProvider::new(&lock);
-        let filters = provider.get_signed_entity_type_condition(signed_entity_type);
-        let mut messages = provider.find(filters)?;
-
-        Ok(messages.next())
-    }
-}
-
 /// Open Message with associated single signatures if any.
 #[derive(Debug, Clone)]
 pub struct OpenMessageWithSingleSignatures {
@@ -550,12 +467,99 @@ order by open_message.created_at desc, open_message.rowid desc
     }
 }
 
+/// ## Open message repository
+///
+/// This is a business oriented layer to perform actions on the database through
+/// providers.
+pub struct OpenMessageRepository {
+    connection: Arc<Mutex<Connection>>,
+}
+
+impl OpenMessageRepository {
+    /// Instanciate service
+    pub fn new(connection: Arc<Mutex<Connection>>) -> Self {
+        Self { connection }
+    }
+
+    /// Return the latest [OpenMessage] for the given Epoch and [SignedEntityType].
+    pub async fn get_open_message(
+        &self,
+        signed_entity_type: &SignedEntityType,
+    ) -> StdResult<Option<OpenMessage>> {
+        let lock = self.connection.lock().await;
+        let provider = OpenMessageProvider::new(&lock);
+        let filters = provider
+            .get_epoch_condition(signed_entity_type.get_epoch())
+            .and_where(provider.get_signed_entity_type_condition(signed_entity_type));
+        let mut messages = provider.find(filters)?;
+
+        Ok(messages.next())
+    }
+
+    /// Create a new [OpenMessage] in the database.
+    pub async fn create_open_message(
+        &self,
+        epoch: Epoch,
+        signed_entity_type: &SignedEntityType,
+        protocol_message: &ProtocolMessage,
+    ) -> StdResult<OpenMessage> {
+        let lock = self.connection.lock().await;
+        let provider = InsertOpenMessageProvider::new(&lock);
+        let filters = provider.get_insert_condition(epoch, signed_entity_type, protocol_message)?;
+        let mut cursor = provider.find(filters)?;
+
+        cursor
+            .next()
+            .ok_or_else(|| panic!("Inserting an open_message should not return nothing."))
+    }
+
+    /// Updates an [OpenMessage] in the database.
+    pub async fn update_open_message(&self, open_message: &OpenMessage) -> StdResult<OpenMessage> {
+        let lock = self.connection.lock().await;
+        let provider = UpdateOpenMessageProvider::new(&lock);
+        let filters = provider.get_update_condition(open_message)?;
+        let mut cursor = provider.find(filters)?;
+
+        cursor
+            .next()
+            .ok_or_else(|| panic!("Updating an open_message should not return nothing."))
+    }
+
+    /// Remove all the [OpenMessage] for the given Epoch in the database.
+    /// It returns the number of messages removed.
+    pub async fn clean_epoch(&self, epoch: Epoch) -> StdResult<usize> {
+        let lock = self.connection.lock().await;
+        let provider = DeleteOpenMessageProvider::new(&lock);
+        let filters = provider.get_epoch_condition(epoch);
+        let cursor = provider.find(filters)?;
+
+        Ok(cursor.count())
+    }
+
+    /// Return an open message with its associated single signatures if any.
+    pub async fn get_open_message_with_single_signatures(
+        &self,
+        signed_entity_type: &SignedEntityType,
+    ) -> StdResult<Option<OpenMessageWithSingleSignatures>> {
+        let lock = self.connection.lock().await;
+        let provider = OpenMessageWithSingleSignaturesProvider::new(&lock);
+        let filters = provider.get_signed_entity_type_condition(signed_entity_type);
+        let mut messages = provider.find(filters)?;
+
+        Ok(messages.next())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use mithril_common::{entities::Beacon, sqlite::SourceAlias};
 
     use crate::{dependency_injection::DependenciesBuilder, Configuration};
 
+    use crate::database::provider::test_helper::{
+        setup_single_signature_db, setup_single_signature_records,
+    };
+
     use super::*;
 
     #[test]
@@ -824,9 +828,52 @@ mod tests {
         assert_eq!(2, count);
     }
 
-    /*
     #[tokio::test]
-    async fn repository_get_open_message_with_single_signatures() {
-        todo!()
-    } */
+    async fn repository_get_open_message_with_single_signatures_when_signatures_exist() {
+        let single_signature_records = setup_single_signature_records(1, 1, 4);
+
+        let connection = Connection::open(":memory:").unwrap();
+        setup_single_signature_db(&connection, single_signature_records.clone()).unwrap();
+        let repository = OpenMessageRepository::new(Arc::new(Mutex::new(connection)));
+
+        let mut open_message = OpenMessage::dummy();
+        open_message.open_message_id = single_signature_records[0].open_message_id;
+        repository.update_open_message(&open_message).await.unwrap();
+
+        let open_message_with_single_signatures = repository
+            .get_open_message_with_single_signatures(&open_message.signed_entity_type)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(
+            4,
+            open_message_with_single_signatures.single_signatures.len()
+        )
+    }
+
+    #[tokio::test]
+    async fn repository_get_open_message_with_single_signatures_when_signatures_not_exist() {
+        let connection = Connection::open(":memory:").unwrap();
+        setup_single_signature_db(&connection, Vec::new()).unwrap();
+        let repository = OpenMessageRepository::new(Arc::new(Mutex::new(connection)));
+
+        let open_message = OpenMessage::dummy();
+        repository
+            .create_open_message(
+                open_message.epoch,
+                &open_message.signed_entity_type,
+                &open_message.protocol_message,
+            )
+            .await
+            .unwrap();
+
+        let open_message_with_single_signatures = repository
+            .get_open_message_with_single_signatures(&open_message.signed_entity_type)
+            .await
+            .unwrap()
+            .unwrap();
+        assert!(open_message_with_single_signatures
+            .single_signatures
+            .is_empty())
+    }
 }

mithril-aggregator/src/database/provider/single_signature.rs

@@ -216,7 +216,7 @@ impl<'conn> UpdateSingleSignatureRecordProvider<'conn> {
         Self { connection }
     }
 
-    fn get_update_condition(
+    pub(crate) fn get_update_condition(
         &self,
         single_signature_record: &SingleSignatureRecord,
     ) -> WhereCondition {
@@ -303,97 +303,10 @@ impl SingleSignatureRepository {
 mod tests {
     use mithril_common::test_utils::fake_data;
 
-    use crate::database::migration::get_migrations;
+    use crate::database::provider::{setup_single_signature_db, setup_single_signature_records};
 
     use super::*;
 
-    fn setup_single_signature_records(
-        total_epoch: u64,
-        total_open_message: u64,
-        total_signer: u64,
-    ) -> Vec<SingleSignatureRecord> {
-        let mut single_signature_records = Vec::new();
-        for epoch in 1..=total_epoch {
-            for open_message_idx in 1..=total_open_message {
-                let open_message_id = Uuid::new_v4();
-                for signer_idx in 1..=total_signer {
-                    let single_signature_id = epoch
-                        + (epoch + 1) * open_message_idx
-                        + (epoch + 1) * (open_message_idx + 1) * signer_idx;
-                    single_signature_records.push(SingleSignatureRecord {
-                        open_message_id,
-                        signer_id: format!("signer-{signer_idx}"),
-                        registration_epoch_setting_id: Epoch(epoch),
-                        lottery_indexes: (1..=single_signature_id).collect(),
-                        signature: format!("signature-{single_signature_id}"),
-                        created_at: format!("created-at-{single_signature_id}"),
-                    });
-                }
-            }
-        }
-        single_signature_records
-    }
-
-    pub fn setup_single_signature_db(
-        connection: &Connection,
-        single_signature_records: Vec<SingleSignatureRecord>,
-    ) -> Result<(), StdError> {
-        for migration in get_migrations() {
-            connection.execute(&migration.alterations)?;
-        }
-
-        if single_signature_records.is_empty() {
-            return Ok(());
-        }
-
-        let query = {
-            // leverage the expanded parameter from this provider which is unit
-            // tested on its own above.
-            let update_provider = UpdateSingleSignatureRecordProvider::new(connection);
-            let (sql_values, _) = update_provider
-                .get_update_condition(single_signature_records.first().unwrap())
-                .expand();
-            format!("insert into single_signature {sql_values}")
-        };
-
-        for single_signature_record in single_signature_records {
-            let mut statement = connection.prepare(&query)?;
-
-            statement
-                .bind(
-                    1,
-                    single_signature_record.open_message_id.to_string().as_str(),
-                )
-                .unwrap();
-            statement
-                .bind(2, single_signature_record.signer_id.as_str())
-                .unwrap();
-            statement
-                .bind(
-                    3,
-                    single_signature_record.registration_epoch_setting_id.0 as i64,
-                )
-                .unwrap();
-            statement
-                .bind(
-                    4,
-                    serde_json::to_string(&single_signature_record.lottery_indexes)
-                        .unwrap()
-                        .as_str(),
-                )
-                .unwrap();
-            statement
-                .bind(5, single_signature_record.signature.as_str())
-                .unwrap();
-            statement
-                .bind(6, single_signature_record.created_at.as_str())
-                .unwrap();
-            statement.next().unwrap();
-        }
-
-        Ok(())
-    }
-
     #[test]
     fn test_convert_single_signatures() {
         let single_signature = fake_data::single_signatures(vec![1, 3, 4, 6, 7, 9]);