post validator message route tests

Author: simzzz

sentry/src/routes/channel.rs

@@ -733,9 +733,10 @@ mod test {
     use super::*;
     use crate::{
         db::{
-            insert_campaign, insert_channel, validator_message::insert_validator_message,
+            insert_campaign, insert_channel, validator_message::{insert_validator_message, get_validator_messages},
             CampaignRemaining,
         },
+        routes::channel::validator_message::create_validator_messages,
         test_util::setup_dummy_app,
     };
     use adapter::{
@@ -746,14 +747,17 @@ mod test {
     use primitives::{
         balances::UncheckedState,
         channel::Nonce,
+        config::GANACHE_CONFIG,
         test_util::{
             ADVERTISER, CREATOR, DUMMY_CAMPAIGN, FOLLOWER, GUARDIAN, IDS, LEADER, LEADER_2,
-            PUBLISHER, PUBLISHER_2,
+            PUBLISHER, PUBLISHER_2
         },
-        validator::{ApproveState, MessageTypes, NewState},
+        sentry::validator_messages::ValidatorMessagesCreateRequest,
+        validator::{ApproveState, MessageTypes, NewState, MessageType, Heartbeat, RejectState},
         BigNum, ChainId, Deposit, UnifiedMap, ValidatorId,
     };
     use std::str::FromStr;
+    use chrono::Utc;
 
     #[tokio::test]
     async fn create_and_fetch_spendable() {
@@ -1570,4 +1574,132 @@ mod test {
         assert_eq!(spender_proof, spender_leaf.merkle_proof);
         assert_eq!(earner_proof, earner_leaf.merkle_proof);
     }
+
+    #[tokio::test]
+    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");
+
+        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(),
+            };
+
+            let req = ValidatorMessagesCreateRequest {
+                messages: vec![],
+            };
+
+            let res = create_validator_messages(app.clone(), Extension(auth), channel_context.clone(), Json(req)).await;
+
+            assert!(matches!(res, Err(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(),
+            };
+
+            let req = ValidatorMessagesCreateRequest {
+                messages: vec![],
+            };
+
+            create_validator_messages(app.clone(), Extension(auth), channel_context.clone(), Json(req)).await.expect("should work");
+
+            let messages = get_validator_messages(&app.pool, &channel_context.context.id(), &Some(IDS[&LEADER]), &all_message_types, 100).await.expect("should get messages");
+
+            assert_eq!(messages.len(), 0);
+        }
+        // Case with 1 message
+        {
+            let auth = Auth {
+                era: 0,
+                uid: IDS[&LEADER],
+                chain: chain_context.chain.clone(),
+            };
+
+            let message = Heartbeat {
+                signature: String::new(),
+                state_root: String::new(),
+                timestamp: Utc::now(),
+            };
+
+            let req = ValidatorMessagesCreateRequest {
+                messages: vec![MessageTypes::Heartbeat(message.clone())],
+            };
+
+            create_validator_messages(app.clone(), Extension(auth), channel_context.clone(), Json(req)).await.expect("Should create messages");
+
+            let messages = get_validator_messages(&app.pool, &channel_context.context.id(), &Some(IDS[&LEADER]), &all_message_types, 100).await.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)]);
+        }
+        // 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(),
+            };
+
+            let state_root =
+                "b1a4fc6c1a1e1ab908a487e504006edcebea297f61b4b8ce6cad3b29e29454cc".to_string();
+            let signature = app
+                .adapter
+                .clone()
+                .unlock()
+                .expect("should unlock")
+                .sign(&state_root.clone())
+                .expect("should sign");
+            let new_state: NewState<UncheckedState> = NewState {
+                state_root: state_root.clone(),
+                signature: signature.clone(),
+                balances: Balances::new(),
+            };
+
+            let approve_state = ApproveState {
+                state_root: state_root.clone(),
+                signature: signature.clone(),
+                is_healthy: true,
+            };
+
+            let reject_state = 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())],
+            };
+
+            create_validator_messages(app.clone(), Extension(auth), channel_context.clone(), Json(req)).await.expect("Should create messages");
+
+            let messages = get_validator_messages(&app.pool, &channel_context.context.id(), &Some(IDS[&LEADER]), &all_message_types, 100).await.expect("should get messages");
+            assert_eq!(messages.len(), 4);
+        }
+    }
 }