Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows
use super::*;
use crate::config::commands::CommandConfig;
use crate::config::{HooksConfig, ProjectId};
use crate::git::HookType;
use crate::testing::TestRepo;
fn test_repo() -> TestRepo {
TestRepo::new()
}
/// Whether mode bits actually restrict reads here. Root ignores them, so the
/// permission tests below would assert an error that never arrives, and skip
/// instead. Probing is what makes that decision on the uid rather than on
/// `$USER`, which a container running as root can leave unset — the same shape
/// the permission tests in `tests/` use.
#[cfg(unix)]
fn permissions_restrict_reads(dir: &std::path::Path) -> bool {
use std::os::unix::fs::PermissionsExt;
let probe = dir.join("permission-probe");
std::fs::write(&probe, b"x").unwrap();
std::fs::set_permissions(&probe, std::fs::Permissions::from_mode(0o000)).unwrap();
let restricted = std::fs::read(&probe).is_err();
let _ = std::fs::set_permissions(&probe, std::fs::Permissions::from_mode(0o644));
let _ = std::fs::remove_file(&probe);
restricted
}
#[test]
fn test_default_config_path_returns_platform_path() {
// default_config_path() returns the platform-specific path without
// CLI or env var overrides. Verify it returns a valid path.
let path = default_config_path();
assert!(path.is_some(), "default_config_path should return Some");
let path = path.unwrap();
assert!(
path.ends_with("worktrunk/config.toml") || path.ends_with(r"worktrunk\config.toml"),
"Expected path ending in worktrunk/config.toml, got: {path:?}"
);
}
// `config_path()`'s fall-through to `default_config_path()` has no test here on
// purpose: it resolves the developer's real config, which is what the
// `#[cfg(test)]` guard in `config_path()` now refuses. The platform path it
// would return is covered above, and the two overrides that outrank it are
// exercised by the subprocess suite, which sets `WORKTRUNK_CONFIG_PATH`.
#[test]
fn test_compute_unknown_tree_empty() {
// Valid config with no unknown keys
let content = r#"
worktree-path = "../{{ main_worktree }}.{{ branch }}"
"#;
let tree = crate::config::compute_unknown_tree::<UserConfig>(content).unwrap();
assert!(tree.is_empty(), "expected no unknowns, got {tree:?}");
}
#[test]
fn test_compute_unknown_tree_with_unknown() {
// Config with unknown top-level keys
let content = r#"
worktree-path = "../{{ main_worktree }}.{{ branch }}"
unknown-key = "value"
another-unknown = 42
"#;
let tree = crate::config::compute_unknown_tree::<UserConfig>(content).unwrap();
assert!(tree.keys.contains("unknown-key"));
assert!(tree.keys.contains("another-unknown"));
}
#[test]
fn test_compute_unknown_tree_known_sections() {
// All known sections should not be reported
let content = r#"
worktree-path = "../{{ main_worktree }}.{{ branch }}"
[list]
full = true
[commit]
stage = "all"
[commit.generation]
command = "llm"
[merge]
squash = true
[step.copy-ignored]
exclude = [".conductor/"]
[post-start]
run = "npm install"
[post-switch]
rename-tab = "echo 'switched'"
"#;
let tree = crate::config::compute_unknown_tree::<UserConfig>(content).unwrap();
assert!(tree.is_empty());
}
#[test]
fn test_commit_generation_config_is_configured_empty() {
let config = CommitGenerationConfig::default();
assert!(!config.is_configured());
}
#[test]
fn test_commit_generation_config_is_configured_with_command() {
let config = CommitGenerationConfig {
command: Some("llm".to_string()),
..Default::default()
};
assert!(config.is_configured());
}
#[test]
fn test_commit_generation_config_is_configured_with_whitespace_only() {
let config = CommitGenerationConfig {
command: Some(" ".to_string()),
..Default::default()
};
assert!(!config.is_configured());
}
#[test]
fn test_commit_generation_config_is_configured_with_empty_string() {
let config = CommitGenerationConfig {
command: Some("".to_string()),
..Default::default()
};
assert!(!config.is_configured());
}
#[test]
fn test_stage_mode_default() {
assert_eq!(StageMode::default(), StageMode::All);
}
#[test]
fn test_stage_mode_serde() {
// Test serialization
let all_json = serde_json::to_string(&StageMode::All).unwrap();
assert_eq!(all_json, "\"all\"");
let tracked_json = serde_json::to_string(&StageMode::Tracked).unwrap();
assert_eq!(tracked_json, "\"tracked\"");
let none_json = serde_json::to_string(&StageMode::None).unwrap();
assert_eq!(none_json, "\"none\"");
// Test deserialization
let all: StageMode = serde_json::from_str("\"all\"").unwrap();
assert_eq!(all, StageMode::All);
let tracked: StageMode = serde_json::from_str("\"tracked\"").unwrap();
assert_eq!(tracked, StageMode::Tracked);
let none: StageMode = serde_json::from_str("\"none\"").unwrap();
assert_eq!(none, StageMode::None);
}
#[test]
fn test_user_project_config_default() {
let config = UserProjectOverrides::default();
assert!(config.worktree_path.is_none());
assert!(config.approved_commands.is_empty());
}
#[test]
fn test_user_project_config_with_worktree_path_serde() {
let config = UserProjectOverrides {
worktree_path: Some(".worktrees/{{ branch | sanitize }}".to_string()),
approved_commands: vec!["npm install".to_string()],
..Default::default()
};
let toml = toml::to_string(&config).unwrap();
insta::assert_snapshot!(toml, @r#"
approved-commands = ["npm install"]
worktree-path = ".worktrees/{{ branch | sanitize }}"
"#);
let parsed: UserProjectOverrides = toml::from_str(&toml).unwrap();
assert_eq!(
parsed.worktree_path,
Some(".worktrees/{{ branch | sanitize }}".to_string())
);
assert_eq!(parsed.approved_commands, vec!["npm install".to_string()]);
}
#[test]
fn test_worktree_path_for_project_uses_project_specific() {
let mut config = UserConfig::default();
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
worktree_path: Some(".worktrees/{{ branch | sanitize }}".to_string()),
..Default::default()
},
);
// Project-specific path should be used
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("github.com/user/repo")),
".worktrees/{{ branch | sanitize }}"
);
}
#[test]
fn test_worktree_path_for_project_falls_back_to_global() {
let mut config = UserConfig {
worktree_path: Some("../{{ repo }}-{{ branch | sanitize }}".to_string()),
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
worktree_path: None, // No project-specific path
approved_commands: vec!["npm install".to_string()],
..Default::default()
},
);
// Should fall back to global worktree-path
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("github.com/user/repo")),
"../{{ repo }}-{{ branch | sanitize }}"
);
}
#[test]
fn test_worktree_path_for_project_falls_back_to_default() {
let config = UserConfig::default();
// Unknown project should fall back to default template
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("github.com/unknown/project")),
"{{ repo_path }}/../{{ repo }}.{{ branch | sanitize }}"
);
}
#[test]
fn test_format_path_with_project_override() {
let test = test_repo();
let mut config = UserConfig {
worktree_path: Some("../{{ repo }}.{{ branch | sanitize }}".to_string()),
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
worktree_path: Some(".worktrees/{{ branch | sanitize }}".to_string()),
..Default::default()
},
);
// With project identifier, should use project-specific template
let path = config
.format_path(
"myrepo",
"feature/branch",
&test.repo,
Some(&ProjectId::from("github.com/user/repo")),
)
.unwrap();
assert_eq!(path, ".worktrees/feature-branch");
// Without project identifier, should use global template
let path = config
.format_path("myrepo", "feature/branch", &test.repo, None)
.unwrap();
assert_eq!(path, "../myrepo.feature-branch");
}
#[test]
fn test_list_config_serde() {
let config = ListConfig {
full: Some(true),
branches: Some(false),
remotes: None,
summary: None,
json_schema: None,
timeout_ms: None,
columns: vec!["branch".into(), "ci".into(), "path".into()],
custom_columns: Default::default(),
};
let json = serde_json::to_string(&config).unwrap();
let parsed: ListConfig = serde_json::from_str(&json).unwrap();
assert_eq!(parsed.full, Some(true));
assert_eq!(parsed.branches, Some(false));
assert_eq!(parsed.remotes, None);
assert_eq!(parsed.summary, None);
assert_eq!(parsed.timeout_ms, None);
assert_eq!(parsed.columns, vec!["branch", "ci", "path"]);
}
#[test]
fn test_list_config_columns_from_toml_array() {
// Config files use a TOML array.
let from_array: ListConfig = toml::from_str(r#"columns = ["branch", "ci"]"#).unwrap();
assert_eq!(from_array.columns, vec!["branch", "ci"]);
// Array entries are taken verbatim, so a stray-space entry survives to fail
// loudly at the wt list edge rather than being silently dropped.
let untrimmed: ListConfig = toml::from_str(r#"columns = [" branch "]"#).unwrap();
assert_eq!(untrimmed.columns, vec![" branch "]);
// Absent → empty (the default column set), not an error.
let absent: ListConfig = toml::from_str("full = true").unwrap();
assert!(absent.columns.is_empty());
// TODO(list-columns-env): the env overlay can only deliver a scalar, so the
// string form is rejected until env-var support lands (see ListConfig::columns).
let from_string: Result<ListConfig, _> = toml::from_str(r#"columns = "branch,ci""#);
assert!(from_string.is_err());
}
#[test]
fn test_commit_config_default() {
let config = CommitConfig::default();
assert!(config.stage.is_none());
}
#[test]
fn test_worktrunk_config_default() {
let config = UserConfig::default();
// worktree_path is None by default, but the getter returns the default
assert!(config.worktree_path.is_none());
assert_eq!(
config.worktree_path(),
"{{ repo_path }}/../{{ repo }}.{{ branch | sanitize }}"
);
assert!(config.projects.is_empty());
assert_eq!(config.list, ListConfig::default());
assert_eq!(config.commit, CommitConfig::default());
assert_eq!(config.merge, MergeConfig::default());
assert!(!config.skip_shell_integration_prompt);
}
#[test]
fn test_worktrunk_config_format_path() {
let test = test_repo();
let config = UserConfig::default();
let path = config
.format_path("myrepo", "feature/branch", &test.repo, None)
.unwrap();
// Default path is now absolute: {{ repo_path }}/../{{ repo }}.{{ branch | sanitize }}
// The template uses forward slashes which work on all platforms
// Check that the path contains the expected components
assert!(
path.contains("myrepo.feature-branch"),
"Expected path containing 'myrepo.feature-branch', got: {path}"
);
// Verify it contains parent directory navigation
assert!(
path.contains("/..") || path.contains(r"\.."),
"Expected path containing parent navigation, got: {path}"
);
// The path should start with the repo path (absolute)
let repo_path = test.repo.repo_path().unwrap().to_string_lossy();
assert!(
path.starts_with(repo_path.as_ref()),
"Expected path starting with repo path '{repo_path}', got: {path}"
);
}
#[test]
fn test_worktrunk_config_format_path_custom_template() {
let test = test_repo();
let config = UserConfig {
worktree_path: Some(".worktrees/{{ branch }}".to_string()),
..Default::default()
};
let path = config
.format_path("myrepo", "feature", &test.repo, None)
.unwrap();
assert_eq!(path, ".worktrees/feature");
}
#[test]
fn test_worktrunk_config_format_path_repo_path_variable() {
let test = test_repo();
let config = UserConfig {
// Use forward slashes in template (works on all platforms)
worktree_path: Some("{{ repo_path }}/worktrees/{{ branch | sanitize }}".to_string()),
..Default::default()
};
let path = config
.format_path("myrepo", "feature/branch", &test.repo, None)
.unwrap();
// Path should contain the expected components
assert!(
path.contains("worktrees") && path.contains("feature-branch"),
"Expected path containing 'worktrees' and 'feature-branch', got: {path}"
);
// The path should start with the repo path
let repo_path = test.repo.repo_path().unwrap().to_string_lossy();
assert!(
path.starts_with(repo_path.as_ref()),
"Expected path starting with repo path '{repo_path}', got: {path}"
);
// The path should be absolute since repo_path is absolute
assert!(
std::path::Path::new(&path).is_absolute() || path.starts_with('/'),
"Expected absolute path, got: {path}"
);
}
#[test]
fn test_worktrunk_config_format_path_tilde_expansion() {
let test = test_repo();
let config = UserConfig {
worktree_path: Some("~/worktrees/{{ repo }}/{{ branch | sanitize }}".to_string()),
..Default::default()
};
let path = config
.format_path("myrepo", "feature/branch", &test.repo, None)
.unwrap();
// Tilde should be expanded to home directory
assert!(
!path.starts_with('~'),
"Tilde should be expanded, got: {path}"
);
// Path should contain expected components
assert!(
path.contains("worktrees") && path.contains("myrepo") && path.contains("feature-branch"),
"Expected path containing 'worktrees/myrepo/feature-branch', got: {path}"
);
// Path should be absolute after tilde expansion
assert!(
std::path::Path::new(&path).is_absolute(),
"Expected absolute path after tilde expansion, got: {path}"
);
}
#[test]
fn test_worktrunk_config_format_path_owner_variable() {
let mut test = TestRepo::with_initial_commit();
test.setup_remote("main");
test.run_git(&[
"remote",
"set-url",
"origin",
"[email protected]:max-sixty/worktrunk.git",
]);
let config = UserConfig {
worktree_path: Some("{{ owner }}/{{ repo }}/{{ branch }}".to_string()),
..Default::default()
};
let path = config
.format_path("myrepo", "feature/branch", &test.repo, None)
.unwrap();
assert_eq!(path, "max-sixty/myrepo/feature/branch");
}
#[test]
fn test_worktrunk_config_format_path_remote_repo_variable() {
let mut test = TestRepo::with_initial_commit();
test.setup_remote("main");
test.run_git(&[
"remote",
"set-url",
"origin",
"[email protected]:company-org/project.git",
]);
let config = UserConfig {
worktree_path: Some("{{ remote_repo }}/{{ repo }}/{{ branch }}".to_string()),
..Default::default()
};
let path = config
.format_path("myrepo", "feature/branch", &test.repo, None)
.unwrap();
assert_eq!(path, "project/myrepo/feature/branch");
}
#[test]
fn test_worktrunk_config_format_path_owner_uses_full_namespace() {
let mut test = TestRepo::with_initial_commit();
test.setup_remote("main");
test.run_git(&[
"remote",
"set-url",
"origin",
"[email protected]:group/subgroup/project.git",
]);
let config = UserConfig {
worktree_path: Some("{{ owner }}/{{ repo }}/{{ branch }}".to_string()),
..Default::default()
};
let path = config
.format_path("myrepo", "feature/branch", &test.repo, None)
.unwrap();
assert_eq!(path, "group/subgroup/myrepo/feature/branch");
}
#[test]
fn test_merge_config_serde() {
let config = MergeConfig {
squash: Some(true),
commit: Some(true),
rebase: Some(false),
remove: Some(true),
verify: Some(true),
ff: None,
};
let json = serde_json::to_string(&config).unwrap();
let parsed: MergeConfig = serde_json::from_str(&json).unwrap();
assert_eq!(parsed.squash, Some(true));
assert_eq!(parsed.rebase, Some(false));
}
#[test]
fn test_remove_config_default_delete_branch_true() {
let config = RemoveConfig::default();
assert!(config.delete_branch());
assert_eq!(config.delete_branch, None);
}
#[test]
fn test_remove_config_parse_delete_branch_false() {
let toml = r#"
[remove]
delete-branch = false
"#;
let parsed = UserConfig::load_from_str(toml).unwrap();
assert_eq!(parsed.remove.delete_branch, Some(false));
assert!(!parsed.remove(None).delete_branch());
}
#[test]
fn test_remove_config_project_override() {
let toml = r#"
[remove]
delete-branch = true
[projects."github.com/user/repo".remove]
delete-branch = false
"#;
let parsed = UserConfig::load_from_str(toml).unwrap();
// Global default is preserved
assert!(parsed.remove(None).delete_branch());
// Project override wins
assert!(
!parsed
.remove(Some(&ProjectId::from("github.com/user/repo")))
.delete_branch()
);
}
#[test]
fn test_remove_config_merge() {
let base = RemoveConfig {
delete_branch: Some(true),
};
let override_config = RemoveConfig {
delete_branch: Some(false),
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.delete_branch, Some(false));
// Empty override falls back to base
let merged = base.merge_with(&RemoveConfig::default());
assert_eq!(merged.delete_branch, Some(true));
}
#[test]
fn test_skip_shell_integration_prompt_default_false() {
let config = UserConfig::default();
assert!(!config.skip_shell_integration_prompt);
}
#[test]
fn test_skip_shell_integration_prompt_serde_roundtrip() {
// Test serialization when true
let config = UserConfig {
skip_shell_integration_prompt: true,
..UserConfig::default()
};
let toml = toml::to_string(&config).unwrap();
assert!(toml.contains("skip-shell-integration-prompt = true"));
// Test deserialization
let parsed: UserConfig = toml::from_str(&toml).unwrap();
assert!(parsed.skip_shell_integration_prompt);
}
#[test]
fn test_skip_shell_integration_prompt_skipped_when_false() {
// When false, the field should not appear in serialized output
let config = UserConfig::default();
let toml = toml::to_string(&config).unwrap();
assert!(!toml.contains("skip-shell-integration-prompt"));
}
#[test]
fn test_skip_shell_integration_prompt_parsed_from_toml() {
let content = r#"
worktree-path = "../{{ main_worktree }}.{{ branch }}"
skip-shell-integration-prompt = true
"#;
let config: UserConfig = toml::from_str(content).unwrap();
assert!(config.skip_shell_integration_prompt);
}
#[test]
fn test_skip_shell_integration_prompt_defaults_when_missing() {
let content = r#"
worktree-path = "../{{ main_worktree }}.{{ branch }}"
"#;
let config: UserConfig = toml::from_str(content).unwrap();
assert!(!config.skip_shell_integration_prompt);
}
#[test]
fn test_set_project_worktree_path() {
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
std::fs::write(&config_path, "# empty config\n").unwrap();
let mut config = UserConfig::default();
config
.set_project_worktree_path(
"github.com/user/repo",
"../{{ branch | sanitize }}".to_string(),
&config_path,
)
.unwrap();
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("github.com/user/repo")),
"../{{ branch | sanitize }}"
);
// Verify it was saved to disk
let content = std::fs::read_to_string(&config_path).unwrap();
assert!(content.contains("[projects.\"github.com/user/repo\"]"));
assert!(content.contains("worktree-path"));
}
// =========================================================================
// Merge trait tests
// =========================================================================
#[test]
fn test_merge_list_config() {
let base = ListConfig {
full: Some(true),
branches: Some(false),
remotes: None,
summary: Some(true),
json_schema: None,
timeout_ms: Some(2000),
columns: vec!["branch".into(), "ci".into()],
custom_columns: Default::default(),
};
let override_config = ListConfig {
full: None, // Should fall back to base
branches: Some(true), // Should override
remotes: Some(true), // Should override (base was None)
summary: None, // Should fall back to base
json_schema: None,
timeout_ms: None, // Should fall back to base
columns: Vec::new(), // Empty → fall back to base
custom_columns: Default::default(),
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.full, Some(true)); // From base
assert_eq!(merged.branches, Some(true)); // From override
assert_eq!(merged.remotes, Some(true)); // From override
assert_eq!(merged.summary, Some(true)); // From base
assert_eq!(merged.timeout_ms, Some(2000)); // From base
assert_eq!(merged.columns, vec!["branch", "ci"]); // From base (override empty)
}
#[test]
fn test_merge_list_config_columns_replace() {
// A non-empty override replaces the whole list (it's an ordering, not a
// keyed set), unlike the per-key union used for custom_columns.
let base = ListConfig {
columns: vec!["branch".into(), "ci".into(), "path".into()],
..Default::default()
};
let override_config = ListConfig {
columns: vec!["status".into(), "branch".into()],
..Default::default()
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.columns, vec!["status", "branch"]);
}
#[test]
fn test_merge_list_config_columns_per_key() {
let column = |template: &str| sections::ListColumnConfig {
template: template.to_string(),
width: None,
priority: None,
};
let mut base = ListConfig::default();
base.custom_columns
.insert("A".to_string(), column("base-a"));
base.custom_columns
.insert("B".to_string(), column("base-b"));
let mut override_config = ListConfig::default();
override_config
.custom_columns
.insert("B".to_string(), column("override-b"));
override_config
.custom_columns
.insert("C".to_string(), column("c"));
// Per-key union: the override wins on collision without clearing the rest
let merged = base.merge_with(&override_config);
assert_eq!(merged.custom_columns.len(), 3);
assert_eq!(merged.custom_columns["A"].template, "base-a");
assert_eq!(merged.custom_columns["B"].template, "override-b");
assert_eq!(merged.custom_columns["C"].template, "c");
}
#[test]
fn test_merge_commit_config() {
let base = CommitConfig {
stage: Some(StageMode::All),
generation: None,
};
let override_config = CommitConfig {
stage: Some(StageMode::Tracked),
generation: None,
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.stage, Some(StageMode::Tracked));
}
#[test]
fn test_merge_commit_config_generation_base_only() {
// Base has generation, override doesn't - use base
let base = CommitConfig {
stage: None,
generation: Some(CommitGenerationConfig {
command: Some("base-llm".to_string()),
..Default::default()
}),
};
let override_config = CommitConfig {
stage: None,
generation: None,
};
let merged = base.merge_with(&override_config);
assert_eq!(
merged.generation.as_ref().unwrap().command,
Some("base-llm".to_string())
);
}
#[test]
fn test_merge_commit_config_generation_override_only() {
// Override has generation, base doesn't - use override
let base = CommitConfig {
stage: None,
generation: None,
};
let override_config = CommitConfig {
stage: None,
generation: Some(CommitGenerationConfig {
command: Some("override-llm".to_string()),
..Default::default()
}),
};
let merged = base.merge_with(&override_config);
assert_eq!(
merged.generation.as_ref().unwrap().command,
Some("override-llm".to_string())
);
}
#[test]
fn test_merge_commit_config_generation_both() {
// Both have generation - merge them
let base = CommitConfig {
stage: Some(StageMode::All),
generation: Some(CommitGenerationConfig {
command: Some("base-llm".to_string()),
template: Some("base-template".to_string()),
..Default::default()
}),
};
let override_config = CommitConfig {
stage: None, // Will use base's stage
generation: Some(CommitGenerationConfig {
command: Some("override-llm".to_string()), // Override command
template: None, // Use base's template
..Default::default()
}),
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.stage, Some(StageMode::All));
let generation = merged.generation.as_ref().unwrap();
assert_eq!(generation.command, Some("override-llm".to_string()));
assert_eq!(generation.template, Some("base-template".to_string()));
}
#[test]
fn test_merge_merge_config() {
let base = MergeConfig {
squash: Some(true),
commit: Some(true),
rebase: Some(true),
remove: Some(true),
verify: Some(true),
ff: Some(true),
};
let override_config = MergeConfig {
squash: Some(false), // Override
commit: None, // Fall back to base
rebase: None, // Fall back to base
remove: Some(false), // Override
verify: None, // Fall back to base
ff: Some(false), // Override
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.squash, Some(false));
assert_eq!(merged.commit, Some(true));
assert_eq!(merged.rebase, Some(true));
assert_eq!(merged.remove, Some(false));
assert_eq!(merged.verify, Some(true));
assert_eq!(merged.ff, Some(false));
}
#[test]
fn test_merge_commit_generation_config() {
let base = CommitGenerationConfig {
command: Some("llm -m claude-haiku-4.5".to_string()),
template: Some("base template".to_string()),
squash_template: None,
template_append: None,
};
let override_config = CommitGenerationConfig {
command: Some("claude -p --model=haiku".to_string()), // Override
template: Some("custom".to_string()), // Override
squash_template: None,
template_append: None,
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.command, Some("claude -p --model=haiku".to_string()));
assert_eq!(merged.template, Some("custom".to_string()));
}
#[test]
fn test_merge_commit_generation_template_append() {
// Override wins when set; otherwise the base value carries through.
let base = CommitGenerationConfig {
template_append: Some("base append".to_string()),
..Default::default()
};
let override_config = CommitGenerationConfig {
template_append: Some("override append".to_string()),
..Default::default()
};
assert_eq!(
base.merge_with(&override_config).template_append,
Some("override append".to_string())
);
assert_eq!(
base.merge_with(&CommitGenerationConfig::default())
.template_append,
Some("base append".to_string())
);
}
// =========================================================================
// Effective config methods tests
// =========================================================================
#[test]
fn test_effective_commit_generation_no_project() {
let config = UserConfig {
commit: CommitConfig {
stage: None,
generation: Some(CommitGenerationConfig {
command: Some("global-llm".to_string()),
..Default::default()
}),
},
..Default::default()
};
let effective = config.commit_generation(None);
assert_eq!(effective.command, Some("global-llm".to_string()));
}
#[test]
fn test_effective_commit_generation_with_project_override() {
let mut config = UserConfig {
commit: CommitConfig {
stage: None,
generation: Some(CommitGenerationConfig {
command: Some("global-llm".to_string()),
..Default::default()
}),
},
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
commit: CommitConfig {
stage: None,
generation: Some(CommitGenerationConfig {
command: Some("project-llm".to_string()),
..Default::default()
}),
},
..Default::default()
},
);
// With project identifier, should merge project config
let effective = config.commit_generation(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(effective.command, Some("project-llm".to_string()));
// Without project or unknown project, should use global
let effective = config.commit_generation(None);
assert_eq!(effective.command, Some("global-llm".to_string()));
let effective = config.commit_generation(Some(&ProjectId::from("github.com/other/repo")));
assert_eq!(effective.command, Some("global-llm".to_string()));
}
#[test]
fn test_effective_merge_with_partial_override() {
let mut config = UserConfig {
merge: MergeConfig {
squash: Some(true),
commit: Some(true),
rebase: Some(true),
remove: Some(true),
verify: Some(true),
ff: Some(true),
},
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
merge: MergeConfig {
squash: Some(false), // Only override squash
commit: None,
rebase: None,
remove: None,
verify: None,
ff: None,
},
..Default::default()
},
);
let effective = config.merge(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(effective.squash, Some(false)); // From project
assert_eq!(effective.commit, Some(true)); // From global
assert_eq!(effective.rebase, Some(true)); // From global
}
#[test]
fn test_effective_list_project_only() {
// No global list config, only project config
let mut config = UserConfig::default();
assert_eq!(config.list, ListConfig::default());
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
list: ListConfig {
full: Some(true),
..Default::default()
},
..Default::default()
},
);
let effective = config.list(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(effective.full, Some(true));
assert!(effective.branches.is_none());
// No global, no matching project falls back to default
assert_eq!(
config.list(Some(&ProjectId::from("github.com/other/repo"))),
ListConfig::default()
);
}
#[test]
fn test_effective_commit_global_only() {
// Only global config, no project config
let config = UserConfig {
commit: CommitConfig {
stage: Some(StageMode::Tracked),
generation: None,
},
..Default::default()
};
let effective = config.commit(Some(&ProjectId::from("github.com/any/project")));
assert_eq!(effective.stage, Some(StageMode::Tracked));
}
// =========================================================================
// Config accessor methods and ResolvedConfig tests
// =========================================================================
#[test]
fn test_list_config_accessor_methods_defaults() {
let config = ListConfig::default();
assert!(!config.full());
assert!(!config.branches());
assert!(!config.remotes());
assert!(config.timeout().is_none());
}
#[test]
fn test_list_config_accessor_methods_with_values() {
let config = ListConfig {
full: Some(true),
branches: Some(true),
remotes: Some(false),
summary: Some(true),
json_schema: None,
timeout_ms: Some(3000),
columns: Vec::new(),
custom_columns: Default::default(),
};
assert!(config.full());
assert!(config.branches());
assert!(!config.remotes());
assert!(config.summary());
assert_eq!(
config.timeout(),
Some(std::time::Duration::from_millis(3000))
);
}
#[test]
fn test_merge_config_accessor_methods_defaults() {
let config = MergeConfig::default();
// MergeConfig defaults are all true (including ff)
assert!(config.squash());
assert!(config.commit());
assert!(config.rebase());
assert!(config.remove());
assert!(config.verify());
assert!(config.ff());
}
#[test]
fn test_merge_config_accessor_methods_with_values() {
let config = MergeConfig {
squash: Some(false),
commit: Some(false),
rebase: Some(false),
remove: Some(false),
verify: Some(false),
ff: Some(false),
};
assert!(!config.squash());
assert!(!config.commit());
assert!(!config.rebase());
assert!(!config.remove());
assert!(!config.verify());
assert!(!config.ff());
}
#[test]
fn test_deprecated_no_ff_migrated_to_ff() {
let config = UserConfig::load_from_str("[merge]\nno-ff = true\n").unwrap();
assert!(!config.merge.ff());
}
#[test]
fn test_deprecated_no_ff_does_not_override_explicit_ff() {
// If both `ff` and `no-ff` are set, `ff` wins (no-ff is ignored)
let config = UserConfig::load_from_str("[merge]\nff = true\nno-ff = true\n").unwrap();
assert!(config.merge.ff());
}
#[test]
fn test_commit_config_accessor_methods() {
let config = CommitConfig::default();
assert_eq!(config.stage(), StageMode::All);
let config = CommitConfig {
stage: Some(StageMode::Tracked),
generation: None,
};
assert_eq!(config.stage(), StageMode::Tracked);
}
// =========================================================================
// SwitchPickerConfig tests
// =========================================================================
#[test]
fn test_switch_picker_config_accessor_methods() {
use crate::config::user::SwitchPickerConfig;
let config = SwitchPickerConfig::default();
assert!(config.pager().is_none());
assert!(config.preview());
let config = SwitchPickerConfig {
pager: Some("delta --paging=never".to_string()),
preview: Some(false),
};
assert_eq!(config.pager(), Some("delta --paging=never"));
assert!(!config.preview());
}
#[test]
fn test_switch_picker_config_parse_toml() {
let content = r#"
[switch.picker]
pager = "delta --paging=never"
preview = false
"#;
let config: UserConfig = toml::from_str(content).unwrap();
let picker = config.switch.picker.as_ref().unwrap();
assert_eq!(picker.pager.as_deref(), Some("delta --paging=never"));
assert_eq!(picker.preview, Some(false));
}
#[test]
fn test_switch_picker_merge() {
use crate::config::user::{Merge, SwitchPickerConfig};
let base = SwitchPickerConfig {
pager: Some("delta".to_string()),
preview: Some(false),
};
let override_config = SwitchPickerConfig {
pager: None, // Fall back to base
preview: Some(true),
};
let merged = base.merge_with(&override_config);
assert_eq!(merged.pager.as_deref(), Some("delta"));
assert_eq!(merged.preview, Some(true));
}
#[test]
fn test_switch_config_merge() {
use crate::config::user::{Merge, SwitchConfig, SwitchPickerConfig};
// Both have picker
let base = SwitchConfig {
picker: Some(SwitchPickerConfig {
pager: Some("delta".to_string()),
..Default::default()
}),
..Default::default()
};
let other = SwitchConfig {
picker: Some(SwitchPickerConfig {
pager: None,
..Default::default()
}),
..Default::default()
};
let merged = base.merge_with(&other);
assert_eq!(
merged.picker.as_ref().unwrap().pager.as_deref(),
Some("delta")
);
// Base has picker, other doesn't
let other_none = SwitchConfig::default();
let merged = base.merge_with(&other_none);
assert_eq!(
merged.picker.as_ref().unwrap().pager.as_deref(),
Some("delta")
);
// Neither has picker
let merged = SwitchConfig::default().merge_with(&other_none);
assert!(merged.picker.is_none());
}
#[test]
fn test_switch_config_cd_accessor() {
use crate::config::user::SwitchConfig;
// Default is true
let config = SwitchConfig::default();
assert!(config.cd());
// Explicit true
let config = SwitchConfig {
cd: Some(true),
..Default::default()
};
assert!(config.cd());
// Explicit false
let config = SwitchConfig {
cd: Some(false),
..Default::default()
};
assert!(!config.cd());
}
#[test]
fn test_switch_config_cd_merge() {
use crate::config::user::{Merge, SwitchConfig};
// Other overrides base
let base = SwitchConfig {
cd: Some(true),
..Default::default()
};
let other = SwitchConfig {
cd: Some(false),
..Default::default()
};
let merged = base.merge_with(&other);
assert!(!merged.cd());
// Base preserved when other is None
let base = SwitchConfig {
cd: Some(false),
..Default::default()
};
let merged = base.merge_with(&SwitchConfig::default());
assert!(!merged.cd());
// Neither set
let merged = SwitchConfig::default().merge_with(&SwitchConfig::default());
assert!(merged.cd()); // default true
}
#[test]
fn test_switch_config_cd_from_toml() {
let toml = r#"
[switch]
cd = false
"#;
let config = UserConfig::load_from_str(toml).unwrap();
let switch = config.switch(None);
assert!(!switch.cd());
}
#[test]
fn test_switch_config_cd_resolved() {
let toml = r#"
[switch]
cd = false
"#;
let config = UserConfig::load_from_str(toml).unwrap();
let resolved = config.resolved(None);
assert!(!resolved.switch.cd());
}
#[test]
fn test_deprecated_no_cd_migrated_to_cd() {
let config = UserConfig::load_from_str("[switch]\nno-cd = true\n").unwrap();
assert!(!config.switch.cd());
}
#[test]
fn test_deprecated_no_cd_does_not_override_explicit_cd() {
let config = UserConfig::load_from_str("[switch]\ncd = true\nno-cd = true\n").unwrap();
assert!(config.switch.cd());
}
#[test]
fn test_switch_picker_fallback_from_select() {
let config = UserConfig::load_from_str(
r#"
[select]
pager = "bat"
"#,
)
.unwrap();
let picker = config.switch_picker(None);
assert_eq!(picker.pager.as_deref(), Some("bat"));
// [select] is migrated to [switch.picker] at the TOML level before parsing
assert_eq!(
config
.switch
.picker
.as_ref()
.and_then(|picker| picker.pager.as_deref()),
Some("bat")
);
}
#[test]
fn test_switch_picker_prefers_new_over_select() {
let config = UserConfig::load_from_str(
r#"
[switch.picker]
pager = "delta"
[select]
pager = "bat"
"#,
)
.unwrap();
let picker = config.switch_picker(None);
assert_eq!(picker.pager.as_deref(), Some("delta"));
}
#[test]
fn test_switch_picker_project_override() {
use crate::config::user::{SwitchConfig, SwitchPickerConfig};
let mut config = UserConfig {
switch: SwitchConfig {
picker: Some(SwitchPickerConfig {
pager: Some("delta".to_string()),
..Default::default()
}),
..Default::default()
},
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
switch: SwitchConfig {
picker: Some(SwitchPickerConfig {
pager: Some("bat".to_string()),
..Default::default()
}),
..Default::default()
},
..Default::default()
},
);
let picker = config.switch_picker(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(picker.pager.as_deref(), Some("bat")); // From project
}
#[test]
fn test_switch_picker_project_fallback_from_select() {
let config = UserConfig::load_from_str(
r#"
[switch.picker]
pager = "delta"
[projects."github.com/user/repo".select]
pager = "bat"
"#,
)
.unwrap();
let picker = config.switch_picker(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(picker.pager.as_deref(), Some("bat"));
// [select] is migrated to [switch.picker] at the TOML level before parsing,
// so it ends up in the switch.picker field, not select
assert!(
config
.projects
.get("github.com/user/repo")
.unwrap()
.switch
.picker
.as_ref()
.and_then(|p| p.pager.as_deref())
== Some("bat")
);
}
#[test]
fn test_resolved_config_for_project() {
use crate::config::user::SwitchConfig;
use crate::config::user::SwitchPickerConfig;
let config = UserConfig {
list: ListConfig {
full: Some(true),
..Default::default()
},
merge: MergeConfig {
squash: Some(false),
..Default::default()
},
commit: CommitConfig {
stage: Some(StageMode::None),
..Default::default()
},
switch: SwitchConfig {
picker: Some(SwitchPickerConfig {
pager: Some("less".to_string()),
..Default::default()
}),
..Default::default()
},
..Default::default()
};
let resolved = config.resolved(None);
// Test that accessor methods work through ResolvedConfig
assert!(resolved.list.full());
assert!(!resolved.list.branches()); // Default
assert!(!resolved.merge.squash()); // Overridden to false
assert!(resolved.merge.commit()); // Default true
assert_eq!(resolved.commit.stage(), StageMode::None);
assert_eq!(resolved.switch_picker.pager(), Some("less"));
assert!(resolved.switch.cd()); // Default true
}
// =========================================================================
// Per-project config serde tests
// =========================================================================
#[test]
fn test_user_project_config_with_nested_configs_serde() {
let config = UserProjectOverrides {
approved_commands: vec!["npm install".to_string()],
worktree_path: Some(".worktrees/{{ branch }}".to_string()),
list: ListConfig {
full: Some(true),
..Default::default()
},
commit: CommitConfig {
stage: Some(StageMode::Tracked),
generation: Some(CommitGenerationConfig {
command: Some("llm -m gpt-4".to_string()),
..Default::default()
}),
},
merge: MergeConfig {
squash: Some(false),
..Default::default()
},
..Default::default()
};
let toml = toml::to_string(&config).unwrap();
let parsed: UserProjectOverrides = toml::from_str(&toml).unwrap();
assert_eq!(
parsed.worktree_path,
Some(".worktrees/{{ branch }}".to_string())
);
assert_eq!(
parsed.commit.generation.as_ref().unwrap().command,
Some("llm -m gpt-4".to_string())
);
assert_eq!(parsed.list.full, Some(true));
assert_eq!(parsed.commit.stage, Some(StageMode::Tracked));
assert_eq!(parsed.merge.squash, Some(false));
}
#[test]
fn test_full_config_with_per_project_sections_serde() {
// Test new format: [commit.generation] instead of [commit-generation]
let content = r#"
worktree-path = "../{{ repo }}.{{ branch | sanitize }}"
[commit.generation]
command = "llm -m claude-haiku-4.5"
[projects."github.com/user/repo"]
worktree-path = ".worktrees/{{ branch | sanitize }}"
approved-commands = ["npm install"]
[projects."github.com/user/repo".commit.generation]
command = "claude -p --model opus"
[projects."github.com/user/repo".list]
full = true
[projects."github.com/user/repo".merge]
squash = false
"#;
let config: UserConfig = toml::from_str(content).unwrap();
// Global config
assert_eq!(
config.worktree_path,
Some("../{{ repo }}.{{ branch | sanitize }}".to_string())
);
assert_eq!(
config.commit.generation.as_ref().unwrap().command,
Some("llm -m claude-haiku-4.5".to_string())
);
// Project config
let project = config.projects.get("github.com/user/repo").unwrap();
assert_eq!(
project.worktree_path,
Some(".worktrees/{{ branch | sanitize }}".to_string())
);
assert_eq!(
project.commit.generation.as_ref().unwrap().command,
Some("claude -p --model opus".to_string())
);
assert_eq!(project.list.full, Some(true));
assert_eq!(project.merge.squash, Some(false));
// Effective config for project
let effective_cg = config.commit_generation(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(
effective_cg.command,
Some("claude -p --model opus".to_string())
);
let effective_merge = config.merge(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(effective_merge.squash, Some(false));
}
#[test]
fn test_copy_ignored_config_merges_global_and_project() {
let project_id = "github.com/user/repo";
let config = UserConfig::load_from_str(
r#"
[step.copy-ignored]
exclude = [".conductor/", ".entire/"]
[projects."github.com/user/repo".step.copy-ignored]
exclude = [".repo-local/", ".entire/"]
"#,
)
.unwrap();
let expected_global = vec![".conductor/".to_string(), ".entire/".to_string()];
let expected_merged = vec![
".conductor/".to_string(),
".entire/".to_string(),
".repo-local/".to_string(),
];
assert_eq!(config.copy_ignored(None).exclude, expected_global);
assert_eq!(
config
.copy_ignored(Some(&ProjectId::from(project_id)))
.exclude,
expected_merged.clone()
);
assert_eq!(
config
.resolved(Some(&ProjectId::from(project_id)))
.step
.copy_ignored()
.exclude,
expected_merged
);
}
#[test]
fn test_deprecated_commit_generation_migrated_on_load() {
// [commit-generation] is migrated to [commit.generation] at the TOML level
// before serde parsing, so it lands in configs.commit.generation
let content = r#"
[commit-generation]
command = "llm -m claude-haiku-4.5"
[projects."github.com/user/repo".commit-generation]
command = "claude -p --model opus"
"#;
let config = UserConfig::load_from_str(content).unwrap();
assert_eq!(
config
.commit
.generation
.as_ref()
.and_then(|generation| generation.command.as_deref()),
Some("llm -m claude-haiku-4.5")
);
let project = config.projects.get("github.com/user/repo").unwrap();
assert_eq!(
project
.commit
.generation
.as_ref()
.and_then(|generation| generation.command.as_deref()),
Some("claude -p --model opus")
);
let effective_cg = config.commit_generation(Some(&ProjectId::from("github.com/user/repo")));
assert_eq!(
effective_cg.command,
Some("claude -p --model opus".to_string())
);
}
#[test]
fn test_deprecated_commit_generation_with_args_field() {
// Test that old format with args field is migrated: args merged into command
let content = r#"
[commit-generation]
command = "llm"
args = ["-m", "claude-haiku-4.5"]
"#;
let config = UserConfig::load_from_str(content).unwrap();
// Migration merges args into command and renames section
assert_eq!(
config
.commit
.generation
.as_ref()
.and_then(|g| g.command.as_deref()),
Some("llm -m claude-haiku-4.5")
);
}
// Validation tests
#[test]
fn test_validation_empty_worktree_path() {
let content = r#"worktree-path = """#;
let result = UserConfig::load_from_str(content);
let err = result.unwrap_err().to_string();
insta::assert_snapshot!(err, @"worktree-path cannot be empty");
}
#[test]
fn test_validation_absolute_worktree_path_allowed() {
// Absolute paths should be allowed for worktree-path
let content = if cfg!(windows) {
r#"worktree-path = "C:\\worktrees\\{{ branch | sanitize }}""#
} else {
r#"worktree-path = "/worktrees/{{ branch | sanitize }}""#
};
let result = UserConfig::load_from_str(content);
assert!(
result.is_ok(),
"Absolute paths should be allowed: {:?}",
result.err()
);
}
#[test]
fn test_validation_project_empty_worktree_path() {
let content = r#"
[projects."github.com/user/repo"]
worktree-path = ""
"#;
let result = UserConfig::load_from_str(content);
let err = result.unwrap_err().to_string();
insta::assert_snapshot!(err, @"projects.github.com/user/repo.worktree-path cannot be empty");
}
#[test]
fn test_validation_project_absolute_worktree_path_allowed() {
// Absolute paths should be allowed for per-project worktree-path
let content = if cfg!(windows) {
r#"
[projects."github.com/user/repo"]
worktree-path = "C:\\worktrees\\{{ branch | sanitize }}"
"#
} else {
r#"
[projects."github.com/user/repo"]
worktree-path = "/worktrees/{{ branch | sanitize }}"
"#
};
let result = UserConfig::load_from_str(content);
assert!(
result.is_ok(),
"Absolute paths should be allowed: {:?}",
result.err()
);
}
// =========================================================================
// Per-project hooks tests (append semantics)
// =========================================================================
/// Helper to parse hooks from TOML
fn parse_hooks(toml_str: &str) -> HooksConfig {
toml::from_str(toml_str).unwrap()
}
#[test]
fn test_hooks_merge_append_semantics() {
// Global has post-start, per-project has post-start
// Both should run (global first, then per-project)
let mut config = UserConfig {
hooks: parse_hooks("post-start = \"echo global\""),
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
hooks: parse_hooks("post-start = \"echo project\""),
..Default::default()
},
);
let effective = config.hooks(Some(&ProjectId::from("github.com/user/repo")));
let post_create = effective.post_create.unwrap();
let commands: Vec<_> = post_create.commands().collect();
assert_eq!(commands.len(), 2);
assert_eq!(commands[0].template, "echo global");
assert_eq!(commands[1].template, "echo project");
}
#[test]
fn test_hooks_no_project_override_uses_global() {
// Global has hooks, project doesn't - global hooks used
let config = UserConfig {
hooks: parse_hooks("post-start = \"echo global\""),
..Default::default()
};
let effective = config.hooks(Some(&ProjectId::from("github.com/other/repo")));
let post_create = effective.post_create.unwrap();
let commands: Vec<_> = post_create.commands().collect();
assert_eq!(commands.len(), 1);
assert_eq!(commands[0].template, "echo global");
}
#[test]
fn test_hooks_project_only_no_global() {
// Project has hooks, global doesn't - project hooks used
let mut config = UserConfig::default();
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
hooks: parse_hooks("post-start = \"echo project\""),
..Default::default()
},
);
let effective = config.hooks(Some(&ProjectId::from("github.com/user/repo")));
let post_create = effective.post_create.unwrap();
let commands: Vec<_> = post_create.commands().collect();
assert_eq!(commands.len(), 1);
assert_eq!(commands[0].template, "echo project");
}
#[test]
fn test_hooks_different_hook_types_not_merged() {
// Global has post-start, per-project has pre-commit
// These should remain separate (different hook types)
let mut config = UserConfig {
hooks: parse_hooks("post-start = \"echo global-start\""),
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
hooks: parse_hooks("pre-commit = \"echo project-commit\""),
..Default::default()
},
);
let effective = config.hooks(Some(&ProjectId::from("github.com/user/repo")));
// post-start: only global
let post_create = effective.post_create.unwrap();
let start_commands: Vec<_> = post_create.commands().collect();
assert_eq!(start_commands.len(), 1);
assert_eq!(start_commands[0].template, "echo global-start");
// pre-commit: only project
let pre_commit = effective.pre_commit.unwrap();
let commit_commands: Vec<_> = pre_commit.commands().collect();
assert_eq!(commit_commands.len(), 1);
assert_eq!(commit_commands[0].template, "echo project-commit");
}
#[test]
fn test_hooks_none_project_uses_global() {
// When no project is provided, only global hooks are used
let config = UserConfig {
hooks: parse_hooks("post-start = \"echo global\""),
..Default::default()
};
let effective = config.hooks(None);
let post_create = effective.post_create.unwrap();
let commands: Vec<_> = post_create.commands().collect();
assert_eq!(commands.len(), 1);
assert_eq!(commands[0].template, "echo global");
}
/// Validates that valid_user_config_keys() includes all hook types from HookType enum.
///
/// The JsonSchema derivation should include all HooksConfig fields, which correspond
/// to HookType variants. HookType uses strum's Display with kebab-case serialization,
/// which matches the serde field names.
#[test]
fn test_valid_user_config_keys_includes_all_hook_types() {
use strum::IntoEnumIterator;
let valid_keys = valid_user_config_keys();
for hook_type in HookType::iter() {
let key = hook_type.to_string(); // e.g., "post-start", "pre-merge"
assert!(
valid_keys.contains(&key),
"HookType::{hook_type:?} ({key}) is missing from valid_user_config_keys()"
);
}
}
/// Validates that all keys from valid_user_config_keys() are accepted by serde.
///
/// Creates a TOML config with each key set to a valid value and verifies
/// deserialization succeeds. This ensures the JsonSchema matches serde's expectations.
#[test]
fn test_valid_user_config_keys_all_deserialize() {
let valid_keys = valid_user_config_keys();
// Build a TOML string with all keys
// Top-level scalar values must come before table sections
let mut scalar_lines = Vec::new();
let mut table_lines = Vec::new();
for key in &valid_keys {
match key.as_str() {
"projects" => continue, // Skip - table type tested separately
// Silent aliases for canonical `pre-start`/`post-start`; including
// both would produce a duplicate-field error.
"pre-create" | "post-create" => continue,
"skip-shell-integration-prompt" | "skip-commit-generation-prompt" => {
scalar_lines.push(format!("{key} = true"));
}
"worktree-path" => {
scalar_lines.push(format!("{key} = \"test-value\""));
}
"list" | "commit" | "merge" | "remove" | "switch" | "step" | "select"
| "commit-generation" | "aliases" => {
// Table sections with minimal content
table_lines.push(format!("[{key}]"));
}
// Hook keys take string values
_ => {
scalar_lines.push(format!("{key} = \"test-value\""));
}
};
}
// Scalars first, then tables
scalar_lines.extend(table_lines);
let toml_content = scalar_lines.join("\n");
// Should deserialize without error
let result: Result<UserConfig, _> = toml::from_str(&toml_content);
assert!(
result.is_ok(),
"Failed to deserialize config with all valid keys:\n{toml_content}\nError: {:?}",
result.err()
);
}
// =========================================================================
// Hooks Merge Behavior Tests
// =========================================================================
//
// Note: Merged configs are only used for execution, never serialized in
// production. These tests verify merge semantics for execution order.
/// Merging string-format global hooks with table-format per-project hooks
/// preserves both and maintains correct execution order.
#[test]
fn test_hooks_merge_mixed_formats_preserves_order() {
// Global uses string format (unnamed command)
let global_hooks = parse_hooks(r#"post-start = "npm install""#);
// Per-project uses table format (named commands)
let project_hooks = parse_hooks(
r#"
[post-start]
setup = "echo setup"
"#,
);
let mut config = UserConfig {
hooks: global_hooks,
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
hooks: project_hooks,
..Default::default()
},
);
// Verify merge preserves order: global first, then project
let effective = config.hooks(Some(&ProjectId::from("github.com/user/repo")));
let commands: Vec<_> = effective.post_create.as_ref().unwrap().commands().collect();
assert_eq!(commands.len(), 2);
assert_eq!(commands[0].template, "npm install"); // Global first
assert_eq!(commands[1].template, "echo setup"); // Project second
}
/// When global and per-project both define same hook type, both run in order.
#[test]
fn test_hooks_merge_same_names_both_run() {
// Both define "test" command - both should execute
let global_hooks = parse_hooks(
r#"
[post-start]
test = "cargo test"
"#,
);
let project_hooks = parse_hooks(
r#"
[post-start]
test = "npm test"
"#,
);
let mut config = UserConfig {
hooks: global_hooks,
..Default::default()
};
config.projects.insert(
"github.com/user/repo".to_string(),
UserProjectOverrides {
hooks: project_hooks,
..Default::default()
},
);
// Both commands present, global first
let effective = config.hooks(Some(&ProjectId::from("github.com/user/repo")));
let commands: Vec<_> = effective.post_create.as_ref().unwrap().commands().collect();
assert_eq!(commands.len(), 2);
assert_eq!(commands[0].template, "cargo test");
assert_eq!(commands[1].template, "npm test");
}
// =========================================================================
// Mutation error path tests
// =========================================================================
/// A mutation returns a parse error with the formatted path when the config
/// file contains invalid TOML.
#[test]
fn test_mutation_invalid_toml() {
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
// Create initial valid config so file exists
std::fs::write(&config_path, "# Valid config\n").unwrap();
// Now corrupt it with invalid TOML
std::fs::write(&config_path, "this is not valid toml [[[").unwrap();
// A mutation reads the file first — it should fail with a parse error
let mut config = UserConfig::default();
let result = config.set_skip_shell_integration_prompt(&config_path);
let error = anyhow::Error::new(result.unwrap_err());
let rendered = crate::git::ErrorExt::render_diagnostic(&error).unwrap();
let rendered = ansi_str::AnsiStr::ansi_strip(&rendered).replace(
&crate::path::format_path_for_display(&config_path),
"[CONFIG]",
);
insta::assert_snapshot!(rendered, @"
✗ User config @ [CONFIG] failed to parse
TOML parse error at line 1, column 6
|
1 | this is not valid toml [[[
| ^
key with no value, expected `=`
");
assert_eq!(
std::fs::read_to_string(&config_path).unwrap(),
"this is not valid toml [[["
);
}
// =========================================================================
// System config loading and merge tests
// =========================================================================
#[test]
fn test_system_config_merged_with_user_config() {
// System config provides base defaults
let system_toml = r#"
[merge]
squash = false
rebase = false
[list]
full = true
"#;
// User config overrides some settings
let user_toml = r#"
[merge]
squash = true
"#;
// Parse both configs separately
let system_config = UserConfig::load_from_str(system_toml).unwrap();
let user_config = UserConfig::load_from_str(user_toml).unwrap();
// Verify system config values
assert_eq!(system_config.merge.squash, Some(false));
assert_eq!(system_config.merge.rebase, Some(false));
assert_eq!(system_config.list.full, Some(true));
// Verify user config values
assert_eq!(user_config.merge.squash, Some(true));
// Simulate the merge that happens via the config crate's builder:
// When both system and user configs define [merge], the config crate
// performs a deep merge where user values override system values.
// This is tested end-to-end via integration tests; here we verify
// the Merge trait works correctly for the layering.
let merged = system_config.merge.merge_with(&user_config.merge);
assert_eq!(merged.squash, Some(true)); // User overrides
assert_eq!(merged.rebase, Some(false)); // System default preserved
}
#[test]
fn test_system_config_worktree_path_overridden_by_user() {
let system_toml = r#"worktree-path = "/company/worktrees/{{ repo }}/{{ branch | sanitize }}""#;
let user_toml = r#"worktree-path = "../{{ repo }}.{{ branch | sanitize }}""#;
let system_config = UserConfig::load_from_str(system_toml).unwrap();
let user_config = UserConfig::load_from_str(user_toml).unwrap();
assert_eq!(
system_config.worktree_path(),
"/company/worktrees/{{ repo }}/{{ branch | sanitize }}"
);
assert_eq!(
user_config.worktree_path(),
"../{{ repo }}.{{ branch | sanitize }}"
);
}
#[test]
fn test_system_config_commit_generation_merged() {
let system_toml = r#"
[commit.generation]
command = "company-llm-tool"
template = "Company standard template: {{ git_diff }}"
"#;
let user_toml = r#"
[commit.generation]
command = "my-preferred-llm"
"#;
let system_config = UserConfig::load_from_str(system_toml).unwrap();
let user_config = UserConfig::load_from_str(user_toml).unwrap();
let system_gen = system_config.commit_generation(None);
assert_eq!(system_gen.command, Some("company-llm-tool".to_string()));
assert_eq!(
system_gen.template,
Some("Company standard template: {{ git_diff }}".to_string())
);
let user_gen = user_config.commit_generation(None);
assert_eq!(user_gen.command, Some("my-preferred-llm".to_string()));
// User didn't set template, so in a merged scenario the system template
// would be preserved via the config crate's deep merge
}
#[test]
fn test_hooks_merge_trait_appends_for_global_project_merge() {
// The Merge trait uses append semantics — used for global→per-project merging
// (in accessors.rs). NOT used for system→user config merging, which goes
// through the config crate's replacement semantics instead.
let global_hooks = parse_hooks("pre-merge = \"global-lint\"");
let project_hooks = parse_hooks("pre-merge = \"project-lint\"");
let merged = global_hooks.merge_with(&project_hooks);
let pre_merge = merged.pre_merge.unwrap();
let commands: Vec<_> = pre_merge.commands().collect();
assert_eq!(commands.len(), 2);
assert_eq!(commands[0].template, "global-lint"); // Global first
assert_eq!(commands[1].template, "project-lint"); // Project second
}
#[test]
fn test_hooks_merge_post_create_both_sides() {
// `post-start` from global and per-project config combine (global first).
let global = parse_hooks("post-start = \"npm install\"");
let project = parse_hooks("post-start = \"cargo build\"");
let merged = global.merge_with(&project);
let post_create = merged
.get(HookType::PostCreate)
.expect("should have post-start");
let commands: Vec<_> = post_create.commands().collect();
assert_eq!(commands.len(), 2);
assert_eq!(commands[0].template, "npm install");
assert_eq!(commands[1].template, "cargo build");
}
#[test]
fn test_aliases_accessor_appends_on_collision() {
let toml_str = r#"
[aliases]
shared = "global-cmd"
global-only = "only-global"
[projects."test-project".aliases]
shared = "project-cmd"
project-only = "only-project"
"#;
let config: UserConfig = toml::from_str(toml_str).unwrap();
let aliases = config.aliases(Some(&ProjectId::from("test-project")));
// Non-colliding aliases are present
assert_eq!(aliases["global-only"].commands().count(), 1);
assert_eq!(
aliases["global-only"].commands().next().unwrap().template,
"only-global"
);
assert_eq!(aliases["project-only"].commands().count(), 1);
assert_eq!(
aliases["project-only"].commands().next().unwrap().template,
"only-project"
);
// Colliding alias: both commands run (global first, then per-project)
let shared: Vec<_> = aliases["shared"].commands().collect();
assert_eq!(shared.len(), 2);
assert_eq!(shared[0].template, "global-cmd");
assert_eq!(shared[1].template, "project-cmd");
// Without project: only global aliases
let global_only = config.aliases(None);
assert_eq!(global_only["shared"].commands().count(), 1);
assert_eq!(
global_only["shared"].commands().next().unwrap().template,
"global-cmd"
);
}
/// A mutation surfaces a permission error when the config file exists but
/// cannot be read.
#[cfg(unix)]
#[test]
fn test_mutation_permission_error() {
use std::os::unix::fs::PermissionsExt;
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
// Create a valid config file
std::fs::write(&config_path, "[projects]\n").unwrap();
// Remove read permissions
let mut perms = std::fs::metadata(&config_path).unwrap().permissions();
perms.set_mode(0o000); // No permissions
std::fs::set_permissions(&config_path, perms).unwrap();
// Restore permissions on drop to allow cleanup
struct RestorePerms<'a>(&'a std::path::Path);
impl Drop for RestorePerms<'_> {
fn drop(&mut self) {
let mut perms = std::fs::metadata(self.0).unwrap().permissions();
perms.set_mode(0o644);
let _ = std::fs::set_permissions(self.0, perms);
}
}
let _guard = RestorePerms(&config_path);
if !permissions_restrict_reads(dir.path()) {
return;
}
// A mutation reads the file first — it should fail with a read error
let mut config = UserConfig::default();
let result = config.set_skip_shell_integration_prompt(&config_path);
assert!(result.is_err());
let err = result.unwrap_err().to_string();
assert!(
err.contains("Failed to read config file"),
"Expected read error, got: {err}"
);
// Verify path is included in error
assert!(
err.contains("config.toml"),
"Expected path in error, got: {err}"
);
}
#[test]
fn test_load_error_display_file() {
let toml_err = toml::from_str::<UserConfig>("[list]\nbranches = \"bad\"\n").unwrap_err();
let err = LoadError::File(crate::config::ConfigParseError::new(
ConfigFileKind::User,
std::path::Path::new("/tmp/config.toml"),
toml_err,
));
let msg = err.to_string();
assert!(msg.contains("User config @"), "{msg}");
assert!(msg.contains("failed to parse"), "{msg}");
let error = anyhow::Error::new(ConfigError::Load(err));
assert!(matches!(
error.downcast_ref::<ConfigError>(),
Some(ConfigError::Load(LoadError::File(_)))
));
assert!(error.root_cause().is::<toml::de::Error>());
let rendered = crate::git::ErrorExt::render_diagnostic(&error).unwrap();
assert!(rendered.contains("line 2"), "{rendered}");
}
#[test]
fn test_load_error_display_env() {
let err = LoadError::Env {
err: "invalid type".into(),
vars: vec![("WORKTRUNK__LIST__BRANCHES".into(), "not-a-bool".into())],
};
assert_eq!(err.to_string(), "invalid type");
}
#[test]
fn test_load_error_display_validation() {
let err = LoadError::Validation("bad".into());
assert_eq!(err.to_string(), "bad");
}
#[test]
fn test_load_error_display_cli_override() {
let err = LoadError::CliOverride {
err: "invalid type".into(),
overrides: vec!["list.full = \"x\"".into()],
};
assert_eq!(err.to_string(), "invalid type");
}
// =========================================================================
// apply_cli_overrides() — CLI `--config-set` config layer
// =========================================================================
/// Apply `--config-set` overrides to a base table the way `load_with_warnings`
/// does, returning the merged table plus any warnings.
fn apply_overrides(base: toml::Table, overrides: &[&str]) -> (toml::Table, Vec<LoadError>) {
let overrides: Vec<String> = overrides.iter().map(|s| s.to_string()).collect();
let mut table = base;
let mut warnings = Vec::new();
UserConfig::apply_cli_overrides(&overrides, &mut table, &mut warnings);
(table, warnings)
}
#[test]
fn test_cli_override_sets_value() {
let (table, warnings) = apply_overrides(toml::Table::new(), &["list.full = true"]);
assert!(warnings.is_empty());
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.list.full, Some(true));
}
#[test]
fn test_cli_override_deep_merges_preserving_siblings() {
// Overriding one key in a section must not wipe sibling keys from a
// lower layer.
let base: toml::Table = "[list]\nbranches = true\n".parse().unwrap();
let (table, warnings) = apply_overrides(base, &["list.full = true"]);
assert!(warnings.is_empty());
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.list.full, Some(true));
assert_eq!(config.list.branches, Some(true)); // preserved
}
#[test]
fn test_cli_override_repeated_key_last_wins() {
// Repeated `--config-set` of the same key replaces (does not accumulate).
let (table, warnings) = apply_overrides(
toml::Table::new(),
&["list.full = false", "list.full = true"],
);
assert!(warnings.is_empty());
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.list.full, Some(true));
}
#[test]
fn test_cli_override_array_replaces_not_appends() {
// An array override replaces the lower-layer array wholesale.
let base: toml::Table = "[step.copy-ignored]\nexclude = [\"a\", \"b\"]\n"
.parse()
.unwrap();
let (table, warnings) = apply_overrides(base, &["step.copy-ignored.exclude = [\"x\"]"]);
assert!(warnings.is_empty());
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.step.copy_ignored().exclude, vec!["x".to_string()]);
}
#[test]
fn test_cli_override_malformed_fragment_drops_layer() {
// A non-TOML fragment warns and leaves lower layers untouched — the whole
// `--config-set` layer rolls back, including the valid earlier fragment.
let base: toml::Table = "[list]\nbranches = true\n".parse().unwrap();
let (table, warnings) = apply_overrides(base, &["list.full = true", "garbage"]);
assert_eq!(warnings.len(), 1);
assert!(matches!(&warnings[0], LoadError::CliOverride { .. }));
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.list.full, None);
assert_eq!(config.list.branches, Some(true)); // base preserved
}
#[test]
fn test_cli_override_type_mismatch_drops_layer() {
// A fragment that parses as TOML but is the wrong type warns and rolls back.
let base: toml::Table = "[list]\nbranches = true\n".parse().unwrap();
let (table, warnings) = apply_overrides(base, &["list.full = \"notabool\""]);
assert_eq!(warnings.len(), 1);
assert!(matches!(&warnings[0], LoadError::CliOverride { .. }));
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.list.branches, Some(true)); // base preserved
}
#[test]
fn test_cli_override_validation_failure_drops_layer() {
// A fragment that deserializes but fails validation (empty worktree-path)
// rolls back to the lower layers instead of wiping them — without the
// validate() probe this would fall through to finalize() and reset to
// defaults.
let base: toml::Table = "[list]\nbranches = true\n".parse().unwrap();
let (table, warnings) = apply_overrides(base, &["worktree-path = \"\""]);
assert_eq!(warnings.len(), 1);
assert!(matches!(&warnings[0], LoadError::CliOverride { .. }));
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.worktree_path, None); // override rolled back
assert_eq!(config.list.branches, Some(true)); // base preserved
}
#[test]
fn test_cli_override_migrates_deprecated_keys() {
// A deprecated key passed via `--config-set` runs through the same
// deprecation migration as a config file, so it is canonicalized and takes
// effect instead of falling through as an unknown field (which serde
// silently drops). The rewrite is silent — there is no file to materialize,
// so no deprecation warning is recorded.
// merge.no-ff = true → merge.ff = false
let (table, warnings) = apply_overrides(toml::Table::new(), &["merge.no-ff = true"]);
assert!(warnings.is_empty(), "merge.no-ff: {warnings:?}");
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.merge.ff, Some(false));
// switch.no-cd = true → switch.cd = false
let (table, warnings) = apply_overrides(toml::Table::new(), &["switch.no-cd = true"]);
assert!(warnings.is_empty(), "switch.no-cd: {warnings:?}");
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.switch.cd, Some(false));
}
#[test]
fn test_cli_override_deprecated_key_wins_over_lower_canonical() {
// Each fragment is migrated *before* it is merged, so the canonicalized
// override replaces a lower layer's canonical key rather than colliding
// with it. (Migrating the merged document instead would leave both
// `merge.ff` and `merge.no-ff` present, and the migration would keep the
// lower layer's `ff`, silently dropping the override.)
let base: toml::Table = "[merge]\nff = true\n".parse().unwrap();
let (table, warnings) = apply_overrides(base, &["merge.no-ff = true"]);
assert!(warnings.is_empty());
let config: UserConfig = toml::Value::Table(table).try_into().unwrap();
assert_eq!(config.merge.ff, Some(false)); // override (no-ff=true → ff=false) wins
}
#[test]
fn test_cli_override_empty_is_noop() {
let (table, warnings) = apply_overrides(toml::Table::new(), &[]);
assert!(warnings.is_empty());
assert!(table.is_empty());
}
#[test]
fn test_try_parse_value() {
use super::try_parse_value;
assert_eq!(try_parse_value("true"), toml::Value::Boolean(true));
assert_eq!(try_parse_value("TRUE"), toml::Value::Boolean(true));
assert_eq!(try_parse_value("false"), toml::Value::Boolean(false));
assert_eq!(try_parse_value("42"), toml::Value::Integer(42));
assert_eq!(try_parse_value("0"), toml::Value::Integer(0));
assert_eq!(try_parse_value("1.5"), toml::Value::Float(1.5));
assert_eq!(
try_parse_value("hello"),
toml::Value::String("hello".into())
);
}
// =========================================================================
// merge_layer() — a layer's global keys vs the `[projects]` entries below
// =========================================================================
const PROJECT: &str = "github.com/owner/repo";
/// A base table with one project entry carrying `body`.
fn base_with_project(body: &str) -> toml::Table {
format!("[projects.\"{PROJECT}\"]\n{body}").parse().unwrap()
}
fn loaded(table: toml::Table) -> UserConfig {
toml::Value::Table(table).try_into().unwrap()
}
#[test]
fn test_cli_layer_outranks_project_worktree_path() {
// The reported bug (#3788), on the `--config-set` half: a project entry's
// `worktree-path` no longer beats a global key a higher layer set.
let base = base_with_project("worktree-path = \"/from-project\"\n");
let (table, warnings) = apply_overrides(base, &["worktree-path = \"/from-cli\""]);
assert!(warnings.is_empty());
assert_eq!(
loaded(table).worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-cli"
);
}
#[test]
fn test_env_layer_outranks_project_worktree_path() {
use super::{EnvVar, try_parse_value};
let var = EnvVar {
name: "WORKTRUNK_WORKTREE_PATH".to_string(),
segments: vec!["worktree-path".to_string()],
typed_value: try_parse_value("/from-env"),
raw_value: "/from-env".to_string(),
};
let mut table = base_with_project("worktree-path = \"/from-project\"\n");
let mut warnings = Vec::new();
UserConfig::apply_env_vars(&[var], &mut table, &mut warnings).unwrap();
assert!(warnings.is_empty());
assert_eq!(
loaded(table).worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-env"
);
}
#[test]
fn test_layer_keeps_an_already_invalid_candidate_untouched() {
// A layer with an empty global `worktree-path` fails validation. Its
// project-precedence removals are dropped as a unit, while the layer still
// reaches the caller for validation and attribution.
let plain_merge = |overlay: &toml::Table| {
let mut plain = base_with_project("worktree-path = \"/from-project\"\n");
deep_merge_table(&mut plain, overlay.clone());
plain
};
let mut table = base_with_project("worktree-path = \"/from-project\"\n");
let overlay: toml::Table = "worktree-path = \"\"\n".parse().unwrap();
let plain = plain_merge(&overlay);
merge_layer(&mut table, overlay);
assert_eq!(
table, plain,
"the removals are discarded as a unit, and the layer still applies"
);
// Control: the same overlay with a valid value does remove the project's
// key, so the assertion above is the discard and not a pass that found
// nothing to do.
let mut table = base_with_project("worktree-path = \"/from-project\"\n");
let overlay: toml::Table = "worktree-path = \"/from-env\"\n".parse().unwrap();
let plain = plain_merge(&overlay);
merge_layer(&mut table, overlay);
assert_ne!(table, plain);
}
#[test]
fn test_file_layer_outranks_lower_layer_project_entry() {
// The same rule where neither layer is an invocation one: the user file's
// global key answers for a project the system file keyed an entry to.
let mut table = base_with_project("worktree-path = \"/from-system-project\"\n");
merge_layer(
&mut table,
"worktree-path = \"/from-user-global\"\n".parse().unwrap(),
);
assert_eq!(
loaded(table).worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-user-global"
);
}
#[test]
fn test_layer_leaves_untouched_project_keys() {
// Only the overridden key is displaced: a project entry's other settings,
// and its sibling keys inside the same section, still apply.
let base = base_with_project(
r#"worktree-path = "/from-project"
[projects."github.com/owner/repo".list]
full = true
branches = true
"#,
);
let (table, warnings) = apply_overrides(base, &["list.full = false"]);
assert!(warnings.is_empty());
let config = loaded(table);
assert_eq!(
config.worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-project"
);
let list = config.list(Some(&ProjectId::from(PROJECT)));
assert_eq!(list.full, Some(false), "the higher layer wins");
assert_eq!(list.branches, Some(true), "sibling key survives");
}
#[test]
fn test_layer_keeps_its_own_project_scoped_override() {
// Naming the project entry is both the highest layer and the most
// specific key, so it outranks the same layer's global key.
let base = base_with_project("worktree-path = \"/from-project\"\n");
let (table, warnings) = apply_overrides(
base,
&[
"worktree-path = \"/from-cli-global\"",
&format!("projects.\"{PROJECT}\".worktree-path = \"/from-cli-project\""),
],
);
assert!(warnings.is_empty());
assert_eq!(
loaded(table).worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-cli-project"
);
}
#[test]
fn test_layer_applies_to_pattern_entries() {
// Pattern entries are project entries too — a `*` key must not smuggle a
// project-scoped value past a higher layer.
let base: toml::Table = "[projects.\"github.com/*\"]\nworktree-path = \"/from-pattern\"\n"
.parse()
.unwrap();
let (table, warnings) = apply_overrides(base, &["worktree-path = \"/from-cli\""]);
assert!(warnings.is_empty());
assert_eq!(
loaded(table).worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-cli"
);
}
#[test]
fn test_layer_leaves_composing_keys_alone() {
// Per-project hooks, aliases and copy-ignored excludes append to the
// global ones rather than replacing them, so both already apply and there
// is no precedence to fix. Dropping the project's copy would silently stop
// it applying.
let base = base_with_project(
r#"pre-merge = "project-hook"
[projects."github.com/owner/repo".aliases]
ship = "project-alias"
[projects."github.com/owner/repo".step.copy-ignored]
exclude = ["project-pattern"]
"#,
);
let (table, warnings) = apply_overrides(
base,
&[
"pre-merge = \"cli-hook\"",
"aliases.ship = \"cli-alias\"",
"step.copy-ignored.exclude = [\"cli-pattern\"]",
],
);
assert!(warnings.is_empty());
let config = loaded(table);
let templates = |commands: &CommandConfig| {
commands
.commands()
.map(|command| command.template.clone())
.collect::<Vec<_>>()
};
assert_eq!(
templates(
&config
.hooks(Some(&ProjectId::from(PROJECT)))
.pre_merge
.unwrap()
),
["cli-hook", "project-hook"]
);
assert_eq!(
templates(&config.aliases(Some(&ProjectId::from(PROJECT)))["ship"]),
["cli-alias", "project-alias"]
);
assert_eq!(
config.copy_ignored(Some(&ProjectId::from(PROJECT))).exclude,
["cli-pattern", "project-pattern"]
);
}
#[test]
fn test_layer_displaces_whole_custom_column() {
// `[list.custom-columns]` merges per column, so an override of one leaf
// has to displace the whole column: leaving the rest of the project's
// column would let it replace the global one wholesale anyway, and
// `template` is required — a column stripped of it stops deserializing,
// which would cost the user their whole config rather than one entry.
let base = base_with_project(
r#"[projects."github.com/owner/repo".list.custom-columns.Ticket]
template = "{{ vars.ticket }}"
width = 30
"#,
);
let (table, warnings) = apply_overrides(
base,
&["list.custom-columns.Ticket.template = \"from-cli\""],
);
assert!(warnings.is_empty());
let column = loaded(table)
.list(Some(&ProjectId::from(PROJECT)))
.custom_columns["Ticket"]
.clone();
assert_eq!(column.template, "from-cli");
assert_eq!(column.width, None, "the column went as a unit");
// Restating the column at project scope wins, as for any other key — and
// states the whole column, since the layer's global already displaced the
// one below it. A column is the unit on both sides of the boundary, so
// `width` is not carried over from the entry that was displaced.
let base = base_with_project(
r#"[projects."github.com/owner/repo".list.custom-columns.Ticket]
template = "{{ vars.ticket }}"
width = 30
"#,
);
let (table, warnings) = apply_overrides(
base,
&[
"list.custom-columns.Ticket.template = \"from-cli\"",
&format!(
"projects.\"{PROJECT}\".list.custom-columns.Ticket.template = \"from-cli-project\""
),
],
);
assert!(warnings.is_empty());
let column = loaded(table)
.list(Some(&ProjectId::from(PROJECT)))
.custom_columns["Ticket"]
.clone();
assert_eq!(column.template, "from-cli-project");
assert_eq!(column.width, None, "the column went as a unit here too");
}
#[test]
fn test_layer_noop_without_overrides() {
// No higher layer, no change: a project entry keeps every key.
let base = base_with_project("worktree-path = \"/from-project\"\n");
let (table, warnings) = apply_overrides(base, &[]);
assert!(warnings.is_empty());
assert_eq!(
loaded(table).worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-project"
);
}
#[test]
fn test_dropped_layer_leaves_projects_intact() {
// A `--config-set` layer that rolls back (malformed fragment) overrides
// nothing, so it must not displace the project entry either.
let base = base_with_project("worktree-path = \"/from-project\"\n");
let (table, warnings) = apply_overrides(base, &["worktree-path = \"/from-cli\"", "garbage"]);
assert_eq!(warnings.len(), 1);
assert_eq!(
loaded(table).worktree_path_for_project(&ProjectId::from(PROJECT)),
"/from-project"
);
}
#[test]
fn test_env_overlay_migrates_deprecated_key() {
use super::{EnvVar, try_parse_value};
// `WORKTRUNK__MERGE__NO_FF=true` resolves to the deprecated key
// `merge.no-ff`. The env overlay runs through the same deprecation migration
// as config files and `--config-set`, so it takes effect as `merge.ff =
// false` instead of falling through as an unknown field.
let var = EnvVar {
name: "WORKTRUNK__MERGE__NO_FF".to_string(),
segments: vec!["merge".to_string(), "no-ff".to_string()],
typed_value: try_parse_value("true"),
raw_value: "true".to_string(),
};
let mut table = toml::Table::new();
let mut warnings = Vec::new();
UserConfig::apply_env_vars(&[var], &mut table, &mut warnings).unwrap();
assert!(warnings.is_empty());
let config = loaded(table);
assert_eq!(config.merge.ff, Some(false));
}
// =========================================================================
// finalize() — defensive fallback
// =========================================================================
#[test]
fn test_finalize_with_undeserializable_table() {
// finalize() falls back to defaults when the table can't deserialize.
// This shouldn't happen in practice (files are individually validated),
// but the fallback exists for safety.
let mut table = toml::Table::new();
table.insert("list".into(), toml::Value::String("not-a-table".into()));
let (config, warnings) = UserConfig::finalize(table, Vec::new());
assert_eq!(config.worktree_path, None); // defaults
assert_eq!(warnings.len(), 1);
assert!(matches!(&warnings[0], LoadError::Validation(_)));
}
// =========================================================================
// ConfigEdit — writing one value into the file
// =========================================================================
#[test]
fn test_config_edit_changes_only_its_value() {
// Each case writes one value and leaves the rest of the file as the user
// wrote it: comments, values at their defaults, and tables written inline
// or as dotted keys. An existing value keeps its trailing comment. A table
// the edit creates is implicit, or inline inside an inline table.
let cases: &[(&str, &[&str], &str)] = &[
(
r#"skip-shell-integration-prompt = false # keep asking
[list]
columns = [] # pick later
# fill in later
[commit]
[commit.generation]
command = "old" # fast model
"#,
&["commit", "generation"],
"command",
),
("", &["commit", "generation"], "command"),
(
"# why we generate\ncommit = { generation = { command = \"old\" } } # trailing\n",
&["commit", "generation"],
"command",
),
(
"projects = { \"a\" = { worktree-path = \"x\" } }\n",
&["projects", "github.com/u/r"],
"worktree-path",
),
(
"commit.generation.command = \"old\"\n",
&["commit", "generation"],
"command",
),
(
"commit.stage = \"all\"\n",
&["commit", "generation"],
"command",
),
];
let mut rendered = String::new();
for (input, tables, key) in cases {
let mut doc: toml_edit::DocumentMut = input.parse().unwrap();
super::persistence::ConfigEdit {
tables: tables.to_vec(),
key,
value: "new".into(),
}
.apply(&mut doc)
.unwrap();
rendered.push_str(&format!("----- {}.{key}\n{doc}", tables.join(".")));
}
insta::assert_snapshot!(rendered, @r#"
----- commit.generation.command
skip-shell-integration-prompt = false # keep asking
[list]
columns = [] # pick later
# fill in later
[commit]
[commit.generation]
command = "new" # fast model
----- commit.generation.command
[commit.generation]
command = "new"
----- commit.generation.command
# why we generate
commit = { generation = { command = "new" } } # trailing
----- projects.github.com/u/r.worktree-path
projects = { "a" = { worktree-path = "x" } , "github.com/u/r" = { worktree-path = "new" } }
----- commit.generation.command
commit.generation.command = "new"
----- commit.generation.command
commit.stage = "all"
[commit.generation]
command = "new"
"#);
}
#[test]
fn test_config_edit_fails_when_a_parent_is_not_a_table() {
let mut doc: toml_edit::DocumentMut = "commit = \"oops\"\n".parse().unwrap();
let err = super::persistence::ConfigEdit {
tables: vec!["commit", "generation"],
key: "command",
value: "llm".into(),
}
.apply(&mut doc)
.unwrap_err();
insta::assert_snapshot!(err.to_string(), @"Failed to write config file: `commit` is not a table");
}
#[test]
fn test_edit_takes_the_migrations_when_one_lands_on_its_path() {
// A deprecated `[commit-generation]` migrates to `[commit.generation]` only
// while that table is absent, so the command can't be written there as the
// file stands: the edit takes the load-time migrations with it, and says so.
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
std::fs::write(
&config_path,
"[commit-generation]\ntemplate = \"MINE\"\n\n[select]\npager = \"delta\"\nheight = 5\n",
)
.unwrap();
let file = super::persistence::ConfigFile::read(&config_path).unwrap();
let mut changed = file.config.clone();
changed
.commit
.generation
.get_or_insert_with(Default::default)
.command = Some("llm".to_string());
let edit = super::persistence::ConfigEdit {
tables: vec!["commit", "generation"],
key: "command",
value: "llm".into(),
};
let super::persistence::Edited::Migrated { content, changes } =
file.edited(&edit, &changed).unwrap()
else {
panic!("the edit should have taken the migrations with it");
};
// `[switch.picker]` has no `height`, so the migration drops it. Every
// change is reported, which is what the caller's warning prints.
insta::assert_snapshot!(
ansi_str::AnsiStr::ansi_strip(&crate::config::deprecation::format_applied_lines(&changes)),
@r"
▲ Moved [commit-generation] to [commit.generation]
▲ Moved [select] to [switch.picker]
▲ Removed [select] height, which its replacement has no field for
"
);
// The migrated file carries every load-path migration, so the unrelated
// `[select]` moves too — what the caller's warning tells the user about.
insta::assert_snapshot!(content, @r#"
[commit.generation]
template = "MINE"
command = "llm"
[switch.picker]
pager = "delta"
"#);
// An edit no migration lands on leaves the file's own spelling alone.
let mut only_flag = file.config.clone();
only_flag.skip_shell_integration_prompt = true;
let flag_edit = super::persistence::ConfigEdit {
tables: vec![],
key: "skip-shell-integration-prompt",
value: true.into(),
};
assert!(matches!(
file.edited(&flag_edit, &only_flag).unwrap(),
super::persistence::Edited::AsWritten(_)
));
}
#[test]
fn test_mutation_fails_on_a_file_that_is_not_a_valid_config_and_leaves_it() {
// Valid TOML that doesn't deserialize as a config (a hand edit like
// `commit = "oops"`) fails the reload, before anything is written.
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
let content = "commit = \"oops\"\n";
std::fs::write(&config_path, content).unwrap();
let err = UserConfig::default()
.set_commit_generation_command("llm".to_string(), &config_path)
.unwrap_err();
assert!(
err.to_string().contains("failed to parse"),
"expected parse error, got: {err}"
);
assert_eq!(std::fs::read_to_string(&config_path).unwrap(), content);
}
// =========================================================================
// mutation.rs — additional coverage
// =========================================================================
#[test]
fn test_set_project_worktree_path_noop_when_unchanged() {
// Covers the `None` early exit in set_project_worktree_path's
// mutator: when the path already matches, nothing is written. We verify
// this by checking that the file content is byte-identical across a
// redundant call.
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
std::fs::write(&config_path, "# keep\n").unwrap();
let mut config = UserConfig::default();
config
.set_project_worktree_path("user/repo", "../custom".to_string(), &config_path)
.unwrap();
let after_first = std::fs::read_to_string(&config_path).unwrap();
// Sanity: first call actually wrote the value
assert!(after_first.contains("../custom"), "{after_first}");
// Second call with identical value should be a no-op — the mutator runs
// on the file's config, compares equal and returns `None`, so nothing is
// written.
let mut config2 = UserConfig::default();
config2
.set_project_worktree_path("user/repo", "../custom".to_string(), &config_path)
.unwrap();
let after_second = std::fs::read_to_string(&config_path).unwrap();
assert_eq!(
after_first, after_second,
"unchanged value should not rewrite the file"
);
}
#[test]
fn test_set_commit_generation_command_noop_when_unchanged() {
// Covers the `None` early exit in set_commit_generation_command's
// mutator: when the command already matches, nothing is written. We verify
// this by checking that the file content is byte-identical across a
// redundant call.
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
std::fs::write(&config_path, "# keep\n").unwrap();
let mut config = UserConfig::default();
config
.set_commit_generation_command("llm -m haiku".to_string(), &config_path)
.unwrap();
let after_first = std::fs::read_to_string(&config_path).unwrap();
// Sanity: first call actually wrote the value
assert!(after_first.contains("llm -m haiku"), "{after_first}");
// Second call with identical value should be a no-op — the mutator runs
// on the file's config, compares equal and returns `None`, so nothing is
// written.
let mut config2 = UserConfig::default();
config2
.set_commit_generation_command("llm -m haiku".to_string(), &config_path)
.unwrap();
let after_second = std::fs::read_to_string(&config_path).unwrap();
assert_eq!(
after_first, after_second,
"unchanged command should not rewrite the file"
);
}
#[test]
fn test_set_skip_shell_integration_prompt_noop_on_second_call() {
// Covers the `None` early exit in set_skip_shell_integration_prompt's
// mutator. The mutator runs on the file's config — after the first
// write, the flag is true on disk, so a second call sees it already true
// and writes nothing.
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
std::fs::write(&config_path, "# empty\n").unwrap();
let mut config = UserConfig::default();
config
.set_skip_shell_integration_prompt(&config_path)
.unwrap();
let after_first = std::fs::read_to_string(&config_path).unwrap();
assert!(after_first.contains("skip-shell-integration-prompt = true"));
// Second call with the flag already true in-memory — mutator returns
// `None`, nothing is written, file is byte-identical.
config
.set_skip_shell_integration_prompt(&config_path)
.unwrap();
let after_second = std::fs::read_to_string(&config_path).unwrap();
assert_eq!(after_first, after_second);
}
#[test]
fn test_mutation_keeps_in_memory_config_the_file_lacks() {
// The in-memory config also carries system config, environment variables,
// and `--config-set`. A mutation applies its change to it without
// replacing it with the file's config, so the rest of the command still
// reads those values.
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
std::fs::write(&config_path, "[list]\nfull = true\n").unwrap();
let mut config = UserConfig {
commit: CommitConfig {
stage: Some(StageMode::None),
generation: None,
},
..Default::default()
};
config
.set_skip_commit_generation_prompt(&config_path)
.unwrap();
assert_eq!(config.commit.stage, Some(StageMode::None));
assert!(config.skip_commit_generation_prompt);
assert_eq!(
std::fs::read_to_string(&config_path).unwrap(),
"skip-commit-generation-prompt = true\n[list]\nfull = true\n"
);
}
#[test]
fn test_acquire_config_lock_handles_root_path() {
// Covers the else branch of `if let Some(parent) = lock_path.parent()`
// in acquire_config_lock: when config_path is `/`, `with_extension` is
// a no-op, and `"/".parent()` is None, so we skip create_dir_all. The
// subsequent OpenOptions.open fails (can't open a directory as a file),
// which surfaces as a "Failed to open lock file" error — proving the
// None branch executes cleanly.
let mut config = UserConfig::default();
let err = config
.set_skip_shell_integration_prompt(std::path::Path::new("/"))
.unwrap_err();
let msg = err.to_string();
assert!(
!msg.contains("Failed to create config directory"),
"should skip create_dir when parent is None, got: {msg}"
);
assert!(
msg.contains("Failed to open lock file"),
"expected open lock error, got: {msg}"
);
}
#[test]
fn test_acquire_config_lock_fails_when_parent_is_file() {
// Covers the create_dir_all error branch in acquire_config_lock:
// if the config path's parent is actually a regular file, we can't
// create the lock directory and the mutation fails fast.
let dir = crate::testing::tempdir().unwrap();
let blocker = dir.path().join("blocker");
std::fs::write(&blocker, "i am a file").unwrap();
let config_path = blocker.join("config.toml");
let mut config = UserConfig::default();
let err = config
.set_skip_shell_integration_prompt(&config_path)
.unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("Failed to create config directory"),
"expected create_dir error, got: {msg}"
);
}
#[cfg(unix)]
#[test]
fn test_with_locked_mutation_propagates_write_error() {
// After lock and reload, the mutator makes the config directory read-only,
// so writing the edited file — a temp file beside it, renamed over it —
// fails, and with_locked_mutation returns that error to the caller.
use std::os::unix::fs::PermissionsExt;
let dir = crate::testing::tempdir().unwrap();
let config_dir = dir.path().join("config");
std::fs::create_dir(&config_dir).unwrap();
let config_path = config_dir.join("config.toml");
std::fs::write(&config_path, "# valid\n").unwrap();
struct RestorePerms<'a>(&'a std::path::Path);
impl Drop for RestorePerms<'_> {
fn drop(&mut self) {
let _ = std::fs::set_permissions(self.0, std::fs::Permissions::from_mode(0o755));
}
}
let _guard = RestorePerms(&config_dir);
if !permissions_restrict_reads(dir.path()) {
return;
}
let dir_for_closure = config_dir.clone();
let mut config = UserConfig::default();
let err = config
.with_locked_mutation(&config_path, move |config| {
std::fs::set_permissions(&dir_for_closure, std::fs::Permissions::from_mode(0o555))
.unwrap();
config.skip_shell_integration_prompt = true;
Some(super::persistence::ConfigEdit {
tables: vec![],
key: "skip-shell-integration-prompt",
value: true.into(),
})
})
.unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("Failed to write config file"),
"expected write error, got: {msg}"
);
assert_eq!(std::fs::read_to_string(&config_path).unwrap(), "# valid\n");
}
/// A mutator sets a value and returns the edit that writes it, so the file
/// loads back as the config the mutation asked for. One whose edit says
/// something else is refused rather than written — the same test both candidate
/// documents face, whether or not writing them takes the migrations along.
#[test]
fn test_with_locked_mutation_refuses_an_edit_that_does_not_load_back() {
let dir = crate::testing::tempdir().unwrap();
let config_path = dir.path().join("config.toml");
std::fs::write(&config_path, "# valid\n").unwrap();
let mut config = UserConfig::default();
let err = config
.with_locked_mutation(&config_path, |_config| {
// The edit, without the matching change to the config beside it.
Some(super::persistence::ConfigEdit {
tables: vec![],
key: "skip-shell-integration-prompt",
value: true.into(),
})
})
.unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("skip-shell-integration-prompt would not load as written"),
"the refusal should name the key, got: {msg}"
);
assert_eq!(std::fs::read_to_string(&config_path).unwrap(), "# valid\n");
}
#[test]
fn test_pattern_project_key_applies_to_every_repo_on_a_host() {
let config = UserConfig::load_from_str(
r#"
worktree-path = "../{{ repo }}.{{ branch | sanitize }}"
[projects."git.company.example/*"]
worktree-path = ".worktrees/{{ branch | sanitize }}"
[projects."git.company.example/*".forge]
platform = "gitlab"
"#,
)
.unwrap();
for project in [
"git.company.example/owner/repo",
"git.company.example/group/team/repo",
] {
assert_eq!(
config.worktree_path_for_project(&ProjectId::from(project)),
".worktrees/{{ branch | sanitize }}"
);
assert!(config.has_project_worktree_path(&ProjectId::from(project)));
assert_eq!(
config.forge_platform(Some(&ProjectId::from(project))),
Some("gitlab")
);
}
// A repo on another host takes the global settings.
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("github.com/owner/repo")),
"../{{ repo }}.{{ branch | sanitize }}"
);
assert_eq!(
config.forge_platform(Some(&ProjectId::from("github.com/owner/repo"))),
None
);
}
#[test]
fn test_exact_project_key_wins_over_a_pattern_that_also_matches() {
let config = UserConfig::load_from_str(
r#"
[projects."git.company.example/*"]
worktree-path = "host"
[projects."git.company.example/team/*"]
worktree-path = "team"
[projects."git.company.example/team/repo"]
worktree-path = "exact"
"#,
)
.unwrap();
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("git.company.example/team/repo")),
"exact"
);
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("git.company.example/team/other")),
"team"
);
assert_eq!(
config.worktree_path_for_project(&ProjectId::from("git.company.example/ops/thing")),
"host"
);
}
#[test]
fn test_pattern_and_exact_entries_layer_field_by_field() {
// Each entry contributes the fields it sets; the more specific one wins
// only where the two collide.
let config = UserConfig::load_from_str(
r#"
[projects."git.company.example/*".list]
full = true
branches = true
[projects."git.company.example/owner/repo".list]
branches = false
"#,
)
.unwrap();
let list = config.list(Some(&ProjectId::from("git.company.example/owner/repo")));
assert_eq!(list.full, Some(true), "kept from the host-wide entry");
assert_eq!(list.branches, Some(false), "overridden by the exact entry");
}
#[test]
fn test_pattern_and_exact_hooks_both_run() {
// Hooks append rather than override, so a host-wide hook and a
// repository-specific one both run, host-wide first.
let config = UserConfig::load_from_str(
r#"
[projects."git.company.example/*"]
post-switch = "host-setup"
[projects."git.company.example/owner/repo"]
post-switch = "repo-setup"
"#,
)
.unwrap();
let hooks = config.hooks(Some(&ProjectId::from("git.company.example/owner/repo")));
let commands: Vec<&str> = hooks
.post_switch
.iter()
.flat_map(CommandConfig::commands)
.map(|c| c.template.as_str())
.collect();
assert_eq!(commands, vec!["host-setup", "repo-setup"]);
}
#[test]
fn test_forge_hostname_from_a_pattern_entry() {
let config = UserConfig::load_from_str(
r#"
[projects."work/*".forge]
platform = "github"
hostname = "github.company.example"
"#,
)
.unwrap();
assert_eq!(
config.forge_platform(Some(&ProjectId::from("work/owner/repo"))),
Some("github")
);
assert_eq!(
config.forge_hostname(Some(&ProjectId::from("work/owner/repo"))),
Some("github.company.example")
);
assert_eq!(config.forge_hostname(None), None);
}
/// Invalid scalar overrides must not erase unrelated environment values.
#[test]
fn test_env_failure_keeps_other_overrides() {
let env_var = |name: &str, path: &[&str], value: &str| super::EnvVar {
name: name.into(),
segments: path.iter().map(|s| s.to_string()).collect(),
typed_value: super::try_parse_value(value),
raw_value: value.into(),
};
let vars = [
// Deliberately pass the custom-column width before its required
// template. Both fields form one valid setting after migration.
env_var(
"WORKTRUNK__LIST__CUSTOM_COLUMNS__TICKET__WIDTH",
&["list", "custom-columns", "ticket", "width"],
"20",
),
env_var(
"WORKTRUNK__LIST__CUSTOM_COLUMNS__TICKET__TEMPLATE",
&["list", "custom-columns", "ticket", "template"],
"{{ branch }}",
),
env_var("WORKTRUNK__LIST__COLUMNS", &["list", "columns"], "oops"),
env_var("WORKTRUNK__LIST__FULL", &["list", "full"], "true"),
env_var("WORKTRUNK_WORKTREE_PATH", &["worktree-path"], "/tmp/zzz"),
// The old select section drops unsupported fields completely. An
// empty migrated overlay must not become a spurious validation unit.
env_var(
"WORKTRUNK__SELECT__OBSOLETE",
&["select", "obsolete"],
"old",
),
];
let mut table = "[list]\nbranches=true\ncolumns=[\"path\"]\n"
.parse()
.unwrap();
let mut warnings = Vec::new();
UserConfig::apply_env_vars(&vars, &mut table, &mut warnings).unwrap();
assert!(!table.contains_key("select"));
let config = loaded(table);
assert_eq!(config.list.full, Some(true));
assert_eq!(config.worktree_path.as_deref(), Some("/tmp/zzz"));
assert_eq!(config.list.branches, Some(true));
assert_eq!(config.list.columns, ["path"]);
assert_eq!(
config.list.custom_columns["ticket"].template,
"{{ branch }}"
);
assert_eq!(config.list.custom_columns["ticket"].width, Some(20));
assert_eq!(warnings.len(), 1);
let LoadError::Env { vars, .. } = &warnings[0] else {
panic!("expected env warning")
};
assert_eq!(vars, &[("WORKTRUNK__LIST__COLUMNS".into(), "oops".into())]);
}
#[test]
fn test_env_override_can_repair_invalid_lower_layer() {
let var = super::EnvVar {
name: "WORKTRUNK_WORKTREE_PATH".into(),
segments: vec!["worktree-path".into()],
typed_value: super::try_parse_value("/tmp/worktrees/{{ branch }}"),
raw_value: "/tmp/worktrees/{{ branch }}".into(),
};
let mut table = "worktree-path = \"\"\n".parse().unwrap();
let mut warnings = Vec::new();
UserConfig::apply_env_vars(&[var], &mut table, &mut warnings).unwrap();
let config = loaded(table);
assert_eq!(
config.worktree_path.as_deref(),
Some("/tmp/worktrees/{{ branch }}")
);
assert!(config.validate().is_ok());
assert!(warnings.is_empty());
}
#[test]
fn test_invalid_project_env_override_keeps_global_repair() {
let global = super::EnvVar {
name: "WORKTRUNK_WORKTREE_PATH".into(),
segments: vec!["worktree-path".into()],
typed_value: toml::Value::String("/valid".into()),
raw_value: "/valid".into(),
};
let project = super::EnvVar {
name: "WORKTRUNK__PROJECTS__GITHUB.COM/OWNER/REPO__WORKTREE_PATH".into(),
segments: vec![
"projects".into(),
"github.com/owner/repo".into(),
"worktree-path".into(),
],
typed_value: toml::Value::String(String::new()),
raw_value: String::new(),
};
let mut table =
"[list]\nbranches = true\n[projects.\"github.com/owner/repo\"]\nworktree-path = \"\"\n"
.parse()
.unwrap();
let mut warnings = Vec::new();
UserConfig::apply_env_vars(&[global, project], &mut table, &mut warnings).unwrap();
let config = loaded(table);
assert_eq!(config.worktree_path.as_deref(), Some("/valid"));
assert_eq!(config.list.branches, Some(true));
assert!(config.validate().is_ok());
assert!(matches!(warnings.as_slice(), [LoadError::Env { vars, .. }]
if vars == &[("WORKTRUNK__PROJECTS__GITHUB.COM/OWNER/REPO__WORKTREE_PATH".into(), String::new())]));
}
/// A broken internal lower-layer contract must surface a schema error without
/// blaming an unrelated environment setting or replacing the lower table.
#[test]
fn test_env_layer_reports_malformed_lower_table() {
let var = super::EnvVar {
name: "WORKTRUNK__LIST__FULL".into(),
segments: vec!["list".into(), "full".into()],
typed_value: toml::Value::Boolean(true),
raw_value: "true".into(),
};
let mut table: toml::Table = "[list]\nbranches = \"invalid\"\n".parse().unwrap();
let original = table.clone();
let mut warnings = Vec::new();
let err = UserConfig::apply_env_vars(&[var], &mut table, &mut warnings).unwrap_err();
assert!(err.contains("branches"), "{err}");
assert!(err.contains("boolean"), "{err}");
assert_eq!(table, original);
assert!(warnings.is_empty());
}