chore: test case for garbled message handling (#180)

* Add test for handling garbled messages

* Refactor utility function to manually replace a tag's value in a raw message

* Add doc comments for invalid message tests

Author: davidsteiner

crates/hotfix/tests/common/actions.rs

@@ -37,6 +37,10 @@ impl When<&mut MockCounterparty<TestMessage>> {
         self.target.send_message(message).await;
     }
 
+    pub async fn sends_raw_message(&mut self, raw_message: Vec<u8>) {
+        self.target.send_raw_message(raw_message).await;
+    }
+
     pub async fn sends_gap_fill(&mut self, start_seq_no: u64, new_seq_no: u64) {
         self.target.send_gap_fill(start_seq_no, new_seq_no).await;
     }

crates/hotfix/tests/common/mock_counterparty.rs

@@ -96,10 +96,14 @@ where
         let raw_message = generate_message(
             &self.session_config.sender_comp_id,
             &self.session_config.target_comp_id,
-            self.sent_messages.len() + 1,
+            self.next_target_sequence_number(),
             message,
         )
         .expect("failed to generate message");
+        self.send_raw_message(raw_message).await;
+    }
+
+    pub async fn send_raw_message(&mut self, raw_message: Vec<u8>) {
         self.sent_messages.push(raw_message.clone());
         self.session_ref
             .new_fix_message_received(RawFixMessage::new(raw_message))
@@ -166,6 +170,10 @@ where
         }
     }
 
+    pub fn next_target_sequence_number(&self) -> usize {
+        self.sent_messages.len() + 1
+    }
+
     fn create_writer() -> (WriterRef, Receiver<WriterMessage>) {
         let (sender, receiver) = mpsc::channel(10);
         (WriterRef::new(sender), receiver)

crates/hotfix/tests/common/test_messages.rs

@@ -147,3 +147,23 @@ impl FixMessage for TestMessage {
         }
     }
 }
+
+/// Replaces the value of a field in a raw FIX message.
+pub fn replace_field_value(raw_message: &mut Vec<u8>, tag: u32, new_value: &[u8]) {
+    let tag_bytes = format!("{}=", tag).into_bytes();
+
+    if let Some(field_start) = raw_message
+        .windows(tag_bytes.len())
+        .position(|window| window == tag_bytes)
+    {
+        let value_start = field_start + tag_bytes.len();
+        if let Some(field_end) = raw_message[value_start..]
+            .iter()
+            .position(|&b| b == b'\x01')
+        {
+            let value_end = value_start + field_end;
+
+            raw_message.splice(value_start..value_end, new_value.iter().cloned());
+        }
+    }
+}

crates/hotfix/tests/session_test_cases/invalid_message_tests.rs

@@ -1,12 +1,16 @@
 use crate::common::actions::when;
 use crate::common::assertions::then;
 use crate::common::setup::given_an_active_session;
-use hotfix::message::FixMessage;
+use crate::common::test_messages::{TestMessage, replace_field_value};
+use hotfix::message::{FixMessage, generate_message};
+use hotfix::session::Status;
 use hotfix_message::dict::{FieldLocation, FixDatatype};
 use hotfix_message::fix44::MSG_TYPE;
 use hotfix_message::message::Message;
 use hotfix_message::{HardCodedFixFieldDefinition, Part, fix44};
 
+/// Tests that when a counterparty sends a message containing an invalid/unrecognised field,
+/// the session rejects the message by sending a Reject (MsgType=3) message back.
 #[tokio::test]
 async fn test_message_with_invalid_field_gets_rejected() {
     let (session, mut mock_counterparty) = given_an_active_session().await;
@@ -22,6 +26,39 @@ async fn test_message_with_invalid_field_gets_rejected() {
     then(&mut mock_counterparty).gets_disconnected().await;
 }
 
+/// Tests that when a counterparty sends a garbled message with an invalid body length,
+/// the session silently ignores it and detects a sequence gap when the next valid message arrives.
+#[tokio::test]
+async fn test_garbled_message_with_invalid_target_comp_id_gets_ignored() {
+    let (session, mut mock_counterparty) = given_an_active_session().await;
+
+    // counterparty sends a message with invalid body length, which constitutes a garbled message
+    let garbled_message = build_execution_report_with_incorrect_body_length(
+        "dummy-acceptor",
+        "dummy-initiator",
+        mock_counterparty.next_target_sequence_number(),
+    );
+    when(&mut mock_counterparty)
+        .sends_raw_message(garbled_message)
+        .await;
+
+    // they then send a valid message
+    when(&mut mock_counterparty)
+        .sends_message(TestMessage::dummy_execution_report())
+        .await;
+
+    // we then initiate a resend, having skipped the garbled message
+    then(&mut mock_counterparty)
+        .receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "2"))
+        .await;
+    then(&session)
+        .status_changes_to(Status::AwaitingResend)
+        .await;
+
+    when(&session).requests_disconnect().await;
+    then(&mut mock_counterparty).gets_disconnected().await;
+}
+
 /// A new order message with an extra, invalid field.
 #[derive(Clone, Debug)]
 struct ExecutionReportWithInvalidField {
@@ -83,3 +120,17 @@ pub const CUSTOM_FIELD: &HardCodedFixFieldDefinition = &HardCodedFixFieldDefinit
     data_type: FixDatatype::String,
     location: FieldLocation::Body,
 };
+
+fn build_execution_report_with_incorrect_body_length(
+    sender_comp_id: &str,
+    target_comp_id: &str,
+    msg_seq_num: usize,
+) -> Vec<u8> {
+    let report = TestMessage::dummy_execution_report();
+    let mut raw_message =
+        generate_message(sender_comp_id, target_comp_id, msg_seq_num, report).unwrap();
+
+    replace_field_value(&mut raw_message, 9, b"999");
+
+    raw_message
+}