Reduce overhead in CLI integration tests (#62153)

## Why

SSE-only mocks return 404 on WebSocket upgrades by default, causing
retries before the tests reach the HTTP stream. In parallel runs, each
CLI subprocess can also start a Tokio worker per host CPU.

## What changed

- Share an SSE mock that returns HTTP 426 on WebSocket upgrades to
  trigger immediate HTTP fallback. Reuse it in the fallback test.
- Set `TOKIO_WORKER_THREADS=2` for CLI subprocesses launched by the
  affected test helpers. Run streaming and resume cases that don't need
  the repository checkout in temporary working directories.
- Test promptless `codex exec fork` option validation without creating a
  source thread. In the successful promptless fork case, keep stdin
  open and rely on the test runner's timeout to catch a blocked read.

GitOrigin-RevId: 94c20d4b2fd7cc65bc0f2a1cd0318ac188f59f22
This commit is contained in:
Dylan Hurd
2026-11-18 01:48:42 +00:00
committed by copyberry
parent 1c2e4cd45f
commit 3aaa23a437
7 changed files with 102 additions and 134 deletions
+14
View File
@@ -34,6 +34,7 @@ use wiremock::Respond;
use wiremock::ResponseTemplate;
use wiremock::http::HeaderName;
use wiremock::http::HeaderValue;
use wiremock::matchers::header;
use wiremock::matchers::method;
use wiremock::matchers::path_regex;
@@ -1273,6 +1274,19 @@ pub async fn start_mock_server() -> MockServer {
server
}
/// Start a server for tests that serve Responses over HTTP/SSE only.
/// A 404 on WebSocket upgrade triggers retries; 426 selects the HTTP fallback immediately.
pub async fn start_sse_server() -> MockServer {
let server = start_mock_server().await;
Mock::given(method("GET"))
.and(path_regex(".*/responses$"))
.and(header("upgrade", "websocket"))
.respond_with(ResponseTemplate::new(426))
.mount(&server)
.await;
server
}
/// Starts a lightweight WebSocket server for `/v1/responses` tests.
///
/// Each connection consumes a queue of request/event sequences. For each
@@ -15,6 +15,8 @@ impl TestCodexExecBuilder {
.expect("should find binary for codex-exec"),
);
cmd.current_dir(self.cwd.path())
// A suite can run many CLI processes. Each only needs a small runtime.
.env("TOKIO_WORKER_THREADS", "2")
.env("CODEX_HOME", self.home.path())
.env("CODEX_SQLITE_HOME", self.home.path())
.env(CODEX_API_KEY_ENV_VAR, "dummy");
+23 -28
View File
@@ -122,6 +122,8 @@ fn run_cli_command(command: &mut Command) -> io::Result<Output> {
command.process_group(0);
command
// Each CLI has its own runtime; keep parallel tests from starting a worker per host CPU.
.env("TOKIO_WORKER_THREADS", "2")
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
@@ -148,7 +150,7 @@ fn run_cli_command(command: &mut Command) -> io::Result<Output> {
async fn responses_mode_stream_cli_supports_personal_access_tokens() {
skip_if_no_network!();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
mount_personal_access_token_startup(&server).await;
let resp_mock = responses::mount_sse_once(&server, cli_sse_response()).await;
let home = TempDir::new().unwrap();
@@ -180,7 +182,7 @@ async fn responses_mode_stream_cli_does_not_attempt_oauth_refresh_for_personal_a
{
skip_if_no_network!();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
mount_personal_access_token_startup(&server).await;
Mock::given(method("POST"))
.and(path("/api/codex/responses"))
@@ -214,8 +216,8 @@ async fn responses_mode_stream_cli_does_not_attempt_oauth_refresh_for_personal_a
async fn responses_mode_stream_cli() {
skip_if_no_network!();
let server = MockServer::start().await;
let repo_root = repo_root();
let server = responses::start_sse_server().await;
let cwd = TempDir::new().unwrap();
let sse = responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_assistant_message("msg-1", "hi"),
@@ -236,8 +238,7 @@ async fn responses_mode_stream_cli() {
.arg(&provider_override)
.arg("-c")
.arg("model_provider=\"mock\"")
.arg("-C")
.arg(&repo_root)
.current_dir(cwd.path())
.arg("hello?");
cmd.env("CODEX_HOME", home.path())
.env("OPENAI_API_KEY", "dummy");
@@ -260,8 +261,8 @@ async fn responses_mode_stream_cli() {
async fn responses_mode_stream_cli_supports_openai_base_url_config_override() {
skip_if_no_network!();
let server = MockServer::start().await;
let repo_root = repo_root();
let server = responses::start_sse_server().await;
let cwd = TempDir::new().unwrap();
let sse = responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_assistant_message("msg-1", "hi"),
@@ -276,8 +277,7 @@ async fn responses_mode_stream_cli_supports_openai_base_url_config_override() {
.arg("--skip-git-repo-check")
.arg("-c")
.arg(format!("openai_base_url=\"{}/v1\"", server.uri()))
.arg("-C")
.arg(&repo_root)
.current_dir(cwd.path())
.arg("hello?");
cmd.env("CODEX_HOME", home.path())
.env("OPENAI_API_KEY", "dummy");
@@ -298,7 +298,7 @@ async fn exec_cli_applies_model_instructions_file() {
// Start mock server which will capture the request and return a minimal
// SSE stream for a single turn.
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let sse = concat!(
"data: {\"type\":\"response.created\",\"response\":{}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"r1\"}}\n\n"
@@ -321,7 +321,7 @@ async fn exec_cli_applies_model_instructions_file() {
);
let home = TempDir::new().unwrap();
let repo_root = repo_root();
let cwd = TempDir::new().unwrap();
let bin = codex_utils_cargo_bin::cargo_bin("codex").unwrap();
let mut cmd = Command::new(bin);
cmd.arg("exec")
@@ -334,8 +334,7 @@ async fn exec_cli_applies_model_instructions_file() {
.arg("model_provider=\"mock\"")
.arg("-c")
.arg(format!("model_instructions_file=\"{custom_path_str}\""))
.arg("-C")
.arg(&repo_root)
.current_dir(cwd.path())
.arg("hello?\n");
cmd.env("CODEX_HOME", home.path())
.env("OPENAI_API_KEY", "dummy");
@@ -363,7 +362,7 @@ async fn exec_cli_applies_model_instructions_file() {
async fn exec_cli_profile_applies_model_instructions_file() {
skip_if_no_network!();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let sse = concat!(
"data: {\"type\":\"response.created\",\"response\":{}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"r1\"}}\n\n"
@@ -388,7 +387,7 @@ async fn exec_cli_profile_applies_model_instructions_file() {
)
.unwrap();
let repo_root = repo_root();
let cwd = TempDir::new().unwrap();
let bin = codex_utils_cargo_bin::cargo_bin("codex").unwrap();
let mut cmd = Command::new(bin);
cmd.arg("exec")
@@ -401,8 +400,7 @@ async fn exec_cli_profile_applies_model_instructions_file() {
.arg(&provider_override)
.arg("-c")
.arg("model_provider=\"mock\"")
.arg("-C")
.arg(&repo_root)
.current_dir(cwd.path())
.arg("hello?\n");
cmd.env("CODEX_HOME", home.path())
.env("OPENAI_API_KEY", "dummy");
@@ -426,9 +424,9 @@ async fn exec_cli_profile_applies_model_instructions_file() {
async fn responses_api_stream_cli() {
skip_if_no_network!();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let resp_mock = responses::mount_sse_once(&server, cli_sse_response()).await;
let repo_root = repo_root();
let cwd = TempDir::new().unwrap();
let home = TempDir::new().unwrap();
let bin = codex_utils_cargo_bin::cargo_bin("codex").unwrap();
@@ -437,8 +435,7 @@ async fn responses_api_stream_cli() {
.arg("--skip-git-repo-check")
.arg("-c")
.arg(format!("openai_base_url=\"{}/v1\"", server.uri()))
.arg("-C")
.arg(&repo_root)
.current_dir(cwd.path())
.arg("hello?");
cmd.env("CODEX_HOME", home.path())
.env("OPENAI_API_KEY", "dummy");
@@ -466,10 +463,10 @@ async fn integration_creates_and_checks_session_file() -> anyhow::Result<()> {
let prompt = format!("echo {marker}");
// 3. Serve two hermetic SSE responses, one for the initial run and one for resume.
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let resp_mock =
responses::mount_sse_sequence(&server, vec![cli_sse_response(), cli_sse_response()]).await;
let repo_root = repo_root();
let cwd = TempDir::new().unwrap();
// 4. Run the codex CLI and invoke `exec`, which is what records a session.
let bin = codex_utils_cargo_bin::cargo_bin("codex").unwrap();
@@ -478,8 +475,7 @@ async fn integration_creates_and_checks_session_file() -> anyhow::Result<()> {
.arg("--skip-git-repo-check")
.arg("-c")
.arg(format!("openai_base_url=\"{}/v1\"", server.uri()))
.arg("-C")
.arg(&repo_root)
.current_dir(cwd.path())
.arg(&prompt);
cmd.env("CODEX_HOME", home.path())
.env(CODEX_API_KEY_ENV_VAR, "dummy");
@@ -594,8 +590,7 @@ async fn integration_creates_and_checks_session_file() -> anyhow::Result<()> {
.arg("--skip-git-repo-check")
.arg("-c")
.arg(format!("openai_base_url=\"{}/v1\"", server.uri()))
.arg("-C")
.arg(&repo_root)
.current_dir(cwd.path())
.arg(&prompt2)
.arg("resume")
.arg("--last");
@@ -37,12 +37,7 @@ mod close_code;
async fn websocket_fallback_switches_to_http_on_upgrade_required_connect() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
Mock::given(method("GET"))
.and(path_regex(".*/responses$"))
.respond_with(ResponseTemplate::new(426))
.mount(&server)
.await;
let server = responses::start_sse_server().await;
let response_mock = mount_sse_once(
&server,
+2 -2
View File
@@ -8,7 +8,7 @@ async fn exec_includes_workspace_agents_md_in_request() -> anyhow::Result<()> {
let test = test_codex_exec();
std::fs::write(test.cwd_path().join("AGENTS.md"), "workspace instructions")?;
let server = responses::start_mock_server().await;
let server = responses::start_sse_server().await;
let body = responses::sse(vec![
responses::ev_response_created("resp1"),
responses::ev_assistant_message("m1", "fixture hello"),
@@ -42,7 +42,7 @@ async fn exec_prefers_workspace_agents_override_md() -> anyhow::Result<()> {
"override instructions",
)?;
let server = responses::start_mock_server().await;
let server = responses::start_sse_server().await;
let body = responses::sse(vec![
responses::ev_response_created("resp1"),
responses::ev_assistant_message("m1", "fixture hello"),
+4 -3
View File
@@ -3,6 +3,7 @@ use core_test_support::responses::ev_completed;
use core_test_support::responses::mount_sse_once_match;
use core_test_support::responses::sse;
use core_test_support::responses::start_mock_server;
use core_test_support::responses::start_sse_server;
use core_test_support::test_codex_exec::test_codex_exec;
use serde_json::json;
use wiremock::Mock;
@@ -14,7 +15,7 @@ use wiremock::matchers::path;
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_uses_codex_api_key_env_var() -> anyhow::Result<()> {
let test = test_codex_exec();
let server = start_mock_server().await;
let server = start_sse_server().await;
let repo_root = codex_utils_cargo_bin::repo_root()?;
mount_sse_once_match(
@@ -39,7 +40,7 @@ async fn exec_uses_codex_api_key_env_var() -> anyhow::Result<()> {
async fn exec_api_key_cannot_discard_stored_workspace_network_policy() -> anyhow::Result<()> {
let test = test_codex_exec();
let policy_server = start_mock_server().await;
let inference_server = start_mock_server().await;
let inference_server = start_sse_server().await;
let token = concat!(
"eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.",
"eyJodHRwczovL2FwaS5vcGVuYWkuY29tL2F1dGgiOnsiY2hhdGdwdF9wbGFuX3R5cGUiOiJlbnRlcnByaXNlIiwiY2hhdGdwdF9hY2NvdW50X2lkIjoid29ya3NwYWNlIn19.",
@@ -101,7 +102,7 @@ async fn exec_bootstrap_rejects_redirected_oauth_and_cloud_policy() -> anyhow::R
let test = test_codex_exec();
let origin = start_mock_server().await;
let destination = start_mock_server().await;
let inference = start_mock_server().await;
let inference = start_sse_server().await;
let token = concat!(
"eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.",
"eyJodHRwczovL2FwaS5vcGVuYWkuY29tL2F1dGgiOnsiY2hhdGdwdF9wbGFuX3R5cGUiOiJlbnRlcnByaXNlIiwiY2hhdGdwdF9hY2NvdW50X2lkIjoid29ya3NwYWNlIn19.",
+56 -95
View File
@@ -10,7 +10,6 @@ use pretty_assertions::assert_eq;
use serde_json::Value;
use std::process::Stdio;
use std::string::ToString;
use std::time::Duration;
use tempfile::TempDir;
use uuid::Uuid;
use walkdir::WalkDir;
@@ -111,10 +110,6 @@ fn last_user_image_count(path: &std::path::Path) -> usize {
last_count
}
fn exec_repo_root() -> anyhow::Result<std::path::PathBuf> {
Ok(codex_utils_cargo_bin::repo_root()?)
}
fn exec_sse_response(index: usize) -> String {
let response_id = format!("resp-exec-{index}");
let message_id = format!("msg-exec-{index}");
@@ -138,7 +133,7 @@ async fn exec_falls_back_to_legacy_history_when_thread_store_cannot_paginate() -
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 1).await;
let store_id = Uuid::new_v4();
@@ -160,7 +155,7 @@ async fn exec_resume_last_appends_to_existing_file() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let response_mock = responses::mount_sse_sequence(
&server,
vec![
@@ -173,7 +168,6 @@ async fn exec_resume_last_appends_to_existing_file() -> anyhow::Result<()> {
],
)
.await;
let repo_root = exec_repo_root()?;
// 1) First run: create a session with a unique marker in the content.
let marker = format!("resume-last-{}", Uuid::new_v4());
@@ -181,8 +175,6 @@ async fn exec_resume_last_appends_to_existing_file() -> anyhow::Result<()> {
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(&prompt)
.assert()
.success();
@@ -209,8 +201,6 @@ async fn exec_resume_last_appends_to_existing_file() -> anyhow::Result<()> {
.cmd_with_server(&server)
.env("RUST_LOG", "codex_app_server::outgoing_message=trace")
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(&prompt2)
.arg("resume")
.arg("--last")
@@ -261,15 +251,12 @@ async fn exec_resume_last_repairs_rollout_missing_from_state_db() -> anyhow::Res
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 2).await;
let repo_root = exec_repo_root()?;
let marker = format!("resume-last-repair-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(format!("echo {marker}"))
.assert()
.success();
@@ -293,8 +280,6 @@ async fn exec_resume_last_repairs_rollout_missing_from_state_db() -> anyhow::Res
let resumed_marker = format!("resume-last-repaired-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg("resume")
.arg("--last")
.arg(format!("echo {resumed_marker}"))
@@ -313,16 +298,13 @@ async fn exec_resume_last_trusts_usable_state_db_candidate() -> anyhow::Result<(
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 3).await;
let repo_root = exec_repo_root()?;
let sessions_dir = test.home_path().join("sessions");
let older_marker = format!("resume-last-indexed-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(format!("echo {older_marker}"))
.assert()
.success();
@@ -332,8 +314,6 @@ async fn exec_resume_last_trusts_usable_state_db_candidate() -> anyhow::Result<(
let newer_marker = format!("resume-last-unindexed-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(format!("echo {newer_marker}"))
.assert()
.success();
@@ -356,8 +336,6 @@ async fn exec_resume_last_trusts_usable_state_db_candidate() -> anyhow::Result<(
let resumed_marker = format!("resume-last-authoritative-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg("resume")
.arg("--last")
.arg(format!("echo {resumed_marker}"))
@@ -384,16 +362,13 @@ async fn exec_resume_last_skips_mismatched_state_db_candidate() -> anyhow::Resul
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 3).await;
let repo_root = exec_repo_root()?;
let sessions_dir = test.home_path().join("sessions");
let older_marker = format!("resume-last-valid-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(format!("echo {older_marker}"))
.assert()
.success();
@@ -403,8 +378,6 @@ async fn exec_resume_last_skips_mismatched_state_db_candidate() -> anyhow::Resul
let newer_marker = format!("resume-last-mismatched-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(format!("echo {newer_marker}"))
.assert()
.success();
@@ -429,8 +402,6 @@ async fn exec_resume_last_skips_mismatched_state_db_candidate() -> anyhow::Resul
let resumed_marker = format!("resume-last-valid-resumed-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg("resume")
.arg("--last")
.arg(format!("echo {resumed_marker}"))
@@ -448,9 +419,8 @@ async fn exec_resume_last_accepts_prompt_after_flag_in_json_mode() -> anyhow::Re
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 2).await;
let repo_root = exec_repo_root()?;
// 1) First run: create a session with a unique marker in the content.
let marker = format!("resume-last-json-{}", Uuid::new_v4());
@@ -458,8 +428,6 @@ async fn exec_resume_last_accepts_prompt_after_flag_in_json_mode() -> anyhow::Re
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(&prompt)
.assert()
.success();
@@ -475,8 +443,6 @@ async fn exec_resume_last_accepts_prompt_after_flag_in_json_mode() -> anyhow::Re
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg("--json")
.arg("resume")
.arg("--last")
@@ -501,7 +467,7 @@ async fn exec_resume_last_respects_cwd_filter_and_all_flag() -> anyhow::Result<(
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 5).await;
let dir_a = TempDir::new()?;
@@ -614,7 +580,7 @@ async fn exec_resume_accepts_global_flags_after_subcommand() -> anyhow::Result<(
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 2).await;
// Seed a session.
@@ -651,7 +617,7 @@ async fn exec_resume_includes_output_schema_in_request() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let response_mock = mount_exec_responses(&server, /*count*/ 2).await;
let schema_contents = serde_json::json!({
@@ -707,9 +673,8 @@ async fn exec_resume_by_id_appends_to_existing_file() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 2).await;
let repo_root = exec_repo_root()?;
// 1) First run: create a session
let marker = format!("resume-by-id-{}", Uuid::new_v4());
@@ -717,8 +682,6 @@ async fn exec_resume_by_id_appends_to_existing_file() -> anyhow::Result<()> {
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(&prompt)
.assert()
.success();
@@ -738,8 +701,6 @@ async fn exec_resume_by_id_appends_to_existing_file() -> anyhow::Result<()> {
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(&prompt2)
.arg("resume")
.arg(&session_id)
@@ -763,9 +724,8 @@ async fn exec_resume_preserves_cli_configuration_overrides() -> anyhow::Result<(
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 2).await;
let repo_root = exec_repo_root()?;
let marker = format!("resume-config-{}", Uuid::new_v4());
let prompt = format!("echo {marker}");
@@ -776,8 +736,6 @@ async fn exec_resume_preserves_cli_configuration_overrides() -> anyhow::Result<(
.arg("workspace-write")
.arg("--model")
.arg("gpt-5.1")
.arg("-C")
.arg(&repo_root)
.arg(&prompt)
.assert()
.success();
@@ -796,8 +754,6 @@ async fn exec_resume_preserves_cli_configuration_overrides() -> anyhow::Result<(
.arg("workspace-write")
.arg("--model")
.arg("gpt-5.1-high")
.arg("-C")
.arg(&repo_root)
.arg(&prompt2)
.arg("resume")
.arg("--last")
@@ -838,17 +794,14 @@ async fn exec_resume_accepts_images_after_subcommand() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 2).await;
let repo_root = exec_repo_root()?;
let marker = format!("resume-image-{}", Uuid::new_v4());
let prompt = format!("echo {marker}");
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg(&prompt)
.assert()
.success();
@@ -869,8 +822,6 @@ async fn exec_resume_accepts_images_after_subcommand() -> anyhow::Result<()> {
let prompt2 = format!("echo {marker2}");
test.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("-C")
.arg(&repo_root)
.arg("resume")
.arg("--last")
.arg("--image")
@@ -893,12 +844,52 @@ async fn exec_resume_accepts_images_after_subcommand() -> anyhow::Result<()> {
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_fork_rejects_turn_options_without_a_prompt() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = responses::start_sse_server().await;
// Option validation precedes thread lookup; it does not require a real source turn.
let source_id = Uuid::new_v4();
for (args, expected_error) in [
(
vec!["--image", "unused.png"],
"Forking with images requires a prompt",
),
(
vec!["--output-schema", "unused.json"],
"Forking with output options requires a prompt",
),
(
vec!["--output-last-message", "unused.md"],
"Forking with output options requires a prompt",
),
(vec!["--ephemeral"], "Ephemeral forks require a prompt"),
] {
let output = test
.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("fork")
.arg(source_id.to_string())
.args(args)
.output()?;
assert!(!output.status.success());
assert!(
String::from_utf8_lossy(&output.stderr).contains(expected_error),
"fork failed without the expected error: {output:?}"
);
}
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_fork_creates_distinct_threads_with_and_without_a_prompt() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = MockServer::start().await;
let server = responses::start_sse_server().await;
let response_mock = mount_exec_responses(&server, /*count*/ 2).await;
let source_marker = format!("fork-source-{}", Uuid::new_v4());
@@ -923,35 +914,6 @@ async fn exec_fork_creates_distinct_threads_with_and_without_a_prompt() -> anyho
)?;
assert_eq!(source_meta["payload"]["thread_source"], "source_feature");
for (args, expected_error) in [
(
vec!["--image", "unused.png"],
"Forking with images requires a prompt",
),
(
vec!["--output-schema", "unused.json"],
"Forking with output options requires a prompt",
),
(
vec!["--output-last-message", "unused.md"],
"Forking with output options requires a prompt",
),
(vec!["--ephemeral"], "Ephemeral forks require a prompt"),
] {
let output = test
.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.arg("fork")
.arg(&source_id)
.args(args)
.output()?;
assert!(!output.status.success());
assert!(
String::from_utf8_lossy(&output.stderr).contains(expected_error),
"fork failed without the expected error: {output:?}"
);
}
let mut promptless_command = test.cmd_with_server(&server);
promptless_command
.arg("--skip-git-repo-check")
@@ -973,10 +935,9 @@ async fn exec_fork_creates_distinct_threads_with_and_without_a_prompt() -> anyho
.kill_on_drop(true);
let mut child = child_command.spawn()?;
let _open_stdin = child.stdin.take().expect("stdin should be piped");
let promptless_output =
tokio::time::timeout(Duration::from_secs(/*secs*/ 10), child.wait_with_output())
.await
.context("promptless fork should not wait for stdin to close")??;
// Keep stdin open until exit. Reading it would deadlock and fail the test under
// the runner's timeout; process startup and shutdown have no separate latency contract.
let promptless_output = child.wait_with_output().await?;
assert!(
promptless_output.status.success(),
"promptless fork failed: {}",