//! Isolated `git` invocations.//!//! Every command built here ignores the machine's system and global Git//! configuration, never prompts for credentials, uses a fixed author and//! committer identity, and runs no automatic maintenance//! ([`NO_AUTO_MAINTENANCE`]), so tests behave the same on a laptop and in CI. use std::ffi::OsStr;use std::io;use std::path::{Path, PathBuf};use std::process::{Command, Output}; /// Global `-c` options that stop `git` from starting automatic maintenance.////// `git fetch`, `commit`, `merge`, `am`, `rebase` and `receive-pack` end by/// starting `git maintenance run --auto`, detached by default. Since Git 2.54/// that runs a `git repack -d -l --cruft --write-midx` whenever a/// repository holds two or more packs that are not in a geometric size/// progression, which a fetch with packfile URIs (one pack per URI) almost/// always leaves. The repack rewrites `objects/pack` in the background, so a/// `git fsck --strict` the test runs next fails now and then with `packfile/// .../.tmp-<pid>-pack-<hash>.pack index not opened` or `unable to load/// rev-index`: fsck lists an `.idx` the repack then renames or deletes/// (issues #72 and #207). With maintenance off, a test checks exactly what/// the server delivered.////// `maintenance.auto=false` turns it off; `gc.auto=0` does on Git older than/// 2.29, which runs `git gc --auto` instead. Pass these before the/// subcommand: `git <NO_AUTO_MAINTENANCE> fetch ...`. [`isolated_git`]/// already does; a suite that builds its own `git` command must add them.pub const NO_AUTO_MAINTENANCE: [&str; 4] = ["-c", "maintenance.auto=false", "-c", "gc.auto=0"]; /// A `git` command isolated from the machine's system and global config, with/// `home` as its home directory, a fixed author identity and no automatic/// maintenance ([`NO_AUTO_MAINTENANCE`]).pub fn isolated_git(home: &Path) -> Command { let mut cmd = Command::new("git"); cmd.env("HOME", home) .env("GIT_CONFIG_NOSYSTEM", "1") .env("GIT_CONFIG_GLOBAL", "/dev/null") .env("GIT_TERMINAL_PROMPT", "0") .env("GIT_AUTHOR_NAME", "Aspen Interop") .env("GIT_AUTHOR_EMAIL", "interop@aspen.invalid") .env("GIT_COMMITTER_NAME", "Aspen Interop") .env("GIT_COMMITTER_EMAIL", "interop@aspen.invalid") .env_remove("GIT_DIR") .env_remove("GIT_WORK_TREE") .env_remove("GIT_INDEX_FILE") .env_remove("GIT_OBJECT_DIRECTORY") .env_remove("GIT_PROTOCOL") .env_remove("GIT_TRACE") .env_remove("GIT_TRACE_PACKET") .args(NO_AUTO_MAINTENANCE); cmd} /// Creates an empty bare repository at `root/name` that accepts pushes over/// HTTP, and returns its path.pub fn init_bare(root: &Path, name: &str) -> io::Result<PathBuf> { let path = root.join(name); run(isolated_git(root) .args(["init", "--quiet", "--bare", "--initial-branch=main"]) .arg(&path))?; run(isolated_git(root) .args(["config", "http.receivepack", "true"]) .current_dir(&path))?; Ok(path)} /// Runs `cmd` and returns its stdout. A non-zero exit becomes an error whose/// message holds the command line, the exit status, stdout and stderr.pub fn run(cmd: &mut Command) -> io::Result<String> { let out = cmd.output()?; if out.status.success() { Ok(String::from_utf8_lossy(&out.stdout).into_owned()) } else { Err(io::Error::other(describe_failure(cmd, &out))) }} /// A readable account of a failed command, for error messages.pub fn describe_failure(cmd: &Command, out: &Output) -> String { format!( "{} failed with {}\nstdout:\n{}\nstderr:\n{}", command_line(cmd), out.status, String::from_utf8_lossy(&out.stdout).trim_end(), String::from_utf8_lossy(&out.stderr).trim_end() )} fn command_line(cmd: &Command) -> String { let mut line = cmd.get_program().to_string_lossy().into_owned(); for arg in cmd.get_args() { line.push(' '); line.push_str(&arg.to_string_lossy()); } if let Some(dir) = cmd.get_current_dir() { line.push_str(&format!(" (in {})", dir.display())); } line} /// The `git --version` line of the `git` on `PATH`.pub fn version() -> io::Result<String> { Ok(run(Command::new("git").arg("--version"))?.trim().to_owned())} /// A git client with its own home directory and optional `-c` settings,/// for tests that run many commands as one user.#[derive(Debug, Clone)]pub struct GitClient { home: PathBuf, config: Vec<String>,} impl GitClient { /// A client whose `HOME` is `home`. The directory must exist. pub fn new(home: &Path) -> Self { Self { home: home.to_path_buf(), config: Vec::new(), } } /// Adds a `-c key=value` setting to every command this client builds, /// for example `protocol.version=2`. pub fn with_config(mut self, key: &str, value: &str) -> Self { self.config.push(format!("{key}={value}")); self } /// The client's home directory. pub fn home(&self) -> &Path { &self.home } /// An isolated `git` command that runs in `dir`. pub fn command(&self, dir: &Path) -> Command { let mut cmd = isolated_git(&self.home); cmd.current_dir(dir); for setting in &self.config { cmd.arg("-c").arg(setting); } cmd } /// Runs `git <args>` in `dir` and returns stdout; fails on a non-zero exit. pub fn run<I, S>(&self, dir: &Path, args: I) -> io::Result<String> where I: IntoIterator<Item = S>, S: AsRef<OsStr>, { run(self.command(dir).args(args)) } /// Runs `git <args>` in `dir` and returns the raw output, whatever the /// exit status. Fails only if `git` could not be started. pub fn output<I, S>(&self, dir: &Path, args: I) -> io::Result<Output> where I: IntoIterator<Item = S>, S: AsRef<OsStr>, { self.command(dir).args(args).output() }} #[cfg(test)]mod tests { use super::*; #[test] fn failures_name_the_command_and_its_stderr() { let tmp = tempfile::tempdir().unwrap(); let client = GitClient::new(tmp.path()); let err = client .run(tmp.path(), ["rev-parse", "--verify", "no-such-ref"]) .unwrap_err() .to_string(); let line = format!( "git {} rev-parse --verify no-such-ref", NO_AUTO_MAINTENANCE.join(" ") ); assert!(err.contains(&line), "{err}"); assert!(err.contains("stderr:"), "{err}"); } #[test] fn init_bare_accepts_http_pushes() { let tmp = tempfile::tempdir().unwrap(); let path = init_bare(tmp.path(), "r.git").unwrap(); let value = GitClient::new(tmp.path()) .run(&path, ["config", "http.receivepack"]) .unwrap(); assert_eq!(value.trim(), "true"); } /// A fetch into a repository that already holds several packs starts /// no `git maintenance` (#72, #207). Git decides whether to start it /// from config alone, before looking at the packs, so this holds on /// every Git version; on Git 2.54 and later the maintenance it would /// start repacks these packs. #[test] fn a_fetch_starts_no_automatic_maintenance() { let tmp = tempfile::tempdir().unwrap(); let client = GitClient::new(tmp.path()); let src = tmp.path().join("src"); let dst = tmp.path().join("dst"); for repo in [&src, &dst] { run(client .command(tmp.path()) .args(["init", "--quiet", "-b", "main"]) .arg(repo)) .unwrap(); } let trace = tmp.path().join("trace2"); for i in 0..3 { std::fs::write(src.join("f"), format!("{i}\n")).unwrap(); client.run(&src, ["add", "f"]).unwrap(); client.run(&src, ["commit", "--quiet", "-m", "c"]).unwrap(); // `fetch.unpackLimit=1` keeps every fetched pack as a pack. run(client .command(&dst) .env("GIT_TRACE2", &trace) .args(["-c", "fetch.unpackLimit=1", "fetch", "--quiet"]) .arg(&src) .arg("main:refs/remotes/origin/main")) .unwrap(); } let trace = std::fs::read_to_string(&trace).unwrap(); assert!( trace.contains(" fetch "), "the trace saw the fetches:\n{trace}" ); assert!( !trace.contains("maintenance run") && !trace.contains("gc --auto"), "a fetch started automatic maintenance:\n{trace}" ); let packs = std::fs::read_dir(dst.join(".git/objects/pack")) .unwrap() .filter(|e| e.as_ref().unwrap().path().extension() == Some(OsStr::new("pack"))) .count(); assert_eq!( packs, 3, "each fetch kept its pack, and nothing repacked them" ); } #[test] fn global_config_is_ignored() { let tmp = tempfile::tempdir().unwrap(); std::fs::write( tmp.path().join(".gitconfig"), "[user]\n\tname = Someone Else\n", ) .unwrap(); let name = GitClient::new(tmp.path()) .output(tmp.path(), ["config", "user.name"]) .unwrap(); assert!(!name.status.success(), "global config leaked in"); }}
//! Isolated `git` invocations.
//!
//! Every command built here ignores the machine's system and global Git
//! configuration, never prompts for credentials, uses a fixed author and
//! committer identity, and runs no automatic maintenance
//! ([`NO_AUTO_MAINTENANCE`]), so tests behave the same on a laptop and in CI.
use std::ffi::OsStr;
use std::io;
use std::path::{Path, PathBuf};
use std::process::{Command, Output};
/// Global `-c` options that stop `git` from starting automatic maintenance.
///
/// `git fetch`, `commit`, `merge`, `am`, `rebase` and `receive-pack` end by
/// starting `git maintenance run --auto`, detached by default. Since Git 2.54
/// that runs a `git repack -d -l --cruft --write-midx` whenever a
/// repository holds two or more packs that are not in a geometric size
/// progression, which a fetch with packfile URIs (one pack per URI) almost
/// always leaves. The repack rewrites `objects/pack` in the background, so a
/// `git fsck --strict` the test runs next fails now and then with `packfile
/// .../.tmp-<pid>-pack-<hash>.pack index not opened` or `unable to load
/// rev-index`: fsck lists an `.idx` the repack then renames or deletes
/// (issues #72 and #207). With maintenance off, a test checks exactly what
/// the server delivered.
///
/// `maintenance.auto=false` turns it off; `gc.auto=0` does on Git older than
/// 2.29, which runs `git gc --auto` instead. Pass these before the
/// subcommand: `git <NO_AUTO_MAINTENANCE> fetch ...`. [`isolated_git`]
/// already does; a suite that builds its own `git` command must add them.
pub const NO_AUTO_MAINTENANCE: [&str; 4] = ["-c", "maintenance.auto=false", "-c", "gc.auto=0"];
/// A `git` command isolated from the machine's system and global config, with
/// `home` as its home directory, a fixed author identity and no automatic
/// maintenance ([`NO_AUTO_MAINTENANCE`]).
pub fn isolated_git(home: &Path) -> Command {
let mut cmd = Command::new("git");
cmd.env("HOME", home)
.env("GIT_CONFIG_NOSYSTEM", "1")
.env("GIT_CONFIG_GLOBAL", "/dev/null")
.env("GIT_TERMINAL_PROMPT", "0")
.env("GIT_AUTHOR_NAME", "Aspen Interop")
.env("GIT_AUTHOR_EMAIL", "interop@aspen.invalid")
.env("GIT_COMMITTER_NAME", "Aspen Interop")
.env("GIT_COMMITTER_EMAIL", "interop@aspen.invalid")
.env_remove("GIT_DIR")
.env_remove("GIT_WORK_TREE")
.env_remove("GIT_INDEX_FILE")
.env_remove("GIT_OBJECT_DIRECTORY")
.env_remove("GIT_PROTOCOL")
.env_remove("GIT_TRACE")
.env_remove("GIT_TRACE_PACKET")
.args(NO_AUTO_MAINTENANCE);
cmd
}
/// Creates an empty bare repository at `root/name` that accepts pushes over
/// HTTP, and returns its path.
pub fn init_bare(root: &Path, name: &str) -> io::Result<PathBuf> {
let path = root.join(name);
run(isolated_git(root)
.args(["init", "--quiet", "--bare", "--initial-branch=main"])
.arg(&path))?;
run(isolated_git(root)
.args(["config", "http.receivepack", "true"])
.current_dir(&path))?;
Ok(path)
}
/// Runs `cmd` and returns its stdout. A non-zero exit becomes an error whose
/// message holds the command line, the exit status, stdout and stderr.
pub fn run(cmd: &mut Command) -> io::Result<String> {
let out = cmd.output()?;
if out.status.success() {
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
} else {
Err(io::Error::other(describe_failure(cmd, &out)))
}
}
/// A readable account of a failed command, for error messages.
pub fn describe_failure(cmd: &Command, out: &Output) -> String {
format!(
"{} failed with {}\nstdout:\n{}\nstderr:\n{}",
command_line(cmd),
out.status,
String::from_utf8_lossy(&out.stdout).trim_end(),
String::from_utf8_lossy(&out.stderr).trim_end()
)
}
fn command_line(cmd: &Command) -> String {
let mut line = cmd.get_program().to_string_lossy().into_owned();
for arg in cmd.get_args() {
line.push(' ');
line.push_str(&arg.to_string_lossy());
}
if let Some(dir) = cmd.get_current_dir() {
line.push_str(&format!(" (in {})", dir.display()));
}
line
}
/// The `git --version` line of the `git` on `PATH`.
pub fn version() -> io::Result<String> {
Ok(run(Command::new("git").arg("--version"))?.trim().to_owned())
}
/// A git client with its own home directory and optional `-c` settings,
/// for tests that run many commands as one user.
#[derive(Debug, Clone)]
pub struct GitClient {
home: PathBuf,
config: Vec<String>,
}
impl GitClient {
/// A client whose `HOME` is `home`. The directory must exist.
pub fn new(home: &Path) -> Self {
Self {
home: home.to_path_buf(),
config: Vec::new(),
}
}
/// Adds a `-c key=value` setting to every command this client builds,
/// for example `protocol.version=2`.
pub fn with_config(mut self, key: &str, value: &str) -> Self {
self.config.push(format!("{key}={value}"));
self
}
/// The client's home directory.
pub fn home(&self) -> &Path {
&self.home
}
/// An isolated `git` command that runs in `dir`.
pub fn command(&self, dir: &Path) -> Command {
let mut cmd = isolated_git(&self.home);
cmd.current_dir(dir);
for setting in &self.config {
cmd.arg("-c").arg(setting);
}
cmd
}
/// Runs `git <args>` in `dir` and returns stdout; fails on a non-zero exit.
pub fn run<I, S>(&self, dir: &Path, args: I) -> io::Result<String>
where
I: IntoIterator<Item = S>,
S: AsRef<OsStr>,
{
run(self.command(dir).args(args))
}
/// Runs `git <args>` in `dir` and returns the raw output, whatever the
/// exit status. Fails only if `git` could not be started.
pub fn output<I, S>(&self, dir: &Path, args: I) -> io::Result<Output>
where
I: IntoIterator<Item = S>,
S: AsRef<OsStr>,
{
self.command(dir).args(args).output()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn failures_name_the_command_and_its_stderr() {
let tmp = tempfile::tempdir().unwrap();
let client = GitClient::new(tmp.path());
let err = client
.run(tmp.path(), ["rev-parse", "--verify", "no-such-ref"])
.unwrap_err()
.to_string();
let line = format!(
"git {} rev-parse --verify no-such-ref",
NO_AUTO_MAINTENANCE.join(" ")
);
assert!(err.contains(&line), "{err}");
assert!(err.contains("stderr:"), "{err}");
}
#[test]
fn init_bare_accepts_http_pushes() {
let tmp = tempfile::tempdir().unwrap();
let path = init_bare(tmp.path(), "r.git").unwrap();
let value = GitClient::new(tmp.path())
.run(&path, ["config", "http.receivepack"])
.unwrap();
assert_eq!(value.trim(), "true");
}
/// A fetch into a repository that already holds several packs starts
/// no `git maintenance` (#72, #207). Git decides whether to start it
/// from config alone, before looking at the packs, so this holds on
/// every Git version; on Git 2.54 and later the maintenance it would
/// start repacks these packs.
#[test]
fn a_fetch_starts_no_automatic_maintenance() {
let tmp = tempfile::tempdir().unwrap();
let client = GitClient::new(tmp.path());
let src = tmp.path().join("src");
let dst = tmp.path().join("dst");
for repo in [&src, &dst] {
run(client
.command(tmp.path())
.args(["init", "--quiet", "-b", "main"])
.arg(repo))
.unwrap();
}
let trace = tmp.path().join("trace2");
for i in 0..3 {
std::fs::write(src.join("f"), format!("{i}\n")).unwrap();
client.run(&src, ["add", "f"]).unwrap();
client.run(&src, ["commit", "--quiet", "-m", "c"]).unwrap();
// `fetch.unpackLimit=1` keeps every fetched pack as a pack.
run(client
.command(&dst)
.env("GIT_TRACE2", &trace)
.args(["-c", "fetch.unpackLimit=1", "fetch", "--quiet"])
.arg(&src)
.arg("main:refs/remotes/origin/main"))
.unwrap();
}
let trace = std::fs::read_to_string(&trace).unwrap();
assert!(
trace.contains(" fetch "),
"the trace saw the fetches:\n{trace}"
);
assert!(
!trace.contains("maintenance run") && !trace.contains("gc --auto"),
"a fetch started automatic maintenance:\n{trace}"
);
let packs = std::fs::read_dir(dst.join(".git/objects/pack"))
.unwrap()
.filter(|e| e.as_ref().unwrap().path().extension() == Some(OsStr::new("pack")))
.count();
assert_eq!(
packs, 3,
"each fetch kept its pack, and nothing repacked them"
);
}
#[test]
fn global_config_is_ignored() {
let tmp = tempfile::tempdir().unwrap();
std::fs::write(
tmp.path().join(".gitconfig"),
"[user]\n\tname = Someone Else\n",
)
.unwrap();
let name = GitClient::new(tmp.path())
.output(tmp.path(), ["config", "user.name"])
.unwrap();
assert!(!name.status.success(), "global config leaked in");
}
}