Lightweight coding agent that runs in your terminal
Rust
Make remote-control conflict retry tests deterministic (#54647)
jiffa46ef3af641
diff --git a/codex-rs/app-server-transport/src/transport/remote_control/websocket_retry_tests.rs b/codex-rs/app-server-transport/src/transport/remote_control/websocket_retry_tests.rsindex 1a3e673acb..b21671c54b 100644--- a/codex-rs/app-server-transport/src/transport/remote_control/websocket_retry_tests.rs+++ b/codex-rs/app-server-transport/src/transport/remote_control/websocket_retry_tests.rs@@ -13,6 +13,7 @@ use super::*;use crate::transport::remote_control::protocol::normalize_remote_control_url;use pretty_assertions::assert_eq;use tempfile::TempDir;+use tokio::io::AsyncReadExt;use tokio::net::TcpListener;use tokio::time::Duration;use tokio::time::Instant;@@ -62,8 +63,8 @@ async fn assert_conflict_recovery(subscribe_cursor: Option<&str>) {shutdown_token.clone(),Arc::new(enabled_desired_state_sender()),);- // Start at the cap to exercise two consecutive capped waits without spending- // another minute reaching it. Use the real handshake and reconnect loop.+ // Start at the cap and advance the retry waits below. Keep socket I/O on+ // real time so a pending handshake cannot auto-advance its own timeout.websocket.reconnect_attempt = 9;websocket.state.lock().await.subscribe_cursor = subscribe_cursor.map(str::to_string);let connect_task = tokio::spawn(async move {@@ -75,7 +76,7 @@ async fn assert_conflict_recovery(subscribe_cursor: Option<&str>) {let mut rejected_at = None;for attempt in 0..3 {- let (stream, _) = timeout(Duration::from_secs(40), listener.accept())+ let (mut stream, _) = timeout(Duration::from_secs(40), listener.accept()).await.expect("connection should retry within the capped delay").unwrap();@@ -86,7 +87,7 @@ async fn assert_conflict_recovery(subscribe_cursor: Option<&str>) {);}rejected_at = Some(Instant::now());- let result = accept_hdr_async(stream, |request: &Request, response: Response| {+ let result = accept_hdr_async(&mut stream, |request: &Request, response: Response| {assert_eq!(request.uri().path(),"/backend-api/wham/remote/control/server"@@ -104,7 +105,7 @@ async fn assert_conflict_recovery(subscribe_cursor: Option<&str>) {if attempt < 2 {Err(tungstenite::http::Response::builder().status(/*status*/ 409)- .body(Some("Remote app server already online".to_string()))+ .body(/*body*/ None).unwrap())} else {Ok(response)@@ -113,23 +114,28 @@ async fn assert_conflict_recovery(subscribe_cursor: Option<&str>) {.await;if attempt < 2 {assert!(result.is_err());- if attempt == 1 {- assert!(- timeout(Duration::from_secs(1), listener.accept())- .await- .is_err(),- "sustained HTTP 409 responses must not restart fast retries"- );- // The real loop is sleeping after the second rejection. Skip the- // middle of this wait, retaining its boundary assertion below.- tokio::time::pause();- tokio::time::advance(Duration::from_secs(13)).await;- tokio::time::resume();- }+ drop(result);+ // The peer closes the rejected socket while processing the 409.+ // On this current-thread runtime it then enters the retry sleep+ // before we can observe EOF, so the clock advance cannot race it.+ assert_eq!(stream.read(&mut [0]).await.unwrap(), 0);+ tokio::time::pause();+ tokio::time::advance(Duration::from_secs(13)).await;+ tokio::time::resume();+ assert!(+ timeout(Duration::from_secs(1), listener.accept())+ .await+ .is_err(),+ "sustained HTTP 409 responses must not restart fast retries"+ );+ tokio::time::pause();+ tokio::time::advance(Duration::from_secs(17)).await;+ tokio::time::resume();} else {let _server_connection = result.expect("available ownership should allow recovery");let (mut websocket, outcome) = connect_task.await.unwrap();assert!(matches!(outcome, ConnectOutcome::Connected(_)));+ assert_eq!(websocket.reconnect_attempt, 11);assert!(next_reconnect_delay(&mut websocket.reconnect_attempt) >= Duration::from_secs(15),"a successful handshake must not reset backoff before the connection stays healthy"