use std::process::Command;
use super::*;
fn run(dir: &Path, args: &[&str]) {
let status = Command::new("git")
.current_dir(dir)
.args([
"-c",
"user.name=t",
"-c",
"user.email=t@t",
"-c",
"commit.gpgsign=false",
])
.args(args)
.env("GIT_CONFIG_GLOBAL", "/dev/null")
.status()
.expect("git runs");
assert!(status.success(), "git {args:?} failed");
}
fn repository() -> (tempfile::TempDir, PathBuf) {
let fixture = tempfile::tempdir().expect("a tempdir");
let main = fixture.path().canonicalize().unwrap().join("main");
std::fs::create_dir_all(main.join("dist")).unwrap();
std::fs::write(main.join("dist/app.js"), "built").unwrap();
std::fs::write(main.join("src.txt"), "source").unwrap();
run(&main, &["init", "-q", "-b", "main"]);
run(&main, &["add", "."]);
run(&main, &["commit", "-q", "-m", "init"]);
(fixture, main)
}
fn add_worktree(main: &Path, name: &str) -> PathBuf {
let path = main.parent().unwrap().join(name);
run(main, &["worktree", "add", "-q", "--detach", path.to_str().unwrap()]);
path
}
fn prune_real(main: &Path, dry_run: bool) -> WorktreePruneResult {
let root = main.parent().expect("a parent").to_path_buf();
prune(
&[main.to_path_buf()],
&[root],
WorktreeOptions {
dry_run,
stale_after: None,
},
)
}
fn state_of<'a>(result: &'a WorktreePruneResult, path: &Path) -> &'a Worktree {
result
.repositories
.iter()
.flat_map(|repository| &repository.worktrees)
.find(|worktree| worktree.path == path)
.expect("the worktree is listed")
}
#[test]
fn should_remove_a_clean_merged_worktree_and_keep_its_branch() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "merged");
let result = prune_real(&main, false);
assert_eq!(state_of(&result, &path).outcome, Some(Outcome::Removed));
assert!(!path.exists());
}
#[test]
fn should_only_report_under_a_dry_run() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "merged");
let result = prune_real(&main, true);
assert_eq!(state_of(&result, &path).outcome, Some(Outcome::WouldRemove));
assert!(path.exists());
}
#[test]
fn should_discard_only_deleted_build_output() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "built");
std::fs::remove_file(path.join("dist/app.js")).unwrap();
let result = prune_real(&main, false);
assert_eq!(state_of(&result, &path).state, State::Merged { discarded: 1 });
assert!(!path.exists());
}
#[test]
fn should_keep_a_deleted_tracked_source_file_under_a_nested_build_directory() {
let (_fixture, main) = repository();
std::fs::create_dir_all(main.join("src/build")).unwrap();
std::fs::write(main.join("src/build/gen.rs"), "source").unwrap();
run(&main, &["add", "src/build/gen.rs"]);
run(&main, &["commit", "-q", "-m", "source"]);
let path = add_worktree(&main, "nested");
std::fs::remove_file(path.join("src/build/gen.rs")).unwrap();
let result = prune_real(&main, false);
assert!(matches!(state_of(&result, &path).state, State::LocalChanges { .. }));
assert!(path.exists());
}
#[test]
fn should_remove_a_merged_worktree_whose_only_change_is_a_deleted_nested_dist() {
let (_fixture, main) = repository();
std::fs::create_dir_all(main.join("app/client/dist")).unwrap();
std::fs::write(main.join("app/client/dist/icons.svg"), "generated").unwrap();
run(&main, &["add", "app/client/dist/icons.svg"]);
run(&main, &["commit", "-q", "-m", "dist"]);
let path = add_worktree(&main, "nested-dist");
std::fs::remove_file(path.join("app/client/dist/icons.svg")).unwrap();
let result = prune_real(&main, false);
assert_eq!(state_of(&result, &path).state, State::Merged { discarded: 1 });
assert!(!path.exists());
}
#[test]
fn should_keep_a_merged_worktree_with_a_modified_file() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "edited");
std::fs::write(path.join("src.txt"), "my work").unwrap();
let result = prune_real(&main, false);
assert_eq!(state_of(&result, &path).state, State::LocalChanges { changed: 1 });
assert_eq!(std::fs::read_to_string(path.join("src.txt")).unwrap(), "my work");
}
#[test]
fn should_keep_a_merged_worktree_with_an_untracked_file() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "scratch");
std::fs::write(path.join("notes.txt"), "todo").unwrap();
let result = prune_real(&main, false);
assert!(matches!(state_of(&result, &path).state, State::LocalChanges { .. }));
assert!(path.exists());
}
#[test]
fn should_keep_a_merged_worktree_with_an_ignored_file() {
let (_fixture, main) = repository();
std::fs::write(main.join(".gitignore"), "*.env\n").unwrap();
run(&main, &["add", ".gitignore"]);
run(&main, &["commit", "-q", "-m", "ignore"]);
let path = add_worktree(&main, "env");
std::fs::write(path.join("local.env"), "SECRET=1").unwrap();
let result = prune_real(&main, false);
assert!(matches!(state_of(&result, &path).state, State::LocalChanges { .. }));
assert!(path.join("local.env").exists(), "an ignored file is not discarded");
}
#[test]
fn should_keep_a_worktree_outside_every_scan_root() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "elsewhere");
let result = prune(
std::slice::from_ref(&main),
std::slice::from_ref(&main),
WorktreeOptions {
dry_run: false,
stale_after: None,
},
);
assert_eq!(state_of(&result, &path).state, State::OutsideRoot);
assert!(path.exists());
}
#[test]
fn should_keep_a_worktree_whose_commits_are_not_in_the_default_branch() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "ahead");
std::fs::write(path.join("new.txt"), "x").unwrap();
run(&path, &["add", "new.txt"]);
run(&path, &["commit", "-q", "-m", "ahead"]);
let result = prune_real(&main, false);
assert_eq!(state_of(&result, &path).state, State::NotMerged);
assert!(path.exists());
}
#[test]
fn should_keep_a_locked_worktree() {
let (_fixture, main) = repository();
let path = add_worktree(&main, "locked");
run(&main, &["worktree", "lock", path.to_str().unwrap()]);
let result = prune_real(&main, false);
assert_eq!(state_of(&result, &path).state, State::Locked);
assert!(path.exists());
}
#[test]
fn should_handle_a_repository_reached_through_several_of_its_worktrees_once() {
let (_fixture, main) = repository();
let first = add_worktree(&main, "one");
let second = add_worktree(&main, "two");
let result = prune(
&[main.clone(), first.clone(), second.clone()],
&[main.parent().expect("a parent").to_path_buf()],
WorktreeOptions {
dry_run: true,
stale_after: None,
},
);
assert_eq!(result.repositories.len(), 1);
assert_eq!(result.repositories[0].worktrees.len(), 2);
}
#[test]
fn should_classify_status_entries() {
let status = b" D dist/a.js\0 D src/b.rs\0?? new.txt\0R new.rs\0old.rs\0";
assert_eq!(classify_status(status), (1, 3));
}
fn unmerged_worktree(main: &Path, name: &str, days: u64) -> PathBuf {
let path = main.parent().unwrap().join(name);
run(main, &["worktree", "add", "-q", "-b", name, path.to_str().unwrap()]);
std::fs::write(path.join("work.txt"), "wip").unwrap();
run(&path, &["add", "work.txt"]);
let then = std::time::SystemTime::now() - Duration::from_secs(days * 86_400);
let stamp = then.duration_since(std::time::UNIX_EPOCH).unwrap().as_secs();
let date = format!("{stamp} +0000");
let status = Command::new("git")
.current_dir(&path)
.args([
"-c",
"user.name=t",
"-c",
"user.email=t@t",
"-c",
"commit.gpgsign=false",
"commit",
"-q",
"-m",
"wip",
])
.env("GIT_CONFIG_GLOBAL", "/dev/null")
.env("GIT_COMMITTER_DATE", &date)
.env("GIT_AUTHOR_DATE", &date)
.status()
.unwrap();
assert!(status.success());
let git_dir = git(&path, &["rev-parse", "--path-format=absolute", "--git-dir"]).unwrap();
let reflog = std::fs::File::options()
.read(true)
.open(Path::new(git_dir.trim()).join("logs/HEAD"))
.unwrap();
reflog.set_modified(then).unwrap();
path
}
fn prune_stale(main: &Path, days: u64) -> WorktreePruneResult {
let root = main.parent().unwrap().to_path_buf();
prune(
&[main.to_path_buf()],
&[root],
WorktreeOptions {
dry_run: false,
stale_after: Some(Duration::from_secs(days * 86_400)),
},
)
}
#[test]
fn should_keep_an_unmerged_worktree_when_no_stale_age_is_given() {
let (_fixture, main) = repository();
let path = unmerged_worktree(&main, "old-work", 90);
let result = prune_real(&main, false);
assert_eq!(state_of(&result, &path).state, State::NotMerged);
assert!(path.exists());
}
#[test]
fn should_remove_an_unmerged_worktree_idle_past_the_stale_age_and_keep_its_branch() {
let (_fixture, main) = repository();
let path = unmerged_worktree(&main, "old-work", 90);
let result = prune_stale(&main, 30);
assert_eq!(state_of(&result, &path).state, State::Stale { discarded: 0 });
assert!(!path.exists());
assert!(git(&main, &["rev-parse", "--verify", "refs/heads/old-work"]).is_some());
}
#[test]
fn should_keep_an_unmerged_worktree_that_is_not_yet_stale() {
let (_fixture, main) = repository();
let path = unmerged_worktree(&main, "recent-work", 5);
let result = prune_stale(&main, 30);
assert_eq!(state_of(&result, &path).state, State::NotMerged);
assert!(path.exists());
}
#[test]
fn should_keep_a_stale_worktree_that_has_uncommitted_work() {
let (_fixture, main) = repository();
let path = unmerged_worktree(&main, "old-work", 90);
std::fs::write(path.join("work.txt"), "more").unwrap();
let result = prune_stale(&main, 30);
assert_eq!(state_of(&result, &path).state, State::LocalChanges { changed: 1 });
assert!(path.exists());
}
#[test]
fn should_never_treat_a_detached_head_no_ref_reaches_as_stale() {
let (_fixture, main) = repository();
let path = unmerged_worktree(&main, "old-work", 90);
run(&path, &["checkout", "-q", "--detach"]);
run(&main, &["branch", "-q", "-D", "-f", "old-work"]);
let reflog = std::fs::File::options()
.read(true)
.open(
Path::new(
git(&path, &["rev-parse", "--path-format=absolute", "--git-dir"])
.unwrap()
.trim(),
)
.join("logs/HEAD"),
)
.unwrap();
reflog
.set_modified(std::time::SystemTime::now() - Duration::from_secs(90 * 86_400))
.unwrap();
let result = prune_stale(&main, 30);
assert_eq!(state_of(&result, &path).state, State::NotMerged);
assert!(path.exists());
}