mirror of
https://github.com/openai/codex.git
synced 2026-11-18 23:02:23 +00:00
## Why The TUI now sits on the app-server layer, but `app-server-client::legacy_core` still exposed core test helpers solely for TUI tests. We've been whittling away the remaining dependencies. This is the next step on that journey. There is no functional change — just a refactor, and this affects only test code, so it should be low risk. ## What changed - remove the `legacy_core::test_support` re-export and call model-manager test helpers directly - keep the bundled model-preset cache local to TUI test support - import constraint types directly from `codex-config`
390 lines
12 KiB
Rust
390 lines
12 KiB
Rust
use super::*;
|
|
use assert_matches::assert_matches;
|
|
use codex_config::types::ModelAvailabilityNuxConfig;
|
|
use codex_protocol::openai_models::ModelAvailabilityNux;
|
|
use pretty_assertions::assert_eq;
|
|
use tokio::sync::mpsc::unbounded_channel;
|
|
|
|
fn all_model_presets() -> Vec<ModelPreset> {
|
|
crate::test_support::TEST_MODEL_PRESETS.clone()
|
|
}
|
|
|
|
fn model_availability_nux_config(shown_count: &[(&str, u32)]) -> ModelAvailabilityNuxConfig {
|
|
ModelAvailabilityNuxConfig {
|
|
shown_count: shown_count
|
|
.iter()
|
|
.map(|(model, count)| ((*model).to_string(), *count))
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
fn model_migration_copy_to_plain_text(copy: &crate::model_migration::ModelMigrationCopy) -> String {
|
|
if let Some(markdown) = copy.markdown.as_ref() {
|
|
return markdown.clone();
|
|
}
|
|
let mut s = String::new();
|
|
for span in ©.heading {
|
|
s.push_str(&span.content);
|
|
}
|
|
s.push('\n');
|
|
s.push('\n');
|
|
for line in ©.content {
|
|
for span in &line.spans {
|
|
s.push_str(&span.content);
|
|
}
|
|
s.push('\n');
|
|
}
|
|
s
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn model_migration_prompt_only_shows_for_deprecated_models() {
|
|
let seen = BTreeMap::new();
|
|
assert!(should_show_model_migration_prompt(
|
|
"gpt-5.2",
|
|
"gpt-5.4",
|
|
&seen,
|
|
&all_model_presets()
|
|
));
|
|
assert!(should_show_model_migration_prompt(
|
|
"gpt-5.3-codex",
|
|
"gpt-5.4",
|
|
&seen,
|
|
&all_model_presets()
|
|
));
|
|
assert!(!should_show_model_migration_prompt(
|
|
"gpt-5.3-codex",
|
|
"gpt-5.3-codex",
|
|
&seen,
|
|
&all_model_presets()
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn select_model_availability_nux_picks_only_eligible_model() {
|
|
let mut presets = all_model_presets();
|
|
presets.iter_mut().for_each(|preset| {
|
|
preset.availability_nux = None;
|
|
});
|
|
let target = presets
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4")
|
|
.expect("target preset present");
|
|
target.availability_nux = Some(ModelAvailabilityNux {
|
|
message: "gpt-5.4 is available".to_string(),
|
|
});
|
|
|
|
let selected = select_model_availability_nux(&presets, &model_availability_nux_config(&[]));
|
|
|
|
assert_eq!(
|
|
selected,
|
|
Some(StartupTooltipOverride {
|
|
model_slug: "gpt-5.4".to_string(),
|
|
message: "gpt-5.4 is available".to_string(),
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn select_model_availability_nux_skips_missing_and_exhausted_models() {
|
|
let mut presets = all_model_presets();
|
|
presets.iter_mut().for_each(|preset| {
|
|
preset.availability_nux = None;
|
|
});
|
|
let gpt_5 = presets
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4")
|
|
.expect("gpt-5.4 preset present");
|
|
gpt_5.availability_nux = Some(ModelAvailabilityNux {
|
|
message: "gpt-5.4 is available".to_string(),
|
|
});
|
|
let gpt_5_2 = presets
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4-mini")
|
|
.expect("gpt-5.4-mini preset present");
|
|
gpt_5_2.availability_nux = Some(ModelAvailabilityNux {
|
|
message: "gpt-5.4-mini is available".to_string(),
|
|
});
|
|
|
|
let selected = select_model_availability_nux(
|
|
&presets,
|
|
&model_availability_nux_config(&[("gpt-5.4", MODEL_AVAILABILITY_NUX_MAX_SHOW_COUNT)]),
|
|
);
|
|
|
|
assert_eq!(
|
|
selected,
|
|
Some(StartupTooltipOverride {
|
|
model_slug: "gpt-5.4-mini".to_string(),
|
|
message: "gpt-5.4-mini is available".to_string(),
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn select_model_availability_nux_uses_existing_model_order_as_priority() {
|
|
let mut presets = all_model_presets();
|
|
presets.iter_mut().for_each(|preset| {
|
|
preset.availability_nux = None;
|
|
});
|
|
let first = presets
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4-mini")
|
|
.expect("gpt-5.4-mini preset present");
|
|
first.availability_nux = Some(ModelAvailabilityNux {
|
|
message: "first".to_string(),
|
|
});
|
|
let second = presets
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4")
|
|
.expect("gpt-5.4 preset present");
|
|
second.availability_nux = Some(ModelAvailabilityNux {
|
|
message: "second".to_string(),
|
|
});
|
|
|
|
let selected = select_model_availability_nux(&presets, &model_availability_nux_config(&[]));
|
|
|
|
assert_eq!(
|
|
selected,
|
|
Some(StartupTooltipOverride {
|
|
model_slug: "gpt-5.4".to_string(),
|
|
message: "second".to_string(),
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn select_model_availability_nux_returns_none_when_all_models_are_exhausted() {
|
|
let mut presets = all_model_presets();
|
|
presets.iter_mut().for_each(|preset| {
|
|
preset.availability_nux = None;
|
|
});
|
|
let target = presets
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4")
|
|
.expect("target preset present");
|
|
target.availability_nux = Some(ModelAvailabilityNux {
|
|
message: "gpt-5.4 is available".to_string(),
|
|
});
|
|
|
|
let selected = select_model_availability_nux(
|
|
&presets,
|
|
&model_availability_nux_config(&[("gpt-5.4", MODEL_AVAILABILITY_NUX_MAX_SHOW_COUNT)]),
|
|
);
|
|
|
|
assert_eq!(selected, None);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn prepare_startup_tooltip_override_persists_model_availability_nux_count() {
|
|
let codex_home = tempdir().expect("temp codex home");
|
|
let mut config = ConfigBuilder::default()
|
|
.codex_home(codex_home.path().to_path_buf())
|
|
.build()
|
|
.await
|
|
.expect("config");
|
|
let mut presets = all_model_presets();
|
|
presets.iter_mut().for_each(|preset| {
|
|
preset.availability_nux = None;
|
|
});
|
|
let target = presets
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4")
|
|
.expect("target preset present");
|
|
target.availability_nux = Some(ModelAvailabilityNux {
|
|
message: "gpt-5.4 is available".to_string(),
|
|
});
|
|
|
|
let tooltip =
|
|
prepare_startup_tooltip_override(&mut config, &presets, /*is_first_run*/ false).await;
|
|
|
|
assert_eq!(tooltip.as_deref(), Some("gpt-5.4 is available"));
|
|
assert_eq!(
|
|
config.model_availability_nux.shown_count,
|
|
HashMap::from([("gpt-5.4".to_string(), 1)])
|
|
);
|
|
|
|
let reloaded = ConfigBuilder::default()
|
|
.codex_home(codex_home.path().to_path_buf())
|
|
.build()
|
|
.await
|
|
.expect("reloaded config");
|
|
assert_eq!(
|
|
reloaded.model_availability_nux.shown_count,
|
|
HashMap::from([("gpt-5.4".to_string(), 1)])
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn accepted_model_migration_persists_target_default_reasoning_effort() {
|
|
let codex_home = tempdir().expect("temp codex home");
|
|
let mut config = ConfigBuilder::default()
|
|
.codex_home(codex_home.path().to_path_buf())
|
|
.build()
|
|
.await
|
|
.expect("config");
|
|
config.model = Some("gpt-5.2".to_string());
|
|
config.model_reasoning_effort = Some(ReasoningEffortConfig::XHigh);
|
|
|
|
let (tx_raw, mut rx) = unbounded_channel();
|
|
let app_event_tx = AppEventSender::new(tx_raw);
|
|
|
|
apply_accepted_model_migration(
|
|
&mut config,
|
|
&app_event_tx,
|
|
"gpt-5.2".to_string(),
|
|
"gpt-5.4".to_string(),
|
|
ReasoningEffortConfig::Medium,
|
|
);
|
|
|
|
assert_eq!(config.model.as_deref(), Some("gpt-5.4"));
|
|
assert_eq!(
|
|
config.model_reasoning_effort,
|
|
Some(ReasoningEffortConfig::Medium)
|
|
);
|
|
|
|
let acknowledged = rx.try_recv().expect("acknowledged event");
|
|
assert_matches!(
|
|
acknowledged,
|
|
AppEvent::PersistModelMigrationPromptAcknowledged { from_model, to_model }
|
|
if from_model == "gpt-5.2" && to_model == "gpt-5.4"
|
|
);
|
|
|
|
let update_model = rx.try_recv().expect("update model event");
|
|
assert_matches!(
|
|
update_model,
|
|
AppEvent::UpdateModel(model) if model == "gpt-5.4"
|
|
);
|
|
|
|
let update_effort = rx.try_recv().expect("update effort event");
|
|
assert_matches!(
|
|
update_effort,
|
|
AppEvent::UpdateReasoningEffort(Some(ReasoningEffortConfig::Medium))
|
|
);
|
|
|
|
let persist_selection = rx.try_recv().expect("persist model selection event");
|
|
assert_matches!(
|
|
persist_selection,
|
|
AppEvent::PersistModelSelection { model, effort }
|
|
if model == "gpt-5.4" && effort == Some(ReasoningEffortConfig::Medium)
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn model_migration_prompt_respects_hide_flag_and_self_target() {
|
|
let mut seen = BTreeMap::new();
|
|
seen.insert("gpt-5.2".to_string(), "gpt-5.4".to_string());
|
|
assert!(!should_show_model_migration_prompt(
|
|
"gpt-5.2",
|
|
"gpt-5.4",
|
|
&seen,
|
|
&all_model_presets()
|
|
));
|
|
assert!(!should_show_model_migration_prompt(
|
|
"gpt-5.4",
|
|
"gpt-5.4",
|
|
&seen,
|
|
&all_model_presets()
|
|
));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn model_migration_prompt_skips_when_target_missing_or_hidden() {
|
|
let mut available = all_model_presets();
|
|
let mut current = available
|
|
.iter()
|
|
.find(|preset| preset.model == "gpt-5.2")
|
|
.cloned()
|
|
.expect("preset present");
|
|
current.upgrade = Some(ModelUpgrade {
|
|
id: "missing-target".to_string(),
|
|
migration_config_key: HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG.to_string(),
|
|
model_link: None,
|
|
upgrade_copy: None,
|
|
migration_markdown: None,
|
|
});
|
|
available.retain(|preset| preset.model != "gpt-5.2");
|
|
available.push(current.clone());
|
|
|
|
assert!(!should_show_model_migration_prompt(
|
|
¤t.model,
|
|
"missing-target",
|
|
&BTreeMap::new(),
|
|
&available,
|
|
));
|
|
|
|
assert!(target_preset_for_upgrade(&available, "missing-target").is_none());
|
|
|
|
let mut with_hidden_target = all_model_presets();
|
|
let target = with_hidden_target
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.4")
|
|
.expect("target preset present");
|
|
target.show_in_picker = false;
|
|
|
|
assert!(!should_show_model_migration_prompt(
|
|
"gpt-5.2",
|
|
"gpt-5.4",
|
|
&BTreeMap::new(),
|
|
&with_hidden_target,
|
|
));
|
|
assert!(target_preset_for_upgrade(&with_hidden_target, "gpt-5.4").is_none());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn model_migration_prompt_shows_for_hidden_model() {
|
|
let codex_home = tempdir().expect("temp codex home");
|
|
let config = ConfigBuilder::default()
|
|
.codex_home(codex_home.path().to_path_buf())
|
|
.build()
|
|
.await
|
|
.expect("config");
|
|
|
|
let mut available_models = all_model_presets();
|
|
let current = available_models
|
|
.iter_mut()
|
|
.find(|preset| preset.model == "gpt-5.3-codex")
|
|
.expect("gpt-5.3-codex preset present");
|
|
current.show_in_picker = false;
|
|
let current = current.clone();
|
|
assert!(
|
|
!current.show_in_picker,
|
|
"expected gpt-5.3-codex to be hidden from picker for this test"
|
|
);
|
|
|
|
let upgrade = current.upgrade.as_ref().expect("upgrade configured");
|
|
available_models
|
|
.iter_mut()
|
|
.find(|preset| preset.model == upgrade.id)
|
|
.expect("upgrade target present")
|
|
.show_in_picker = true;
|
|
assert!(
|
|
should_show_model_migration_prompt(
|
|
¤t.model,
|
|
&upgrade.id,
|
|
&config.notices.model_migrations,
|
|
&available_models,
|
|
),
|
|
"expected migration prompt to be eligible for hidden model"
|
|
);
|
|
|
|
let target =
|
|
target_preset_for_upgrade(&available_models, &upgrade.id).expect("upgrade target present");
|
|
let target_description = (!target.description.is_empty()).then(|| target.description.clone());
|
|
let can_opt_out = true;
|
|
let copy = migration_copy_for_models(
|
|
¤t.model,
|
|
&upgrade.id,
|
|
upgrade.model_link.clone(),
|
|
upgrade.upgrade_copy.clone(),
|
|
upgrade.migration_markdown.clone(),
|
|
target.display_name.clone(),
|
|
target_description,
|
|
can_opt_out,
|
|
);
|
|
|
|
assert_snapshot!(
|
|
"model_migration_prompt_shows_for_hidden_model",
|
|
model_migration_copy_to_plain_text(©)
|
|
);
|
|
}
|