Files
codex/codex-rs/git-utils/src/apply.rs
T

1358 lines
55 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Helpers for applying unified diffs using the system `git` binary.
//!
//! The entry point is [`apply_git_patch`], which writes a diff to a temporary
//! file, shells out to `git apply` with the right flags, and then parses the
//! command’s output into structured details. Callers can opt into dry-run
//! mode via [`ApplyGitRequest::preflight`] and inspect the resulting paths to
//! learn what would change before applying for real.
use std::io;
use std::path::Path;
use std::path::PathBuf;
use crate::apply_output::parse_git_apply_output;
use crate::git_command::GitRunner;
use crate::guarded_config::GuardedGitConfig;
use crate::patch_paths::extract_patch_path_inventory_guarded;
use crate::reverse_staging::ReverseApplyMode;
use crate::reverse_staging::execute_reverse_staging_plan;
use crate::reverse_staging::execute_reverse_staging_plan_in_scratch;
use crate::reverse_staging::prepare_reverse_staging_plan;
use crate::reverse_staging::seal_reverse_staging_plan;
use crate::reverse_staging::validate_effective_paths_for_reverse;
#[cfg(test)]
use crate::safe_git::isolate_git_command_environment;
/// Parameters for invoking [`apply_git_patch`].
#[derive(Debug, Clone)]
pub struct ApplyGitRequest {
pub cwd: PathBuf,
pub diff: String,
pub revert: bool,
pub preflight: bool,
}
/// Result of running [`apply_git_patch`], including paths gleaned from stdout/stderr.
#[derive(Debug, Clone)]
pub struct ApplyGitResult {
pub exit_code: i32,
pub applied_paths: Vec<String>,
pub skipped_paths: Vec<String>,
pub conflicted_paths: Vec<String>,
pub stdout: String,
pub stderr: String,
pub cmd_for_log: String,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum ApplyStrategy {
Direct,
ThreeWay,
}
#[cfg(test)]
thread_local! {
static AFTER_REVERSE_STAGING_HOOK: std::cell::RefCell<Option<Box<dyn FnOnce()>>> =
std::cell::RefCell::new(None);
}
#[cfg(test)]
fn install_after_reverse_staging_hook(hook: impl FnOnce() + 'static) {
AFTER_REVERSE_STAGING_HOOK.with(|slot| {
let previous = slot.borrow_mut().replace(Box::new(hook));
assert!(
previous.is_none(),
"reverse staging test hook already installed"
);
});
}
#[cfg(test)]
fn run_after_reverse_staging_hook() {
AFTER_REVERSE_STAGING_HOOK.with(|slot| {
if let Some(hook) = slot.borrow_mut().take() {
hook();
}
});
}
impl ApplyStrategy {
fn reverse_mode(self) -> ReverseApplyMode {
match self {
Self::Direct => ReverseApplyMode::Direct,
Self::ThreeWay => ReverseApplyMode::ThreeWay,
}
}
}
/// Apply a unified diff to the target repository by shelling out to `git apply`.
///
/// When [`ApplyGitRequest::preflight`] is `true`, this behaves like `git apply --check` and
/// leaves the working tree untouched while still parsing the command output for diagnostics.
pub fn apply_git_patch(req: &ApplyGitRequest) -> io::Result<ApplyGitResult> {
let cfg_parts = configured_git_config_parts();
// Construct from the caller's exact route before canonicalization so
// repository authority retains lexical enclosing worktrees.
let git = GitRunner::for_cwd_io(&req.cwd)?;
let requested_cwd = std::fs::canonicalize(&req.cwd)?;
let expected_root = crate::get_git_repo_root(&requested_cwd)
.ok_or_else(|| io::Error::other("not a Git repository"))
.and_then(std::fs::canonicalize)?;
let mut config = GuardedGitConfig::authorize(&git, &expected_root, cfg_parts)?;
resolve_git_root(&config, &requested_cwd)?;
config.freeze_apply_policy()?;
// Write unified diff into a temporary file
let (tmpdir, patch_path) = write_temp_patch(&req.diff)?;
// Keep tmpdir alive until function end to ensure the file exists
let _guard = tmpdir;
let patch_path_inventory =
extract_patch_path_inventory_guarded(&config, &patch_path, req.revert)?;
let patch_paths = &patch_path_inventory.effective_paths;
config.authorize_filter_paths(patch_paths)?;
let patch_arg = patch_path.to_string_lossy().to_string();
// Applicability checks conflate content conflicts with fatal whitespace
// policy. Parse the requested orientation independently first: numstat
// enforces the frozen whitespace policy without consulting or changing
// the index/worktree. This ordering makes a mixed conflict + policy error
// fail before merge-policy reads or reverse staging.
let (policy_rendered, policy_output) = config.run_apply_policy_gate(req.revert, &patch_arg)?;
let policy_code = policy_output.status.code().unwrap_or(-1);
let policy_stdout = String::from_utf8_lossy(&policy_output.stdout).into_owned();
let policy_stderr = String::from_utf8_lossy(&policy_output.stderr).into_owned();
if policy_code != 0 {
return Ok(structured_apply_result(
policy_code,
policy_stdout,
policy_stderr,
policy_rendered,
));
}
// Optional preflight: dry-run only; do not modify working tree
if req.preflight {
let (rendered, output) = config.run_apply_preflight_check(req.revert, &patch_arg)?;
let c_code = output.status.code().unwrap_or(-1);
let c_out = String::from_utf8_lossy(&output.stdout).into_owned();
let c_err = String::from_utf8_lossy(&output.stderr).into_owned();
if req.revert {
let mode = if c_code == 0 {
ReverseApplyMode::Direct
} else {
ReverseApplyMode::ThreeWay
};
validate_effective_paths_for_reverse(&config, patch_paths, mode)?;
}
let (mut applied_paths, mut skipped_paths, mut conflicted_paths) =
parse_git_apply_output(&c_out, &c_err);
applied_paths.sort();
applied_paths.dedup();
skipped_paths.sort();
skipped_paths.dedup();
conflicted_paths.sort();
conflicted_paths.dedup();
return Ok(ApplyGitResult {
exit_code: c_code,
applied_paths,
skipped_paths,
conflicted_paths,
stdout: c_out,
stderr: c_err,
cmd_for_log: rendered,
});
}
// Avoid three-way machinery entirely when the patch applies cleanly. A
// reverse check must inspect the working tree before staging: requiring
// the old index to match would misclassify a clean undo as a three-way
// fallback. Forward direct application still requires index agreement.
let plain_check = config.run_apply_strategy_check(req.revert, &patch_arg)?;
let plain_check_code = plain_check.status.code().unwrap_or(-1);
let strategy = if plain_check_code != 0 {
ApplyStrategy::ThreeWay
} else {
ApplyStrategy::Direct
};
let reverse_plan = req
.revert
.then(|| prepare_reverse_staging_plan(&config, patch_paths, strategy.reverse_mode()))
.transpose()?;
if strategy == ApplyStrategy::ThreeWay {
config.install_three_way_merge_policy(&patch_path_inventory.primary_records)?;
}
let mut reverse_plan = reverse_plan
.map(|plan| seal_reverse_staging_plan(&mut config, plan))
.transpose()?;
if strategy == ApplyStrategy::ThreeWay && config.three_way_requires_merge_policy_proof()? {
let scratch = config.create_three_way_scratch_storage()?;
if let Some(plan) = &mut reverse_plan {
execute_reverse_staging_plan_in_scratch(&config, plan, &scratch)?;
}
config.prove_three_way_merge_policy_safety(&scratch, req.revert, &patch_arg)?;
}
if let Some(plan) = reverse_plan {
// The same sealed plan was modeled in scratch before any merge-policy
// refusal could mutate the real index.
execute_reverse_staging_plan(&config, plan)?;
#[cfg(test)]
run_after_reverse_staging_hook();
}
let (cmd_for_log, output) = match strategy {
ApplyStrategy::Direct => {
// The fixed helper requires proof that the successful frozen-
// policy gate covered this exact patch and orientation.
let rendered = config.render_direct_apply_for_log(req.revert, &patch_arg)?;
let output = config.run_direct_apply(req.revert, &patch_arg)?;
(
rendered,
(
output.status.code().unwrap_or(-1),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
),
)
}
ApplyStrategy::ThreeWay => {
let rendered = config.render_three_way_apply_for_log(req.revert, &patch_arg)?;
let output = config.run_three_way_apply(req.revert, &patch_arg)?;
(
rendered,
(
output.status.code().unwrap_or(-1),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
),
)
}
};
let (code, stdout, stderr) = output;
let (mut applied_paths, mut skipped_paths, mut conflicted_paths) = if code == 0 {
(patch_path_inventory.primary_paths, Vec::new(), Vec::new())
} else {
parse_git_apply_output(&stdout, &stderr)
};
applied_paths.sort();
applied_paths.dedup();
skipped_paths.sort();
skipped_paths.dedup();
conflicted_paths.sort();
conflicted_paths.dedup();
Ok(ApplyGitResult {
exit_code: code,
applied_paths,
skipped_paths,
conflicted_paths,
stdout,
stderr,
cmd_for_log,
})
}
fn structured_apply_result(
exit_code: i32,
stdout: String,
stderr: String,
cmd_for_log: String,
) -> ApplyGitResult {
let (mut applied_paths, mut skipped_paths, mut conflicted_paths) =
parse_git_apply_output(&stdout, &stderr);
applied_paths.sort();
applied_paths.dedup();
skipped_paths.sort();
skipped_paths.dedup();
conflicted_paths.sort();
conflicted_paths.dedup();
ApplyGitResult {
exit_code,
applied_paths,
skipped_paths,
conflicted_paths,
stdout,
stderr,
cmd_for_log,
}
}
fn resolve_git_root(config: &GuardedGitConfig<'_>, requested_cwd: &Path) -> io::Result<PathBuf> {
let mut command = config.rev_parse_command()?;
command.arg("--show-toplevel");
let out = command.output()?;
let code = out.status.code().unwrap_or(-1);
if code != 0 {
return Err(io::Error::other(format!(
"not a git repository (exit {}): {}",
code,
String::from_utf8_lossy(&out.stderr)
)));
}
let reported_root = PathBuf::from(String::from_utf8_lossy(&out.stdout).trim());
let root = std::fs::canonicalize(&reported_root)?;
let expected_root = config.canonical_root();
if root != expected_root {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
format!(
"refusing to apply a patch because Git resolved worktree {} instead of expected worktree {} for requested cwd {}",
root.display(),
expected_root.display(),
requested_cwd.display()
),
));
}
Ok(root)
}
pub(crate) fn configured_git_config_parts() -> Vec<String> {
let mut cfg_parts = Vec::new();
if let Ok(cfg) = std::env::var("CODEX_APPLY_GIT_CFG") {
for pair in cfg.split(',') {
let pair = pair.trim();
if pair.is_empty() || !pair.contains('=') {
continue;
}
cfg_parts.push("-c".to_string());
cfg_parts.push(pair.to_string());
}
}
cfg_parts
}
pub(crate) fn write_temp_patch(diff: &str) -> io::Result<(tempfile::TempDir, PathBuf)> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("patch.diff");
std::fs::write(&path, diff)?;
Ok((dir, path))
}
#[cfg(all(test, unix))]
#[path = "apply_transport_tests.rs"]
mod transport_tests;
#[cfg(test)]
#[path = "apply_filter_tests.rs"]
mod filter_tests;
#[cfg(test)]
#[path = "reverse_apply_tests.rs"]
mod reverse_apply_tests;
#[cfg(test)]
mod tests {
use super::*;
use crate::guarded_config::config_source_authorization_count;
use crate::guarded_config::merge_attribute_read_count;
use crate::guarded_config::merge_config_read_count;
use crate::guarded_config::merge_overlay_count;
use crate::guarded_config::reset_config_source_authorization_count;
use crate::guarded_config::reset_merge_policy_counts;
use crate::safe_git::filter_policy_overlay_count;
use crate::safe_git::filter_policy_read_count;
use crate::safe_git::reset_filter_policy_counts;
use std::ffi::OsStr;
use std::path::Path;
use std::sync::Mutex;
use std::sync::OnceLock;
fn env_lock() -> &'static Mutex<()> {
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
LOCK.get_or_init(|| Mutex::new(()))
}
fn run(cwd: &Path, args: &[&str]) -> (i32, String, String) {
let mut command = std::process::Command::new(args[0]);
isolate_git_command_environment(&mut command);
let out = command
.args(&args[1..])
.current_dir(cwd)
.output()
.expect("spawn ok");
(
out.status.code().unwrap_or(-1),
String::from_utf8_lossy(&out.stdout).into_owned(),
String::from_utf8_lossy(&out.stderr).into_owned(),
)
}
fn run_isolated_test(test_name: &str, env: &[(&str, &OsStr)]) {
let mut command = std::process::Command::new(std::env::current_exe().expect("test binary"));
isolate_git_command_environment(&mut command);
command
.arg(test_name)
.arg("--exact")
.arg("--nocapture")
.env("CODEX_GIT_UTILS_APPLY_ENV_CHILD", "1")
.env("RUST_TEST_THREADS", "1");
for (name, value) in env {
command.env(name, value);
}
let output = command.output().expect("run isolated test process");
assert!(
output.status.success(),
"isolated test {test_name} failed:\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
fn init_repo() -> tempfile::TempDir {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
// git init and minimal identity
let _ = run(root, &["git", "init"]);
let _ = run(root, &["git", "config", "user.email", "codex@example.com"]);
let _ = run(root, &["git", "config", "user.name", "Codex"]);
dir
}
fn read_file_normalized(path: &Path) -> String {
std::fs::read_to_string(path)
.expect("read file")
.replace("\r\n", "\n")
}
#[cfg(unix)]
fn trusted_git_directory() -> PathBuf {
std::env::split_paths(&std::env::var_os("PATH").expect("PATH"))
.find(|directory| directory.is_absolute() && directory.join("git").is_file())
.expect("trusted Git directory")
}
#[test]
fn parse_output_unescapes_quoted_paths() {
let stderr = "error: patch failed: \"hello\\tworld.txt\":1\n";
let (applied, skipped, conflicted) = parse_git_apply_output("", stderr);
assert_eq!(applied, Vec::<String>::new());
assert_eq!(conflicted, Vec::<String>::new());
assert_eq!(skipped, vec!["hello\tworld.txt".to_string()]);
}
#[test]
fn apply_add_success() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
let nested_cwd = root.join("nested");
std::fs::create_dir(&nested_cwd).expect("nested cwd");
let diff = "diff --git a/hello.txt b/hello.txt\nnew file mode 100644\n--- /dev/null\n+++ b/hello.txt\n@@ -0,0 +1,2 @@\n+hello\n+world\n";
let req = ApplyGitRequest {
cwd: nested_cwd,
diff: diff.to_string(),
revert: false,
preflight: false,
};
reset_config_source_authorization_count();
let r = apply_git_patch(&req).expect("run apply");
assert_eq!(config_source_authorization_count(), 1);
assert_eq!(r.exit_code, 0, "exit code 0");
assert_eq!(r.applied_paths, vec!["hello.txt"]);
// File exists now
assert!(root.join("hello.txt").exists());
}
#[test]
fn preflight_uses_one_authorization_and_skips_merge_policy() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
let request = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: "diff --git a/preflight.txt b/preflight.txt\nnew file mode 100644\n--- /dev/null\n+++ b/preflight.txt\n@@ -0,0 +1 @@\n+preflight\n".to_string(),
revert: false,
preflight: true,
};
reset_config_source_authorization_count();
reset_merge_policy_counts();
let result = apply_git_patch(&request).expect("preflight");
assert_eq!(result.exit_code, 0, "{}", result.stderr);
assert_eq!(config_source_authorization_count(), 1);
assert_eq!(merge_config_read_count(), 0);
assert_eq!(merge_attribute_read_count(), 0);
assert!(!root.join("preflight.txt").exists());
}
#[test]
fn apply_resolves_relative_primary_config_from_repository_root() {
let _g = env_lock().lock().unwrap();
if std::env::var_os("CODEX_GIT_UTILS_APPLY_ENV_CHILD").is_none() {
run_isolated_test(
"apply::tests::apply_resolves_relative_primary_config_from_repository_root",
&[("GIT_CONFIG_GLOBAL", OsStr::new("../external/config"))],
);
return;
}
let fixture = tempfile::tempdir().expect("fixture");
let root = fixture.path().join("repo");
let nested_cwd = root.join("nested");
let external_config = fixture.path().join("external/config");
let mismatched_nested_config = root.join("external/config");
std::fs::create_dir_all(&nested_cwd).expect("nested cwd");
std::fs::create_dir_all(external_config.parent().expect("config parent"))
.expect("external config directory");
std::fs::create_dir_all(
mismatched_nested_config
.parent()
.expect("mismatched config parent"),
)
.expect("mismatched config directory");
std::fs::write(&external_config, "[codex]\n\tprobe = loaded\n").expect("external config");
std::fs::write(&mismatched_nested_config, "[invalid\n")
.expect("mismatched nested-cwd config");
let (init_code, _, init_err) = run(&root, &["git", "init"]);
assert_eq!(init_code, 0, "init repository: {init_err}");
let result = apply_git_patch(&ApplyGitRequest {
cwd: nested_cwd,
diff: "diff --git a/hello.txt b/hello.txt\nnew file mode 100644\n--- /dev/null\n+++ b/hello.txt\n@@ -0,0 +1 @@\n+hello\n".to_string(),
revert: false,
preflight: false,
})
.expect("apply with root-relative primary config");
assert_eq!(result.exit_code, 0, "apply result: {result:?}");
assert_eq!(read_file_normalized(&root.join("hello.txt")), "hello\n");
}
#[cfg(target_os = "linux")]
#[test]
fn apply_refuses_process_relative_primary_config_before_mutating_the_repository() {
const TEST_NAME: &str = "apply::tests::apply_refuses_process_relative_primary_config_before_mutating_the_repository";
if std::env::var_os("CODEX_GIT_UTILS_APPLY_ENV_CHILD").is_none() {
run_isolated_test(
TEST_NAME,
&[
(
"GIT_CONFIG_GLOBAL",
OsStr::new("/proc/self/cwd/codex-process-relative.gitconfig"),
),
("GIT_CONFIG_NOSYSTEM", OsStr::new("1")),
],
);
return;
}
let repo = init_repo();
let root = repo.path();
std::fs::write(
root.join("codex-process-relative.gitconfig"),
"[filter \"unsafe\"]\nclean = false\n",
)
.expect("worktree config");
let before_index = run(root, &["git", "ls-files", "--stage", "-z"]).1;
let request = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: "diff --git a/hello.txt b/hello.txt\nnew file mode 100644\n--- /dev/null\n+++ b/hello.txt\n@@ -0,0 +1 @@\n+hello\n".to_string(),
revert: false,
preflight: false,
};
let error = apply_git_patch(&request).expect_err("process-relative primary config");
assert_eq!(error.kind(), io::ErrorKind::PermissionDenied, "{error}");
assert!(error.to_string().contains("process-relative"), "{error}");
assert!(!root.join("hello.txt").exists());
assert_eq!(
run(root, &["git", "ls-files", "--stage", "-z"]).1,
before_index
);
}
#[test]
fn numstat_path_discovery_does_not_preempt_apply_whitespace_result() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
let (config_code, _, config_err) =
run(root, &["git", "config", "apply.whitespace", "error"]);
assert_eq!(config_code, 0, "configure whitespace policy: {config_err}");
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: "diff --git a/trailing.txt b/trailing.txt\nnew file mode 100644\n--- /dev/null\n+++ b/trailing.txt\n@@ -0,0 +1 @@\n+trailing \n".to_string(),
revert: false,
preflight: false,
})
.expect("path discovery must leave apply failure in the structured result");
assert_ne!(result.exit_code, 0);
assert!(
result.stderr.contains("trailing whitespace"),
"apply result: {result:?}"
);
assert!(!root.join("trailing.txt").exists());
}
#[test]
fn fatal_whitespace_policy_precedes_selected_merge_driver_without_mutation() {
let _g = env_lock().lock().unwrap();
for policy in ["error", "error-all"] {
let repo = init_repo();
let root = repo.path();
std::fs::write(root.join(".gitattributes"), "file.txt merge=selected\n")
.expect("write attributes");
std::fs::write(root.join("file.txt"), "old\n").expect("write file");
assert_eq!(run(root, &["git", "add", "."]).0, 0);
assert_eq!(run(root, &["git", "commit", "-m", "base"]).0, 0);
assert_eq!(
run(
root,
&[
"git",
"config",
"merge.selected.driver",
"git config --file .git/config codex.mergeran true && false",
],
)
.0,
0
);
assert_eq!(
run(root, &["git", "config", "apply.whitespace", policy]).0,
0
);
let index_before = std::fs::read(root.join(".git/index")).expect("read index");
reset_merge_policy_counts();
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: "diff --git a/file.txt b/file.txt\n--- a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new \n".to_string(),
revert: false,
preflight: false,
})
.expect("return structured whitespace failure");
assert_ne!(result.exit_code, 0, "{policy}: {result:?}");
assert!(
result.stderr.contains("trailing whitespace"),
"{policy}: {result:?}"
);
assert!(result.cmd_for_log.contains("--numstat"), "{result:?}");
assert_eq!(merge_config_read_count(), 0, "{policy}");
assert_eq!(merge_attribute_read_count(), 0, "{policy}");
assert_eq!(merge_overlay_count(), 0, "{policy}");
assert_eq!(read_file_normalized(&root.join("file.txt")), "old\n");
assert_eq!(
std::fs::read(root.join(".git/index")).expect("reread index"),
index_before,
"{policy}"
);
assert_ne!(
run(root, &["git", "config", "--get", "codex.mergeran"]).0,
0,
"{policy}: merge driver must not run"
);
}
}
#[test]
fn nonfatal_whitespace_policies_reach_the_final_apply() {
let _g = env_lock().lock().unwrap();
for (policy, expected) in [("warn", "new \n"), ("fix", "new\n")] {
let repo = init_repo();
let root = repo.path();
std::fs::write(root.join("file.txt"), "old\n").expect("write file");
assert_eq!(run(root, &["git", "add", "file.txt"]).0, 0);
assert_eq!(run(root, &["git", "commit", "-m", "base"]).0, 0);
assert_eq!(
run(root, &["git", "config", "apply.whitespace", policy]).0,
0
);
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: "diff --git a/file.txt b/file.txt\n--- a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new \n".to_string(),
revert: false,
preflight: false,
})
.expect("apply with nonfatal whitespace policy");
assert_eq!(result.exit_code, 0, "{policy}: {result:?}");
assert_eq!(read_file_normalized(&root.join("file.txt")), expected);
}
}
#[test]
fn fatal_whitespace_gate_remains_authoritative_after_reverse_staging() {
let _g = env_lock().lock().unwrap();
for policy in ["error", "error-all"] {
let repo = init_repo();
let root = repo.path();
std::fs::write(root.join(".gitattributes"), "file.txt -whitespace\n")
.expect("write permissive attributes");
std::fs::write(root.join("file.txt"), "bad \n").expect("write base file");
assert_eq!(
run(root, &["git", "add", ".gitattributes", "file.txt"]).0,
0
);
assert_eq!(run(root, &["git", "commit", "-m", "base"]).0, 0);
std::fs::write(root.join("file.txt"), "good\n").expect("write patched file");
let patch = run(root, &["git", "diff", "--full-index", "--", "file.txt"]);
assert_eq!(patch.0, 0, "create patch: {}", patch.2);
assert_eq!(
run(root, &["git", "config", "apply.whitespace", policy]).0,
0
);
let attributes = root.join(".gitattributes");
install_after_reverse_staging_hook(move || {
std::fs::write(attributes, "file.txt whitespace\n")
.expect("tighten whitespace attributes after staging");
});
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: patch.1,
revert: true,
preflight: false,
})
.expect("reverse apply after attribute mutation");
assert_eq!(result.exit_code, 0, "{policy}: {result:?}");
assert!(
result.cmd_for_log.contains("--whitespace=nowarn"),
"{policy}: {}",
result.cmd_for_log
);
assert_eq!(
read_file_normalized(&root.join(".gitattributes")),
"file.txt whitespace\n",
"{policy}: race hook did not tighten the attribute"
);
assert_eq!(read_file_normalized(&root.join("file.txt")), "bad \n");
let cached = run(
root,
&["git", "diff", "--cached", "--quiet", "--", "file.txt"],
);
assert_eq!(cached.0, 0, "{policy}: index retained staged data");
}
}
#[test]
fn fatal_whitespace_gate_and_projection_cover_reverse_three_way_staging() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
std::fs::write(root.join(".gitattributes"), "file.txt -whitespace\n")
.expect("write permissive attributes");
let base_contents = "01\n02\n03\n04\n05\n06\n07\n08\n09\nbad \n11\n12\n13\n14\n15\n";
let patched_contents = "01\n02\n03\n04\n05\n06\n07\n08\n09\ngood\n11\n12\n13\n14\n15\n";
let independent_contents =
"01\n02\n03\n04\n05\n06\nSEVEN\n08\n09\ngood\n11\n12\n13\n14\n15\n";
let expected_contents = "01\n02\n03\n04\n05\n06\nSEVEN\n08\n09\nbad \n11\n12\n13\n14\n15\n";
std::fs::write(root.join("file.txt"), base_contents).expect("write base");
assert_eq!(
run(root, &["git", "add", ".gitattributes", "file.txt"]).0,
0
);
assert_eq!(run(root, &["git", "commit", "-m", "base"]).0, 0);
let base = run(root, &["git", "rev-parse", "HEAD"]).1;
std::fs::write(root.join("file.txt"), patched_contents).expect("write patch side");
assert_eq!(run(root, &["git", "add", "file.txt"]).0, 0);
assert_eq!(run(root, &["git", "commit", "-m", "patched"]).0, 0);
let patch = run(
root,
&[
"git",
"diff",
"--full-index",
base.trim(),
"HEAD",
"--",
"file.txt",
],
);
assert_eq!(patch.0, 0, "create patch: {}", patch.2);
std::fs::write(root.join("file.txt"), independent_contents)
.expect("write independent worktree edit");
assert_eq!(
run(root, &["git", "config", "apply.whitespace", "error"]).0,
0
);
let attributes = root.join(".gitattributes");
install_after_reverse_staging_hook(move || {
std::fs::write(attributes, "file.txt whitespace\n")
.expect("tighten whitespace attributes after staging");
});
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: patch.1,
revert: true,
preflight: false,
})
.expect("reverse three-way after attribute mutation");
assert_eq!(result.exit_code, 0, "{result:?}");
assert!(result.cmd_for_log.contains("GIT_COMMON_DIR=<isolated>"));
assert!(result.cmd_for_log.contains("--3way"));
assert!(result.cmd_for_log.contains("--whitespace=nowarn"));
assert_eq!(
read_file_normalized(&root.join(".gitattributes")),
"file.txt whitespace\n",
"race hook did not tighten the attribute"
);
assert_eq!(
read_file_normalized(&root.join("file.txt")),
expected_contents
);
assert_eq!(
run(root, &["git", "diff", "--quiet", "--", "file.txt"]).0,
0,
"final index and worktree differ"
);
}
#[test]
fn mixed_reverse_conflict_and_whitespace_error_does_not_mutate() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
let base = "01\n02\n03\n04\n05\n06\n07\n08\n09\n10\nbase \n12\n13\n14\n15\n";
let theirs = "01\n02\n03\n04\n05\n06\n07\n08\n09\n10\ntheirs\n12\n13\n14\n15\n";
let independently_edited =
"01\n02\n03\n04\n05\n06\n07\nEIGHT\n09\n10\ntheirs\n12\n13\n14\n15\n";
std::fs::write(root.join("file.txt"), base).expect("write base");
assert_eq!(run(root, &["git", "add", "file.txt"]).0, 0);
assert_eq!(run(root, &["git", "commit", "-m", "base"]).0, 0);
let base_oid = run(root, &["git", "rev-parse", "HEAD"]).1;
std::fs::write(root.join("file.txt"), theirs).expect("write theirs");
assert_eq!(run(root, &["git", "add", "file.txt"]).0, 0);
assert_eq!(run(root, &["git", "commit", "-m", "theirs"]).0, 0);
let patch = run(
root,
&[
"git",
"diff",
"--full-index",
base_oid.trim(),
"HEAD",
"--",
"file.txt",
],
);
assert_eq!(patch.0, 0, "create patch: {}", patch.2);
std::fs::write(root.join("file.txt"), independently_edited)
.expect("write independent edit");
let patch_dir = tempfile::tempdir().expect("patch directory");
let patch_path = patch_dir.path().join("mixed.diff");
std::fs::write(&patch_path, &patch.1).expect("write patch");
let patch_path = patch_path.to_str().expect("UTF-8 patch path");
let structural = run(
root,
&[
"git",
"apply",
"--check",
"--whitespace=nowarn",
"-R",
patch_path,
],
);
assert_ne!(
structural.0, 0,
"fixture must retain a structural reverse conflict"
);
assert_eq!(
run(root, &["git", "config", "apply.whitespace", "error"]).0,
0
);
let index_before = std::fs::read(root.join(".git/index")).expect("read index");
let worktree_before = std::fs::read(root.join("file.txt")).expect("read worktree");
reset_merge_policy_counts();
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: patch.1,
revert: true,
preflight: false,
})
.expect("return mixed policy failure");
assert_ne!(result.exit_code, 0, "{result:?}");
assert!(result.stderr.contains("trailing whitespace"), "{result:?}");
assert_eq!(merge_config_read_count(), 0);
assert_eq!(merge_attribute_read_count(), 0);
assert_eq!(merge_overlay_count(), 0);
assert_eq!(
std::fs::read(root.join(".git/index")).expect("reread index"),
index_before
);
assert_eq!(
std::fs::read(root.join("file.txt")).expect("reread worktree"),
worktree_before
);
}
#[test]
fn apply_uses_cwd_repo_despite_inherited_repository_selectors() {
let _g = env_lock().lock().unwrap();
if std::env::var_os("CODEX_GIT_UTILS_APPLY_ENV_CHILD").is_none() {
let alternate = init_repo();
let alternate_root = alternate.path();
std::fs::write(alternate_root.join("sentinel.txt"), "alternate\n")
.expect("write alternate sentinel");
let (add_code, _, add_err) = run(alternate_root, &["git", "add", "sentinel.txt"]);
assert_eq!(add_code, 0, "add alternate sentinel: {add_err}");
let (commit_code, _, commit_err) =
run(alternate_root, &["git", "commit", "-m", "alternate"]);
assert_eq!(commit_code, 0, "commit alternate sentinel: {commit_err}");
let alternate_git_dir = alternate_root.join(".git");
let alternate_index = alternate_git_dir.join("index");
run_isolated_test(
"apply::tests::apply_uses_cwd_repo_despite_inherited_repository_selectors",
&[
("GIT_DIR", alternate_git_dir.as_os_str()),
("GIT_WORK_TREE", alternate_root.as_os_str()),
("GIT_COMMON_DIR", alternate_git_dir.as_os_str()),
("GIT_INDEX_FILE", alternate_index.as_os_str()),
("GIT_PREFIX", OsStr::new("elsewhere/")),
],
);
assert_eq!(
read_file_normalized(&alternate_root.join("sentinel.txt")),
"alternate\n"
);
return;
}
let repo = init_repo();
let root = repo.path();
std::fs::write(root.join("file.txt"), "old\n").expect("write target file");
let (add_code, _, add_err) = run(root, &["git", "add", "file.txt"]);
assert_eq!(add_code, 0, "add target file: {add_err}");
let (commit_code, _, commit_err) = run(root, &["git", "commit", "-m", "target"]);
assert_eq!(commit_code, 0, "commit target file: {commit_err}");
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: "diff --git a/file.txt b/file.txt\n--- a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new\n".to_string(),
revert: false,
preflight: false,
})
.expect("apply in cwd-selected repository");
assert_eq!(result.exit_code, 0);
assert_eq!(read_file_normalized(&root.join("file.txt")), "new\n");
}
#[cfg(unix)]
#[test]
fn apply_uses_logical_process_cwd_to_reject_enclosing_git() {
use std::os::unix::fs::PermissionsExt;
let _g = env_lock().lock().unwrap();
if std::env::var_os("CODEX_GIT_UTILS_APPLY_LOGICAL_CWD_CHILD").is_none() {
let fixture = tempfile::tempdir().expect("fixture");
let outer = fixture.path().join("outer");
let physical_nested = fixture.path().join("physical-nested");
let lexical_nested = outer.join("nested");
let outer_bin = outer.join("bin");
let outer_git = outer_bin.join("git");
let marker = outer_bin.join("git.ran");
std::fs::create_dir_all(&outer_bin).expect("outer Git directory");
std::fs::create_dir_all(&physical_nested).expect("physical nested repository");
let (outer_init, _, outer_err) = run(&outer, &["git", "init", "-q"]);
assert_eq!(outer_init, 0, "init outer repository: {outer_err}");
let (nested_init, _, nested_err) = run(&physical_nested, &["git", "init", "-q"]);
assert_eq!(nested_init, 0, "init nested repository: {nested_err}");
std::os::unix::fs::symlink(&physical_nested, &lexical_nested)
.expect("symlink nested repository");
std::fs::write(&outer_git, "#!/bin/sh\nprintf ran >\"$0.ran\"\nexit 1\n")
.expect("outer Git shim");
let mut permissions = std::fs::metadata(&outer_git)
.expect("outer Git metadata")
.permissions();
permissions.set_mode(0o755);
std::fs::set_permissions(&outer_git, permissions).expect("executable outer Git");
let path = std::env::join_paths([outer_bin, trusted_git_directory()]).expect("PATH");
let mut command =
std::process::Command::new(std::env::current_exe().expect("test binary"));
isolate_git_command_environment(&mut command);
let output = command
.arg("apply::tests::apply_uses_logical_process_cwd_to_reject_enclosing_git")
.arg("--exact")
.arg("--nocapture")
.current_dir(&lexical_nested)
.env("CODEX_GIT_UTILS_APPLY_LOGICAL_CWD_CHILD", "1")
.env("CODEX_GIT_UTILS_APPLY_LOGICAL_CWD_MARKER", &marker)
.env("PWD", &lexical_nested)
.env("PATH", path)
.env("RUST_TEST_THREADS", "1")
.output()
.expect("run isolated logical-cwd test");
assert!(
output.status.success(),
"isolated logical-cwd test failed:\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert!(!marker.exists(), "enclosing Git shim must not run");
return;
}
let cwd = std::env::current_dir().expect("physical process cwd");
let marker = PathBuf::from(
std::env::var_os("CODEX_GIT_UTILS_APPLY_LOGICAL_CWD_MARKER").expect("marker path"),
);
let result = apply_git_patch(&ApplyGitRequest {
cwd,
diff: "diff --git a/hello.txt b/hello.txt\nnew file mode 100644\n--- /dev/null\n+++ b/hello.txt\n@@ -0,0 +1 @@\n+hello\n".to_string(),
revert: false,
preflight: true,
})
.expect("preflight through trusted Git");
assert_eq!(result.exit_code, 0, "preflight should succeed");
assert!(!marker.exists(), "enclosing Git shim must not run");
}
#[cfg(unix)]
#[test]
fn apply_uses_physical_repository_for_symlinked_nested_cwd() {
let _g = env_lock().lock().unwrap();
let fixture = tempfile::tempdir().expect("fixture");
let outer = fixture.path().join("outer");
let target = fixture.path().join("target");
let nested = target.join("nested");
std::fs::create_dir_all(&outer).expect("outer");
std::fs::create_dir_all(&nested).expect("nested");
let (outer_init, _, outer_error) = run(&outer, &["git", "init", "-q"]);
assert_eq!(outer_init, 0, "outer init: {outer_error}");
let (target_init, _, target_error) = run(&target, &["git", "init", "-q"]);
assert_eq!(target_init, 0, "target init: {target_error}");
let lexical_cwd = outer.join("linked-nested");
std::os::unix::fs::symlink(&nested, &lexical_cwd).expect("nested cwd symlink");
reset_config_source_authorization_count();
let result = apply_git_patch(&ApplyGitRequest {
cwd: lexical_cwd,
diff: "diff --git a/physical.txt b/physical.txt\nnew file mode 100644\n--- /dev/null\n+++ b/physical.txt\n@@ -0,0 +1 @@\n+physical\n".to_string(),
revert: false,
preflight: false,
})
.expect("apply through symlinked nested cwd");
assert_eq!(result.exit_code, 0);
assert_eq!(config_source_authorization_count(), 1);
assert_eq!(
read_file_normalized(&target.join("physical.txt")),
"physical\n"
);
assert!(!outer.join("physical.txt").exists());
}
#[test]
fn apply_modify_conflict() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
// seed file and commit
std::fs::write(root.join("file.txt"), "line1\nline2\nline3\n").unwrap();
let _ = run(root, &["git", "add", "file.txt"]);
let _ = run(root, &["git", "commit", "-m", "seed"]);
// local edit (unstaged)
std::fs::write(root.join("file.txt"), "line1\nlocal2\nline3\n").unwrap();
// patch wants to change the same line differently
let diff = "diff --git a/file.txt b/file.txt\n--- a/file.txt\n+++ b/file.txt\n@@ -1,3 +1,3 @@\n line1\n-line2\n+remote2\n line3\n";
let req = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: false,
preflight: false,
};
let r = apply_git_patch(&req).expect("run apply");
assert_ne!(r.exit_code, 0, "non-zero exit on conflict");
}
#[test]
fn apply_modify_skipped_missing_index() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
// Try to modify a file that is not in the index
let diff = "diff --git a/ghost.txt b/ghost.txt\n--- a/ghost.txt\n+++ b/ghost.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n";
let req = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: false,
preflight: false,
};
let r = apply_git_patch(&req).expect("run apply");
assert_ne!(r.exit_code, 0, "non-zero exit on missing index");
}
#[cfg(unix)]
#[test]
fn missing_index_three_way_classification_does_not_run_post_index_change_hook() {
use std::os::unix::fs::PermissionsExt;
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
let hooks = root.join(".githooks");
std::fs::create_dir(&hooks).expect("create hooks directory");
let hook = hooks.join("post-index-change");
std::fs::write(&hook, "#!/bin/sh\nprintf ran > \"$PWD/hook-ran\"\n")
.expect("write post-index-change hook");
let mut permissions = std::fs::metadata(&hook)
.expect("hook metadata")
.permissions();
permissions.set_mode(0o755);
std::fs::set_permissions(&hook, permissions).expect("make hook executable");
assert_eq!(
run(root, &["git", "config", "core.hooksPath", ".githooks"]).0,
0
);
std::fs::write(root.join("new.txt"), b"local\n").expect("write untracked path");
assert!(
!root.join(".git/index").exists(),
"fixture has a real index"
);
let result = apply_git_patch(&ApplyGitRequest {
cwd: root.to_path_buf(),
diff: "diff --git a/new.txt b/new.txt\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..893adcd31e963b01dfbbcfe3ec58a008f0d81201\n--- /dev/null\n+++ b/new.txt\n@@ -0,0 +1 @@\n+patched\n".to_string(),
revert: false,
preflight: false,
})
.expect("classify missing-index three-way fallback");
assert_ne!(
result.exit_code, 0,
"untracked destination must not be replaced"
);
assert!(result.cmd_for_log.contains("--3way"), "{result:?}");
assert!(
!root.join("hook-ran").exists(),
"post-index-change hook ran"
);
assert!(
!root.join(".git/index").exists(),
"scratch initialization created the real index"
);
assert_eq!(
std::fs::read(root.join("new.txt")).expect("read untracked path"),
b"local\n"
);
}
#[test]
fn apply_then_revert_success() {
let _g = env_lock().lock().unwrap();
if std::env::var_os("CODEX_GIT_UTILS_APPLY_ENV_CHILD").is_none() {
let config_dir = tempfile::tempdir().expect("config tempdir");
let global_config = config_dir.path().join("global.gitconfig");
let system_config = config_dir.path().join("system.gitconfig");
std::fs::write(&global_config, "").expect("empty global config");
std::fs::write(&system_config, "").expect("empty system config");
run_isolated_test(
"apply::tests::apply_then_revert_success",
&[
("GIT_CONFIG_GLOBAL", global_config.as_os_str()),
("GIT_CONFIG_SYSTEM", system_config.as_os_str()),
],
);
return;
}
let repo = init_repo();
let root = repo.path();
// Seed file and commit original content
std::fs::write(root.join("file.txt"), "orig\n").unwrap();
let _ = run(root, &["git", "add", "file.txt"]);
let _ = run(root, &["git", "commit", "-m", "seed"]);
// Forward patch: orig -> ORIG
let diff = "diff --git a/file.txt b/file.txt\n--- a/file.txt\n+++ b/file.txt\n@@ -1,1 +1,1 @@\n-orig\n+ORIG\n";
let apply_req = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: false,
preflight: false,
};
reset_config_source_authorization_count();
let res_apply = apply_git_patch(&apply_req).expect("apply ok");
assert_eq!(config_source_authorization_count(), 1);
assert_eq!(res_apply.exit_code, 0, "forward apply succeeded");
let after_apply = read_file_normalized(&root.join("file.txt"));
assert_eq!(after_apply, "ORIG\n");
// Revert patch: ORIG -> orig (stage paths first; engine handles it)
let revert_req = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: true,
preflight: false,
};
reset_config_source_authorization_count();
reset_filter_policy_counts();
let res_revert = apply_git_patch(&revert_req).expect("revert ok");
assert_eq!(config_source_authorization_count(), 1);
assert_eq!(
filter_policy_read_count(),
1,
"reverse staging must skip a fresh Git-add policy when the index already matches"
);
assert_eq!(filter_policy_overlay_count(), 0);
assert_eq!(res_revert.exit_code, 0, "revert apply succeeded");
let after_revert = read_file_normalized(&root.join("file.txt"));
assert_eq!(after_revert, "orig\n");
}
#[test]
fn revert_preflight_does_not_stage_index() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
// Seed repo and apply forward patch so the working tree reflects the change.
std::fs::write(root.join("file.txt"), "orig\n").unwrap();
let _ = run(root, &["git", "add", "file.txt"]);
let _ = run(root, &["git", "commit", "-m", "seed"]);
let diff = "diff --git a/file.txt b/file.txt\n--- a/file.txt\n+++ b/file.txt\n@@ -1,1 +1,1 @@\n-orig\n+ORIG\n";
let apply_req = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: false,
preflight: false,
};
let res_apply = apply_git_patch(&apply_req).expect("apply ok");
assert_eq!(res_apply.exit_code, 0, "forward apply succeeded");
let (commit_code, _, commit_err) = run(root, &["git", "commit", "-am", "apply change"]);
assert_eq!(commit_code, 0, "commit applied change: {commit_err}");
let (_code_before, staged_before, _stderr_before) =
run(root, &["git", "diff", "--cached", "--name-only"]);
let preflight_req = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: true,
preflight: true,
};
reset_config_source_authorization_count();
let res_preflight = apply_git_patch(&preflight_req).expect("preflight ok");
assert_eq!(config_source_authorization_count(), 1);
assert_eq!(res_preflight.exit_code, 0, "revert preflight succeeded");
let (_code_after, staged_after, _stderr_after) =
run(root, &["git", "diff", "--cached", "--name-only"]);
assert_eq!(
staged_after.trim(),
staged_before.trim(),
"preflight should not stage new paths",
);
let after_preflight = read_file_normalized(&root.join("file.txt"));
assert_eq!(after_preflight, "ORIG\n");
}
#[test]
fn preflight_blocks_partial_changes() {
let _g = env_lock().lock().unwrap();
let repo = init_repo();
let root = repo.path();
// Build a multi-file diff: one valid add (ok.txt) and one invalid modify (ghost.txt)
let diff = "diff --git a/ok.txt b/ok.txt\nnew file mode 100644\n--- /dev/null\n+++ b/ok.txt\n@@ -0,0 +1,2 @@\n+alpha\n+beta\n\n\
diff --git a/ghost.txt b/ghost.txt\n--- a/ghost.txt\n+++ b/ghost.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n";
// 1) With preflight enabled, nothing should be changed (even though ok.txt could be added)
let req1 = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: false,
preflight: true,
};
reset_config_source_authorization_count();
let r1 = apply_git_patch(&req1).expect("preflight apply");
assert_eq!(config_source_authorization_count(), 1);
assert_ne!(r1.exit_code, 0, "preflight reports failure");
assert!(
!root.join("ok.txt").exists(),
"preflight must prevent adding ok.txt"
);
assert!(
r1.cmd_for_log.contains("--check"),
"preflight path recorded --check"
);
// 2) Without preflight, we should see no --check in the executed command
let req2 = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: diff.to_string(),
revert: false,
preflight: false,
};
reset_config_source_authorization_count();
let r2 = apply_git_patch(&req2).expect("direct apply");
assert_eq!(config_source_authorization_count(), 1);
assert_ne!(r2.exit_code, 0, "apply is expected to fail overall");
assert!(
!r2.cmd_for_log.contains("--check"),
"non-preflight path should not use --check"
);
}
#[test]
fn resolve_git_root_rejects_core_worktree_redirection() {
let temp = tempfile::tempdir().expect("tempdir");
let attacker = temp.path().join("attacker");
let victim = temp.path().join("victim");
std::fs::create_dir_all(&attacker).expect("attacker");
std::fs::create_dir_all(&victim).expect("victim");
let (init_code, _, init_err) = run(&attacker, &["git", "init"]);
assert_eq!(init_code, 0, "init attacker repo: {init_err}");
for redirected_worktree in [&victim, temp.path()] {
let redirected_worktree = redirected_worktree.to_string_lossy();
let (config_code, _, config_err) = run(
&attacker,
&["git", "config", "core.worktree", &redirected_worktree],
);
assert_eq!(config_code, 0, "configure core.worktree: {config_err}");
let git = GitRunner::for_cwd_io(&attacker).expect("trusted Git");
let guarded = GuardedGitConfig::authorize(&git, &attacker, Vec::new())
.expect("authorize attacker repository config");
let error =
resolve_git_root(&guarded, &attacker).expect_err("reject redirected worktree");
assert_eq!(error.kind(), io::ErrorKind::PermissionDenied);
assert!(error.to_string().contains("instead of expected worktree"));
}
}
#[cfg(unix)]
#[test]
fn apply_propagates_unsafe_repository_metadata_before_git_launch() {
use std::os::unix::fs::symlink;
let repo = init_repo();
let root = repo.path();
let external = tempfile::tempdir().expect("external metadata parent");
let admin = external.path().join("admin");
std::fs::rename(root.join(".git"), &admin).expect("move metadata external");
symlink(&admin, root.join("switch")).expect("worktree metadata switch");
std::fs::write(root.join(".git"), "gitdir: switch\n").expect("write gitdir marker");
let (code, _, stderr) = run(root, &["git", "rev-parse", "--absolute-git-dir"]);
assert_eq!(code, 0, "native Git fixture: {stderr}");
let request = ApplyGitRequest {
cwd: root.to_path_buf(),
diff: String::new(),
revert: false,
preflight: true,
};
let error = apply_git_patch(&request).expect_err("unsafe metadata route");
assert_eq!(error.kind(), io::ErrorKind::PermissionDenied);
assert!(error.to_string().contains("Git metadata route crosses"));
assert!(!error.to_string().contains("PATH"));
}
}