config: add override config foundation

# Conflicts:
#	codex-rs/config/src/loader/mod.rs
This commit is contained in:
Brent Traut
2026-05-19 13:29:23 -07:00
parent 5c43a64e2b
commit ed68380a48
27 changed files with 1814 additions and 125 deletions
+11 -2
View File
@@ -228,11 +228,20 @@ where
fn config_path_for_layer(layer: &ConfigLayerEntry, config_toml_file: &str) -> Option<PathBuf> {
match &layer.name {
ConfigLayerSource::System { file } => Some(file.to_path_buf()),
ConfigLayerSource::User { file, .. } => Some(file.to_path_buf()),
ConfigLayerSource::System { file } | ConfigLayerSource::SystemOverride { file } => {
Some(file.to_path_buf())
}
ConfigLayerSource::User { file, .. } | ConfigLayerSource::UserOverride { file } => {
Some(file.to_path_buf())
}
ConfigLayerSource::Project { dot_codex_folder } => {
Some(dot_codex_folder.as_path().join(config_toml_file))
}
ConfigLayerSource::ProjectOverride { dot_codex_folder } => Some(
dot_codex_folder
.as_path()
.join(crate::CONFIG_OVERRIDE_TOML_FILE),
),
ConfigLayerSource::LegacyManagedConfigTomlFromFile { file } => Some(file.to_path_buf()),
ConfigLayerSource::Mdm { .. }
| ConfigLayerSource::SessionFlags
+1
View File
@@ -27,6 +27,7 @@ mod tui_keymap;
pub mod types;
pub const CONFIG_TOML_FILE: &str = "config.toml";
pub const CONFIG_OVERRIDE_TOML_FILE: &str = "config.override.toml";
pub use cloud_requirements::CloudRequirementsLoadError;
pub use cloud_requirements::CloudRequirementsLoadErrorCode;
+226 -27
View File
@@ -5,6 +5,7 @@ mod macos;
mod tests;
use self::layer_io::LoadedConfigLayers;
use crate::CONFIG_OVERRIDE_TOML_FILE;
use crate::CONFIG_TOML_FILE;
use crate::ProfileV2Name;
use crate::cloud_requirements::CloudRequirementsLoader;
@@ -210,6 +211,23 @@ pub async fn load_config_layers_state(
)
.await?;
layers.push(system_layer);
if let Some(system_override_layer) = load_optional_override_layer(
fs,
&system_config_toml_file,
strict_config,
|override_file, config_toml| {
ConfigLayerEntry::new(
ConfigLayerSource::SystemOverride {
file: override_file,
},
config_toml,
)
},
)
.await?
{
layers.push(system_override_layer);
}
// Add the base user config layer. When profile-v2 is selected, add the
// profile config as a second user layer on top so the profile only needs to
@@ -242,6 +260,24 @@ pub async fn load_config_layers_state(
));
}
layers.push(base_user_layer);
if !ignore_user_config
&& let Some(user_override_layer) = load_optional_override_layer(
fs,
&base_user_file,
strict_config,
|override_file, config_toml| {
ConfigLayerEntry::new(
ConfigLayerSource::UserOverride {
file: override_file,
},
config_toml,
)
},
)
.await?
{
layers.push(user_override_layer);
}
if active_user_file != base_user_file {
layers.push(
@@ -480,6 +516,36 @@ async fn load_config_toml_for_required_layer(
Ok(create_entry(toml_value))
}
async fn load_optional_override_layer(
fs: &dyn ExecutorFileSystem,
config_toml_file: &AbsolutePathBuf,
strict_config: bool,
create_entry: impl FnOnce(AbsolutePathBuf, TomlValue) -> ConfigLayerEntry,
) -> io::Result<Option<ConfigLayerEntry>> {
let parent = config_toml_file.parent().ok_or_else(|| {
io::Error::new(
io::ErrorKind::InvalidData,
format!(
"Config file {} has no parent directory",
config_toml_file.as_path().display()
),
)
})?;
let override_file = parent.join(CONFIG_OVERRIDE_TOML_FILE);
let Some(config_toml) = layer_io::read_config_from_path(
fs,
&override_file,
/*log_missing_as_info*/ false,
strict_config,
)
.await?
else {
return Ok(None);
};
let config_toml = resolve_relative_paths_in_config_toml(config_toml, parent.as_path())?;
Ok(Some(create_entry(override_file, config_toml)))
}
fn validate_config_toml_strictly(
toml_file: &Path,
contents: &str,
@@ -862,10 +928,38 @@ fn project_layer_entry(
disabled_reason: Option<String>,
hooks_config_folder_override: Option<AbsolutePathBuf>,
) -> ConfigLayerEntry {
let source = ConfigLayerSource::Project {
dot_codex_folder: dot_codex_folder.clone(),
};
project_config_layer_entry(
ConfigLayerSource::Project {
dot_codex_folder: dot_codex_folder.clone(),
},
config,
disabled_reason,
hooks_config_folder_override,
)
}
fn project_override_layer_entry(
dot_codex_folder: &AbsolutePathBuf,
config: TomlValue,
disabled_reason: Option<String>,
hooks_config_folder_override: Option<AbsolutePathBuf>,
) -> ConfigLayerEntry {
project_config_layer_entry(
ConfigLayerSource::ProjectOverride {
dot_codex_folder: dot_codex_folder.clone(),
},
config,
disabled_reason,
hooks_config_folder_override,
)
}
fn project_config_layer_entry(
source: ConfigLayerSource,
config: TomlValue,
disabled_reason: Option<String>,
hooks_config_folder_override: Option<AbsolutePathBuf>,
) -> ConfigLayerEntry {
let entry = if let Some(reason) = disabled_reason {
ConfigLayerEntry::new_disabled(source, config, reason)
} else {
@@ -890,10 +984,9 @@ fn sanitize_project_config(config: &mut TomlValue) -> Vec<String> {
}
fn project_ignored_config_keys_warning(
dot_codex_folder: &AbsolutePathBuf,
config_path: AbsolutePathBuf,
ignored_keys: &[String],
) -> String {
let config_path = dot_codex_folder.join(CONFIG_TOML_FILE);
let ignored_keys = ignored_keys.join(", ");
format!(
concat!(
@@ -1191,31 +1284,20 @@ async fn load_project_layers(
continue;
}
};
let mut config = config;
if disabled_reason.is_none() && strict_config {
validate_config_toml_strictly(
config_file.as_path(),
&contents,
&config,
dot_codex_abs.as_path(),
)?;
}
let ignored_project_config_keys = sanitize_project_config(&mut config);
let config =
resolve_relative_paths_in_config_toml(config, dot_codex_abs.as_path())?;
let config = merge_root_checkout_project_hooks(
let config = prepare_project_layer_config(
fs,
&config_file,
CONFIG_TOML_FILE,
&contents,
config,
&dot_codex_abs,
hooks_config_folder_override.as_ref(),
decision.is_trusted(),
strict_config,
disabled_reason.is_none(),
&mut startup_warnings,
)
.await?;
if disabled_reason.is_none() && !ignored_project_config_keys.is_empty() {
startup_warnings.push(project_ignored_config_keys_warning(
&dot_codex_abs,
&ignored_project_config_keys,
));
}
let entry = project_layer_entry(
&dot_codex_abs,
config,
@@ -1234,13 +1316,14 @@ async fn load_project_layers(
TomlValue::Table(toml::map::Map::new()),
hooks_config_folder_override.as_ref(),
decision.is_trusted(),
CONFIG_TOML_FILE,
)
.await?;
layers.push(project_layer_entry(
&dot_codex_abs,
config,
disabled_reason,
hooks_config_folder_override,
disabled_reason.clone(),
hooks_config_folder_override.clone(),
));
} else {
let config_file_display = config_file.as_path().display();
@@ -1251,6 +1334,80 @@ async fn load_project_layers(
}
}
}
let override_file = dot_codex_abs.join(CONFIG_OVERRIDE_TOML_FILE);
match fs.read_file_text(&override_file, /*sandbox*/ None).await {
Ok(contents) => {
let config: TomlValue = match toml::from_str(&contents) {
Ok(config) => config,
Err(err) => {
if decision.is_trusted() {
let override_file_display = override_file.as_path().display();
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!(
"Error parsing project override config file {override_file_display}: {err}"
),
));
}
layers.push(project_override_layer_entry(
&dot_codex_abs,
TomlValue::Table(toml::map::Map::new()),
disabled_reason.clone(),
hooks_config_folder_override.clone(),
));
continue;
}
};
let config = prepare_project_layer_config(
fs,
&override_file,
CONFIG_OVERRIDE_TOML_FILE,
&contents,
config,
&dot_codex_abs,
hooks_config_folder_override.as_ref(),
decision.is_trusted(),
strict_config,
disabled_reason.is_none(),
&mut startup_warnings,
)
.await?;
layers.push(project_override_layer_entry(
&dot_codex_abs,
config,
disabled_reason.clone(),
hooks_config_folder_override.clone(),
));
}
Err(err) if err.kind() == io::ErrorKind::NotFound => {
if hooks_config_folder_override.is_some() {
let config = merge_root_checkout_project_hooks(
fs,
TomlValue::Table(toml::map::Map::new()),
hooks_config_folder_override.as_ref(),
decision.is_trusted(),
CONFIG_OVERRIDE_TOML_FILE,
)
.await?;
layers.push(project_override_layer_entry(
&dot_codex_abs,
config,
disabled_reason.clone(),
hooks_config_folder_override.clone(),
));
}
}
Err(err) => {
let override_file_display = override_file.as_path().display();
return Err(io::Error::new(
err.kind(),
format!(
"Failed to read project override config file {override_file_display}: {err}"
),
));
}
}
}
Ok(LoadedProjectLayers {
@@ -1259,6 +1416,47 @@ async fn load_project_layers(
})
}
#[allow(clippy::too_many_arguments)]
async fn prepare_project_layer_config(
fs: &dyn ExecutorFileSystem,
config_file: &AbsolutePathBuf,
config_file_name: &str,
contents: &str,
mut config: TomlValue,
dot_codex_abs: &AbsolutePathBuf,
hooks_config_folder_override: Option<&AbsolutePathBuf>,
is_trusted: bool,
strict_config: bool,
is_enabled: bool,
startup_warnings: &mut Vec<String>,
) -> io::Result<TomlValue> {
if is_enabled && strict_config {
validate_config_toml_strictly(
config_file.as_path(),
contents,
&config,
dot_codex_abs.as_path(),
)?;
}
let ignored_project_config_keys = sanitize_project_config(&mut config);
let config = resolve_relative_paths_in_config_toml(config, dot_codex_abs.as_path())?;
let config = merge_root_checkout_project_hooks(
fs,
config,
hooks_config_folder_override,
is_trusted,
config_file_name,
)
.await?;
if is_enabled && !ignored_project_config_keys.is_empty() {
startup_warnings.push(project_ignored_config_keys_warning(
config_file.clone(),
&ignored_project_config_keys,
));
}
Ok(config)
}
/// For linked worktrees, preserve ordinary worktree-local project config while
/// replacing only hook declarations with the matching root-checkout layer.
async fn merge_root_checkout_project_hooks(
@@ -1266,11 +1464,12 @@ async fn merge_root_checkout_project_hooks(
mut config: TomlValue,
hooks_config_folder_override: Option<&AbsolutePathBuf>,
is_trusted: bool,
config_toml_file: &str,
) -> io::Result<TomlValue> {
let Some(hooks_config_folder) = hooks_config_folder_override else {
return Ok(config);
};
let hooks_config_file = hooks_config_folder.join(CONFIG_TOML_FILE);
let hooks_config_file = hooks_config_folder.join(config_toml_file);
let root_config = match fs
.read_file_text(&hooks_config_file, /*sandbox*/ None)
.await
+169 -76
View File
@@ -180,9 +180,16 @@ impl ConfigLayerEntry {
pub fn config_folder(&self) -> Option<AbsolutePathBuf> {
match &self.name {
ConfigLayerSource::Mdm { .. } => None,
ConfigLayerSource::System { file } => file.parent(),
ConfigLayerSource::User { file, .. } => file.parent(),
ConfigLayerSource::Project { dot_codex_folder } => Some(dot_codex_folder.clone()),
ConfigLayerSource::System { file } | ConfigLayerSource::SystemOverride { file } => {
file.parent()
}
ConfigLayerSource::User { file, .. } | ConfigLayerSource::UserOverride { file } => {
file.parent()
}
ConfigLayerSource::Project { dot_codex_folder }
| ConfigLayerSource::ProjectOverride { dot_codex_folder } => {
Some(dot_codex_folder.clone())
}
ConfigLayerSource::SessionFlags => None,
ConfigLayerSource::LegacyManagedConfigTomlFromFile { .. } => None,
ConfigLayerSource::LegacyManagedConfigTomlFromMdm => None,
@@ -301,8 +308,8 @@ impl ConfigLayerStack {
/// Returns all user config layers in the requested precedence order.
///
/// With profile-v2 enabled, `LowestPrecedenceFirst` returns the base user
/// config before the profile overlay, while `HighestPrecedenceFirst` returns
/// the profile overlay before the base user config.
/// config, sibling user override, then profile overlay, while
/// `HighestPrecedenceFirst` returns that order in reverse.
pub fn get_user_layers(
&self,
ordering: ConfigLayerStackOrdering,
@@ -310,14 +317,14 @@ impl ConfigLayerStack {
) -> Vec<&ConfigLayerEntry> {
self.get_layers(ordering, include_disabled)
.into_iter()
.filter(|layer| matches!(layer.name, ConfigLayerSource::User { .. }))
.filter(|layer| is_user_config_layer(&layer.name))
.collect()
}
/// Returns the merged config from enabled user layers only.
///
/// When profile config is active, this includes the base user config followed
/// by the profile override config.
/// When profile config is active, this includes the base user config, any
/// sibling user override, then the profile override config.
pub fn effective_user_config(&self) -> Option<TomlValue> {
let user_layers = self.get_user_layers(
ConfigLayerStackOrdering::LowestPrecedenceFirst,
@@ -358,6 +365,25 @@ impl ConfigLayerStack {
self.with_user_config_profile(config_toml, profile.as_ref(), user_config)
}
pub fn with_user_override_config(
&self,
config_toml: &AbsolutePathBuf,
user_config: TomlValue,
) -> Self {
let user_layer = ConfigLayerEntry::new(
ConfigLayerSource::UserOverride {
file: config_toml.clone(),
},
user_config,
);
self.with_user_layer(user_layer, |layer| {
matches!(
&layer.name,
ConfigLayerSource::UserOverride { file } if file == config_toml
)
})
}
pub fn with_user_config_profile(
&self,
config_toml: &AbsolutePathBuf,
@@ -372,38 +398,12 @@ impl ConfigLayerStack {
user_config,
);
let mut layers = self.layers.clone();
if let Some(index) = layers.iter().position(|layer| {
self.with_user_layer(user_layer, |layer| {
matches!(
&layer.name,
ConfigLayerSource::User { file, .. } if file == config_toml
)
}) {
layers.remove(index);
}
match layers
.iter()
.position(|layer| layer.name.precedence() > user_layer.name.precedence())
{
Some(index) => layers.insert(index, user_layer),
None => layers.push(user_layer),
}
let user_layer_index = layers.iter().enumerate().rev().find_map(|(index, layer)| {
if matches!(layer.name, ConfigLayerSource::User { .. }) {
Some(index)
} else {
None
}
});
Self {
layers,
user_layer_index,
requirements: self.requirements.clone(),
requirements_toml: self.requirements_toml.clone(),
ignore_user_and_project_exec_policy_rules: self
.ignore_user_and_project_exec_policy_rules,
startup_warnings: self.startup_warnings.clone(),
}
})
}
/// Returns a new stack with the user layer copied from `other`, preserving
@@ -412,31 +412,37 @@ impl ConfigLayerStack {
let user_layers = other
.layers
.iter()
.filter(|layer| matches!(layer.name, ConfigLayerSource::User { .. }))
.filter(|layer| is_user_config_layer(&layer.name))
.cloned()
.collect::<Vec<_>>();
let mut layers = self
.layers
.iter()
.filter(|layer| !matches!(layer.name, ConfigLayerSource::User { .. }))
.filter(|layer| !is_user_config_layer(&layer.name))
.cloned()
.collect::<Vec<_>>();
for user_layer in user_layers {
match layers
.iter()
.position(|layer| layer.name.precedence() > user_layer.name.precedence())
{
Some(index) => layers.insert(index, user_layer),
None => layers.push(user_layer),
}
insert_user_layer(&mut layers, user_layer);
}
let user_layer_index = layers.iter().enumerate().rev().find_map(|(index, layer)| {
if matches!(layer.name, ConfigLayerSource::User { .. }) {
Some(index)
} else {
None
}
});
self.with_layers(layers)
}
fn with_user_layer(
&self,
user_layer: ConfigLayerEntry,
matches_existing: impl Fn(&ConfigLayerEntry) -> bool,
) -> Self {
let mut layers = self.layers.clone();
if let Some(index) = layers.iter().position(matches_existing) {
layers[index] = user_layer;
} else {
insert_user_layer(&mut layers, user_layer);
}
self.with_layers(layers)
}
fn with_layers(&self, layers: Vec<ConfigLayerEntry>) -> Self {
let user_layer_index = active_user_layer_index(&layers);
Self {
layers,
user_layer_index,
@@ -511,6 +517,63 @@ impl ConfigLayerStack {
}
}
fn is_user_config_layer(layer: &ConfigLayerSource) -> bool {
matches!(
layer,
ConfigLayerSource::User { .. } | ConfigLayerSource::UserOverride { .. }
)
}
fn insert_user_layer(layers: &mut Vec<ConfigLayerEntry>, user_layer: ConfigLayerEntry) {
let index = layers.iter().position(|layer| {
layer.name.precedence() > user_layer.name.precedence()
|| matches!(
(&user_layer.name, &layer.name),
(
ConfigLayerSource::User {
file,
profile: None,
},
ConfigLayerSource::UserOverride {
file: override_file,
}
) if user_base_file_has_sibling_override(file, override_file)
)
|| matches!(
(&user_layer.name, &layer.name),
(
ConfigLayerSource::UserOverride {
file: override_file,
},
ConfigLayerSource::User {
file,
profile: None,
}
) if !user_base_file_has_sibling_override(file, override_file)
)
});
match index {
Some(index) => layers.insert(index, user_layer),
None => layers.push(user_layer),
}
}
fn user_base_file_has_sibling_override(
file: &AbsolutePathBuf,
override_file: &AbsolutePathBuf,
) -> bool {
file.parent() == override_file.parent()
&& file
.file_name()
.is_some_and(|name| name == crate::CONFIG_TOML_FILE)
}
fn active_user_layer_index(layers: &[ConfigLayerEntry]) -> Option<usize> {
layers.iter().enumerate().rev().find_map(|(index, layer)| {
matches!(layer.name, ConfigLayerSource::User { .. }).then_some(index)
})
}
/// Ensures precedence ordering of config layers is correct. Returns the index
/// of the active user config layer, if any.
fn verify_layer_ordering(layers: &[ConfigLayerEntry]) -> std::io::Result<Option<usize>> {
@@ -525,41 +588,71 @@ fn verify_layer_ordering(layers: &[ConfigLayerEntry]) -> std::io::Result<Option<
// further verify that project layers are ordered from root to cwd. Multiple
// user layers are allowed so a profile override can layer on top of the base
// user config.
let mut user_layer_index: Option<usize> = None;
let mut previous_project_dot_codex_folder: Option<&AbsolutePathBuf> = None;
for (index, layer) in layers.iter().enumerate() {
if matches!(layer.name, ConfigLayerSource::User { .. }) {
user_layer_index = Some(index);
let mut previous_user_layer: Option<&ConfigLayerSource> = None;
let mut previous_project_layer: Option<(&AbsolutePathBuf, bool)> = None;
for layer in layers {
if let Some(previous) = previous_user_layer
&& let (
ConfigLayerSource::UserOverride {
file: override_file,
},
ConfigLayerSource::User {
file,
profile: None,
},
) = (previous, &layer.name)
&& user_base_file_has_sibling_override(file, override_file)
{
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"user layers are not ordered from config.toml to config.override.toml",
));
}
if is_user_config_layer(&layer.name) {
previous_user_layer = Some(&layer.name);
}
if let ConfigLayerSource::Project {
dot_codex_folder: current_project_dot_codex_folder,
} = &layer.name
let current_project_layer = match &layer.name {
ConfigLayerSource::Project { dot_codex_folder } => Some((dot_codex_folder, false)),
ConfigLayerSource::ProjectOverride { dot_codex_folder } => {
Some((dot_codex_folder, true))
}
_ => None,
};
if let Some((current_project_dot_codex_folder, current_is_override)) = current_project_layer
{
if let Some(previous) = previous_project_dot_codex_folder {
let Some(parent) = previous.as_path().parent() else {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"project layer has no parent directory",
));
};
if previous == current_project_dot_codex_folder
|| !current_project_dot_codex_folder
if let Some((previous, previous_is_override)) = previous_project_layer {
if previous == current_project_dot_codex_folder {
if previous_is_override || !current_is_override {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"project layers are not ordered from config.toml to config.override.toml",
));
}
} else {
let Some(parent) = previous.as_path().parent() else {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"project layer has no parent directory",
));
};
if !current_project_dot_codex_folder
.as_path()
.ancestors()
.any(|ancestor| ancestor == parent)
{
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"project layers are not ordered from root to cwd",
));
{
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"project layers are not ordered from root to cwd",
));
}
}
}
previous_project_dot_codex_folder = Some(current_project_dot_codex_folder);
previous_project_layer = Some((current_project_dot_codex_folder, current_is_override));
}
}
Ok(user_layer_index)
Ok(active_user_layer_index(layers))
}
#[cfg(test)]
+231
View File
@@ -90,6 +90,237 @@ approval_policy = "on-failure"
);
}
#[test]
fn effective_user_config_merges_user_override_after_base_layer() {
let temp_dir = TempDir::new().expect("tempdir");
let base_file = test_user_config_path(&temp_dir, "config.toml");
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
let stack = ConfigLayerStack::new(
vec![
ConfigLayerEntry::new(
ConfigLayerSource::User {
file: base_file,
profile: None,
},
toml::from_str(r#"model = "base""#).expect("base config"),
),
ConfigLayerEntry::new(
ConfigLayerSource::UserOverride {
file: override_file,
},
toml::from_str(r#"model = "override""#).expect("override config"),
),
],
ConfigRequirements::default(),
ConfigRequirementsToml::default(),
)
.expect("user override stack should be valid");
assert_eq!(
stack
.effective_user_config()
.expect("merged user config")
.get("model")
.and_then(toml::Value::as_str),
Some("override")
);
}
#[test]
fn with_user_config_preserves_user_override_precedence() {
let temp_dir = TempDir::new().expect("tempdir");
let base_file = test_user_config_path(&temp_dir, "config.toml");
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
let stack = ConfigLayerStack::new(
vec![
ConfigLayerEntry::new(
ConfigLayerSource::User {
file: base_file.clone(),
profile: None,
},
toml::from_str(r#"model = "base""#).expect("base config"),
),
ConfigLayerEntry::new(
ConfigLayerSource::UserOverride {
file: override_file,
},
toml::from_str(r#"model = "override""#).expect("override config"),
),
],
ConfigRequirements::default(),
ConfigRequirementsToml::default(),
)
.expect("user override stack should be valid");
let updated = stack.with_user_config(
&base_file,
toml::from_str(r#"model = "updated-base""#).expect("updated base config"),
);
let user_layers = updated
.get_user_layers(
ConfigLayerStackOrdering::LowestPrecedenceFirst,
/*include_disabled*/ false,
)
.into_iter()
.map(|layer| layer.name.clone())
.collect::<Vec<_>>();
assert!(matches!(
user_layers.as_slice(),
[
ConfigLayerSource::User { .. },
ConfigLayerSource::UserOverride { .. },
]
));
assert_eq!(
updated
.effective_user_config()
.expect("merged user config")
.get("model")
.and_then(toml::Value::as_str),
Some("override")
);
}
#[test]
fn with_user_config_preserves_selected_non_profile_user_precedence() {
let temp_dir = TempDir::new().expect("tempdir");
let base_file = test_user_config_path(&temp_dir, "config.toml");
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
let selected_file = test_user_config_path(&temp_dir, "selected.toml");
let stack = ConfigLayerStack::new(
vec![
ConfigLayerEntry::new(
ConfigLayerSource::User {
file: base_file,
profile: None,
},
toml::from_str(r#"model = "base""#).expect("base config"),
),
ConfigLayerEntry::new(
ConfigLayerSource::UserOverride {
file: override_file,
},
toml::from_str(r#"model = "override""#).expect("override config"),
),
ConfigLayerEntry::new(
ConfigLayerSource::User {
file: selected_file.clone(),
profile: None,
},
toml::from_str(r#"model = "selected""#).expect("selected config"),
),
],
ConfigRequirements::default(),
ConfigRequirementsToml::default(),
)
.expect("selected user stack should be valid");
let updated = stack.with_user_config(
&selected_file,
toml::from_str(r#"model = "selected-updated""#).expect("updated selected config"),
);
assert_eq!(
updated
.effective_user_config()
.expect("merged user config")
.get("model")
.and_then(toml::Value::as_str),
Some("selected-updated")
);
}
#[test]
fn with_user_override_config_preserves_selected_non_profile_user_precedence() {
let temp_dir = TempDir::new().expect("tempdir");
let base_file = test_user_config_path(&temp_dir, "config.toml");
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
let selected_file = test_user_config_path(&temp_dir, "selected.toml");
let stack = ConfigLayerStack::new(
vec![
ConfigLayerEntry::new(
ConfigLayerSource::User {
file: base_file,
profile: None,
},
toml::from_str(r#"model = "base""#).expect("base config"),
),
ConfigLayerEntry::new(
ConfigLayerSource::User {
file: selected_file,
profile: None,
},
toml::from_str(r#"model = "selected""#).expect("selected config"),
),
],
ConfigRequirements::default(),
ConfigRequirementsToml::default(),
)
.expect("selected user stack should be valid");
let updated = stack.with_user_override_config(
&override_file,
toml::from_str(r#"model = "override""#).expect("override config"),
);
let user_layers = updated
.get_user_layers(
ConfigLayerStackOrdering::LowestPrecedenceFirst,
/*include_disabled*/ false,
)
.into_iter()
.map(|layer| layer.name.clone())
.collect::<Vec<_>>();
assert!(matches!(
user_layers.as_slice(),
[
ConfigLayerSource::User { .. },
ConfigLayerSource::UserOverride { .. },
ConfigLayerSource::User { .. },
]
));
assert_eq!(
updated
.effective_user_config()
.expect("merged user config")
.get("model")
.and_then(toml::Value::as_str),
Some("selected")
);
}
#[test]
fn stack_rejects_base_user_config_after_sibling_override() {
let temp_dir = TempDir::new().expect("tempdir");
let base_file = test_user_config_path(&temp_dir, "config.toml");
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
let err = ConfigLayerStack::new(
vec![
ConfigLayerEntry::new(
ConfigLayerSource::UserOverride {
file: override_file,
},
toml::from_str(r#"model = "override""#).expect("override config"),
),
ConfigLayerEntry::new(
ConfigLayerSource::User {
file: base_file,
profile: None,
},
toml::from_str(r#"model = "base""#).expect("base config"),
),
],
ConfigRequirements::default(),
ConfigRequirementsToml::default(),
)
.expect_err("base user config should not follow its sibling override");
assert_eq!(
err.to_string(),
"user layers are not ordered from config.toml to config.override.toml"
);
}
#[test]
fn with_user_config_updates_matching_user_layer_without_replacing_active_profile() {
let temp_dir = TempDir::new().expect("tempdir");