refactor(client): make configuration reusable across endpoints

crates/irtt-client/tests/client/close.rs

@@ -9,9 +9,12 @@ fn operations_fail_after_local_close_without_datagrams() {
         socket.send_to(&reply, peer).unwrap();
         let _ = recv_request(&socket, &tx);
     });
-    let mut config = default_test_config(server.addr);
-    config.socket_config.recv_timeout = Some(Duration::from_millis(50));
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.close().unwrap();
     assert!(matches!(client.open(), Err(ClientError::AlreadyClosed)));
@@ -52,7 +55,7 @@ fn send_probe_fails_after_close() {
             }
         }
     });
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
     assert_open_started(client.open().unwrap());
     client.close().unwrap();
     assert!(matches!(
@@ -89,7 +92,7 @@ fn recv_available_stops_after_peer_close() {
             socket.send_to(&close, peer).unwrap();
         }
     });
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
 
@@ -137,14 +140,10 @@ fn close_flagged_duplicate_emits_duplicate_then_closes() {
             socket.send_to(&close, peer).unwrap();
         }
     });
-    let mut client = Client::connect(ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    })
-    .unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
 
@@ -194,15 +193,17 @@ fn close_flagged_retained_timeout_emits_late_then_closes() {
                 .unwrap();
         }
     });
-    let mut client = Client::connect(ClientConfig {
-        probe_timeout: Duration::from_millis(50),
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
+    let mut client = Client::connect(
+        server.addr.to_string(),
+        ClientConfig {
+            probe_timeout: Duration::from_millis(50),
+            ..default_test_config()
         },
-        ..default_test_config(server.addr)
-    })
+    )
     .unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     let sent = client.send_probe().unwrap();
     let ClientEvent::EchoSent { sent_at, .. } = &sent[0] else {
@@ -289,15 +290,17 @@ fn close_flagged_evicted_sequence_emits_late_then_closes() {
                 .unwrap();
         }
     });
-    let mut client = Client::connect(ClientConfig {
-        max_pending_probes: 1,
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
+    let mut client = Client::connect(
+        server.addr.to_string(),
+        ClientConfig {
+            max_pending_probes: 1,
+            ..default_test_config()
         },
-        ..default_test_config(server.addr)
-    })
+    )
     .unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
 
     client.send_probe().unwrap();
@@ -354,14 +357,10 @@ fn close_flagged_untracked_sequence_emits_warning_then_closes() {
                 .unwrap();
         }
     });
-    let mut client = Client::connect(ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    })
-    .unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
 
     assert!(matches!(
@@ -412,14 +411,10 @@ fn wrong_token_close_flag_does_not_close_session() {
             let _ = recv_request(&socket, &tx);
         }
     });
-    let mut client = Client::connect(ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    })
-    .unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
 
@@ -467,14 +462,11 @@ fn close_flagged_echo_reply_emits_reply_then_closes_without_sending_close() {
             while recv_request_timeout(&socket, &tx).is_some() {}
         }
     });
-    let config = ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    };
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
 

crates/irtt-client/tests/client/config.rs

@@ -8,7 +8,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "oversized UDP payload",
             ClientConfig {
-                length: MAX_UDP_PAYLOAD_LENGTH + 1,
+                request: SessionRequest {
+                    length: MAX_UDP_PAYLOAD_LENGTH + 1,
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "packet length",
@@ -16,7 +19,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "zero finite duration",
             ClientConfig {
-                duration: Some(Duration::ZERO),
+                request: SessionRequest {
+                    duration: Some(Duration::ZERO),
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "duration must be greater than zero; use None for continuous mode",
@@ -24,7 +30,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "zero interval",
             ClientConfig {
-                interval: Duration::ZERO,
+                request: SessionRequest {
+                    interval: Duration::ZERO,
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "interval must be greater than zero",
@@ -32,7 +41,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "duration nanosecond overflow",
             ClientConfig {
-                duration: Some(too_large),
+                request: SessionRequest {
+                    duration: Some(too_large),
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "duration is too large to encode as nanoseconds",
@@ -40,7 +52,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "interval nanosecond overflow",
             ClientConfig {
-                interval: too_large,
+                request: SessionRequest {
+                    interval: too_large,
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "interval is too large to encode as nanoseconds",
@@ -48,7 +63,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "invalid DSCP codepoint",
             ClientConfig {
-                dscp: 64,
+                request: SessionRequest {
+                    dscp: 64,
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "dscp",
@@ -58,7 +76,10 @@ fn connect_rejects_invalid_configuration() {
             // client mode; a client that needs timestamps must name a clock.
             "unspecified clock",
             ClientConfig {
-                clock: Clock::Unspecified,
+                request: SessionRequest {
+                    clock: Clock::Unspecified,
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "clock must be wall, monotonic, or both",
@@ -66,7 +87,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "empty server fill",
             ClientConfig {
-                server_fill: Some("".to_owned()),
+                request: SessionRequest {
+                    server_fill: Some("".to_owned()),
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "server_fill",
@@ -74,7 +98,10 @@ fn connect_rejects_invalid_configuration() {
         (
             "oversized server fill",
             ClientConfig {
-                server_fill: Some("0123456789abcdef0123456789abcdefx".to_owned()),
+                request: SessionRequest {
+                    server_fill: Some("0123456789abcdef0123456789abcdefx".to_owned()),
+                    ..Default::default()
+                },
                 ..ClientConfig::default()
             },
             "server_fill",
@@ -84,7 +111,7 @@ fn connect_rejects_invalid_configuration() {
     for (name, config, expected_reason) in cases {
         assert!(
             matches!(
-                Client::connect(config),
+                Client::connect("127.0.0.1:2112", config),
                 Err(ClientError::InvalidConfig { .. })
             ),
             "{name} should fail with InvalidConfig ({expected_reason})"
@@ -95,11 +122,14 @@ fn connect_rejects_invalid_configuration() {
 #[test]
 fn minimum_open_timeout_under_200ms_is_rejected() {
     let config = ClientConfig {
-        open_timeouts: vec![Duration::from_millis(199)],
+        open: OpenPolicy {
+            timeouts: vec![Duration::from_millis(199)],
+            ..Default::default()
+        },
         ..ClientConfig::default()
     };
     assert!(matches!(
-        Client::connect(config),
+        Client::connect("127.0.0.1:2112", config),
         Err(ClientError::OpenTimeoutTooSmall { .. })
     ));
 }
@@ -107,11 +137,14 @@ fn minimum_open_timeout_under_200ms_is_rejected() {
 #[test]
 fn empty_open_timeouts_is_rejected() {
     let config = ClientConfig {
-        open_timeouts: vec![],
+        open: OpenPolicy {
+            timeouts: vec![],
+            ..Default::default()
+        },
         ..ClientConfig::default()
     };
     assert!(matches!(
-        Client::connect(config),
+        Client::connect("127.0.0.1:2112", config),
         Err(ClientError::NoOpenTimeouts)
     ));
 }

crates/irtt-client/tests/client/hmac.rs

@@ -4,7 +4,7 @@ use irtt_client::{Authentication, HmacKey};
 #[test]
 fn hmac_open_ignores_missing_hmac_before_valid_reply() {
     let key = b"secret".to_vec();
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    let mut config = default_test_config();
     config.auth = Authentication::Hmac(HmacKey::new(key.clone()));
     let params = default_params();
     let server = start_fake_server(move |socket, tx| {
@@ -14,8 +14,7 @@ fn hmac_open_ignores_missing_hmac_before_valid_reply() {
         socket.send_to(&missing, peer).unwrap();
         socket.send_to(&valid, peer).unwrap();
     });
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     assert_open_started(client.open().unwrap());
     assert_eq!(server.rx.iter().take(1).count(), 1);
     assert!(server.rx.try_recv().is_err());
@@ -26,7 +25,7 @@ fn hmac_open_ignores_missing_hmac_before_valid_reply() {
 fn hmac_open_ignores_bad_hmac_before_valid_reply() {
     let key = b"secret".to_vec();
     let wrong_key = b"wrong".to_vec();
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    let mut config = default_test_config();
     config.auth = Authentication::Hmac(HmacKey::new(key.clone()));
     let params = default_params();
     let server = start_fake_server(move |socket, tx| {
@@ -36,8 +35,7 @@ fn hmac_open_ignores_bad_hmac_before_valid_reply() {
         socket.send_to(&bad, peer).unwrap();
         socket.send_to(&valid, peer).unwrap();
     });
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     assert_open_started(client.open().unwrap());
     assert_eq!(server.rx.iter().take(1).count(), 1);
     assert!(server.rx.try_recv().is_err());
@@ -47,7 +45,7 @@ fn hmac_open_ignores_bad_hmac_before_valid_reply() {
 #[test]
 fn post_token_hmac_negotiation_failure_sends_authenticated_cleanup_close() {
     let key = b"secret".to_vec();
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
+    let mut config = default_test_config();
     config.auth = Authentication::Hmac(HmacKey::new(key.clone()));
     let mut returned = default_params();
     returned.interval_ns += 1;
@@ -58,8 +56,7 @@ fn post_token_hmac_negotiation_failure_sends_authenticated_cleanup_close() {
         socket.send_to(&reply, peer).unwrap();
         let _ = recv_request(&socket, &tx);
     });
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
 
     assert!(matches!(
         client.open(),

crates/irtt-client/tests/client/no_test.rs

@@ -2,8 +2,8 @@ use super::*;
 
 #[test]
 fn no_test_rejects_non_close_open_reply() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.run_mode = RunMode::NoTest;
+    let mut config = default_test_config();
+    config.request.run_mode = RunMode::NoTest;
     let params = default_params();
     let server = start_fake_server(move |socket, tx| {
         let (_, peer) = recv_request(&socket, &tx);
@@ -15,8 +15,7 @@ fn no_test_rejects_non_close_open_reply() {
             .unwrap();
         let _ = recv_request(&socket, &tx);
     });
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     assert!(matches!(
         client.open(),
         Err(ClientError::UnexpectedNoTestReply)
@@ -32,12 +31,11 @@ fn no_test_rejects_non_close_open_reply() {
 
 #[test]
 fn no_test_rejects_non_zero_token_with_close_reply() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.run_mode = RunMode::NoTest;
+    let mut config = default_test_config();
+    config.request.run_mode = RunMode::NoTest;
     let params = default_params();
     let server = no_test_server(params, TOKEN);
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     assert!(matches!(
         client.open(),
         Err(ClientError::NonZeroNoTestToken { token: TOKEN })
@@ -47,13 +45,12 @@ fn no_test_rejects_non_zero_token_with_close_reply() {
 
 #[test]
 fn no_test_strict_negotiation_rejects_changed_params() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.run_mode = RunMode::NoTest;
+    let mut config = default_test_config();
+    config.request.run_mode = RunMode::NoTest;
     let mut params = default_params();
     params.dscp = 1;
     let server = no_test_server(params, 0);
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     assert!(matches!(
         client.open(),
         Err(ClientError::NegotiationRejected { .. })
@@ -63,15 +60,14 @@ fn no_test_strict_negotiation_rejects_changed_params() {
 
 #[test]
 fn no_test_loose_negotiation_accepts_restricted_params() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.run_mode = RunMode::NoTest;
-    config.negotiation_policy = NegotiationPolicy::Loose;
+    let mut config = default_test_config();
+    config.request.run_mode = RunMode::NoTest;
+    config.open.negotiation = NegotiationPolicy::Loose;
     let requested = default_params();
     let mut params = requested.clone();
     params.duration_ns /= 2;
     let server = no_test_server(params.clone(), 0);
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     let negotiated = assert_no_test_completed(client.open().unwrap());
     assert_eq!(negotiated.params, params);
     assert_eq!(
@@ -86,12 +82,11 @@ fn no_test_loose_negotiation_accepts_restricted_params() {
 
 #[test]
 fn send_probe_fails_after_no_test_completed() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.run_mode = RunMode::NoTest;
+    let mut config = default_test_config();
+    config.request.run_mode = RunMode::NoTest;
     let params = default_params();
     let server = no_test_server(params, 0);
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     assert_no_test_completed(client.open().unwrap());
     assert!(matches!(
         client.send_probe(),
@@ -102,13 +97,15 @@ fn send_probe_fails_after_no_test_completed() {
 
 #[test]
 fn operations_fail_after_no_test_completed_without_datagrams() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.run_mode = RunMode::NoTest;
-    config.socket_config.recv_timeout = Some(Duration::from_millis(50));
+    let mut config = default_test_config();
+    config.request.run_mode = RunMode::NoTest;
+
     let params = default_params();
     let server = no_test_server(params, 0);
-    config.server_addr = server.addr.to_string();
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
     assert_no_test_completed(client.open().unwrap());
     assert!(matches!(client.open(), Err(ClientError::AlreadyCompleted)));
     let results = [

crates/irtt-client/tests/client/open.rs

@@ -3,10 +3,13 @@ use super::*;
 #[test]
 fn receive_before_open_returns_not_open_without_datagrams() {
     let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
-    let mut config = default_test_config(peer.local_addr().unwrap());
+    let config = default_test_config();
     // Bound the old implementation's blocking receive without sending a packet.
-    config.socket_config.recv_timeout = Some(Duration::from_millis(50));
-    let mut client = Client::connect(config).unwrap();
+
+    let mut client = Client::connect(peer.local_addr().unwrap().to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
 
     let results = [
         client.recv_once(),
@@ -35,10 +38,13 @@ fn loose_open_rejects_nonpositive_returned_intervals() {
         returned.interval_ns = interval_ns;
         let server = open_success_server(returned);
         let config = ClientConfig {
-            negotiation_policy: NegotiationPolicy::Loose,
-            ..default_test_config(server.addr)
+            open: OpenPolicy {
+                negotiation: NegotiationPolicy::Loose,
+                ..default_test_config().open
+            },
+            ..default_test_config()
         };
-        let mut client = Client::connect(config).unwrap();
+        let mut client = Client::connect(server.addr.to_string(), config).unwrap();
         assert!(
             matches!(client.open(), Err(ClientError::NegotiationRejected { .. })),
             "returned interval {interval_ns} must be rejected"
@@ -51,7 +57,7 @@ fn loose_open_rejects_nonpositive_returned_intervals() {
 fn open_fails_when_already_open() {
     let params = default_params();
     let server = open_success_server(params);
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
     assert_open_started(client.open().unwrap());
     assert!(matches!(client.open(), Err(ClientError::AlreadyOpen)));
     server.join();
@@ -68,10 +74,13 @@ fn open_retries_after_first_timeout() {
         socket.send_to(&reply, peer).unwrap();
     });
     let config = ClientConfig {
-        open_timeouts: vec![Duration::from_millis(200), Duration::from_millis(500)],
-        ..default_test_config(server.addr)
+        open: OpenPolicy {
+            timeouts: vec![Duration::from_millis(200), Duration::from_millis(500)],
+            ..default_test_config().open
+        },
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     let outcome = client.open().unwrap();
     assert_open_started(outcome);
     assert_eq!(server.rx.iter().take(2).count(), 2);
@@ -80,12 +89,12 @@ fn open_retries_after_first_timeout() {
 
 #[test]
 fn protocol_version_mismatch_fails() {
-    let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
-    config.negotiation_policy = NegotiationPolicy::Loose;
+    let mut config = default_test_config();
+    config.open.negotiation = NegotiationPolicy::Loose;
     let mut params = default_params();
     params.protocol_version = 2;
     let server = open_success_server(params);
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
     assert!(matches!(
         client.open(),
         Err(ClientError::ProtocolVersionMismatch { received: 2, .. })
@@ -102,7 +111,7 @@ fn server_rejection_fails_in_normal_mode() {
         let reply = open_reply(FLAG_OPEN | FLAG_REPLY | flags::FLAG_CLOSE, 0, &params, None);
         socket.send_to(&reply, peer).unwrap();
     });
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
     assert!(matches!(client.open(), Err(ClientError::ServerRejected)));
     assert_eq!(server.rx.iter().take(1).count(), 1);
     server.join();
@@ -119,10 +128,13 @@ fn ignored_datagrams_do_not_restart_the_attempt_deadline() {
         let _ = recv_request(&socket, &tx);
     });
     let config = ClientConfig {
-        open_timeouts: vec![Duration::from_millis(250), Duration::from_millis(250)],
-        ..default_test_config(server.addr)
+        open: OpenPolicy {
+            timeouts: vec![Duration::from_millis(250), Duration::from_millis(250)],
+            ..default_test_config().open
+        },
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     let started = Instant::now();
 
     assert!(matches!(client.open(), Err(ClientError::OpenTimeout)));
@@ -139,10 +151,13 @@ fn ignored_datagrams_do_not_restart_the_attempt_deadline() {
 fn opening_deadline_overflow_occurs_before_send() {
     let server = timeout_server(Duration::from_millis(250));
     let config = ClientConfig {
-        open_timeouts: vec![Duration::MAX],
-        ..default_test_config(server.addr)
+        open: OpenPolicy {
+            timeouts: vec![Duration::MAX],
+            ..default_test_config().open
+        },
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
 
     assert!(matches!(client.open(), Err(ClientError::DurationOverflow)));
     assert!(server.rx.try_recv().is_err());
@@ -163,7 +178,7 @@ fn post_token_negotiation_failure_sends_cleanup_close() {
             .unwrap();
         let _ = recv_request(&socket, &tx);
     });
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
 
     assert!(matches!(
         client.open(),
@@ -182,14 +197,16 @@ fn post_token_negotiation_failure_sends_cleanup_close() {
 fn open_timeout_after_all_timeouts() {
     let server = timeout_server(Duration::from_millis(700));
     let config = ClientConfig {
-        open_timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(50)),
-            ..Default::default()
+        open: OpenPolicy {
+            timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
+            ..default_test_config().open
         },
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
     assert!(matches!(client.open(), Err(ClientError::OpenTimeout)));
     assert_eq!(server.rx.iter().take(2).count(), 2);
     server.join();
@@ -221,7 +238,7 @@ fn multiple_untrusted_datagrams_before_valid_reply_use_one_attempt() {
             socket.send_to(&packet, peer).unwrap();
         }
     });
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
 
     assert_open_started(client.open().unwrap());
     assert_eq!(server.rx.iter().take(1).count(), 1);
@@ -241,14 +258,16 @@ fn only_ignored_open_datagrams_eventually_time_out() {
         thread::sleep(Duration::from_millis(300));
     });
     let config = ClientConfig {
-        open_timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(50)),
-            ..Default::default()
+        open: OpenPolicy {
+            timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
+            ..default_test_config().open
         },
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
 
     assert!(matches!(client.open(), Err(ClientError::OpenTimeout)));
     assert_eq!(server.rx.iter().take(2).count(), 2);
@@ -268,7 +287,7 @@ fn trusted_zero_token_normal_reply_is_terminal() {
         reply[HMAC_OFFSET..HMAC_OFFSET + 8].copy_from_slice(&0_u64.to_le_bytes());
         socket.send_to(&reply, peer).unwrap();
     });
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), default_test_config()).unwrap();
 
     assert!(matches!(
         client.open(),

crates/irtt-client/tests/client/probes_replies/packet_length.rs

@@ -23,14 +23,16 @@ fn short_echo_reply_does_not_emit_echo_reply() {
         }
     });
     let config = ClientConfig {
-        length: 64,
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
+        request: SessionRequest {
+            length: 64,
+            ..default_test_config().request
         },
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
 
@@ -69,14 +71,16 @@ fn overlong_datagram_detection_uses_extra_receive_byte() {
         }
     });
     let config = ClientConfig {
-        length: 4096,
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
+        request: SessionRequest {
+            length: 4096,
+            ..default_test_config().request
         },
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
 
@@ -112,14 +116,16 @@ fn exact_length_echo_reply_still_emits_echo_reply() {
         }
     });
     let config = ClientConfig {
-        length: 4096,
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
+        request: SessionRequest {
+            length: 4096,
+            ..default_test_config().request
         },
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
 

crates/irtt-client/tests/client/probes_replies/reply_classification.rs

@@ -22,14 +22,11 @@ fn duplicate_reply_emits_duplicate_event() {
             socket.send_to(&reply_packet, peer).unwrap();
         }
     });
-    let config = ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    };
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
     thread::sleep(Duration::from_millis(50));
@@ -76,14 +73,11 @@ fn out_of_order_reply_emits_late_event() {
         let reply0 = echo_reply_packet(TOKEN, seqs[0], &params, &ts, None);
         socket.send_to(&reply0, peer).unwrap();
     });
-    let config = ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    };
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     client.send_probe().unwrap();
     client.send_probe().unwrap();

crates/irtt-client/tests/client/probes_replies/reply_decode.rs

@@ -4,14 +4,11 @@ use super::*;
 fn recv_once_returns_empty_on_timeout() {
     let params = default_params();
     let server = open_success_server(params);
-    let config = ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(50)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    };
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     let events = client.recv_once().unwrap();
     assert!(events.is_empty());
@@ -52,14 +49,11 @@ fn recv_once_decodes_only_received_bytes_after_longer_datagram() {
         );
         socket.send_to(&shorter, peer).unwrap();
     });
-    let config = ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    };
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
 
     client.send_probe().unwrap();

crates/irtt-client/tests/client/probes_replies/reply_metadata.rs

@@ -19,14 +19,11 @@ fn echo_reply_metadata_propagates_observed_dscp_with_ancillary() {
             echo_reply_packet(TOKEN, seq, &params, &TimestampFields::default(), None);
         socket.send_to(&reply_packet, peer).unwrap();
     });
-    let config = ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    };
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
 
     client.send_probe().unwrap();

crates/irtt-client/tests/client/probes_replies/timeouts.rs

@@ -20,9 +20,9 @@ fn probe_timeout_overflow_transmits_no_echo() {
     });
     let config = ClientConfig {
         probe_timeout: Duration::MAX,
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
     assert_open_started(client.open().unwrap());
     assert!(matches!(
         client.send_probe(),
@@ -46,13 +46,12 @@ fn poll_timeouts_emits_echo_loss() {
     let server = silent_open_server(params);
     let config = ClientConfig {
         probe_timeout: Duration::from_millis(100),
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(50)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
 
     client.send_probe().unwrap();
@@ -97,13 +96,12 @@ fn late_reply_after_timeout_preserves_measurement_metadata() {
     });
     let config = ClientConfig {
         probe_timeout: Duration::from_millis(40),
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
 
     client.send_probe().unwrap();
@@ -157,15 +155,17 @@ fn pending_full_does_not_send_packet() {
     };
     let server = silent_open_server(params);
     let config = ClientConfig {
-        duration: Some(Duration::from_secs(60)),
-        max_pending_probes: 2,
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(50)),
-            ..Default::default()
+        request: SessionRequest {
+            duration: Some(Duration::from_secs(60)),
+            ..SessionRequest::default()
         },
-        ..default_test_config(server.addr)
+        max_pending_probes: 2,
+        ..default_test_config()
     };
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(50)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
 
     client.send_probe().unwrap();

crates/irtt-client/tests/client/support.rs

@@ -25,10 +25,12 @@ impl FakeServer {
     }
 }
 
-pub(super) fn default_test_config(addr: SocketAddr) -> ClientConfig {
+pub(super) fn default_test_config() -> ClientConfig {
     ClientConfig {
-        server_addr: addr.to_string(),
-        open_timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
+        open: OpenPolicy {
+            timeouts: vec![Duration::from_millis(200), Duration::from_millis(200)],
+            ..Default::default()
+        },
         ..ClientConfig::default()
     }
 }
@@ -252,14 +254,11 @@ pub(super) fn assert_no_test_completed(outcome: OpenOutcome) -> NegotiatedParams
 
 pub(super) fn open_client_with_echo_server(params: &Params) -> (Client, FakeServer) {
     let server = echo_server(params.clone());
-    let config = ClientConfig {
-        socket_config: irtt_client::SocketConfig {
-            recv_timeout: Some(Duration::from_millis(200)),
-            ..Default::default()
-        },
-        ..default_test_config(server.addr)
-    };
-    let mut client = Client::connect(config).unwrap();
+    let config = default_test_config();
+    let mut client = Client::connect(server.addr.to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(200)))
+        .unwrap();
     assert_open_started(client.open().unwrap());
     (client, server)
 }

crates/irtt-client/tests/client/ttl.rs

@@ -3,19 +3,19 @@ use super::*;
 #[test]
 fn connect_accepts_valid_ttl_config_values() {
     for ttl in [None, Some(1), Some(255)] {
-        let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 9)));
-        config.socket_config.ttl = ttl;
-        Client::connect(config).unwrap();
+        let mut config = default_test_config();
+        config.socket.ttl = ttl;
+        Client::connect(SocketAddr::from(([127, 0, 0, 1], 9)).to_string(), config).unwrap();
     }
 }
 
 #[test]
 fn connect_rejects_invalid_ttl_values() {
     for ttl in [0, 256] {
-        let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 9)));
-        config.socket_config.ttl = Some(ttl);
+        let mut config = default_test_config();
+        config.socket.ttl = Some(ttl);
         assert!(matches!(
-            Client::connect(config),
+            Client::connect(SocketAddr::from(([127, 0, 0, 1], 9)).to_string(), config),
             Err(ClientError::InvalidConfig { .. })
         ));
     }