test(core): stabilize post-rebase regression checks

ericjuta · ericjuta · commit b7d30387e296 · 2026-05-17T16:38:19.000Z
diff --git a/codex-rs/.cargo/config.toml b/codex-rs/.cargo/config.toml
@@ -1,3 +1,6 @@
+[env]
+RUST_MIN_STACK = "8388608"
+
 [target.'cfg(all(windows, target_env = "msvc"))']
 rustflags = ["-C", "link-arg=/STACK:8388608"]
 
diff --git a/codex-rs/core/src/agent/control_tests.rs b/codex-rs/core/src/agent/control_tests.rs
@@ -239,6 +239,31 @@ async fn wait_for_live_thread_spawn_children(
     .expect("expected persisted child tree");
 }
 
+fn run_agent_control_test_with_large_stack<Fut>(
+    test_name: &'static str,
+    test: impl FnOnce() -> Fut + Send + 'static,
+) where
+    Fut: std::future::Future<Output = ()> + 'static,
+{
+    const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;
+
+    let handle = std::thread::Builder::new()
+        .name(test_name.to_string())
+        .stack_size(TEST_STACK_SIZE_BYTES)
+        .spawn(move || {
+            let runtime = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .expect("build test runtime");
+            runtime.block_on(test());
+        })
+        .expect("spawn large-stack test thread");
+
+    handle
+        .join()
+        .expect("large-stack test thread should finish");
+}
+
 #[tokio::test]
 async fn send_input_errors_when_manager_dropped() {
     let control = AgentControl::default();
@@ -1729,8 +1754,15 @@ async fn resume_agent_from_rollout_reads_archived_rollout_path() {
         .expect("resumed child shutdown should succeed");
 }
 
-#[tokio::test]
-async fn list_agent_subtree_thread_ids_includes_anonymous_and_closed_descendants() {
+#[test]
+fn list_agent_subtree_thread_ids_includes_anonymous_and_closed_descendants() {
+    run_agent_control_test_with_large_stack(
+        "list_agent_subtree_thread_ids_includes_anonymous_and_closed_descendants",
+        list_agent_subtree_thread_ids_includes_anonymous_and_closed_descendants_impl,
+    );
+}
+
+async fn list_agent_subtree_thread_ids_includes_anonymous_and_closed_descendants_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, _parent_thread) = harness.start_thread().await;
     let worker_path = AgentPath::root().join("worker").expect("worker path");
@@ -1855,8 +1887,15 @@ async fn list_agent_subtree_thread_ids_includes_anonymous_and_closed_descendants
     );
 }
 
-#[tokio::test]
-async fn shutdown_agent_tree_closes_live_descendants() {
+#[test]
+fn shutdown_agent_tree_closes_live_descendants() {
+    run_agent_control_test_with_large_stack(
+        "shutdown_agent_tree_closes_live_descendants",
+        shutdown_agent_tree_closes_live_descendants_impl,
+    );
+}
+
+async fn shutdown_agent_tree_closes_live_descendants_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, _parent_thread) = harness.start_thread().await;
 
@@ -1940,8 +1979,15 @@ async fn shutdown_agent_tree_closes_live_descendants() {
     assert_eq!(shutdown_ids, expected_shutdown_ids);
 }
 
-#[tokio::test]
-async fn shutdown_agent_tree_closes_descendants_when_started_at_child() {
+#[test]
+fn shutdown_agent_tree_closes_descendants_when_started_at_child() {
+    run_agent_control_test_with_large_stack(
+        "shutdown_agent_tree_closes_descendants_when_started_at_child",
+        shutdown_agent_tree_closes_descendants_when_started_at_child_impl,
+    );
+}
+
+async fn shutdown_agent_tree_closes_descendants_when_started_at_child_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, _parent_thread) = harness.start_thread().await;
 
@@ -2031,8 +2077,15 @@ async fn shutdown_agent_tree_closes_descendants_when_started_at_child() {
     assert_eq!(shutdown_ids, expected_shutdown_ids);
 }
 
-#[tokio::test]
-async fn resume_agent_from_rollout_does_not_reopen_closed_descendants() {
+#[test]
+fn resume_agent_from_rollout_does_not_reopen_closed_descendants() {
+    run_agent_control_test_with_large_stack(
+        "resume_agent_from_rollout_does_not_reopen_closed_descendants",
+        resume_agent_from_rollout_does_not_reopen_closed_descendants_impl,
+    );
+}
+
+async fn resume_agent_from_rollout_does_not_reopen_closed_descendants_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, parent_thread) = harness.start_thread().await;
 
@@ -2126,8 +2179,15 @@ async fn resume_agent_from_rollout_does_not_reopen_closed_descendants() {
         .expect("tree shutdown after resume should succeed");
 }
 
-#[tokio::test]
-async fn resume_closed_child_reopens_open_descendants() {
+#[test]
+fn resume_closed_child_reopens_open_descendants() {
+    run_agent_control_test_with_large_stack(
+        "resume_closed_child_reopens_open_descendants",
+        resume_closed_child_reopens_open_descendants_impl,
+    );
+}
+
+async fn resume_closed_child_reopens_open_descendants_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, parent_thread) = harness.start_thread().await;
 
@@ -2223,8 +2283,15 @@ async fn resume_closed_child_reopens_open_descendants() {
         .expect("parent shutdown should succeed");
 }
 
-#[tokio::test]
-async fn resume_agent_from_rollout_reopens_open_descendants_after_manager_shutdown() {
+#[test]
+fn resume_agent_from_rollout_reopens_open_descendants_after_manager_shutdown() {
+    run_agent_control_test_with_large_stack(
+        "resume_agent_from_rollout_reopens_open_descendants_after_manager_shutdown",
+        resume_agent_from_rollout_reopens_open_descendants_after_manager_shutdown_impl,
+    );
+}
+
+async fn resume_agent_from_rollout_reopens_open_descendants_after_manager_shutdown_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, parent_thread) = harness.start_thread().await;
 
@@ -2314,8 +2381,15 @@ async fn resume_agent_from_rollout_reopens_open_descendants_after_manager_shutdo
         .expect("tree shutdown after subtree resume should succeed");
 }
 
-#[tokio::test]
-async fn resume_agent_from_rollout_uses_edge_data_when_descendant_metadata_source_is_stale() {
+#[test]
+fn resume_agent_from_rollout_uses_edge_data_when_descendant_metadata_source_is_stale() {
+    run_agent_control_test_with_large_stack(
+        "resume_agent_from_rollout_uses_edge_data_when_descendant_metadata_source_is_stale",
+        resume_agent_from_rollout_uses_edge_data_when_descendant_metadata_source_is_stale_impl,
+    );
+}
+
+async fn resume_agent_from_rollout_uses_edge_data_when_descendant_metadata_source_is_stale_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, parent_thread) = harness.start_thread().await;
 
@@ -2445,8 +2519,15 @@ async fn resume_agent_from_rollout_uses_edge_data_when_descendant_metadata_sourc
         .expect("tree shutdown after subtree resume should succeed");
 }
 
-#[tokio::test]
-async fn resume_agent_from_rollout_skips_descendants_when_parent_resume_fails() {
+#[test]
+fn resume_agent_from_rollout_skips_descendants_when_parent_resume_fails() {
+    run_agent_control_test_with_large_stack(
+        "resume_agent_from_rollout_skips_descendants_when_parent_resume_fails",
+        resume_agent_from_rollout_skips_descendants_when_parent_resume_fails_impl,
+    );
+}
+
+async fn resume_agent_from_rollout_skips_descendants_when_parent_resume_fails_impl() {
     let harness = AgentControlHarness::new().await;
     let (parent_thread_id, parent_thread) = harness.start_thread().await;
 
diff --git a/codex-rs/core/src/tools/spec_plan_tests.rs b/codex-rs/core/src/tools/spec_plan_tests.rs
@@ -2388,7 +2388,7 @@ fn code_mode_only_exec_description_omits_deferred_tools() {
 
     assert!(!description.contains("mcp__rmcp__echo"));
     assert!(!description.contains("Deferred RMCP tool."));
-    assert!(registry.has_handler(&ToolName::namespaced("mcp__rmcp__", "echo")));
+    assert!(registry.has_tool(&ToolName::namespaced("mcp__rmcp__", "echo")));
 }
 
 #[test]
diff --git a/codex-rs/core/tests/suite/compact_remote_parity.rs b/codex-rs/core/tests/suite/compact_remote_parity.rs
@@ -3,6 +3,7 @@
 use std::fs;
 use std::path::Path;
 use std::path::PathBuf;
+use std::time::Duration;
 
 use anyhow::Result;
 use codex_features::Feature;
@@ -20,6 +21,7 @@ use core_test_support::skip_if_no_network;
 use core_test_support::test_codex::TestCodexHarness;
 use core_test_support::test_codex::test_codex;
 use core_test_support::wait_for_event;
+use core_test_support::wait_for_event_with_timeout;
 use pretty_assertions::assert_eq;
 use serde_json::Value;
 use serde_json::json;
@@ -115,34 +117,56 @@ const FULL_MIX: &[Step] = &[
     Step::Assistant,
 ];
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compaction_parity_manual_transcripts() -> Result<()> {
-    skip_if_no_network!(Ok(()));
+#[test]
+fn remote_compaction_parity_manual_transcripts() -> Result<()> {
+    const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;
+    const WORKER_THREADS: usize = 2;
+
+    let handle = std::thread::Builder::new()
+        .name("remote_compaction_parity_manual_transcripts".to_string())
+        .stack_size(TEST_STACK_SIZE_BYTES)
+        .spawn(|| -> Result<()> {
+            let runtime = tokio::runtime::Builder::new_multi_thread()
+                .worker_threads(WORKER_THREADS)
+                .thread_stack_size(TEST_STACK_SIZE_BYTES)
+                .enable_all()
+                .build()?;
+            runtime.block_on(async {
+                skip_if_no_network!(Ok(()));
+
+                let scenarios = [
+                    Scenario {
+                        name: "assistant_only",
+                        steps: ASSISTANT_ONLY,
+                    },
+                    Scenario {
+                        name: "reasoning_image",
+                        steps: REASONING_IMAGE,
+                    },
+                    Scenario {
+                        name: "tool_mix",
+                        steps: TOOL_MIX,
+                    },
+                    Scenario {
+                        name: "full_mix",
+                        steps: FULL_MIX,
+                    },
+                ];
+
+                for scenario in scenarios {
+                    compare_manual_scenario(&scenario, RunSettings::default()).await?;
+                }
 
-    let scenarios = [
-        Scenario {
-            name: "assistant_only",
-            steps: ASSISTANT_ONLY,
-        },
-        Scenario {
-            name: "reasoning_image",
-            steps: REASONING_IMAGE,
-        },
-        Scenario {
-            name: "tool_mix",
-            steps: TOOL_MIX,
-        },
-        Scenario {
-            name: "full_mix",
-            steps: FULL_MIX,
-        },
-    ];
-
-    for scenario in scenarios {
-        compare_manual_scenario(&scenario, RunSettings::default()).await?;
-    }
+                Ok(())
+            })
+        })?;
 
-    Ok(())
+    match handle.join() {
+        Ok(result) => result,
+        Err(_) => Err(anyhow::anyhow!(
+            "remote_compaction_parity_manual_transcripts thread panicked"
+        )),
+    }
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -613,7 +637,14 @@ async fn submit_user_input(codex: &codex_core::CodexThread, items: Vec<UserInput
 }
 
 async fn wait_for_turn_complete(codex: &codex_core::CodexThread) {
-    wait_for_event(codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
+    const PARITY_EVENT_TIMEOUT_SECS: u64 = 30;
+
+    wait_for_event_with_timeout(
+        codex,
+        |ev| matches!(ev, EventMsg::TurnComplete(_)),
+        Duration::from_secs(PARITY_EVENT_TIMEOUT_SECS),
+    )
+    .await;
 }
 
 fn user_input_for_step(scenario_name: &str, idx: usize, step: Step) -> Vec<UserInput> {

Original file line number	Diff line number	Diff line change
`@@ -2388,7 +2388,7 @@ fn code_mode_only_exec_description_omits_deferred_tools() {`
`2388`	`2388`
`2389`	`2389`	`assert!(!description.contains("mcp__rmcp__echo"));`
`2390`	`2390`	`assert!(!description.contains("Deferred RMCP tool."));`
`2391`		`- assert!(registry.has_handler(&ToolName::namespaced("mcp__rmcp__", "echo")));`
	`2391`	`+ assert!(registry.has_tool(&ToolName::namespaced("mcp__rmcp__", "echo")));`
`2392`	`2392`	`}`
`2393`	`2393`
`2394`	`2394`	`#[test]`