Externalize registration event sending to use it in test

Author: sfauvel

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

@@ -153,6 +153,7 @@ mod tests {
         use crate::event_store::{
             database::test_helper::event_store_db_connection, TransmitterService,
         };
+        use crate::http_server::routes::signer_routes;
         use crate::test_tools::TestLogger;
         use mithril_common::entities::Stake;
         use mithril_common::{entities::SignerWithStake, test_utils::fake_data, StdResult};
@@ -168,11 +169,6 @@ mod tests {
             stake: Stake,
             signer_node_version: &str,
         ) {
-            let headers = vec![
-                ("signer-node-version", signer_node_version),
-                ("epoch", epoch),
-            ];
-
             let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<EventMessage>();
             let transmitter_service = Arc::new(TransmitterService::new(tx, TestLogger::stdout()));
 
@@ -183,11 +179,11 @@ mod tests {
                 ..signers[0].clone()
             };
 
-            let _result = transmitter_service.send_event_message::<SignerWithStake>(
-                "HTTP::signer_register",
-                "register_signer",
+            let _ = signer_routes::handlers::send_registration_event(
+                &transmitter_service,
                 &signer,
-                headers,
+                Some(signer_node_version.to_string()),
+                epoch,
             );
 
             let message: EventMessage = rx.try_recv().unwrap();

mithril-aggregator/src/http_server/routes/mod.rs

@@ -7,7 +7,7 @@ pub(crate) mod reply;
 mod root_routes;
 pub mod router;
 mod signatures_routes;
-mod signer_routes;
+pub(crate) mod signer_routes;
 mod statistics_routes;
 
 /// Match the given result and do an early return with an internal server error (500)

mithril-aggregator/src/http_server/routes/signer_routes.rs

@@ -90,7 +90,7 @@ async fn compute_registration_epoch(
     }
 }
 
-mod handlers {
+pub(crate) mod handlers {
     use crate::database::repository::SignerGetter;
     use crate::dependency_injection::EpochServiceWrapper;
     use crate::entities::{
@@ -102,12 +102,36 @@ mod handlers {
     };
     use crate::{http_server::routes::reply, SignerRegisterer, SignerRegistrationError};
     use crate::{FromRegisterSignerAdapter, MetricsService, VerificationKeyStorer};
+    use mithril_common::entities::SignerWithStake;
     use mithril_common::messages::{RegisterSignerMessage, TryFromMessageAdapter};
     use slog::{debug, warn, Logger};
     use std::convert::Infallible;
     use std::sync::Arc;
     use warp::http::StatusCode;
 
+    pub(crate) fn send_registration_event(
+        transmitter: &TransmitterService<EventMessage>,
+        signer_with_stake: &SignerWithStake,
+        signer_node_version: Option<String>,
+        epoch_str: &str,
+    ) -> Result<(), String> {
+        let mut headers: Vec<(&str, &str)> = match signer_node_version.as_ref() {
+            Some(version) => vec![("signer-node-version", version)],
+            None => Vec::new(),
+        };
+
+        if !epoch_str.is_empty() {
+            headers.push(("epoch", epoch_str));
+        }
+
+        transmitter.send_event_message::<SignerWithStake>(
+            "HTTP::signer_register",
+            "register_signer",
+            &signer_with_stake,
+            headers,
+        )
+    }
+
     /// Register Signer
     pub async fn register_signer(
         signer_node_version: Option<String>,
@@ -137,37 +161,30 @@ mod handlers {
             }
         };
 
-        let mut headers: Vec<(&str, &str)> = match signer_node_version.as_ref() {
-            Some(version) => vec![("signer-node-version", version)],
-            None => Vec::new(),
-        };
-
         let epoch_str = fetch_epoch_header_value(epoch_service, &logger).await;
-        if !epoch_str.is_empty() {
-            headers.push(("epoch", epoch_str.as_str()));
-        }
 
         match signer_registerer
             .register_signer(registration_epoch, &signer)
             .await
         {
             Ok(signer_with_stake) => {
-                let _ = event_transmitter.send_event_message(
-                    "HTTP::signer_register",
-                    "register_signer",
+                let _ = send_registration_event(
+                    &event_transmitter,
                     &signer_with_stake,
-                    headers,
+                    signer_node_version,
+                    epoch_str.as_str(),
                 );
 
                 Ok(reply::empty(StatusCode::CREATED))
             }
             Err(SignerRegistrationError::ExistingSigner(signer_with_stake)) => {
                 debug!(logger, "register_signer::already_registered");
-                let _ = event_transmitter.send_event_message(
-                    "HTTP::signer_register",
-                    "register_signer",
+
+                let _ = send_registration_event(
+                    &event_transmitter,
                     &signer_with_stake,
-                    headers,
+                    signer_node_version,
+                    epoch_str.as_str(),
                 );
                 Ok(reply::empty(StatusCode::CREATED))
             }