refactor(client): make configuration reusable across endpoints

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

@@ -3,9 +3,7 @@ mod support;
 
 use std::time::Duration;
 
-use irtt_client::{
-    Client, ClientConfig, ClientError, ClientEvent, OpenOutcome, SocketConfig, WarningKind,
-};
+use irtt_client::{Client, ClientConfig, ClientError, ClientEvent, OpenOutcome, WarningKind};
 use irtt_proto::TimestampFields;
 
 use support::{
@@ -27,9 +25,9 @@ fn hmac_open_success_negotiates_without_warnings() {
         params.clone(),
         TimestampFields::default(),
         Some(key),
-        |addr| ClientConfig {
+        || ClientConfig {
             auth: Authentication::Hmac(HmacKey::new(config_key)),
-            ..config_for_params(addr, &config_params)
+            ..config_for_params(&config_params)
         },
     );
 
@@ -51,10 +49,10 @@ fn hmac_echo_success_verifies_request_and_accepts_reply() {
     let config_params = params.clone();
     let config_key = key.clone();
 
-    let run = run_one_probe_with_config(params.clone(), standard_timestamps(), Some(key), |addr| {
+    let run = run_one_probe_with_config(params.clone(), standard_timestamps(), Some(key), || {
         ClientConfig {
             auth: Authentication::Hmac(HmacKey::new(config_key)),
-            ..config_for_params(addr, &config_params)
+            ..config_for_params(&config_params)
         }
     });
 
@@ -94,10 +92,13 @@ fn hmac_close_success_sends_authenticated_close_and_closes_session() {
     let key = b"compat-secret".to_vec();
     let params = default_params();
     let server = start_hmac_close_server(params.clone(), key.clone());
-    let mut config = config_for_params(server.addr, &params);
+    let mut config = config_for_params(&params);
     config.auth = Authentication::Hmac(HmacKey::new(key));
 
-    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(500)))
+        .unwrap();
     let outcome = client.open().unwrap();
     assert_started(outcome, &params);
 
@@ -134,13 +135,16 @@ fn hmac_required_server_rejects_missing_or_wrong_client_key() {
     ] {
         let server_key = b"compat-secret".to_vec();
         let server = start_hmac_required_open_drop_server(server_key, Duration::from_millis(250));
-        let mut config = config_for_params(server.addr, &default_params());
-        config.open_timeouts = vec![Duration::from_millis(200)];
+        let mut config = config_for_params(&default_params());
+        config.open.timeouts = vec![Duration::from_millis(200)];
         config.auth = hmac_key.map_or(Authentication::Unauthenticated, |key| {
             Authentication::Hmac(HmacKey::new(key))
         });
 
-        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(500)))
+            .unwrap();
         assert!(matches!(client.open(), Err(ClientError::OpenTimeout)));
 
         let observations = server.observations(1);
@@ -160,14 +164,13 @@ fn bad_hmac_echo_reply_is_rejected_without_echo_reply_event() {
     let key = b"compat-secret".to_vec();
     let params = default_params();
     let server = start_bad_hmac_echo_reply_server(params.clone(), key.clone());
-    let mut config = config_for_params(server.addr, &params);
+    let mut config = config_for_params(&params);
     config.auth = Authentication::Hmac(HmacKey::new(key));
-    config.socket_config = SocketConfig {
-        recv_timeout: Some(Duration::from_millis(500)),
-        ..Default::default()
-    };
 
-    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(500)))
+        .unwrap();
     let outcome = client.open().unwrap();
     assert_started(outcome, &params);
 
@@ -207,10 +210,13 @@ fn hmac_open_reply_with_bad_hmac_is_ignored_until_timeout() {
     let wrong_key = b"wrong-secret".to_vec();
     let params = default_params();
     let server = support::start_bad_hmac_open_reply_server(params.clone(), key.clone(), wrong_key);
-    let mut config = config_for_params(server.addr, &params);
+    let mut config = config_for_params(&params);
     config.auth = Authentication::Hmac(HmacKey::new(key));
 
-    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(500)))
+        .unwrap();
     assert!(matches!(client.open(), Err(ClientError::OpenTimeout)));
     server.join();
 }
@@ -223,10 +229,13 @@ fn non_hmac_client_open_does_not_set_hmac_flag() {
         irtt_proto::Clock::Both,
     );
     let server = support::start_open_server(params.clone(), None);
-    let mut config = config_for_params(server.addr, &params);
+    let mut config = config_for_params(&params);
     config.auth = Authentication::Unauthenticated;
 
-    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(500)))
+        .unwrap();
     let outcome = client.open().unwrap();
     assert_started(outcome, &params);
 
@@ -280,10 +289,13 @@ fn backend_hmac_correct_key_succeeds() {
     let key = b"compat-secret".to_vec();
     let params = default_params();
     let peer = BackendPeer::start_open_echo(Some(key.clone()));
-    let mut config = config_for_params(peer.addr(), &params);
+    let mut config = config_for_params(&params);
     config.auth = Authentication::Hmac(HmacKey::new(key));
 
-    let mut client = Client::connect(config).unwrap();
+    let mut client = Client::connect(peer.addr().to_string(), config).unwrap();
+    client
+        .set_recv_timeout(Some(Duration::from_millis(500)))
+        .unwrap();
     let outcome = client.open().unwrap();
     assert!(matches!(outcome, OpenOutcome::Started { .. }));
 
@@ -302,13 +314,16 @@ fn backend_hmac_required_rejects_missing_or_wrong_client_key() {
     for hmac_key in [None, Some(b"wrong-secret".to_vec())] {
         let server_key = b"compat-secret".to_vec();
         let peer = BackendPeer::start_hmac_required(server_key);
-        let mut config = config_for_params(peer.addr(), &default_params());
-        config.open_timeouts = vec![Duration::from_millis(200)];
+        let mut config = config_for_params(&default_params());
+        config.open.timeouts = vec![Duration::from_millis(200)];
         config.auth = hmac_key.map_or(Authentication::Unauthenticated, |key| {
             Authentication::Hmac(HmacKey::new(key))
         });
 
-        let mut client = Client::connect(config).unwrap();
+        let mut client = Client::connect(peer.addr().to_string(), config).unwrap();
+        client
+            .set_recv_timeout(Some(Duration::from_millis(500)))
+            .unwrap();
         assert!(matches!(client.open(), Err(ClientError::OpenTimeout)));
     }
 }