From a7288cc6121f64a22d8fa5754c3eaec4681b32c2 Mon Sep 17 00:00:00 2001 From: Nils Andreas Svee Date: Sun, 17 May 2026 00:17:10 +0700 Subject: [PATCH] test(client): extract backend smoke tests into a dedicated module --- crates/irtt-client/tests/protocol_options.rs | 161 +----------------- .../tests/protocol_options/backend_smoke.rs | 158 +++++++++++++++++ 2 files changed, 163 insertions(+), 156 deletions(-) create mode 100644 crates/irtt-client/tests/protocol_options/backend_smoke.rs diff --git a/crates/irtt-client/tests/protocol_options.rs b/crates/irtt-client/tests/protocol_options.rs index fe29873..8e696ee 100644 --- a/crates/irtt-client/tests/protocol_options.rs +++ b/crates/irtt-client/tests/protocol_options.rs @@ -1,4 +1,7 @@ mod support; +mod protocol_options { + pub mod backend_smoke; +} use std::time::Duration; @@ -10,8 +13,8 @@ use irtt_proto::{Clock, Params, ReceivedStats, StampAt, TimestampFields}; use support::{ config_for_params, default_params, params_for_modes, run_one_probe, run_one_probe_with_config, - server_fill, standard_timestamps, start_open_server, BackendPeer, OneProbeRun, - ServerObservation, RECV_COUNT, RECV_WINDOW, TOKEN, + server_fill, standard_timestamps, start_open_server, OneProbeRun, ServerObservation, + RECV_COUNT, RECV_WINDOW, TOKEN, }; use crate::support::test_echo_packet_len; @@ -364,46 +367,6 @@ fn assert_one_way_presence( assert_eq!(sample.server_to_client.is_some(), server_to_client); } -#[test] -fn backend_basic_open_echo_close() { - let params = default_params(); - let peer = BackendPeer::start_open_echo(params.clone(), None); - let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); - - let outcome = client.open().unwrap(); - assert!(matches!(outcome, irtt_client::OpenOutcome::Started { .. })); - - let sent = client.send_probe().unwrap(); - assert_eq!(sent.len(), 1); - - let events = client.recv_once().unwrap(); - assert_eq!(events.len(), 1); - assert!(matches!(events[0], ClientEvent::EchoReply { .. })); - - client.close().unwrap(); -} - -#[test] -fn backend_ttl_smoke() { - let params = default_params(); - let peer = BackendPeer::start_open_echo(params.clone(), None); - let mut config = config_for_params(peer.addr(), ¶ms); - config.socket_config.ttl = Some(64); - let mut client = Client::connect(config).unwrap(); - - let outcome = client.open().unwrap(); - assert!(matches!(outcome, irtt_client::OpenOutcome::Started { .. })); - - let sent = client.send_probe().unwrap(); - assert_eq!(sent.len(), 1); - - let events = client.recv_once().unwrap(); - assert_eq!(events.len(), 1); - assert!(matches!(events[0], ClientEvent::EchoReply { .. })); - - client.close().unwrap(); -} - #[test] fn dscp_configured_open_close_smoke() { let mut params = default_params(); @@ -416,117 +379,3 @@ fn dscp_configured_open_close_smoke() { client.close().unwrap(); server.join(); } - -#[test] -fn backend_received_stats_smoke() { - for mode in [ - ReceivedStats::None, - ReceivedStats::Count, - ReceivedStats::Window, - ReceivedStats::Both, - ] { - let params = params_for_modes(mode, StampAt::None, Clock::Both); - let peer = BackendPeer::start_open_echo(params.clone(), None); - let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); - - client.open().unwrap(); - client.send_probe().unwrap(); - let events = client.recv_once().unwrap(); - assert_eq!(events.len(), 1); - assert!(matches!(events[0], ClientEvent::EchoReply { .. })); - - client.close().unwrap(); - } -} - -#[test] -fn backend_timestamp_smoke() { - for mode in [ - StampAt::None, - StampAt::Send, - StampAt::Receive, - StampAt::Both, - StampAt::Midpoint, - ] { - let params = params_for_modes(ReceivedStats::None, mode, Clock::Both); - let peer = BackendPeer::start_open_echo(params.clone(), None); - let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); - - client.open().unwrap(); - client.send_probe().unwrap(); - let events = client.recv_once().unwrap(); - assert_eq!(events.len(), 1); - - match &events[0] { - ClientEvent::EchoReply { - server_timing, - one_way, - .. - } => match mode { - StampAt::None => { - assert!(server_timing.is_none()); - assert!(one_way.is_none()); - } - StampAt::Send => { - let st = server_timing.as_ref().unwrap(); - assert!(st.send_wall_ns.is_some() || st.send_mono_ns.is_some()); - } - StampAt::Receive => { - let st = server_timing.as_ref().unwrap(); - assert!(st.receive_wall_ns.is_some() || st.receive_mono_ns.is_some()); - } - StampAt::Both => { - let st = server_timing.as_ref().unwrap(); - assert!(st.receive_wall_ns.is_some() || st.receive_mono_ns.is_some()); - assert!(st.send_wall_ns.is_some() || st.send_mono_ns.is_some()); - } - StampAt::Midpoint => { - let st = server_timing.as_ref().unwrap(); - assert!(st.midpoint_wall_ns.is_some() || st.midpoint_mono_ns.is_some()); - } - }, - other => panic!("expected EchoReply, got {other:?}"), - } - - client.close().unwrap(); - } -} - -#[test] -fn backend_clock_smoke() { - for clock in [Clock::Wall, Clock::Monotonic, Clock::Both] { - let params = params_for_modes(ReceivedStats::None, StampAt::Both, clock); - let peer = BackendPeer::start_open_echo(params.clone(), None); - let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); - - client.open().unwrap(); - client.send_probe().unwrap(); - let events = client.recv_once().unwrap(); - assert_eq!(events.len(), 1); - - match &events[0] { - ClientEvent::EchoReply { server_timing, .. } => { - let st = server_timing.as_ref().unwrap(); - match clock { - Clock::Wall => { - assert!(st.receive_wall_ns.is_some()); - assert!(st.send_wall_ns.is_some()); - } - Clock::Monotonic => { - assert!(st.receive_mono_ns.is_some()); - assert!(st.send_mono_ns.is_some()); - } - Clock::Both => { - assert!(st.receive_wall_ns.is_some()); - assert!(st.receive_mono_ns.is_some()); - assert!(st.send_wall_ns.is_some()); - assert!(st.send_mono_ns.is_some()); - } - } - } - other => panic!("expected EchoReply, got {other:?}"), - } - - client.close().unwrap(); - } -} diff --git a/crates/irtt-client/tests/protocol_options/backend_smoke.rs b/crates/irtt-client/tests/protocol_options/backend_smoke.rs new file mode 100644 index 0000000..ffd040a --- /dev/null +++ b/crates/irtt-client/tests/protocol_options/backend_smoke.rs @@ -0,0 +1,158 @@ +use irtt_client::{Client, ClientEvent}; +use irtt_proto::{Clock, ReceivedStats, StampAt}; + +use crate::support::{config_for_params, default_params, params_for_modes, BackendPeer}; + +#[test] +fn backend_basic_open_echo_close() { + let params = default_params(); + let peer = BackendPeer::start_open_echo(params.clone(), None); + let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); + + let outcome = client.open().unwrap(); + assert!(matches!(outcome, irtt_client::OpenOutcome::Started { .. })); + + let sent = client.send_probe().unwrap(); + assert_eq!(sent.len(), 1); + + let events = client.recv_once().unwrap(); + assert_eq!(events.len(), 1); + assert!(matches!(events[0], ClientEvent::EchoReply { .. })); + + client.close().unwrap(); +} + +#[test] +fn backend_ttl_smoke() { + let params = default_params(); + let peer = BackendPeer::start_open_echo(params.clone(), None); + let mut config = config_for_params(peer.addr(), ¶ms); + config.socket_config.ttl = Some(64); + let mut client = Client::connect(config).unwrap(); + + let outcome = client.open().unwrap(); + assert!(matches!(outcome, irtt_client::OpenOutcome::Started { .. })); + + let sent = client.send_probe().unwrap(); + assert_eq!(sent.len(), 1); + + let events = client.recv_once().unwrap(); + assert_eq!(events.len(), 1); + assert!(matches!(events[0], ClientEvent::EchoReply { .. })); + + client.close().unwrap(); +} + +#[test] +fn backend_received_stats_smoke() { + for mode in [ + ReceivedStats::None, + ReceivedStats::Count, + ReceivedStats::Window, + ReceivedStats::Both, + ] { + let params = params_for_modes(mode, StampAt::None, Clock::Both); + let peer = BackendPeer::start_open_echo(params.clone(), None); + let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); + + client.open().unwrap(); + client.send_probe().unwrap(); + let events = client.recv_once().unwrap(); + assert_eq!(events.len(), 1); + assert!(matches!(events[0], ClientEvent::EchoReply { .. })); + + client.close().unwrap(); + } +} + +#[test] +fn backend_timestamp_smoke() { + for mode in [ + StampAt::None, + StampAt::Send, + StampAt::Receive, + StampAt::Both, + StampAt::Midpoint, + ] { + let params = params_for_modes(ReceivedStats::None, mode, Clock::Both); + let peer = BackendPeer::start_open_echo(params.clone(), None); + let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); + + client.open().unwrap(); + client.send_probe().unwrap(); + let events = client.recv_once().unwrap(); + assert_eq!(events.len(), 1); + + match &events[0] { + ClientEvent::EchoReply { + server_timing, + one_way, + .. + } => match mode { + StampAt::None => { + assert!(server_timing.is_none()); + assert!(one_way.is_none()); + } + StampAt::Send => { + let st = server_timing.as_ref().unwrap(); + assert!(st.send_wall_ns.is_some() || st.send_mono_ns.is_some()); + } + StampAt::Receive => { + let st = server_timing.as_ref().unwrap(); + assert!(st.receive_wall_ns.is_some() || st.receive_mono_ns.is_some()); + } + StampAt::Both => { + let st = server_timing.as_ref().unwrap(); + assert!(st.receive_wall_ns.is_some() || st.receive_mono_ns.is_some()); + assert!(st.send_wall_ns.is_some() || st.send_mono_ns.is_some()); + } + StampAt::Midpoint => { + let st = server_timing.as_ref().unwrap(); + assert!(st.midpoint_wall_ns.is_some() || st.midpoint_mono_ns.is_some()); + } + }, + other => panic!("expected EchoReply, got {other:?}"), + } + + client.close().unwrap(); + } +} + +#[test] +fn backend_clock_smoke() { + for clock in [Clock::Wall, Clock::Monotonic, Clock::Both] { + let params = params_for_modes(ReceivedStats::None, StampAt::Both, clock); + let peer = BackendPeer::start_open_echo(params.clone(), None); + let mut client = Client::connect(config_for_params(peer.addr(), ¶ms)).unwrap(); + + client.open().unwrap(); + client.send_probe().unwrap(); + let events = client.recv_once().unwrap(); + assert_eq!(events.len(), 1); + + match &events[0] { + ClientEvent::EchoReply { server_timing, .. } => { + let st = server_timing.as_ref().unwrap(); + match clock { + Clock::Wall => { + assert!(st.receive_wall_ns.is_some()); + assert!(st.send_wall_ns.is_some()); + } + Clock::Monotonic => { + assert!(st.receive_mono_ns.is_some()); + assert!(st.send_mono_ns.is_some()); + } + Clock::Both => { + assert!(st.receive_wall_ns.is_some()); + assert!(st.receive_mono_ns.is_some()); + assert!(st.send_wall_ns.is_some()); + assert!(st.send_mono_ns.is_some()); + } + } + } + other => panic!("expected EchoReply, got {other:?}"), + } + + client.close().unwrap(); + } +}