Files
codex/codex-rs/tui/tests/suite/provider_defaults.rs
T
Joe Savona 46f5a1df9f Render selected MCP statusline providers in the TUI footer (#61979)
## 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
2026-11-17 06:33:13 +00:00

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(())
}