sentry - router - channel - get validator-messages:

- sentry - routers - tests for GET validator-messages channel routers
- primitives - validator - MessageTypes::message_type helper fn
- sentry - test_util - move body_to_string
- sentry - test_util - body_to deserialize from response
- sentry - routes - channel - clean-up

Author: elpiel

primitives/src/validator.rs

@@ -400,6 +400,12 @@ pub mod messages {
         Heartbeat(Heartbeat),
     }
 
+    impl MessageTypes {
+        pub fn message_type(&self) -> MessageType {
+            self.into()
+        }
+    }
+
     /// All available message type names.
     #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, FromStr, Display)]
     #[display(style = "CamelCase")]

sentry/src/middleware.rs

@@ -1,21 +1,6 @@
 //! This module contains all the routers' middlewares
 //!
 
-#[cfg(test)]
-pub use test_util::*;
-
 pub mod auth;
 pub mod campaign;
 pub mod channel;
-
-#[cfg(test)]
-pub mod test_util {
-    use axum::{body::BoxBody, response::Response};
-
-    /// Extracts the body as a String from the Response.
-    ///
-    /// Used when you want to check the response body or debug a response.
-    pub async fn body_to_string(response: Response<BoxBody>) -> String {
-        String::from_utf8(hyper::body::to_bytes(response).await.unwrap().to_vec()).unwrap()
-    }
-}

sentry/src/middleware/auth.rs

@@ -210,7 +210,10 @@ mod test {
     };
     use primitives::test_util::{ADVERTISER, DUMMY_AUTH, FOLLOWER, IDS, LEADER, PUBLISHER};
 
-    use crate::{middleware::body_to_string, test_util::setup_dummy_app, Session};
+    use crate::{
+        test_util::{body_to_string, setup_dummy_app},
+        Session,
+    };
 
     use super::*;
 

sentry/src/routes/channel.rs

@@ -744,9 +744,8 @@ pub mod validator_message {
 
         use primitives::{
             balances::UncheckedState,
-            config::GANACHE_CONFIG,
             sentry::validator_messages::ValidatorMessagesCreateRequest,
-            test_util::{ADVERTISER, DUMMY_CAMPAIGN, IDS, LEADER},
+            test_util::{ADVERTISER, CAMPAIGNS, IDS, LEADER},
             validator::{
                 ApproveState, Heartbeat, MessageType, MessageTypes, NewState, RejectState,
             },
@@ -757,34 +756,25 @@ pub mod validator_message {
         async fn post_validator_messages() {
             let app_guard = setup_dummy_app().await;
             let app = Extension(Arc::new(app_guard.app.clone()));
-            let config = GANACHE_CONFIG.clone();
             let all_message_types: [MessageType; 4] = [
                 MessageType::NewState,
                 MessageType::ApproveState,
                 MessageType::RejectState,
                 MessageType::Heartbeat,
             ];
 
-            let channel_context = Extension(
-                app.config
-                    .find_chain_of(DUMMY_CAMPAIGN.channel.token)
-                    .expect("Dummy channel Token should be present in config!")
-                    .with(DUMMY_CAMPAIGN.channel),
-            );
-
-            let chain_context = config
-                .find_chain_of(DUMMY_CAMPAIGN.channel.token)
-                .expect("Campaign's Channel.token should be set in config");
+            let channel_context = Extension(CAMPAIGNS[0].clone().of_channel());
 
             insert_channel(&app.pool, &channel_context)
                 .await
                 .expect("should insert channel");
+
             // Case when the request is not sent by a channel validator
             {
                 let auth = Auth {
                     era: 0,
                     uid: IDS[&ADVERTISER],
-                    chain: chain_context.chain.clone(),
+                    chain: channel_context.chain.clone(),
                 };
 
                 let req = ValidatorMessagesCreateRequest { messages: vec![] };
@@ -795,17 +785,19 @@ pub mod validator_message {
                     channel_context.clone(),
                     Json(req),
                 )
-                .await;
+                .await
+                .expect_err("We expect an error to be returned");
 
-                assert!(matches!(res, Err(ResponseError::Unauthorized)));
+                assert_eq!(res, ResponseError::Unauthorized);
             }
+
             // Cases where we insert validator messages
             // Case with 0 messages
             {
                 let auth = Auth {
                     era: 0,
                     uid: IDS[&LEADER],
-                    chain: chain_context.chain.clone(),
+                    chain: channel_context.chain.clone(),
                 };
 
                 let req = ValidatorMessagesCreateRequest { messages: vec![] };
@@ -836,17 +828,17 @@ pub mod validator_message {
                 let auth = Auth {
                     era: 0,
                     uid: IDS[&LEADER],
-                    chain: chain_context.chain.clone(),
+                    chain: channel_context.chain.clone(),
                 };
 
-                let message = Heartbeat {
+                let message = MessageTypes::Heartbeat(Heartbeat {
                     signature: String::new(),
                     state_root: String::new(),
                     timestamp: Utc::now(),
-                };
+                });
 
                 let req = ValidatorMessagesCreateRequest {
-                    messages: vec![MessageTypes::Heartbeat(message.clone())],
+                    messages: vec![message.clone()],
                 };
 
                 create_validator_messages(
@@ -869,14 +861,14 @@ pub mod validator_message {
                 .expect("should get messages");
                 let inner_messages: Vec<MessageTypes> =
                     messages.into_iter().map(|m| m.msg.clone()).collect();
-                assert_eq!(inner_messages, vec![MessageTypes::Heartbeat(message)]);
+                assert_eq!(inner_messages, vec![message]);
             }
             // Case with 4 messages (one of each type, heartbeat is already inserted)
             {
                 let auth = Auth {
                     era: 0,
                     uid: IDS[&LEADER],
-                    chain: chain_context.chain.clone(),
+                    chain: channel_context.chain.clone(),
                 };
 
                 let state_root =
@@ -888,31 +880,31 @@ pub mod validator_message {
                     .expect("should unlock")
                     .sign(&state_root.clone())
                     .expect("should sign");
-                let new_state: NewState<UncheckedState> = NewState {
+                let new_state = MessageTypes::NewState(NewState {
                     state_root: state_root.clone(),
                     signature: signature.clone(),
-                    balances: Balances::new(),
-                };
+                    balances: Balances::<UncheckedState>::new(),
+                });
 
-                let approve_state = ApproveState {
+                let approve_state = MessageTypes::ApproveState(ApproveState {
                     state_root: state_root.clone(),
                     signature: signature.clone(),
                     is_healthy: true,
-                };
+                });
 
-                let reject_state = RejectState {
+                let reject_state = MessageTypes::RejectState(RejectState {
                     state_root,
                     signature: signature.clone(),
                     timestamp: Utc::now(),
                     reason: "rejected".to_string(),
                     balances: None,
-                };
+                });
 
                 let req = ValidatorMessagesCreateRequest {
                     messages: vec![
-                        MessageTypes::NewState(new_state.clone()),
-                        MessageTypes::ApproveState(approve_state.clone()),
-                        MessageTypes::RejectState(reject_state.clone()),
+                        new_state.clone(),
+                        approve_state.clone(),
+                        reject_state.clone(),
                     ],
                 };