Take idea of when/then wording further

Author: davidsteiner

crates/hotfix/tests/common/mock_counterparty.rs

@@ -54,10 +54,10 @@ where
             self.session_config.heartbeat_interval,
             ResetSeqNumConfig::NoReset(None),
         );
-        self.send_message(logon).await;
+        self.when_message_is_sent(logon).await;
     }
 
-    pub async fn send_message(&mut self, message: impl FixMessage) {
+    pub async fn when_message_is_sent(&mut self, message: impl FixMessage) {
         let raw_message = generate_message(
             &self.session_config.sender_comp_id,
             &self.session_config.target_comp_id,
@@ -110,7 +110,7 @@ where
             .await;
     }
 
-    pub async fn assert_next_with_timeout<F>(&mut self, assertion: F, timeout: Duration)
+    async fn assert_next_with_timeout<F>(&mut self, assertion: F, timeout: Duration)
     where
         F: FnOnce(&Message),
     {
@@ -127,11 +127,11 @@ where
         }
     }
 
-    pub async fn then_disconnects(&mut self) {
+    pub async fn then_gets_disconnected(&mut self) {
         self.assert_disconnected_with_timeout(DEFAULT_TIMEOUT).await;
     }
 
-    pub async fn assert_disconnected_with_timeout(&mut self, timeout: Duration) {
+    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,5 +1,6 @@
 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

@@ -0,0 +1,12 @@
+use crate::common::test_messages::TestMessage;
+use hotfix::session::SessionRef;
+
+pub trait SessionActions {
+    async fn when_disconnect_is_requested(&self);
+}
+
+impl SessionActions for SessionRef<TestMessage> {
+    async fn when_disconnect_is_requested(&self) {
+        self.disconnect("Test Session Finished".to_string()).await;
+    }
+}

crates/hotfix/tests/common/session_assertions.rs

@@ -6,17 +6,16 @@ pub const DEFAULT_TIMEOUT: Duration = Duration::from_millis(50);
 
 pub trait SessionAssertions {
     async fn then_status_changes_to(&self, expected_status: Status);
-    async fn assert_status_with_timeout(&self, expected_status: Status, timeout: Duration);
-    async fn when_disconnected(&self);
+    async fn then_status_changes_within_time(&self, expected_status: Status, timeout: Duration);
 }
 
 impl SessionAssertions for SessionRef<TestMessage> {
     async fn then_status_changes_to(&self, expected_status: Status) {
-        self.assert_status_with_timeout(expected_status, DEFAULT_TIMEOUT)
+        self.then_status_changes_within_time(expected_status, DEFAULT_TIMEOUT)
             .await;
     }
 
-    async fn assert_status_with_timeout(&self, expected_status: Status, timeout: Duration) {
+    async fn then_status_changes_within_time(&self, expected_status: Status, timeout: Duration) {
         let deadline = tokio::time::Instant::now() + timeout;
         let retry_interval = Duration::from_millis(5);
 
@@ -34,8 +33,4 @@ impl SessionAssertions for SessionRef<TestMessage> {
             "session did not reach expected status within timeout. Expected: {expected_status:?}, Actual: {actual_status:?}"
         );
     }
-
-    async fn when_disconnected(&self) {
-        self.disconnect("Test Session Finished".to_string()).await;
-    }
 }

crates/hotfix/tests/session_test_cases/heartbeat_tests.rs

@@ -1,14 +1,11 @@
+use crate::common::session_actions::SessionActions;
 use crate::common::session_assertions::SessionAssertions;
 use crate::common::setup::{HEARTBEAT_INTERVAL, setup};
 use hotfix::session::Status;
 use hotfix_message::Part;
 use hotfix_message::fix44::MSG_TYPE;
 use std::time::Duration;
 
-async fn when_time_advances(duration: Duration) {
-    tokio::time::advance(duration).await;
-}
-
 /// Tests the automatic heartbeat mechanism in an active FIX session:
 /// 1. Establishes a session by exchanging logon messages with the counterparty
 /// 2. Advances time beyond the configured heartbeat interval
@@ -31,13 +28,13 @@ async fn test_heartbeats() {
     session.then_status_changes_to(Status::Active).await;
 
     // let's wait enough time for a heartbeat and assert that the heartbeat was sent
-    when_time_advances(Duration::from_secs(HEARTBEAT_INTERVAL + 1)).await;
+    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"))
         .await;
 
-    session.when_disconnected().await;
-    mock_counterparty.then_disconnects().await;
+    session.when_disconnect_is_requested().await;
+    mock_counterparty.then_gets_disconnected().await;
 }
 
 /// Tests the peer timeout and disconnection mechanism:
@@ -65,19 +62,23 @@ async fn test_peer_timeout() {
     session.then_status_changes_to(Status::Active).await;
 
     // let's wait enough time for a heartbeat and assert that the heartbeat was sent
-    when_time_advances(Duration::from_secs(HEARTBEAT_INTERVAL + 1)).await;
+    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"))
         .await;
 
     // we wait enough time for the peer deadline to pass
-    when_time_advances(Duration::from_secs(peer_interval - HEARTBEAT_INTERVAL)).await;
+    when_time_elapses(Duration::from_secs(peer_interval - HEARTBEAT_INTERVAL)).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"))
         .await;
 
     // we wait even longer and the counterparty never responds, so we disconnect from the counterparty
-    when_time_advances(Duration::from_secs(peer_interval)).await;
-    mock_counterparty.then_disconnects().await;
+    when_time_elapses(Duration::from_secs(peer_interval)).await;
+    mock_counterparty.then_gets_disconnected().await;
+}
+
+async fn when_time_elapses(duration: Duration) {
+    tokio::time::advance(duration).await;
 }

crates/hotfix/tests/session_test_cases/logon_tests.rs

@@ -1,3 +1,4 @@
+use crate::common::session_actions::SessionActions;
 use crate::common::session_assertions::SessionAssertions;
 use crate::common::setup::setup;
 use hotfix::session::Status;
@@ -19,6 +20,6 @@ async fn test_happy_logon() {
     mock_counterparty.when_logon_is_sent().await;
     session.then_status_changes_to(Status::Active).await;
 
-    session.when_disconnected().await;
-    mock_counterparty.then_disconnects().await;
+    session.when_disconnect_is_requested().await;
+    mock_counterparty.then_gets_disconnected().await;
 }