Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
fix(dev): isolate Git state in pre-push tests
Éverton Toffanetto38c267d9b492
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.mdindex 8150bded..3d00d76f 100644--- a/CONTRIBUTING.md+++ b/CONTRIBUTING.md@@ -81,6 +81,12 @@ Bash on Windows). It appends or updates only ai-memory's managed block in`.git/hooks/pre-push`, preserving any existing hook body. Bypass it on awork-in-progress branch with `git push --no-verify`.+The managed test block clears Git's repository environment and disables global+and system Git configuration for Cargo and its children. Fixture commands can+then use their own repositories without inheriting the checkout being pushed.+The publishing Git process and other hook code retain their configuration.+Run the installer again to update an existing installation.+Integration tests live in `tests/suite/` per crate and compile into thecrate's own test harness (declare a new file with `mod name;` in`tests/suite/mod.rs`); only the CLI keeps a separate test binary, because itsdiff --git a/crates/ai-memory-cli/tests/suite/packaging.rs b/crates/ai-memory-cli/tests/suite/packaging.rsindex db61b258..3fd2b827 100644--- a/crates/ai-memory-cli/tests/suite/packaging.rs+++ b/crates/ai-memory-cli/tests/suite/packaging.rs@@ -1144,6 +1144,740 @@ fn macos_docs_use_valid_install_commands_and_release_body_points_to_them() {assert!(release.contains("follow the bundled docs/macos.md"));}+// ---------------------------------------------------------------------------+// The generated pre-push hook and the Git environment it hands to Cargo.+//+// Git exports the repository-local environment to every hook it runs. The test+// suite builds throwaway Git repositories as fixtures, and a fixture that+// inherits GIT_DIR / GIT_WORK_TREE / GIT_INDEX_FILE runs against the checkout+// being pushed instead of its own temp directory. These tests pin the scrub.+//+// `cargo` here is a fake -- an exported Bash function that records its argv and+// the environment it was given and returns a chosen code. It is an observation+// boundary only: nothing below runs the real test suite. Git's own repository+// and config resolution is never mocked: both fixture repositories are real and+// every probe is a read-only `git` command.+//+// Unix and Windows both run these; on Windows via Git for Windows' bash.exe.+// Every give-up path goes through `skip_pre_push_tests`.+// ---------------------------------------------------------------------------++/// Every external command the installer, the generated hook, and the probes+/// below actually run. Shell builtins (`printf`, `echo`, `command`) are not+/// here; neither is `cargo`, which is an exported function, nor `rm`, which+/// only the installer's failure trap needs and these tests never reach.+#[cfg(any(unix, windows))]+const FIXTURE_TOOLS: &[&str] = &[+ "awk", "bash", "cat", "chmod", "env", "git", "grep", "mktemp", "mv", "sort", "uname",+];++/// Give up on the pre-push tests, or refuse to.+///+/// A contributor whose machine lacks Git Bash or a fixture tool gets a skip,+/// matching the convention in `install_hooks`' shell-contract test. On CI that+/// same skip would turn a missing prerequisite into a green Windows job that+/// proved nothing, so there it is a failure with the concrete reason.+#[cfg(any(unix, windows))]+fn skip_pre_push_tests<T>(reason: &str) -> Option<T> {+ let on_ci = ["GITHUB_ACTIONS", "CI"].iter().any(|key| {+ std::env::var_os(key).is_some_and(|value| !value.is_empty() && value != "false")+ });+ assert!(+ !on_ci,+ "the pre-push hook regressions must run on CI, but {reason}"+ );+ eprintln!("skipping pre-push hook tests: {reason}");+ None+}++/// Resolve `tool` against a `PATH`-shaped value, trying the bare name and the+/// `.exe` Windows carries.+#[cfg(any(unix, windows))]+fn resolve_in_path(path: &std::ffi::OsStr, tool: &str) -> Option<PathBuf> {+ std::env::split_paths(path).find_map(|dir| {+ let bare = dir.join(tool);+ if bare.is_file() {+ return Some(bare);+ }+ let exe = dir.join(format!("{tool}.exe"));+ exe.is_file().then_some(exe)+ })+}++/// macOS hands back `/var/folders/...` while Git reports `/private/var/...`.+/// Windows canonicalization yields a `\\?\` verbatim path that Git Bash cannot+/// use, so leave it alone there.+#[cfg(unix)]+fn sandbox_root(path: PathBuf) -> PathBuf {+ std::fs::canonicalize(path).unwrap()+}++#[cfg(windows)]+fn sandbox_root(path: PathBuf) -> PathBuf {+ path+}++/// The Git for Windows installation root, derived from wherever `bash.exe`+/// lives. Mirrors the discovery in `install_hooks`' shell-contract test, plus+/// the root implied by a `git.exe` already on `PATH`.+#[cfg(windows)]+fn git_for_windows_root() -> Option<PathBuf> {+ let mut candidates = Vec::new();+ if let Some(root) = std::env::var_os("EXEPATH") {+ candidates.push(PathBuf::from(root));+ }+ for env_key in ["ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"] {+ if let Some(root) = std::env::var_os(env_key) {+ candidates.push(PathBuf::from(root).join("Git"));+ }+ }+ // `<root>/cmd/git.exe` and `<root>/mingw64/bin/git.exe` both sit under the+ // installation root; walk up to it.+ for dir in std::env::split_paths(&std::env::var_os("PATH").unwrap_or_default()) {+ if !dir.join("git.exe").is_file() {+ continue;+ }+ let mut up = dir.clone();+ for _ in 0..2 {+ if !up.pop() {+ break;+ }+ candidates.push(up.clone());+ }+ }+ candidates.sort();+ candidates.dedup();+ candidates+ .into_iter()+ .find(|root| {+ root.join("usr").join("bin").join("bash.exe").is_file()+ || root.join("bin").join("bash.exe").is_file()+ })+ .or_else(|| skip_pre_push_tests("Git for Windows bash.exe was not found"))+}++/// The `PATH` the fixture hands the installer and the hook.+///+/// It must hold every tool those scripts run and must not hold `cargo-nextest`,+/// which the hook branches on. `cargo` is an exported Bash function, so it+/// never needs to be on `PATH` at all.+///+/// Unix: symlink each tool into the fixture's own `bin`. Dropping inherited+/// `PATH` directories instead would cost a contributor with `cargo-nextest`+/// next to `git` or `bash` those unrelated commands.+#[cfg(unix)]+fn fixture_path(bin: &Path) -> Option<std::ffi::OsString> {+ let dirs: Vec<PathBuf> =+ std::env::split_paths(&std::env::var_os("PATH").unwrap_or_default()).collect();+ for tool in FIXTURE_TOOLS {+ let Some(real) = dirs+ .iter()+ .map(|dir| dir.join(tool))+ .find(|candidate| candidate.is_file())+ else {+ return skip_pre_push_tests(&format!("{tool} was not found on PATH"));+ };+ std::os::unix::fs::symlink(real, bin.join(tool)).unwrap();+ }+ Some(bin.as_os_str().to_owned())+}++/// Windows: NTFS has no mode bits and MSYS will not treat a plain fixture file+/// as executable, so a curated `bin` of shims is not available. Use the Git for+/// Windows tool directories instead -- they hold every tool in+/// [`FIXTURE_TOOLS`], and `cargo-nextest` (installed under `~/.cargo/bin`) is+/// excluded by construction rather than by filtering the inherited `PATH`.+#[cfg(windows)]+fn fixture_path(_bin: &Path) -> Option<std::ffi::OsString> {+ let root = git_for_windows_root()?;+ let dirs: Vec<PathBuf> = [+ Path::new("usr").join("bin"),+ Path::new("mingw64").join("bin"),+ Path::new("mingw32").join("bin"),+ PathBuf::from("bin"),+ PathBuf::from("cmd"),+ ]+ .iter()+ .map(|relative| root.join(relative))+ .filter(|dir| dir.is_dir())+ .collect();+ Some(std::env::join_paths(dirs).expect("Git for Windows paths must not contain ';'"))+}++#[cfg(any(unix, windows))]+fn log_field<'a>(log: &'a str, key: &str) -> &'a str {+ let prefix = format!("{key}:");+ log.lines()+ .find_map(|line| line.strip_prefix(prefix.as_str()))+ .unwrap_or_else(|| panic!("no `{key}:` line in:\n{log}"))+}++#[cfg(any(unix, windows))]+fn log_section<'a>(log: &'a str, name: &str) -> &'a str {+ let begin = format!("{name}-begin\n");+ let end = format!("{name}-end\n");+ let start = log+ .find(begin.as_str())+ .unwrap_or_else(|| panic!("no `{name}-begin` in:\n{log}"))+ + begin.len();+ let rest = &log[start..];+ let stop = rest+ .find(end.as_str())+ .unwrap_or_else(|| panic!("no `{name}-end` in:\n{log}"));+ &rest[..stop]+}++/// A retained sandbox for the generated pre-push hook.+///+/// `hook_repo` stands in for the checkout being pushed; `fixture_repo` for the+/// throwaway repository a test would build. Both are real Git repositories in+/// the same temp root, so even the pre-fix hook cannot reach this checkout.+#[cfg(any(unix, windows))]+struct PrePushFixture {+ hook_repo: PathBuf,+ fixture_repo: PathBuf,+ home: PathBuf,+ hook: PathBuf,+ runner: PathBuf,+ cargo_log: PathBuf,+ caller_log: PathBuf,+ global_config: PathBuf,+ system_config: PathBuf,+ path: std::ffi::OsString,+ bash: PathBuf,+ git: PathBuf,+ /// `Some` under Git Bash, where scripts need MSYS paths. `None` on Unix.+ cygpath: Option<PathBuf>,+ hook_toplevel: String,+ fixture_toplevel: String,+}++#[cfg(any(unix, windows))]+impl PrePushFixture {+ fn new() -> Option<Self> {+ // `keep()`: the sandbox is the evidence behind a failure, so it outlives+ // the test rather than being deleted on drop.+ let root = sandbox_root(tempfile::tempdir().unwrap().keep());+ assert!(+ !root.starts_with(repo_root()),+ "the sandbox must live outside this checkout, got {}",+ root.display()+ );++ // Every fixture path carries an apostrophe and a space, so a path+ // interpolated into a shell literal anywhere below would break.+ let work = root.join("it's a sandbox");+ let home = work.join("home");+ let bin = work.join("bin");+ let hook_repo = work.join("hook repo");+ let fixture_repo = work.join("fixture repo");+ for dir in [&home, &bin, &hook_repo, &fixture_repo] {+ std::fs::create_dir_all(dir).unwrap();+ }+ std::fs::create_dir_all(home.join(".config")).unwrap();++ // Synthetic machine config. The caller must keep seeing these; Cargo+ // must not.+ let global_config = work.join("global.gitconfig");+ let system_config = work.join("system.gitconfig");+ std::fs::write(&global_config, "[fixture]\n\tglobal = from-global-config\n").unwrap();+ std::fs::write(&system_config, "[fixture]\n\tsystem = from-system-config\n").unwrap();++ let path = fixture_path(&bin)?;+ for tool in FIXTURE_TOOLS {+ if resolve_in_path(&path, tool).is_none() {+ return skip_pre_push_tests(&format!(+ "{tool} is missing from the fixture PATH ({})",+ path.to_string_lossy()+ ));+ }+ }+ if let Some(found) = resolve_in_path(&path, "cargo-nextest") {+ return skip_pre_push_tests(&format!(+ "cargo-nextest is reachable at {}, so the fallback branch is not deterministic",+ found.display()+ ));+ }+ let cygpath = resolve_in_path(&path, "cygpath");+ if cfg!(windows) && cygpath.is_none() {+ return skip_pre_push_tests("cygpath is missing from the Git for Windows PATH");+ }++ let mut fixture = Self {+ bash: resolve_in_path(&path, "bash").expect("checked above"),+ git: resolve_in_path(&path, "git").expect("checked above"),+ hook: hook_repo.join(".git").join("hooks").join("pre-push"),+ runner: work.join("runner.sh"),+ cargo_log: work.join("cargo.log"),+ caller_log: work.join("caller.log"),+ cygpath,+ path,+ hook_repo,+ fixture_repo,+ home,+ global_config,+ system_config,+ hook_toplevel: String::new(),+ fixture_toplevel: String::new(),+ };+ fixture.git(&fixture.hook_repo, &["init", "-q"]);+ fixture.git(&fixture.fixture_repo, &["init", "-q"]);+ // Compare Git's own answers rather than Rust path strings: Git Bash+ // reports `C:/...` where Rust reports `C:\...`.+ fixture.hook_toplevel = fixture.git(&fixture.hook_repo, &["rev-parse", "--show-toplevel"]);+ fixture.fixture_toplevel =+ fixture.git(&fixture.fixture_repo, &["rev-parse", "--show-toplevel"]);+ Some(fixture)+ }++ /// Drop the ambient Git environment and point HOME and the global/system+ /// config at the sandbox.+ fn isolate(&self, command: &mut Command) {+ for (key, _) in std::env::vars_os() {+ if key.to_string_lossy().starts_with("GIT_") {+ command.env_remove(&key);+ }+ }+ command+ .env("PATH", &self.path)+ .env("HOME", &self.home)+ .env("USERPROFILE", &self.home)+ .env("XDG_CONFIG_HOME", self.home.join(".config"))+ .env("GIT_CONFIG_GLOBAL", &self.global_config)+ .env("GIT_CONFIG_SYSTEM", &self.system_config);+ }++ /// The paths the generated scripts read. They go through the environment so+ /// no path is ever interpolated into a shell literal.+ fn shell_env(&self, command: &mut Command) {+ command+ .env("AI_MEMORY_FIXTURE_REPO", self.shell_arg(&self.fixture_repo))+ .env(+ "AI_MEMORY_FIXTURE_CARGO_LOG",+ self.shell_arg(&self.cargo_log),+ )+ .env(+ "AI_MEMORY_FIXTURE_CALLER_LOG",+ self.shell_arg(&self.caller_log),+ )+ .env("AI_MEMORY_FIXTURE_HOOK", self.shell_arg(&self.hook));+ }++ /// A path as the fixture's shell sees it: unchanged on Unix, MSYS-converted+ /// by `cygpath` under Git Bash.+ fn shell_arg(&self, path: &Path) -> String {+ let Some(cygpath) = &self.cygpath else {+ return path.display().to_string();+ };+ let output = Command::new(cygpath).arg("-u").arg(path).output().unwrap();+ assert!(+ output.status.success(),+ "cygpath -u {} failed: {}",+ path.display(),+ String::from_utf8_lossy(&output.stderr)+ );+ String::from_utf8(output.stdout).unwrap().trim().to_string()+ }++ fn git(&self, dir: &Path, args: &[&str]) -> String {+ let mut command = Command::new(&self.git);+ self.isolate(&mut command);+ let output = command.args(args).current_dir(dir).output().unwrap();+ assert!(+ output.status.success(),+ "git {args:?} in {} failed: {}",+ dir.display(),+ String::from_utf8_lossy(&output.stderr)+ );+ String::from_utf8(output.stdout).unwrap().trim().to_string()+ }++ /// A read-only probe block, reused by the fake Cargo and by the user hook.+ fn probe(&self, name: &str) -> String {+ let log = if name == "cargo" {+ "AI_MEMORY_FIXTURE_CARGO_LOG"+ } else {+ "AI_MEMORY_FIXTURE_CALLER_LOG"+ };+ format!(+ r#"{{+ printf '{name}-begin\n'+ env | grep '^GIT_' | LC_ALL=C sort+ printf '{name}-end\n'+ printf '{name}-ifs:[%s]\n' "$IFS"+ printf '{name}-toplevel:%s\n' "$(git -C "$AI_MEMORY_FIXTURE_REPO" rev-parse --show-toplevel 2>&1)"+ printf '{name}-injected:%s\n' "$(git -C "$AI_MEMORY_FIXTURE_REPO" config --get fixture.injected 2>&1)"+ printf '{name}-counted:%s\n' "$(git -C "$AI_MEMORY_FIXTURE_REPO" config --get fixture.counted 2>&1)"+ printf '{name}-global:%s\n' "$(git -C "$AI_MEMORY_FIXTURE_REPO" config --get fixture.global 2>&1)"+ printf '{name}-system:%s\n' "$(git -C "$AI_MEMORY_FIXTURE_REPO" config --get fixture.system 2>&1)"+}} >> "${log}" 2>&1+"#+ )+ }++ /// The runner that stands in for Cargo and then execs the installed hook.+ ///+ /// Both fakes are exported Bash functions: a function needs no execute bit,+ /// which NTFS cannot give a fixture file under Git Bash, and it lets the+ /// hook's `command -v cargo-nextest` probe answer what the test asked for.+ fn write_runner(&self, exit_code: i32, with_nextest: bool) {+ let mut runner = format!(+ "#!/usr/bin/env bash\n\+ cargo() {{\n\+ \x20 printf 'cargo-argv:%s\\n' \"$*\" >> \"$AI_MEMORY_FIXTURE_CARGO_LOG\"\n\+ {probe}\+ \x20 return {exit_code}\n\+ }}\n\+ export -f cargo\n",+ probe = self.probe("cargo"),+ );+ if with_nextest {+ runner.push_str("cargo-nextest() { return 0; }\nexport -f cargo-nextest\n");+ }+ runner.push_str("exec bash \"$AI_MEMORY_FIXTURE_HOOK\"\n");+ std::fs::write(&self.runner, runner).unwrap();+ }++ /// Seed a user hook whose own content precedes the managed block.+ fn write_user_hook(&self, prelude: &str) {+ std::fs::write(+ &self.hook,+ format!(+ "#!/usr/bin/env bash\n# A user hook that predates the managed block.\n{prelude}{}",+ self.probe("before"),+ ),+ )+ .unwrap();+ }++ /// Append the user's trailing content after the managed block's end marker.+ fn append_after_managed_block(&self) {+ let installed = std::fs::read_to_string(&self.hook).unwrap();+ assert!(+ installed+ .trim_end()+ .ends_with("# <<< ai-memory pre-push <<<"),+ "the managed block should close the installed hook:\n{installed}"+ );+ std::fs::write(&self.hook, format!("{installed}{}", self.probe("after"))).unwrap();+ }++ fn install_hook(&self) {+ let mut command = Command::new(&self.bash);+ command.arg(self.shell_arg(&repo_root().join("scripts/install-git-hooks.sh")));+ self.isolate(&mut command);+ let output = command.current_dir(&self.hook_repo).output().unwrap();+ assert!(+ output.status.success(),+ "installer failed: stdout={} stderr={}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+ }++ /// Run the installed hook with exactly the repository-local environment Git+ /// exports to a pre-push hook. Every injected path is inside the sandbox.+ fn run_hook(&self) -> std::process::Output {+ let mut command = Command::new(&self.bash);+ command.arg(self.shell_arg(&self.runner));+ self.isolate(&mut command);+ self.shell_env(&mut command);+ command+ .current_dir(&self.hook_repo)+ .env("GIT_DIR", self.hook_repo.join(".git"))+ .env("GIT_COMMON_DIR", self.hook_repo.join(".git"))+ .env("GIT_WORK_TREE", &self.hook_repo)+ .env("GIT_INDEX_FILE", self.hook_repo.join(".git").join("index"))+ .env("GIT_PREFIX", "")+ .env(+ "GIT_CONFIG_PARAMETERS",+ "'fixture.injected=from-parameters'",+ )+ .env("GIT_CONFIG_COUNT", "1")+ .env("GIT_CONFIG_KEY_0", "fixture.counted")+ .env("GIT_CONFIG_VALUE_0", "from-count");+ command.output().unwrap()+ }++ fn cargo_log(&self) -> String {+ std::fs::read_to_string(&self.cargo_log).unwrap_or_default()+ }++ fn caller_log(&self) -> String {+ std::fs::read_to_string(&self.caller_log).unwrap_or_default()+ }+}++#[test]+#[cfg(any(unix, windows))]+fn pre_push_hook_scrubs_the_repository_git_environment_before_cargo() {+ let Some(fixture) = PrePushFixture::new() else {+ return;+ };+ fixture.write_runner(0, false);+ fixture.install_hook();++ let output = fixture.run_hook();+ assert!(+ output.status.success(),+ "hook failed: stdout={} stderr={}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );++ let log = fixture.cargo_log();+ let git_env = log_section(&log, "cargo");+ for leaked in [+ "GIT_DIR=",+ "GIT_COMMON_DIR=",+ "GIT_WORK_TREE=",+ "GIT_INDEX_FILE=",+ "GIT_CONFIG_PARAMETERS=",+ "GIT_CONFIG_COUNT=",+ "GIT_PREFIX=",+ ] {+ assert!(+ !git_env.contains(leaked),+ "{leaked} reached cargo; a fixture repo would act on the pushed checkout:\n{git_env}"+ );+ }+ for expected in [+ "GIT_CONFIG_NOSYSTEM=1",+ "GIT_CONFIG_GLOBAL=/dev/null",+ "GIT_CONFIG_SYSTEM=/dev/null",+ ] {+ assert!(+ git_env.contains(expected),+ "cargo should run with {expected}:\n{git_env}"+ );+ }++ // The decisive check: a child `git` aimed at the fixture repository must+ // land there, not in the repository whose hook is running.+ assert_eq!(+ log_field(&log, "cargo-toplevel"),+ fixture.fixture_toplevel,+ "child git resolved the wrong repository:\n{log}"+ );+ for (key, source) in [+ ("cargo-injected", "GIT_CONFIG_PARAMETERS"),+ ("cargo-counted", "GIT_CONFIG_COUNT"),+ ("cargo-global", "the global config"),+ ("cargo-system", "the system config"),+ ] {+ assert_eq!(+ log_field(&log, key),+ "",+ "{source} still reached the fixture repository:\n{log}"+ );+ }+}++#[test]+#[cfg(any(unix, windows))]+fn pre_push_hook_leaves_the_user_hook_environment_intact_around_the_block() {+ let Some(fixture) = PrePushFixture::new() else {+ return;+ };+ fixture.write_runner(0, false);+ fixture.write_user_hook("");+ fixture.install_hook();+ fixture.append_after_managed_block();++ let output = fixture.run_hook();+ assert!(+ output.status.success(),+ "hook failed: stdout={} stderr={}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );++ let log = fixture.caller_log();+ for stage in ["before", "after"] {+ let git_env = log_section(&log, stage);+ for kept in ["GIT_DIR=", "GIT_INDEX_FILE=", "GIT_CONFIG_COUNT=1"] {+ assert!(+ git_env.contains(kept),+ "the scrub escaped the managed block and took {kept} from the {stage} content:\n{git_env}"+ );+ }+ // The scrub's own settings must not leak outward either: the caller+ // keeps its synthetic global/system config and never sees NOSYSTEM.+ assert!(+ !git_env.contains("GIT_CONFIG_GLOBAL=/dev/null")+ && !git_env.contains("GIT_CONFIG_SYSTEM=/dev/null"),+ "the {stage} content must keep the caller's own config paths:\n{git_env}"+ );+ assert!(+ !git_env.contains("GIT_CONFIG_NOSYSTEM"),+ "the {stage} content must not inherit the scrub's GIT_CONFIG_NOSYSTEM:\n{git_env}"+ );+ // The caller's Git still resolves through the inherited GIT_DIR, which+ // points at the hook's repository rather than the fixture repository+ // the command names.+ assert_eq!(+ log_field(&log, &format!("{stage}-toplevel")),+ fixture.hook_toplevel,+ "the {stage} content lost the repository Git gave it:\n{log}"+ );+ for (key, expected, source) in [+ ("global", "from-global-config", "the global config"),+ ("system", "from-system-config", "the system config"),+ ("injected", "from-parameters", "GIT_CONFIG_PARAMETERS"),+ ("counted", "from-count", "GIT_CONFIG_COUNT"),+ ] {+ assert_eq!(+ log_field(&log, &format!("{stage}-{key}")),+ expected,+ "the {stage} content lost {source}:\n{log}"+ );+ }+ }+}++/// Reinstalling must keep the user's own content and leave exactly one managed+/// block.+///+/// It asserts nothing about where that content ends up relative to the block:+/// the installer strips the old block and appends the new one at the end, so a+/// body that used to follow the block now precedes it. That reordering predates+/// this change and is deliberately left alone here.+#[test]+#[cfg(any(unix, windows))]+fn pre_push_hook_reinstall_keeps_user_content_and_one_managed_block() {+ let Some(fixture) = PrePushFixture::new() else {+ return;+ };+ fixture.write_runner(0, false);+ fixture.write_user_hook("");+ fixture.install_hook();+ fixture.append_after_managed_block();+ fixture.install_hook();++ let installed = std::fs::read_to_string(&fixture.hook).unwrap();+ assert_eq!(+ installed.matches("# >>> ai-memory pre-push >>>").count(),+ 1,+ "reinstalling duplicated the managed block:\n{installed}"+ );+ assert_eq!(+ installed.matches("printf 'before-begin\\n'").count(),+ 1,+ "reinstalling lost or duplicated the user's leading content:\n{installed}"+ );+ assert_eq!(+ installed.matches("printf 'after-begin\\n'").count(),+ 1,+ "reinstalling lost or duplicated the user's trailing content:\n{installed}"+ );++ let output = fixture.run_hook();+ assert!(+ output.status.success(),+ "reinstalled hook failed: stdout={} stderr={}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+ assert_eq!(+ log_field(&fixture.cargo_log(), "cargo-toplevel"),+ fixture.fixture_toplevel,+ "the scrub did not survive a reinstall"+ );+}++/// A user hook that narrowed `IFS` before the managed block used to break the+/// split of `git rev-parse --local-env-vars`, leaving the whole newline-joined+/// list as one word.+#[test]+#[cfg(any(unix, windows))]+fn pre_push_hook_splits_the_local_env_var_list_under_a_narrowed_ifs() {+ let Some(fixture) = PrePushFixture::new() else {+ return;+ };+ fixture.write_runner(0, false);+ fixture.write_user_hook("IFS=:\n");+ fixture.install_hook();+ fixture.append_after_managed_block();++ let output = fixture.run_hook();+ assert!(+ output.status.success(),+ "the hook did not survive a narrowed IFS: stdout={} stderr={}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+ assert_eq!(+ log_field(&fixture.cargo_log(), "cargo-toplevel"),+ fixture.fixture_toplevel,+ "the scrub did not survive a narrowed IFS"+ );++ let caller = fixture.caller_log();+ for stage in ["before", "after"] {+ assert_eq!(+ log_field(&caller, &format!("{stage}-ifs")),+ "[:]",+ "the managed block changed the user hook's IFS:\n{caller}"+ );+ }+}++#[test]+#[cfg(any(unix, windows))]+fn pre_push_hook_keeps_the_full_tier_and_propagates_a_cargo_failure() {+ for (with_nextest, expected_argv, expected_notice) in [+ (+ true,+ "nextest run --workspace -P full",+ "pre-push: cargo nextest run --workspace -P full",+ ),+ (+ false,+ "test --workspace --all-targets",+ "pre-push: cargo test --workspace --all-targets (nextest not installed)",+ ),+ ] {+ let Some(fixture) = PrePushFixture::new() else {+ return;+ };+ fixture.write_runner(0, with_nextest);+ fixture.install_hook();++ let output = fixture.run_hook();+ assert!(+ output.status.success(),+ "hook failed with {expected_argv:?}: stdout={} stderr={}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+ assert_eq!(+ log_field(&fixture.cargo_log(), "cargo-argv"),+ expected_argv,+ "wrong cargo invocation for nextest={with_nextest}"+ );+ assert!(+ String::from_utf8_lossy(&output.stdout).contains(expected_notice),+ "the hook stopped announcing what it runs: {}",+ String::from_utf8_lossy(&output.stdout)+ );+ }++ // A failing test run must still stop the push.+ let Some(fixture) = PrePushFixture::new() else {+ return;+ };+ fixture.write_runner(3, true);+ fixture.install_hook();+ let output = fixture.run_hook();+ assert_eq!(+ output.status.code(),+ Some(3),+ "the subshell swallowed cargo's exit status: stdout={} stderr={}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+}+/// The slow tier. These drive the real wrapper scripts, a fake `uname`, and/// fake container engines, 10-20s each, and cannot break from an ordinary Rust/// edit. `.config/nextest.toml` skips every `slow::` module in the everydaydiff --git a/scripts/install-git-hooks.sh b/scripts/install-git-hooks.shindex a23104e3..b4b26eb6 100755--- a/scripts/install-git-hooks.sh+++ b/scripts/install-git-hooks.sh@@ -43,13 +43,30 @@ if [ "$(uname -s 2>/dev/null || true)" = "Darwin" ] && [ -z "${SSL_CERT_FILE:-}"export SSL_CERT_FILE=/etc/ssl/cert.pemfi-if command -v cargo-nextest >/dev/null 2>&1; then- echo "pre-push: cargo nextest run --workspace -P full"- cargo nextest run --workspace -P full-else- echo "pre-push: cargo test --workspace --all-targets (nextest not installed)"- cargo test --workspace --all-targets-fi+# Git's hook environment would redirect fixture commands into this checkout.+# Isolate Cargo and its children so other hook code keeps its Git context.+(+ # A plain assignment, so `set -e` still aborts if `git rev-parse` fails.+ git_local_env_vars=$(git rev-parse --local-env-vars)+ # A surrounding user hook may have narrowed IFS; the list below is split on+ # newlines, so restore the default before splitting it.+ IFS=$' \t\n'+ # Unquoted on purpose: the output is one variable name per line.+ for git_local_env_var in $git_local_env_vars; do+ unset "$git_local_env_var"+ done+ # Fixture repositories must not inherit machine settings such as signing.+ # Git for Windows maps /dev/null to nul.+ export GIT_CONFIG_NOSYSTEM=1 GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_SYSTEM=/dev/null++ if command -v cargo-nextest >/dev/null 2>&1; then+ echo "pre-push: cargo nextest run --workspace -P full"+ cargo nextest run --workspace -P full+ else+ echo "pre-push: cargo test --workspace --all-targets (nextest not installed)"+ cargo test --workspace --all-targets+ fi+)# <<< ai-memory pre-push <<<HOOK