Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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"