mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
## What changed - With `tui_extensions_statusline` enabled, resolve the saved MCP provider and read its resource with a snapshot of the displayed thread's statusline state. - Show initialization and error messages, validate the JSON UI tree response, and preserve provider content through native statusline refreshes. Ignore stale results when the thread, provider, or working directory changes. - Request workspace headlines and thread usage for custom providers even when no built-in statusline items are selected. ## Testing Add unit coverage for response validation and footer lifecycle, plus end-to-end tests for embedded and remote app servers, startup delays, current thread metadata, and rejection of project-level provider overrides. GitOrigin-RevId: 80a46ec780c1f1536f1fd4749f468629627dedf6
204 lines
7.7 KiB
Rust
204 lines
7.7 KiB
Rust
//! Resume and fork picker and --last provider defaults through the real CLI and app server.
|
|
|
|
use super::focus_palette::PtyCodex;
|
|
use super::focus_palette::write_test_config;
|
|
use anyhow::Context;
|
|
use anyhow::Result;
|
|
use anyhow::ensure;
|
|
use app_test_support::create_fake_rollout;
|
|
use std::time::Duration;
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn resume_lists_all_providers_and_fork_keeps_provider_filter() -> Result<()> {
|
|
let cwd = codex_utils_cargo_bin::repo_root()?;
|
|
for action in ["resume", "fork"] {
|
|
for (embedded, last, explicit) in [
|
|
(false, false, false),
|
|
(true, false, false),
|
|
(false, true, false),
|
|
(true, true, false),
|
|
(false, true, true),
|
|
(false, false, true),
|
|
] {
|
|
let home = tempfile::tempdir_in("/tmp")?;
|
|
write_test_config(home.path(), &cwd)?;
|
|
let config_path = home.path().join("config.toml");
|
|
let config = std::fs::read_to_string(&config_path)?;
|
|
std::fs::write(
|
|
config_path,
|
|
format!(
|
|
"{config}\n[model_providers.server-provider]\nname = 'Server provider'\nbase_url = 'http://127.0.0.1:9/v1'\nwire_api = 'responses'\nrequires_openai_auth = false\n[projects.'/']\ntrust_level = 'trusted'\n"
|
|
),
|
|
)?;
|
|
for (hour, provider, preview) in [
|
|
("10", "openai", "Client provider history"),
|
|
("11", "server-provider", "Server provider history"),
|
|
] {
|
|
create_fake_rollout(
|
|
home.path(),
|
|
&format!("2025-01-02T{hour}-00-00"),
|
|
&format!("2025-01-02T{hour}:00:00Z"),
|
|
preview,
|
|
Some(provider),
|
|
/*git_info*/ None,
|
|
)?;
|
|
}
|
|
let (mut daemon, remote_endpoint) = super::unix_daemon::start(
|
|
home.path(),
|
|
&["-c", "model_provider=\"server-provider\""],
|
|
)
|
|
.await?;
|
|
let mut args = vec![action, "--all"];
|
|
if embedded {
|
|
args.push("--no-daemon");
|
|
}
|
|
if last {
|
|
args.push("--last");
|
|
}
|
|
if explicit {
|
|
args.extend([
|
|
"--remote",
|
|
remote_endpoint.as_str(),
|
|
"-c",
|
|
"model_provider=\"openai\"",
|
|
]);
|
|
}
|
|
let case = format!("{action}: embedded={embedded}, last={last}, explicit={explicit}");
|
|
let mut terminal = PtyCodex::start_cli(&cwd, home, &args)?;
|
|
if action == "resume" && last && explicit {
|
|
// --last finds the newest thread across providers. An explicit override
|
|
// cannot switch that thread from server-provider to openai.
|
|
terminal
|
|
.wait_for_screen("Cannot change this thread's model provider")
|
|
.with_context(|| format!("{case}; screen:\n{}", terminal.screen_contents()))?;
|
|
} else if action == "resume" {
|
|
terminal
|
|
.wait_for_screen("Server provider history")
|
|
.with_context(|| format!("{case}; screen:\n{}", terminal.screen_contents()))?;
|
|
if !last {
|
|
terminal
|
|
.wait_for_screen("Client provider history")
|
|
.with_context(|| {
|
|
format!("{case}; screen:\n{}", terminal.screen_contents())
|
|
})?;
|
|
}
|
|
} else {
|
|
let (expected, excluded) = if embedded || explicit {
|
|
("Client provider history", "Server provider history")
|
|
} else {
|
|
("Server provider history", "Client provider history")
|
|
};
|
|
terminal
|
|
.wait_for_screen(expected)
|
|
.with_context(|| format!("{case}; screen:\n{}", terminal.screen_contents()))?;
|
|
ensure!(
|
|
!terminal.screen_contains(excluded),
|
|
"{case}: unexpected provider history"
|
|
);
|
|
}
|
|
drop(terminal);
|
|
daemon.kill().await?;
|
|
daemon.wait().await?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn selected_gateway_authenticates_before_its_first_chat() -> Result<()> {
|
|
use core_test_support::responses;
|
|
|
|
let server = responses::start_mock_server().await;
|
|
let reply = responses::mount_sse_once_match(
|
|
&server,
|
|
wiremock::matchers::body_string_contains(r#"\"thread_source\":\"user\""#),
|
|
responses::sse(vec![
|
|
responses::ev_assistant_message("msg", "gateway handoff verified"),
|
|
responses::ev_completed("resp"),
|
|
]),
|
|
)
|
|
.await;
|
|
let workspace = tempfile::tempdir()?;
|
|
let home = tempfile::tempdir()?;
|
|
let cwd = workspace.path().canonicalize()?;
|
|
let profile = home.path().join("work.config.toml");
|
|
let auth = home.path().join("auth.json");
|
|
let url = server.uri();
|
|
let trusted = toml::Value::String(cwd.display().to_string());
|
|
std::fs::write(
|
|
&profile,
|
|
format!(
|
|
r#"
|
|
model_provider = "openai"
|
|
model = "gpt-5.1"
|
|
forced_login_method = "api"
|
|
cli_auth_credentials_store = "file"
|
|
suppress_unstable_features_warning = true
|
|
[features]
|
|
gateway_setup_wizard = true
|
|
bedrock_setup_wizard = false
|
|
gcp_setup_wizard = false
|
|
api_key_model_discovery = false
|
|
[projects.{trusted}]
|
|
trust_level = "trusted"
|
|
[model_providers.office]
|
|
name = "Office gateway"
|
|
base_url = "{url}/v1"
|
|
wire_api = "responses"
|
|
supports_websockets = false
|
|
requires_openai_auth = true
|
|
"#
|
|
),
|
|
)?;
|
|
let mut terminal = PtyCodex::start(
|
|
&cwd,
|
|
home,
|
|
&["--profile", "work", "--no-daemon", "verify the gateway"],
|
|
)?;
|
|
terminal
|
|
.wait_for_screen("Sign in another way")
|
|
.with_context(|| terminal.screen_contents())?;
|
|
// Startup drains input after its first draw. Retry the menu shortcut until it is accepted.
|
|
let deadline = std::time::Instant::now() + Duration::from_secs(/*secs*/ 30);
|
|
while !terminal.screen_contains("Use a custom provider or gateway") {
|
|
ensure!(
|
|
std::time::Instant::now() < deadline,
|
|
"gateway option missing: {}",
|
|
terminal.screen_contents()
|
|
);
|
|
terminal.write_input(b"2")?;
|
|
terminal.read_output(Duration::from_millis(/*millis*/ 50))?;
|
|
}
|
|
// Arrow navigation avoids carrying the menu shortcut across two screens.
|
|
terminal.write_input(b"\x1b[B\r")?;
|
|
terminal.wait_for_screen("Office gateway")?;
|
|
terminal.write_input(b"\x1b[H\r")?;
|
|
terminal.wait_for_screen("Paste or type your API key")?;
|
|
let deadline = std::time::Instant::now() + Duration::from_secs(/*secs*/ 30);
|
|
while !auth.is_file() && terminal.screen_contains("Paste or type your API key") {
|
|
ensure!(
|
|
std::time::Instant::now() < deadline,
|
|
"API key was not saved: {}",
|
|
terminal.screen_contents()
|
|
);
|
|
terminal.write_input(b"\r")?;
|
|
terminal.read_output(Duration::from_millis(/*millis*/ 50))?;
|
|
}
|
|
terminal.wait_for_screen("gateway handoff verified")?;
|
|
let first_chat = reply
|
|
.requests()
|
|
.into_iter()
|
|
.find(|request| {
|
|
request
|
|
.message_input_texts("user")
|
|
.iter()
|
|
.any(|text| text == "verify the gateway")
|
|
})
|
|
.context("the selected gateway received the first chat")?;
|
|
assert_eq!(
|
|
first_chat.header("authorization").as_deref(),
|
|
Some("Bearer focus-palette-test")
|
|
);
|
|
Ok(())
|
|
}
|