refactor: formalise when and then structure of test actions and assertions (#171)

* An attempt at creating a when wrapper for assertions

* Remove unnecessary mutability modifier for session assertions

* Move when_time_elapses to the new structure for actions

* Move all mock_counterparty actions to When implementation

* Create Then wrapper struct for session ref assertions

* Move all mock counterparty assertions to Then struct implementation

Author: davidsteiner

crates/hotfix/tests/common/actions.rs

@@ -0,0 +1,53 @@
+use crate::common::mock_counterparty::MockCounterparty;
+use crate::common::test_messages::TestMessage;
+use hotfix::message::FixMessage;
+use hotfix::session::SessionRef;
+use std::time::Duration;
+
+pub struct When<T> {
+    pub target: T,
+}
+
+pub fn when<T>(target: T) -> When<T> {
+    When { target }
+}
+
+impl When<&SessionRef<TestMessage>> {
+    pub async fn requests_disconnect(self) {
+        self.target
+            .disconnect("Test Session Finished".to_string())
+            .await;
+    }
+
+    pub async fn sends_message(self, message: TestMessage) {
+        self.target.send_message(message).await;
+    }
+}
+
+impl When<&mut MockCounterparty<TestMessage>> {
+    pub async fn has_previously_sent(&mut self, message: impl FixMessage) {
+        self.target.push_previously_sent_message(message).await;
+    }
+
+    pub async fn resends_message(&mut self, sequence_number: u64) {
+        self.target.resend_message(sequence_number).await;
+    }
+
+    pub async fn sends_message(&mut self, message: impl FixMessage) {
+        self.target.send_message(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;
+    }
+
+    pub async fn sends_logon(&mut self) {
+        self.target.send_logon().await;
+    }
+}
+
+impl When<Duration> {
+    pub async fn elapses(self) {
+        tokio::time::advance(self.target).await;
+    }
+}

crates/hotfix/tests/common/assertions.rs

@@ -0,0 +1,58 @@
+use crate::common::mock_counterparty::MockCounterparty;
+use crate::common::test_messages::TestMessage;
+use hotfix::session::{SessionRef, Status};
+use hotfix_message::message::Message;
+use std::time::Duration;
+
+pub const DEFAULT_TIMEOUT: Duration = Duration::from_millis(500);
+
+pub struct Then<T> {
+    target: T,
+}
+
+pub fn then<T>(target: T) -> Then<T> {
+    Then { target }
+}
+
+impl Then<&SessionRef<TestMessage>> {
+    pub async fn status_changes_to(self, expected_status: Status) {
+        self.status_changes_within_time(expected_status, DEFAULT_TIMEOUT)
+            .await;
+    }
+
+    pub async fn status_changes_within_time(self, expected_status: Status, timeout: Duration) {
+        let deadline = tokio::time::Instant::now() + timeout;
+        let retry_interval = Duration::from_millis(1);
+
+        let mut session_info = self.target.get_session_info().await;
+        while tokio::time::Instant::now() < deadline {
+            if session_info.status == expected_status {
+                return;
+            }
+            tokio::time::sleep(retry_interval).await;
+            session_info = self.target.get_session_info().await;
+        }
+
+        let actual_status = session_info.status;
+        panic!(
+            "session did not reach expected status within timeout. Expected: {expected_status:?}, Actual: {actual_status:?}"
+        );
+    }
+}
+
+impl Then<&mut MockCounterparty<TestMessage>> {
+    pub async fn receives<F>(self, assertion: F)
+    where
+        F: FnOnce(&Message),
+    {
+        self.target
+            .assert_next_with_timeout(assertion, DEFAULT_TIMEOUT)
+            .await;
+    }
+
+    pub async fn gets_disconnected(self) {
+        self.target
+            .assert_disconnected_with_timeout(DEFAULT_TIMEOUT)
+            .await;
+    }
+}

crates/hotfix/tests/common/mock_counterparty.rs

@@ -1,4 +1,3 @@
-use crate::common::session_assertions::DEFAULT_TIMEOUT;
 use hotfix::config::SessionConfig;
 use hotfix::message::logon::{Logon, ResetSeqNumConfig};
 use hotfix::message::sequence_reset::SequenceReset;
@@ -50,7 +49,7 @@ where
         }
     }
 
-    pub async fn when_previously_sent(&mut self, message: impl FixMessage) {
+    pub async fn push_previously_sent_message(&mut self, message: impl FixMessage) {
         let raw_message = generate_message(
             &self.session_config.sender_comp_id,
             &self.session_config.target_comp_id,
@@ -61,14 +60,14 @@ where
         self.sent_messages.push(raw_message);
     }
 
-    pub async fn when_message_is_resent(&mut self, sequence_number: u64) {
+    pub async fn resend_message(&mut self, sequence_number: u64) {
         let message = self.sent_messages[sequence_number as usize - 1].clone();
         self.session_ref
             .new_fix_message_received(RawFixMessage::new(message))
             .await;
     }
 
-    pub async fn when_gap_fill_is_sent(&mut self, start_seq_no: u64, new_seq_no: u64) {
+    pub async fn send_gap_fill(&mut self, start_seq_no: u64, new_seq_no: u64) {
         let sequence_reset = SequenceReset {
             gap_fill: true,
             new_seq_no,
@@ -85,15 +84,15 @@ where
             .await;
     }
 
-    pub async fn when_logon_is_sent(&mut self) {
+    pub async fn send_logon(&mut self) {
         let logon = Logon::new(
             self.session_config.heartbeat_interval,
             ResetSeqNumConfig::NoReset(None),
         );
-        self.when_message_is_sent(logon).await;
+        self.send_message(logon).await;
     }
 
-    pub async fn when_message_is_sent(&mut self, message: impl FixMessage) {
+    pub async fn send_message(&mut self, message: impl FixMessage) {
         let raw_message = generate_message(
             &self.session_config.sender_comp_id,
             &self.session_config.target_comp_id,
@@ -138,15 +137,7 @@ where
         }
     }
 
-    pub async fn then_receives<F>(&mut self, assertion: F)
-    where
-        F: FnOnce(&Message),
-    {
-        self.assert_next_with_timeout(assertion, DEFAULT_TIMEOUT)
-            .await;
-    }
-
-    async fn assert_next_with_timeout<F>(&mut self, assertion: F, timeout: Duration)
+    pub(crate) async fn assert_next_with_timeout<F>(&mut self, assertion: F, timeout: Duration)
     where
         F: FnOnce(&Message),
     {
@@ -163,11 +154,7 @@ where
         }
     }
 
-    pub async fn then_gets_disconnected(&mut self) {
-        self.assert_disconnected_with_timeout(DEFAULT_TIMEOUT).await;
-    }
-
-    async fn assert_disconnected_with_timeout(&mut self, timeout: Duration) {
+    pub async fn assert_disconnected_with_timeout(&mut self, timeout: Duration) {
         if tokio::time::timeout(timeout, async {
             // keep consuming messages until a disconnect occurs
             while self.get_next().await.is_some() {}

crates/hotfix/tests/common/mod.rs

@@ -1,6 +1,6 @@
+pub mod actions;
+pub mod assertions;
 pub mod mock_application;
 pub mod mock_counterparty;
-pub mod session_actions;
-pub mod session_assertions;
 pub mod setup;
 pub mod test_messages;

crates/hotfix/tests/common/session_actions.rs

@@ -1,6 +1,7 @@
+use crate::common::actions::when;
+use crate::common::assertions::then;
 use crate::common::mock_application::MockApplication;
 use crate::common::mock_counterparty::MockCounterparty;
-use crate::common::session_assertions::SessionAssertions;
 use crate::common::test_messages::TestMessage;
 use hotfix::application::ApplicationRef;
 use hotfix::config::SessionConfig;
@@ -35,11 +36,11 @@ pub async fn given_a_connected_session_with_store(
 pub async fn given_an_active_session() -> (SessionRef<TestMessage>, MockCounterparty<TestMessage>) {
     let (session, mut mock_counterparty) = given_a_connected_session().await;
 
-    mock_counterparty
-        .then_receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "A"))
+    then(&mut mock_counterparty)
+        .receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "A"))
         .await;
-    mock_counterparty.when_logon_is_sent().await;
-    session.then_status_changes_to(Status::Active).await;
+    when(&mut mock_counterparty).sends_logon().await;
+    then(&session).status_changes_to(Status::Active).await;
 
     (session, mock_counterparty)
 }

crates/hotfix/tests/common/session_assertions.rs

@@ -1,4 +1,5 @@
-use crate::common::session_actions::SessionActions;
+use crate::common::actions::when;
+use crate::common::assertions::then;
 use crate::common::setup::given_an_active_session;
 use crate::common::test_messages::TestMessage;
 use hotfix::message::FixMessage;
@@ -8,21 +9,21 @@ async fn test_new_order_single() {
     let (session, mut mock_counterparty) = given_an_active_session().await;
 
     // we send a new order to the counterparty and they receive it successfully
-    session
-        .when_message_is_sent(TestMessage::dummy_new_order_single())
+    when(&session)
+        .sends_message(TestMessage::dummy_new_order_single())
         .await;
-    mock_counterparty
-        .then_receives(|msg| {
+    then(&mut mock_counterparty)
+        .receives(|msg| {
             let parsed = TestMessage::parse(msg);
             assert_eq!(parsed.message_type(), "D");
         })
         .await;
 
-    mock_counterparty
-        .when_message_is_sent(TestMessage::dummy_execution_report())
+    when(&mut mock_counterparty)
+        .sends_message(TestMessage::dummy_execution_report())
         .await;
     // TODO: we currently have no good way of asserting this message was received
 
-    session.when_disconnect_is_requested().await;
-    mock_counterparty.then_gets_disconnected().await;
+    when(&session).requests_disconnect().await;
+    then(&mut mock_counterparty).gets_disconnected().await;
 }

crates/hotfix/tests/common/setup.rs

@@ -1,4 +1,5 @@
-use crate::common::session_actions::{SessionActions, when_time_elapses};
+use crate::common::actions::when;
+use crate::common::assertions::then;
 use crate::common::setup::{HEARTBEAT_INTERVAL, given_an_active_session};
 use hotfix_message::Part;
 use hotfix_message::fix44::MSG_TYPE;
@@ -18,13 +19,15 @@ async fn test_heartbeats() {
     let (session, mut mock_counterparty) = given_an_active_session().await;
 
     // let's wait enough time for a heartbeat and assert that the heartbeat was sent
-    when_time_elapses(Duration::from_secs(HEARTBEAT_INTERVAL + 1)).await;
-    mock_counterparty
-        .then_receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "0"))
+    when(Duration::from_secs(HEARTBEAT_INTERVAL + 1))
+        .elapses()
+        .await;
+    then(&mut mock_counterparty)
+        .receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "0"))
         .await;
 
-    session.when_disconnect_is_requested().await;
-    mock_counterparty.then_gets_disconnected().await;
+    when(&session).requests_disconnect().await;
+    then(&mut mock_counterparty).gets_disconnected().await;
 }
 
 /// Tests the peer timeout and disconnection mechanism:
@@ -42,19 +45,23 @@ async fn test_peer_timeout() {
     let (_session, mut mock_counterparty) = given_an_active_session().await;
 
     // let's wait enough time for a heartbeat and assert that the heartbeat was sent
-    when_time_elapses(Duration::from_secs(HEARTBEAT_INTERVAL + 1)).await;
-    mock_counterparty
-        .then_receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "0"))
+    when(Duration::from_secs(HEARTBEAT_INTERVAL + 1))
+        .elapses()
+        .await;
+    then(&mut mock_counterparty)
+        .receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "0"))
         .await;
 
     // we wait enough time for the peer deadline to pass
-    when_time_elapses(Duration::from_secs(peer_interval - HEARTBEAT_INTERVAL)).await;
+    when(Duration::from_secs(peer_interval - HEARTBEAT_INTERVAL))
+        .elapses()
+        .await;
     // a TestRequest (type '1') is sent to the counterparty
-    mock_counterparty
-        .then_receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "1"))
+    then(&mut mock_counterparty)
+        .receives(|msg| assert_eq!(msg.header().get::<&str>(MSG_TYPE).unwrap(), "1"))
         .await;
 
     // we wait even longer and the counterparty never responds, so we disconnect from the counterparty
-    when_time_elapses(Duration::from_secs(peer_interval)).await;
-    mock_counterparty.then_gets_disconnected().await;
+    when(Duration::from_secs(peer_interval)).elapses().await;
+    then(&mut mock_counterparty).gets_disconnected().await;
 }