reya/signed
1
0
Fork 0
Code Issues Pull Requests Actions 7 Releases Activity
Files
40deb9db66118b3e65b2b9230901dd7a49a39bbf
signed/crates/signed_git/src/tests.rs
T
reya 38e8b2b933
Rust / build (macos-latest, stable) (push) Canceled after 0s
Details
Rust / build (ubuntu-latest, stable) (push) Canceled after 0s
Details
Rust / build (windows-latest, stable) (push) Canceled after 0s
Details
chore: refactor the backend (#17) 
Reviewed-on: #17
2026-09-10 09:43:35 +00:00

1793 lines
59 KiB
Rust
Raw Blame History

use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::process::Command;
use nostr::prelude::*;
use signed_core::{Announcement, repo_addr};
use super::*;
#[test]
fn keeps_plain_ids() {
assert_eq!(sanitize_path_component("my-repo"), "my-repo");
assert_eq!(sanitize_path_component("repo.v2"), "repo.v2");
assert_eq!(sanitize_path_component("a_b-c"), "a_b-c");
}
#[test]
fn replaces_unsafe_characters() {
assert_eq!(sanitize_path_component("a/b\\c:d"), "a_b_c_d");
assert_eq!(sanitize_path_component(""), "");
}
#[test]
fn blocks_parent_components() {
assert_eq!(sanitize_path_component(".."), "_");
assert_eq!(sanitize_path_component("."), "_");
// Separators are neutralized before the check, so these stay safe.
assert_eq!(sanitize_path_component("../.."), ".._..");
assert_eq!(sanitize_path_component("a/../b"), "a_.._b");
}
#[test]
fn fork_namespace_combines_owner_and_sanitized_id() {
let keys = Keys::generate();
let event = EventBuilder::new(Kind::GitRepoAnnouncement, "")
.tags([Tag::parse(["d", "my/repo"]).expect("valid tag")])
.finalize(&keys)
.expect("signed event");
let announcement = Announcement::from_event(&event).expect("parses");
assert_eq!(
fork_namespace(&announcement),
format!("{}/my_repo", keys.public_key().to_hex())
);
}
#[test]
fn repo_path_stays_inside_root() {
let cache = GitCache::new("/cache".into());
let owner = Keys::generate().public_key();
let path = cache.repo_path(&repo_addr(owner, ".."));
assert!(path.starts_with("/cache"));
assert_eq!(
path.file_name().map(|n| n.to_string_lossy().into_owned()),
Some("_".into())
);
}
#[test]
fn find_git_repos_discovers_repositories_recursively() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
// Repositories are found at any depth.
// A linked worktree, with a `.git` file instead of a directory, counts too.
let nested = root.join("a/b/project");
std::fs::create_dir_all(nested.join(".git")).unwrap();
let worktree = root.join("wt");
std::fs::create_dir_all(&worktree).unwrap();
std::fs::write(
worktree.join(".git"),
"gitdir: ../a/b/project/.git/worktrees/wt",
)
.unwrap();
// Plain directories are not repositories.
std::fs::create_dir_all(root.join("plain")).unwrap();
// A `.gitignore` at the root excludes dependency caches.
std::fs::write(root.join(".gitignore"), "node_modules/\n").unwrap();
std::fs::create_dir_all(root.join("node_modules/pkg/.git")).unwrap();
// Hidden entries are skipped.
std::fs::create_dir_all(root.join(".hidden/repo/.git")).unwrap();
// A repository is not descended into.
// Repositories inside it, like submodule worktrees, are not reported.
let outer = root.join("outer");
std::fs::create_dir_all(outer.join(".git")).unwrap();
std::fs::create_dir_all(outer.join("sub/other/.git")).unwrap();
let mut found = find_git_repos(root);
found.sort();
let mut expected = vec![
nested.canonicalize().unwrap(),
worktree.canonicalize().unwrap(),
outer.canonicalize().unwrap(),
];
expected.sort();
assert_eq!(found, expected);
}
#[test]
fn root_commit_reports_the_first_ancestor() {
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
let root = root_commit(dir).expect("root").expect("commit");
assert_eq!(root.len(), 40);
// The root commit does not change when history grows.
std::fs::write(dir.join("b.txt"), b"two").expect("write");
commit_all(&repo, "second");
assert_eq!(
root_commit(dir).expect("root").as_deref(),
Some(root.as_str())
);
}
#[test]
fn root_commit_is_none_without_commits() {
let (_dir, repo) = fixture(&[("a.txt", b"one")]);
let workdir = repo.workdir().expect("workdir");
assert_eq!(root_commit(workdir).expect("root"), None);
}
#[test]
fn push_all_mirrors_branches_and_tags() {
// A bare server repository reachable via a `file://` URL.
// Mirrors a grasp server's `{base}/{owner}/{repo-id}.git` layout.
let server = tempfile::tempdir().unwrap();
let server_repo = server.path().join("npub1test").join("my-repo.git");
std::fs::create_dir_all(server_repo.parent().unwrap()).unwrap();
let init_status = Command::new("git")
.args(["init", "--bare", "-q"])
.arg(&server_repo)
.status()
.expect("spawn git init --bare");
assert!(init_status.success());
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
// Two branches plus a tag are all mirrored.
git_run(dir, &["checkout", "-b", "feature"]);
std::fs::write(dir.join("b.txt"), b"two").expect("write");
commit_all(&repo, "feature work");
git_run(dir, &["checkout", "-"]);
git_run(dir, &["tag", "v1.0"]);
let base_url = format!("file://{}", server.path().display());
push_all(dir, &base_url, "npub1test", "my-repo").expect("push");
let refs = git_in(&server_repo, &["show-ref"]).expect("server refs");
assert!(refs.contains("refs/heads/main"));
assert!(refs.contains("refs/heads/feature"));
assert!(refs.contains("refs/tags/v1.0"));
}
#[test]
fn push_all_tolerates_a_missing_ref_kind() {
// A repository with only tags and no branches still pushes.
// Wildcard refspecs without a local match are ignored.
let server = tempfile::tempdir().unwrap();
let server_repo = server.path().join("npub1test").join("my-repo.git");
std::fs::create_dir_all(server_repo.parent().unwrap()).unwrap();
let init_status = Command::new("git")
.args(["init", "--bare", "-q"])
.arg(&server_repo)
.status()
.expect("spawn git init --bare");
assert!(init_status.success());
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
git_run(dir, &["tag", "v1.0"]);
git_run(dir, &["update-ref", "-d", "refs/heads/main"]);
let base_url = format!("file://{}", server.path().display());
push_all(dir, &base_url, "npub1test", "my-repo").expect("push");
let refs = git_in(&server_repo, &["show-ref"]).expect("server refs");
assert!(refs.contains("refs/tags/v1.0"));
assert!(!refs.contains("refs/heads/"));
}
#[test]
fn remote_has_refs_reports_whether_pushed_refs_landed() {
let server = tempfile::tempdir().unwrap();
let server_repo = server.path().join("npub1test").join("my-repo.git");
std::fs::create_dir_all(server_repo.parent().unwrap()).unwrap();
let init_status = Command::new("git")
.args(["init", "--bare", "-q"])
.arg(&server_repo)
.status()
.expect("spawn git init --bare");
assert!(init_status.success());
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
let main = git_in(dir, &["rev-parse", "refs/heads/main"]).expect("main oid");
let url = format!("file://{}/npub1test/my-repo.git", server.path().display());
let expected = vec![("refs/heads/main".to_owned(), main.clone())];
// Nothing pushed yet: the ref is absent.
assert!(!remote_has_refs(dir, &url, &expected).expect("probe"));
push_all(
dir,
&format!("file://{}", server.path().display()),
"npub1test",
"my-repo",
)
.expect("push");
// The pushed ref is advertised at the expected commit.
assert!(remote_has_refs(dir, &url, &expected).expect("probe"));
// A stale expectation - the exact race a retry resolves - is false.
let stale = vec![("refs/heads/main".to_owned(), "0".repeat(40))];
assert!(!remote_has_refs(dir, &url, &stale).expect("probe"));
// Extra remote refs (e.g. a tag pushed later) do not invalidate the
// refs this push wanted to land.
git_run(dir, &["tag", "v1.0"]);
push_all(
dir,
&format!("file://{}", server.path().display()),
"npub1test",
"my-repo",
)
.expect("push");
assert!(remote_has_refs(dir, &url, &expected).expect("probe"));
}
#[test]
fn repo_ref_state_lists_branches_tags_and_head() {
let (_dir, repo) = fixture(&[("a.txt", b"hello")]);
commit_all(&repo, "initial");
let workdir = repo.workdir().expect("workdir").to_path_buf();
let state = repo_ref_state(&repo).expect("refs");
let branch = current_branch(&repo).expect("branch").expect("on a branch");
assert_eq!(state.head.as_deref(), Some(branch.as_str()));
assert_eq!(state.refs.len(), 1);
assert_eq!(state.refs[0].0, format!("refs/heads/{branch}"));
assert_eq!(state.refs[0].1.len(), 40);
// Additional branches and tags are listed alongside.
git_run(&workdir, &["branch", "feature"]);
git_run(&workdir, &["tag", "v1.0"]);
let state = repo_ref_state(&repo).expect("refs");
let mut expected: Vec<String> = vec![
format!("refs/heads/{branch}"),
"refs/heads/feature".to_owned(),
"refs/tags/v1.0".to_owned(),
];
expected.sort();
assert_eq!(
state
.refs
.iter()
.map(|(name, _)| name.clone())
.collect::<Vec<_>>(),
expected
);
// A detached HEAD yields no head branch.
git_run(&workdir, &["checkout", "--detach"]);
let state = repo_ref_state(&repo).expect("refs");
assert!(state.head.is_none());
assert_eq!(state.refs.len(), 3);
}
/// Build a throwaway non-bare repository from `(rel, bytes)` file pairs.
fn fixture(files: &[(&str, &[u8])]) -> (tempfile::TempDir, gix::Repository) {
let dir = tempfile::tempdir().expect("tempdir");
let repo = gix::init(&dir).expect("init");
for (rel, bytes) in files {
let path = dir.path().join(rel);
std::fs::create_dir_all(path.parent().expect("parent")).expect("mkdir");
std::fs::write(&path, bytes).expect("write");
}
(dir, repo)
}
#[test]
fn worktree_entries_lists_all_files_and_dirs() {
let (_dir, repo) = fixture(&[
("README.md", b"# Hi"),
("src/main.rs", b"fn main() {}"),
("src/lib.rs", b""),
("docs/guide.md", b"guide"),
]);
let entries = worktree_entries(&repo).expect("entries");
let entries: Vec<String> = entries
.iter()
.map(|p| p.to_string_lossy().into_owned())
.collect();
assert_eq!(
entries,
vec![
"docs",
"src",
"README.md",
"docs/guide.md",
"src/lib.rs",
"src/main.rs"
]
);
}
#[test]
fn worktree_read_returns_bytes_or_none() {
let (_dir, repo) = fixture(&[("a.txt", b"hello"), ("sub/b.bin", b"\x00\x01")]);
assert_eq!(
worktree_read(&repo, Path::new("a.txt")).expect("read"),
Some(b"hello".to_vec())
);
assert_eq!(
worktree_read(&repo, Path::new("sub/b.bin")).expect("read"),
Some(vec![0x00, 0x01])
);
assert_eq!(
worktree_read(&repo, Path::new("missing.txt")).expect("read"),
None
);
}
/// Stage everything and create a commit with the git CLI.
/// Like [`apply_patch`], the crate already shells out to the CLI.
fn commit_all(repo: &gix::Repository, message: &str) {
git_run(repo.workdir().expect("workdir"), &["add", "-A"]);
git_run(repo.workdir().expect("workdir"), &["commit", "-m", message]);
}
#[test]
fn merge_base_finds_the_fork_point_and_reports_unrelated_history() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("repo");
let initial = init_repository(&path, "My Repo", "desc").expect("init");
// A feature branch and a mainline commit diverge from the initial commit.
// The initial commit is their merge base.
git_run(&path, &["checkout", "-b", "feature"]);
std::fs::write(path.join("feature.txt"), "feature\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "feature commit");
git_run(&path, &["checkout", "main"]);
std::fs::write(path.join("main.txt"), "main\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "mainline commit");
assert_eq!(
merge_base(&path, "feature", "main")
.expect("merge base")
.as_deref(),
Some(initial.as_str())
);
// An orphan branch shares no history with main, so `Ok(None)`.
git_run(&path, &["checkout", "--orphan", "orphan"]);
std::fs::write(path.join("orphan.txt"), "orphan\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "orphan commit");
assert_eq!(merge_base(&path, "orphan", "main").expect("ok"), None);
// An unresolvable revision is an error, not a missing ancestor.
assert!(merge_base(&path, "orphan", "no-such-ref").is_err());
}
#[test]
fn format_patch_between_produces_the_series_and_rejects_empty_ranges() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("repo");
let initial = init_repository(&path, "My Repo", "desc").expect("init");
git_run(&path, &["checkout", "-b", "feature"]);
std::fs::write(path.join("feature.txt"), "feature\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "feature commit");
let patch = format_patch_between(&path, &initial, "feature").expect("patch");
assert!(patch.contains("Subject: [PATCH] feature commit"));
assert!(patch.contains("feature.txt"));
// An empty range has no commits to send.
assert!(format_patch_between(&path, "feature", "feature").is_err());
}
#[test]
fn push_commit_ref_pushes_to_the_event_namespace() {
// A bare server repository reachable via a `file://` URL.
// Mirrors a grasp server's `{base}/{owner}/{repo-id}.git` layout.
let server = tempfile::tempdir().unwrap();
let server_repo = server.path().join("npub1test").join("my-repo.git");
std::fs::create_dir_all(server_repo.parent().unwrap()).unwrap();
let init_status = Command::new("git")
.args(["init", "--bare", "-q"])
.arg(&server_repo)
.status()
.expect("spawn git init --bare");
assert!(init_status.success());
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
let tip = git_in(dir, &["rev-parse", "HEAD"]).expect("tip");
let url = format!("file://{}/npub1test/my-repo.git", server.path().display());
push_commit_ref(dir, &url, &tip, "refs/nostr/abcd1234").expect("push");
let refs = git_in(&server_repo, &["show-ref"]).expect("server refs");
assert!(refs.contains("refs/nostr/abcd1234"));
}
#[test]
fn split_patch_series_splits_real_multi_commit_mboxes() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("repo");
let initial = init_repository(&path, "My Repo", "desc").expect("init");
git_run(&path, &["checkout", "-b", "feature"]);
std::fs::write(path.join("one.txt"), "one\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "first commit");
std::fs::write(path.join("two.txt"), "two\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "second commit");
let series = format_patch_between(&path, &initial, "feature").expect("series");
let parts = split_patch_series(&series);
assert_eq!(parts.len(), 2);
assert!(parts[0].contains("Subject: [PATCH 1/2] first commit"));
assert!(parts[1].contains("Subject: [PATCH 2/2] second commit"));
// Each part starts its own mbox message with its own commit id.
let first = parts[0].lines().next().expect("first header");
let second = parts[1].lines().next().expect("second header");
assert!(first.starts_with("From ") && first.len() >= 45);
assert_ne!(first, second);
}
#[test]
fn split_patch_series_keeps_single_patches_whole() {
let patch = "From abcdefabcdefabcdefabcdefabcdefabcdefab Mon Sep 17 00:00:00 2001\nFrom: A <a@b>\nSubject: [PATCH] fix\n\n---\n";
let parts = split_patch_series(patch);
assert_eq!(parts.len(), 1);
assert_eq!(parts[0], patch);
}
#[test]
fn head_commit_and_commits_since_track_applied_commits() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("repo");
let initial = init_repository(&path, "My Repo", "desc").expect("init");
assert_eq!(
head_commit_id(&path).expect("head").as_deref(),
Some(initial.as_str())
);
// No commits yet, `HEAD` alone.
assert_eq!(
commits_since(&path, None).expect("commits"),
vec![initial.clone()]
);
std::fs::write(path.join("one.txt"), "one\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "first commit");
let first = head_commit_id(&path).expect("head").expect("on a branch");
std::fs::write(path.join("two.txt"), "two\n").expect("write");
commit_all(&gix::open(&path).expect("open"), "second commit");
let second = head_commit_id(&path).expect("head").expect("on a branch");
// Oldest first, like the order `git am` creates them.
assert_eq!(
commits_since(&path, Some(&initial)).expect("commits"),
vec![first.clone(), second.clone()]
);
assert_eq!(
commits_since(&path, Some(&first)).expect("commits"),
vec![second]
);
}
#[test]
fn head_commit_reports_unborn_repositories() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("repo");
let status = Command::new("git")
.args(["init", "-q"])
.arg(&path)
.status()
.expect("spawn git init");
assert!(status.success());
assert_eq!(head_commit_id(&path).expect("head"), None);
assert_eq!(
commits_since(&path, None).expect("commits"),
Vec::<String>::new()
);
}
#[test]
fn init_repository_creates_main_branch_and_readme() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("my-repo");
let commit = init_repository(&path, "My Repo", "Does things.\n\nCool.").expect("init");
assert_eq!(commit.len(), 40);
let repo = gix::open(&path).expect("open");
let workdir = repo.workdir().expect("workdir");
assert_eq!(
std::fs::read_to_string(workdir.join("README.md")).expect("read"),
"# My Repo\n\nDoes things.\n\nCool.\n"
);
let branch = current_branch(&repo).expect("branch").expect("on a branch");
assert_eq!(branch, "main");
// [`FileCommit`] carries the short id, the full id is 40 chars.
assert_eq!(
head_commit(&repo).expect("head").expect("commit").id,
&commit[..7]
);
let state = repo_ref_state(&repo).expect("refs");
assert_eq!(state.head.as_deref(), Some("main"));
assert_eq!(state.refs, vec![("refs/heads/main".to_owned(), commit)]);
// The index matches the committed tree, so the fresh repo is clean.
assert!(!worktree_dirty(workdir));
}
#[test]
fn init_repository_omits_description_when_empty() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("my-repo");
init_repository(&path, "My Repo", " ").expect("init");
let repo = gix::open(&path).expect("open");
let workdir = repo.workdir().expect("workdir");
assert_eq!(
std::fs::read_to_string(workdir.join("README.md")).expect("read"),
"# My Repo\n"
);
}
#[test]
fn ensure_origin_adds_remote_only_once() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("my-repo");
init_repository(&path, "My Repo", "").expect("init");
ensure_origin(&path, "https://gitnostr.com/npub1test/repo.git").expect("add");
assert_eq!(
git_in(&path, &["remote", "get-url", "origin"]).expect("url"),
"https://gitnostr.com/npub1test/repo.git"
);
// The standard fetch mapping is configured with the remote.
// Later `git fetch origin` updates `refs/remotes/origin/*`.
assert_eq!(
git_in(&path, &["config", "remote.origin.fetch"]).expect("refspec"),
"+refs/heads/*:refs/remotes/origin/*"
);
// A second call must not override the existing remote.
ensure_origin(&path, "https://other.example/repo.git").expect("keep");
assert_eq!(
git_in(&path, &["remote", "get-url", "origin"]).expect("url"),
"https://gitnostr.com/npub1test/repo.git"
);
}
#[test]
fn origin_url_reads_the_remote_or_reports_none() {
let (dir, _repo) = fixture(&[("a.txt", b"one")]);
commit_all(&_repo, "initial");
let dir = dir.path();
// No remote configured yet.
assert_eq!(origin_url(dir).expect("read"), None);
ensure_origin(dir, "https://gitnostr.com/npub1test/repo.git").expect("add");
assert_eq!(
origin_url(dir).expect("read").as_deref(),
Some("https://gitnostr.com/npub1test/repo.git")
);
}
#[test]
fn set_origin_creates_or_replaces_the_remote() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("my-repo");
init_repository(&path, "My Repo", "").expect("init");
// No origin yet, so one is added.
set_origin(&path, "https://gitnostr.com/npub1test/repo.git").expect("add");
assert_eq!(
origin_url(&path).expect("url").as_deref(),
Some("https://gitnostr.com/npub1test/repo.git")
);
// An existing origin is replaced, not duplicated.
// A clone's origin points at the cloned-from path.
// It is re-targeted at the grasp server.
set_origin(&path, "https://grasp.example/npub1test/repo.git").expect("replace");
assert_eq!(
origin_url(&path).expect("url").as_deref(),
Some("https://grasp.example/npub1test/repo.git")
);
}
#[test]
fn working_copy_cloned_from_the_mirror_matches_head_and_origin() {
// The mirror is a freshly initialized repository, standing in for
// the grasp server. Its `origin` points at the (fake) grasp server.
// `GitCache::ensure_clone` lazily clones from a URL shaped like this
// the first time a repository is opened.
let dir = tempfile::tempdir().expect("tempdir");
let mirror = dir.path().join("mirror");
let commit = init_repository(&mirror, "My Repo", "Does things.").expect("init");
ensure_origin(&mirror, "https://gitnostr.com/npub1test/my-repo.git").expect("origin");
// The working copy is cloned from the mirror.
// It then shares the announced history exactly.
// `origin` is re-pointed at the grasp server instead of the mirror path.
let destination = dir.path().join("folder").join("My_Repo");
std::fs::create_dir_all(destination.parent().unwrap()).expect("parent");
clone_repo(&[format!("file://{}", mirror.display())], &destination).expect("clone");
set_origin(&destination, "https://gitnostr.com/npub1test/my-repo.git").expect("set origin");
assert_eq!(
origin_url(&destination).expect("url").as_deref(),
Some("https://gitnostr.com/npub1test/my-repo.git")
);
assert_eq!(
head_commit_id(&destination).expect("head").as_deref(),
Some(commit.as_str())
);
assert!(destination.join("README.md").is_file());
}
#[test]
fn fast_forward_branches_moves_the_mirror_and_keeps_local_work() {
// A bare server, like a grasp server's `{base}/{owner}/{repo}.git` layout.
let dir = tempfile::tempdir().expect("tempdir");
let base_server = dir.path().join("npub1test").join("repo.git");
std::fs::create_dir_all(base_server.parent().unwrap()).unwrap();
let init_status = Command::new("git")
.args(["init", "--bare", "-q"])
.arg(&base_server)
.status()
.expect("spawn git init --bare");
assert!(init_status.success());
// The owner's working repo pushes the initial commit.
let (work_dir, work_repo) = fixture(&[("a.txt", b"one")]);
commit_all(&work_repo, "initial");
let work = work_dir.path();
let base_url = format!("file://{}", dir.path().display());
push_all(work, &base_url, "npub1test", "repo").expect("push");
// A mirror clone, like the app's GitCache clones.
let mirror = dir.path().join("mirror");
git_run(
dir.path(),
&[
"clone",
"-q",
&format!("{base_url}/npub1test/repo.git"),
mirror.to_str().unwrap(),
],
);
let initial = git_in(&mirror, &["rev-parse", "HEAD"]).expect("initial");
// The owner pushes a new commit.
// The mirror fetches it, but its local `main` and worktree stay behind.
std::fs::write(work.join("new.txt"), b"new\n").expect("write");
commit_all(&gix::open(work).expect("open"), "new commit");
push_all(work, &base_url, "npub1test", "repo").expect("push");
git_run(&mirror, &["fetch", "origin"]);
let remote = git_in(&mirror, &["rev-parse", "refs/remotes/origin/main"]).expect("remote");
assert_eq!(
git_in(&mirror, &["rev-parse", "HEAD"]).expect("local"),
initial
);
assert_ne!(remote, initial);
// Fast-forwarding catches the branch and its worktree up.
// The second call has nothing left to move.
assert!(fast_forward_branches(&mirror).expect("ff"));
assert_eq!(
git_in(&mirror, &["rev-parse", "HEAD"]).expect("local"),
remote
);
assert!(mirror.join("new.txt").is_file());
assert!(!fast_forward_branches(&mirror).expect("idle"));
// A branch with local commits of its own is never touched.
git_run(&mirror, &["checkout", "-b", "wip"]);
std::fs::write(mirror.join("wip.txt"), b"wip\n").expect("write");
commit_all(&gix::open(&mirror).expect("open"), "local wip");
let wip = git_in(&mirror, &["rev-parse", "HEAD"]).expect("wip");
assert!(!fast_forward_branches(&mirror).expect("wip skipped"));
assert_eq!(
git_in(&mirror, &["rev-parse", "HEAD"]).expect("wip kept"),
wip
);
}
#[test]
fn fetch_repo_refs_imports_heads_under_a_prefix() {
let dir = tempfile::tempdir().expect("tempdir");
// A bare base server holding the initial commit.
// Like a grasp server's `{base}/{owner}/{repo-id}.git` layout.
let base_server = dir.path().join("npub1base").join("base.git");
std::fs::create_dir_all(base_server.parent().unwrap()).unwrap();
let init_status = Command::new("git")
.args(["init", "--bare", "-q"])
.arg(&base_server)
.status()
.expect("spawn git init --bare");
assert!(init_status.success());
let (upstream_dir, upstream_repo) = fixture(&[("a.txt", b"one")]);
commit_all(&upstream_repo, "initial");
let upstream_path = upstream_dir.path();
let initial = git_in(upstream_path, &["rev-parse", "HEAD"]).expect("initial");
push_all(
upstream_path,
&format!("file://{}", dir.path().display()),
"npub1base",
"base",
)
.expect("push");
// The base mirror is a plain clone of the base server.
let base_url = format!("file://{}", base_server.display());
let mirror = dir.path().join("mirror");
git_run(
dir.path(),
&["clone", "-q", &base_url, mirror.to_str().unwrap()],
);
// The fork server has the same initial commit.
// It also carries a feature commit on its own `feature` branch.
let fork_work = dir.path().join("fork-work");
git_run(
dir.path(),
&["clone", "-q", &base_url, fork_work.to_str().unwrap()],
);
git_run(&fork_work, &["checkout", "-b", "feature"]);
std::fs::write(fork_work.join("feature.txt"), "feature\n").expect("write");
commit_all(&gix::open(&fork_work).expect("open"), "feature commit");
let tip = git_in(&fork_work, &["rev-parse", "HEAD"]).expect("tip");
let fork_server = dir.path().join("npub1fork").join("fork.git");
std::fs::create_dir_all(fork_server.parent().unwrap()).unwrap();
let init_status = Command::new("git")
.args(["init", "--bare", "-q"])
.arg(&fork_server)
.status()
.expect("spawn git init --bare");
assert!(init_status.success());
push_commit_ref(
&fork_work,
&format!("file://{}", fork_server.display()),
&tip,
"refs/heads/feature",
)
.expect("push");
// Import the fork's heads into the mirror under a private prefix.
// The first dead URL is skipped, the second works.
let dead = format!("file://{}/missing.git", dir.path().display());
fetch_repo_refs(
&mirror,
&[dead, format!("file://{}", fork_server.display())],
"+refs/heads/*:refs/fork/npub1fork/fork/*",
)
.expect("fetch");
// The imported refs are listed under the prefix only.
assert_eq!(
refs_with_prefix(&mirror, "refs/fork/npub1fork/fork").expect("refs"),
vec!["refs/fork/npub1fork/fork/feature"]
);
// Nothing leaked into the normal ref namespaces.
assert_eq!(
refs_with_prefix(&mirror, "refs/heads/fork").expect("refs"),
Vec::<String>::new()
);
// The mirror can now range across both histories.
// The fork point is the shared initial commit, the proposal covers the fork commit.
assert_eq!(
merge_base(
&mirror,
"refs/remotes/origin/main",
"refs/fork/npub1fork/fork/feature",
)
.expect("merge base")
.as_deref(),
Some(initial.as_str())
);
let patch =
format_patch_between(&mirror, &initial, "refs/fork/npub1fork/fork/feature").expect("patch");
assert!(patch.contains("Subject: [PATCH] feature commit"));
assert!(patch.contains("feature.txt"));
// Pruning the prefix removes the import again.
delete_refs_with_prefix(&mirror, "refs/fork/npub1fork/fork").expect("delete");
assert_eq!(
refs_with_prefix(&mirror, "refs/fork/npub1fork/fork").expect("refs"),
Vec::<String>::new()
);
}
#[test]
fn fetch_repo_refs_fails_when_every_url_fails() {
let (_dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = _dir.path();
let dead = format!("file://{}/missing.git", dir.display());
let err =
fetch_repo_refs(dir, &[dead], "+refs/heads/*:refs/fork/x/*").expect_err("all URLs fail");
assert!(err.to_string().contains("failed to fetch"));
// Without any URL there is nothing to try.
let err =
fetch_repo_refs(dir, &[] as &[String], "+refs/heads/*:refs/fork/x/*").expect_err("no URLs");
assert!(err.to_string().contains("no clone URLs"));
}
#[test]
fn delete_refs_with_prefix_is_a_noop_without_matches() {
let (_dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
delete_refs_with_prefix(_dir.path(), "refs/fork/nothing").expect("noop");
}
/// Run a git command in `dir`, asserting success.
fn git_run(dir: &Path, args: &[&str]) {
let status = Command::new("git")
.current_dir(dir)
.env("GIT_AUTHOR_NAME", "Test Author")
.env("GIT_AUTHOR_EMAIL", "test@example.com")
.env("GIT_COMMITTER_NAME", "Test Author")
.env("GIT_COMMITTER_EMAIL", "test@example.com")
.env("GIT_EDITOR", "true")
.args(args)
.status()
.expect("spawn git");
assert!(status.success(), "git {args:?} failed");
}
#[test]
fn last_commit_returns_most_recent_change() {
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
std::fs::write(dir.path().join("a.txt"), b"two").expect("write");
commit_all(&repo, "change a");
// A commit touching another file must not be reported for a.txt.
std::fs::write(dir.path().join("b.txt"), b"other").expect("write");
commit_all(&repo, "add b");
let commit = last_commit(&repo, Path::new("a.txt"))
.expect("lookup")
.expect("found");
assert_eq!(commit.summary, "change a");
assert_eq!(commit.author, "Test Author");
assert!(!commit.id.is_empty());
assert!(commit.time > 0);
}
#[test]
fn all_commits_lists_every_commit() {
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
std::fs::write(dir.path().join("a.txt"), b"two").expect("write");
commit_all(&repo, "second");
std::fs::write(dir.path().join("b.txt"), b"b").expect("write");
commit_all(&repo, "third");
let list = all_commits(&repo).expect("commits");
assert_eq!(list.total, 3);
let mut summaries: Vec<&str> = list.commits.iter().map(|c| c.summary.as_str()).collect();
summaries.sort();
assert_eq!(summaries, vec!["initial", "second", "third"]);
assert!(
list.commits
.iter()
.all(|c| c.author == "Test Author" && !c.id.is_empty() && c.time > 0)
);
}
#[test]
fn all_commits_returns_empty_without_head() {
let (_dir, repo) = fixture(&[("a.txt", b"one")]);
let list = all_commits(&repo).expect("commits");
assert!(list.commits.is_empty());
assert_eq!(list.total, 0);
}
#[test]
fn last_commit_returns_none_for_untracked_files() {
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
std::fs::write(dir.path().join("untracked.txt"), b"x").expect("write");
let commit = last_commit(&repo, Path::new("untracked.txt")).expect("lookup");
assert!(commit.is_none());
}
#[test]
fn last_commit_reports_merge_commits() {
let (dir, repo) = fixture(&[("a.txt", b"base")]);
commit_all(&repo, "initial");
let run = |args: &[&str]| {
let status = Command::new("git")
.current_dir(dir.path())
.env("GIT_AUTHOR_NAME", "Test Author")
.env("GIT_AUTHOR_EMAIL", "test@example.com")
.env("GIT_COMMITTER_NAME", "Test Author")
.env("GIT_COMMITTER_EMAIL", "test@example.com")
.env("GIT_EDITOR", "true")
.args(args)
.status()
.expect("spawn git");
assert!(status.success(), "git {args:?} failed");
};
run(&["checkout", "-b", "feature"]);
std::fs::write(dir.path().join("a.txt"), b"feature").expect("write");
commit_all(&repo, "feature change");
run(&["checkout", "-"]);
// `--no-ff` forces a merge commit, it is the latest commit changing a.txt.
run(&["merge", "--no-ff", "--no-edit", "feature"]);
let commit = last_commit(&repo, Path::new("a.txt"))
.expect("lookup")
.expect("found");
assert_eq!(
commit.id,
repo.head_id().expect("head").shorten_or_id().to_string()
);
assert!(commit.summary.starts_with("Merge branch"));
}
#[test]
fn last_commits_batches_multiple_paths() {
let (dir, repo) = fixture(&[("a.txt", b"one"), ("b.txt", b"b")]);
commit_all(&repo, "initial");
std::fs::write(dir.path().join("a.txt"), b"two").expect("write");
commit_all(&repo, "change a");
std::fs::write(dir.path().join("b.txt"), b"bb").expect("write");
commit_all(&repo, "change b");
let found = worktree_last_commits(
dir.path(),
&[
PathBuf::from("a.txt"),
PathBuf::from("b.txt"),
// Untracked paths are absent from the result.
PathBuf::from("missing.txt"),
],
)
.expect("commits");
let by_path: HashMap<&Path, &FileCommit> = found
.iter()
.map(|(path, commit)| (path.as_path(), commit))
.collect();
assert_eq!(by_path.len(), 2);
assert_eq!(by_path[Path::new("a.txt")].summary, "change a");
assert_eq!(by_path[Path::new("b.txt")].summary, "change b");
}
#[test]
fn find_readme_prefers_markdown() {
let (_dir, repo) = fixture(&[("readme.txt", b"txt"), ("README.md", b"md")]);
let readme = find_readme(&repo).expect("find");
assert_eq!(
readme.map(|p| p.to_string_lossy().into_owned()),
Some("README.md".into())
);
}
#[test]
fn find_readme_falls_back_to_any_readme() {
let (_dir, repo) = fixture(&[("README.rst", b"rst")]);
let readme = find_readme(&repo).expect("find");
assert_eq!(
readme.map(|p| p.to_string_lossy().into_owned()),
Some("README.rst".into())
);
}
#[test]
fn find_readme_returns_none_without_one() {
let (_dir, repo) = fixture(&[("main.rs", b"")]);
assert!(find_readme(&repo).expect("find").is_none());
}
#[test]
fn head_commit_reports_head() {
let (_dir, repo) = fixture(&[("a.txt", b"one")]);
// Unborn HEAD means no commit yet.
assert!(head_commit(&repo).expect("head").is_none());
commit_all(&repo, "initial");
let head = head_commit(&repo).expect("head").expect("commit");
assert_eq!(
head.id,
repo.head_id().expect("head id").shorten_or_id().to_string()
);
assert_eq!(head.summary, "initial");
assert_eq!(head.author, "Test Author");
}
#[test]
fn worktree_branches_and_tags_list_short_names() {
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
git_run(dir, &["checkout", "-b", "feature"]);
git_run(dir, &["tag", "v0.9"]);
git_run(dir, &["tag", "v1.0"]);
// The initial branch name depends on git configuration.
// Only the branch we created is fixed.
let branches = worktree_branches(dir).expect("branches");
assert_eq!(branches.len(), 2);
assert!(branches.contains(&"feature".to_string()));
assert!(branches.windows(2).all(|pair| pair[0] <= pair[1]), "sorted");
assert_eq!(
repo_tags(&repo).expect("tags"),
vec!["v0.9".to_string(), "v1.0".to_string()]
);
}
#[test]
fn current_branch_tracks_checkout() {
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
let default = worktree_branches(dir)
.expect("branches")
.into_iter()
.next()
.expect("default branch");
assert_eq!(
current_branch(&repo).expect("branch").as_deref(),
Some(default.as_str())
);
git_run(dir, &["checkout", "-b", "feature"]);
assert_eq!(
current_branch(&repo).expect("branch").as_deref(),
Some("feature")
);
// Tags detach HEAD.
git_run(dir, &["tag", "v1.0"]);
worktree_checkout_tag(dir, "v1.0").expect("checkout tag");
assert_eq!(current_branch(&repo).expect("branch"), None);
// Branches re-attach HEAD.
worktree_checkout_branch(dir, &default).expect("checkout branch");
assert_eq!(
current_branch(&repo).expect("branch").as_deref(),
Some(default.as_str())
);
}
#[test]
fn worktree_snapshot_reflects_checked_out_ref() {
let (dir, repo) = fixture(&[("README.md", b"# main"), ("a.txt", b"one")]);
commit_all(&repo, "initial");
let dir = dir.path();
git_run(dir, &["checkout", "-b", "feature"]);
std::fs::write(dir.join("README.md"), b"# feature").expect("write");
std::fs::write(dir.join("b.txt"), b"b").expect("write");
commit_all(&repo, "feature work");
let snapshot = worktree_snapshot(dir).expect("snapshot");
assert_eq!(snapshot.current_branch.as_deref(), Some("feature"));
assert_eq!(
snapshot.head_commit.as_ref().expect("head commit").summary,
"feature work"
);
assert_eq!(
String::from_utf8(snapshot.readme.expect("readme")).expect("utf8"),
"# feature"
);
let entries: Vec<String> = snapshot
.entries
.iter()
.map(|p| p.to_string_lossy().into_owned())
.collect();
assert!(entries.contains(&"b.txt".to_string()));
let default = worktree_branches(dir)
.expect("branches")
.into_iter()
.find(|name| name != "feature")
.expect("default branch");
worktree_checkout_branch(dir, &default).expect("checkout");
let snapshot = worktree_snapshot(dir).expect("snapshot");
assert_eq!(snapshot.current_branch.as_deref(), Some(default.as_str()));
assert_eq!(
snapshot.head_commit.as_ref().expect("head commit").summary,
"initial"
);
assert_eq!(
String::from_utf8(snapshot.readme.expect("readme")).expect("utf8"),
"# main"
);
assert!(
!snapshot
.entries
.iter()
.any(|p| p.to_string_lossy() == "b.txt")
);
}
#[test]
fn commit_diff_lists_added_modified_and_deleted_files() {
let (dir, repo) = fixture(&[("keep.txt", b"keep"), ("mod.txt", b"one\ntwo\nthree\n")]);
commit_all(&repo, "initial");
std::fs::write(dir.path().join("mod.txt"), b"one\ntwo!\nthree\n").expect("write");
std::fs::write(dir.path().join("new.txt"), b"hello\n").expect("write");
std::fs::remove_file(dir.path().join("keep.txt")).expect("remove");
commit_all(&repo, "changes");
let head = repo.head_id().expect("head").shorten_or_id().to_string();
let diff = worktree_commit_diff(dir.path(), &head).expect("diff");
let by_path: HashMap<&str, &FileDiff> = diff
.files
.iter()
.map(|file| (file.path.as_str(), file))
.collect();
assert_eq!(by_path.len(), 3);
let added = by_path["new.txt"];
assert_eq!(added.status, DiffStatus::Added);
assert_eq!(added.insertions, 1);
assert_eq!(added.deletions, 0);
assert_eq!(added.hunks.len(), 1);
assert_eq!(added.hunks[0].lines.len(), 1);
assert_eq!(added.hunks[0].lines[0].kind, DiffLineKind::Addition);
assert_eq!(added.hunks[0].lines[0].old, None);
assert_eq!(added.hunks[0].lines[0].new, Some(1));
assert_eq!(added.hunks[0].lines[0].text, "hello");
let modified = by_path["mod.txt"];
assert_eq!(modified.status, DiffStatus::Modified);
assert_eq!(modified.insertions, 1);
assert_eq!(modified.deletions, 1);
assert!(!modified.binary);
let lines = &modified.hunks[0].lines;
// One hunk with context around the single-line change.
// The removed line is old 2, the added line is new 2.
assert!(lines.iter().any(|line| {
line.kind == DiffLineKind::Deletion
&& line.old == Some(2)
&& line.new.is_none()
&& line.text == "two"
}));
assert!(lines.iter().any(|line| {
line.kind == DiffLineKind::Addition
&& line.old.is_none()
&& line.new == Some(2)
&& line.text == "two!"
}));
assert!(lines.iter().any(|line| {
line.kind == DiffLineKind::Context && line.old == Some(1) && line.new == Some(1)
}));
let deleted = by_path["keep.txt"];
assert_eq!(deleted.status, DiffStatus::Deleted);
assert_eq!(deleted.deletions, 1);
assert_eq!(deleted.hunks[0].lines[0].kind, DiffLineKind::Deletion);
assert_eq!(deleted.hunks[0].lines[0].old, Some(1));
assert_eq!(deleted.hunks[0].lines[0].new, None);
}
#[test]
fn commit_range_diff_lists_changes_between_two_commits() {
let (dir, repo) = fixture(&[("a.txt", b"a\n"), ("b.txt", b"b\n")]);
commit_all(&repo, "first");
let base = repo.head_id().expect("head").to_string();
std::fs::write(dir.path().join("a.txt"), b"changed\n").expect("write");
std::fs::write(dir.path().join("c.txt"), b"new\n").expect("write");
commit_all(&repo, "second");
let tip = repo.head_id().expect("head").to_string();
let diff = worktree_commit_range_diff(dir.path(), &base, &tip).expect("diff");
let by_path: HashMap<&str, &FileDiff> = diff
.files
.iter()
.map(|file| (file.path.as_str(), file))
.collect();
assert_eq!(by_path.len(), 2);
assert_eq!(by_path["a.txt"].status, DiffStatus::Modified);
assert_eq!(by_path["a.txt"].insertions, 1);
assert_eq!(by_path["a.txt"].deletions, 1);
assert_eq!(by_path["c.txt"].status, DiffStatus::Added);
// b.txt is unchanged between the two commits.
assert!(diff.files.iter().all(|file| file.path != "b.txt"));
}
#[test]
fn commit_range_commits_lists_only_new_commits_newest_first() {
let (dir, repo) = fixture(&[("a.txt", b"one\n")]);
commit_all(&repo, "one");
let base = repo.head_id().expect("head").to_string();
std::fs::write(dir.path().join("a.txt"), b"two\n").expect("write");
commit_all(&repo, "two");
std::fs::write(dir.path().join("a.txt"), b"three\n").expect("write");
commit_all(&repo, "three");
let tip = repo.head_id().expect("head").to_string();
let commits = worktree_commit_range_commits(dir.path(), &base, &tip).expect("commits");
assert_eq!(commits.len(), 2);
assert_eq!(commits[0].summary, "three");
assert_eq!(commits[1].summary, "two");
}
#[test]
fn commit_diff_reports_binary_files_without_hunks() {
let (_dir, repo) = fixture(&[("blob.bin", b"\x00\x01\x02")]);
commit_all(&repo, "initial");
std::fs::write(_dir.path().join("blob.bin"), b"\x00\x03").expect("write");
commit_all(&repo, "binary change");
let head = repo.head_id().expect("head").shorten_or_id().to_string();
let diff = worktree_commit_diff(_dir.path(), &head).expect("diff");
let file = diff
.files
.iter()
.find(|f| f.path == "blob.bin")
.expect("file");
assert!(file.binary);
assert!(file.hunks.is_empty());
assert_eq!(file.insertions, 0);
assert_eq!(file.deletions, 0);
}
#[test]
fn commit_diff_resolves_short_ids_and_root_commit() {
let (dir, repo) = fixture(&[("a.txt", b"one\n")]);
commit_all(&repo, "initial");
// The root commit diffs against the empty tree, everything is added.
let head = repo.head_id().expect("head").shorten_or_id().to_string();
let diff = worktree_commit_diff(dir.path(), &head).expect("diff");
assert_eq!(diff.files.len(), 1);
assert_eq!(diff.files[0].path, "a.txt");
assert_eq!(diff.files[0].status, DiffStatus::Added);
assert_eq!(diff.files[0].insertions, 1);
}
#[test]
fn file_commit_includes_message_body() {
let (_dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "title");
// A single-line message has no body.
let head = head_commit(&repo).expect("head").expect("commit");
assert_eq!(head.summary, "title");
assert_eq!(head.description, None);
// A message with a body exposes it, trimmed.
let dir = _dir.path();
let status = Command::new("git")
.current_dir(dir)
.env("GIT_AUTHOR_NAME", "Test Author")
.env("GIT_AUTHOR_EMAIL", "test@example.com")
.env("GIT_COMMITTER_NAME", "Test Author")
.env("GIT_COMMITTER_EMAIL", "test@example.com")
.env("GIT_EDITOR", "true")
.args([
"commit",
"--allow-empty",
"-m",
"title two",
"-m",
"line one\n\nline two",
])
.status()
.expect("spawn git");
assert!(status.success(), "git commit failed");
let head = head_commit(&repo).expect("head").expect("commit");
assert_eq!(head.summary, "title two");
assert_eq!(head.description.as_deref(), Some("line one\n\nline two"));
}
#[test]
fn commit_diff_reports_renames() {
let (_dir, repo) = fixture(&[("old.txt", b"same content\n")]);
commit_all(&repo, "initial");
std::fs::rename(_dir.path().join("old.txt"), _dir.path().join("new.txt")).expect("rename");
commit_all(&repo, "rename");
let head = repo.head_id().expect("head").shorten_or_id().to_string();
let diff = worktree_commit_diff(_dir.path(), &head).expect("diff");
let file = diff
.files
.iter()
.find(|f| f.path == "new.txt")
.expect("file");
assert_eq!(file.status, DiffStatus::Renamed);
assert_eq!(file.old_path.as_deref(), Some("old.txt"));
// A pure rename has no content change, the file is still listed.
assert!(file.hunks.is_empty());
assert_eq!(file.insertions, 0);
assert_eq!(file.deletions, 0);
}
#[test]
fn parses_format_patch_output() {
let patch = r#"From 1f6c0c5f3f1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a Mon Sep 17 00:00:00 2001
From: A <a@b.c>
Subject: [PATCH] fix
fix the thing
---
src/lib.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/lib.rs b/src/lib.rs
index 1234567..89abcde 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,3 @@
fn main() {
- println!("old");
+ println!("new");
}
"#;
let diff = patch_diffs(patch).expect("parse");
assert_eq!(diff.files.len(), 1);
let file = &diff.files[0];
assert_eq!(file.path, "src/lib.rs");
assert_eq!(file.old_path, None);
assert_eq!(file.status, DiffStatus::Modified);
assert_eq!(file.insertions, 1);
assert_eq!(file.deletions, 1);
let hunk = &file.hunks[0];
assert_eq!(hunk.old_start, 1);
assert_eq!(hunk.old_lines, 3);
assert_eq!(hunk.new_start, 1);
assert_eq!(hunk.new_lines, 3);
assert_eq!(hunk.lines.len(), 4);
assert_eq!(hunk.lines[0].kind, DiffLineKind::Context);
assert_eq!(hunk.lines[0].old, Some(1));
assert_eq!(hunk.lines[0].new, Some(1));
assert_eq!(hunk.lines[1].kind, DiffLineKind::Deletion);
assert_eq!(hunk.lines[1].old, Some(2));
assert_eq!(hunk.lines[1].new, None);
assert_eq!(hunk.lines[2].kind, DiffLineKind::Addition);
assert_eq!(hunk.lines[2].old, None);
assert_eq!(hunk.lines[2].new, Some(2));
assert_eq!(hunk.lines[3].kind, DiffLineKind::Context);
assert_eq!(hunk.lines[3].old, Some(3));
assert_eq!(hunk.lines[3].new, Some(3));
}
#[test]
fn parses_new_file_as_added() {
let patch = r#"diff --git a/README.md b/README.md
new file mode 100644
index 0000000..1234567
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+# hello
"#;
let diff = patch_diffs(patch).expect("parse");
let file = &diff.files[0];
assert_eq!(file.path, "README.md");
assert_eq!(file.status, DiffStatus::Added);
assert_eq!(file.old_path, None);
assert_eq!(file.insertions, 1);
assert_eq!(file.deletions, 0);
assert_eq!(file.hunks[0].old_start, 0);
assert_eq!(file.hunks[0].old_lines, 0);
assert_eq!(file.hunks[0].new_start, 1);
}
#[test]
fn parses_renames_with_old_path() {
let patch = r#"diff --git a/old.rs b/new.rs
similarity index 85%
rename from old.rs
rename to new.rs
index 123..456 100644
--- a/old.rs
+++ b/new.rs
@@ -1 +1 @@
-fn main() {}
+fn main() { println!("hi"); }
"#;
let diff = patch_diffs(patch).expect("parse");
let file = &diff.files[0];
assert_eq!(file.path, "new.rs");
assert_eq!(file.old_path.as_deref(), Some("old.rs"));
assert_eq!(file.status, DiffStatus::Renamed);
assert_eq!(file.insertions, 1);
assert_eq!(file.deletions, 1);
}
#[test]
fn parses_patch_series_and_skips_envelope() {
let patch = r#"From aaaa Mon Sep 17 00:00:00 2001
From: A <a@b.c>
Subject: [PATCH 1/2] one
---
a.txt | 1 +
1 file changed, 1 insertion(+)
diff --git a/a.txt b/a.txt
index 1..2 100644
--- a/a.txt
+++ b/a.txt
@@ -1 +1,2 @@
a
+b
From bbbb Mon Sep 17 00:00:00 2001
From: A <a@b.c>
Subject: [PATCH 2/2] two
diff --git a/b.txt b/b.txt
index 3..4 100644
--- a/b.txt
+++ b/b.txt
@@ -1 +1 @@
-x
+y
"#;
let diff = patch_diffs(patch).expect("parse");
assert_eq!(diff.files.len(), 2);
assert_eq!(diff.files[0].path, "a.txt");
assert_eq!(diff.files[0].insertions, 1);
assert_eq!(diff.files[1].path, "b.txt");
assert_eq!(diff.files[1].deletions, 1);
}
#[test]
fn patch_commits_lists_every_patch_in_order() {
let patch = r#"From 1111111111111111111111111111111111111111 Mon Sep 17 00:00:00 2001
From: Alice <alice@example.com>
Date: Tue, 1 Aug 2023 10:00:00 +0200
Subject: [PATCH 1/2] first
body one
---
a.txt | 1 +
1 file changed, 1 insertion(+)
diff --git a/a.txt b/a.txt
@@ -1 +1,2 @@
a
+b
From 2222222222222222222222222222222222222222 Mon Sep 17 00:00:00 2001
From: Bob <bob@example.com>
Date: Wed, 2 Aug 2023 11:30:00 +0000
Subject: [PATCH 2/2] second
body two
---
b.txt | 1 +
1 file changed, 1 insertion(+)
diff --git a/b.txt b/b.txt
@@ -1 +1,2 @@
x
+y
"#;
let commits = patch_commits(patch);
assert_eq!(commits.len(), 2);
assert_eq!(commits[0].id, "1111111111111111111111111111111111111111");
assert_eq!(commits[0].summary, "first");
assert_eq!(commits[0].author, "Alice");
assert_eq!(commits[0].time, 1690876800);
assert_eq!(commits[1].id, "2222222222222222222222222222222222222222");
assert_eq!(commits[1].summary, "second");
assert_eq!(commits[1].author, "Bob");
assert_eq!(commits[1].time, 1690975800);
}
#[test]
fn patch_commits_strips_patch_subject_prefixes() {
let patch = r#"From 1111111111111111111111111111111111111111 Mon Sep 17 00:00:00 2001
From: A <a@b.c>
Subject: [RFC PATCH v3 4/7] the real title
---
"#;
let commits = patch_commits(patch);
assert_eq!(commits.len(), 1);
assert_eq!(commits[0].summary, "the real title");
}
#[test]
fn patch_commits_handles_missing_headers() {
// A hand-written patch without author or date headers still lists a commit.
// Time stays 0 and the author stays empty.
let patch = r#"From 1111111111111111111111111111111111111111 Mon Sep 17 00:00:00 2001
Subject: [PATCH] plain
---
"#;
let commits = patch_commits(patch);
assert_eq!(commits.len(), 1);
assert_eq!(commits[0].summary, "plain");
assert_eq!(commits[0].author, "");
assert_eq!(commits[0].time, 0);
}
#[test]
fn patch_commits_ignores_non_patch_lines() {
assert!(patch_commits("").is_empty());
assert!(patch_commits("just some text\nFrom 123\n").is_empty());
// A diff-only body without an mbox envelope has no commits.
let patch = "diff --git a/x b/x\n--- a/x\n+++ b/x\n";
assert!(patch_commits(patch).is_empty());
}
#[test]
fn marks_binary_sections() {
let patch = r#"diff --git a/img.png b/img.png
index 123..456 100644
Binary files a/img.png and b/img.png differ
"#;
let diff = patch_diffs(patch).expect("parse");
assert!(diff.files[0].binary);
assert!(diff.files[0].hunks.is_empty());
}
#[test]
fn unquotes_quoted_paths() {
let patch = r#"diff --git "a/weird file.rs" "b/weird file.rs"
index 123..456 100644
--- "a/weird file.rs"
+++ "b/weird file.rs"
@@ -1 +1 @@
-x
+y
"#;
let diff = patch_diffs(patch).expect("parse");
assert_eq!(diff.files[0].path, "weird file.rs");
assert_eq!(diff.files[0].status, DiffStatus::Modified);
}
#[test]
fn unquotes_non_ascii_quoted_paths() {
let patch = r#"diff --git "a/说明.md" "b/说明.md"
index 123..456 100644
--- "a/说明.md"
+++ "b/说明.md"
@@ -1 +1 @@
-x
+y
"#;
let diff = patch_diffs(patch).expect("parse");
assert_eq!(diff.files[0].path, "说明.md");
assert_eq!(diff.files[0].status, DiffStatus::Modified);
}
#[test]
fn unquotes_octal_escaped_paths() {
let patch = r#"diff --git "a/\345\270\226.md" "b/\345\270\226.md"
index 123..456 100644
--- "a/\345\270\226.md"
+++ "b/\345\270\226.md"
@@ -1 +1 @@
-x
+y
"#;
let diff = patch_diffs(patch).expect("parse");
assert_eq!(diff.files[0].path, "帖.md");
assert_eq!(diff.files[0].status, DiffStatus::Modified);
}
#[test]
fn empty_or_unparseable_patch_yields_no_files() {
assert_eq!(patch_diffs("").expect("parse").files.len(), 0);
assert_eq!(patch_diffs("just some text").expect("parse").files.len(), 0);
assert_eq!(
patch_diffs("---\nnot a patch\n")
.expect("parse")
.files
.len(),
0
);
}
#[test]
fn parses_real_format_patch_output() {
// Build a commit touching a mix of file kinds.
// Feed genuine `git format-patch` output through the parser.
// It covers quoted and octal-escaped paths.
// There are also a rename-free modification, an addition and a binary deletion.
let (dir, repo) = fixture(&[
("src/main.rs", b"fn main() {\n println!(\"one\");\n}\n"),
("my file.txt", b"hello\n"),
("\u{8bf4}\u{660e}.md", "# \u{8bf4}\u{660e}\n".as_bytes()),
("img.png", b"\x89PNG\r\n\x1a\n\x00binary"),
]);
commit_all(&repo, "initial");
std::fs::write(
dir.path().join("src/main.rs"),
b"fn main() {\n println!(\"two\");\n println!(\"three\");\n}\n",
)
.expect("write");
std::fs::write(dir.path().join("my file.txt"), b"hello world\n").expect("write");
std::fs::write(
dir.path().join("\u{8bf4}\u{660e}.md"),
"# \u{8bf4}\u{660e}\nupdated\n",
)
.expect("write");
std::fs::remove_file(dir.path().join("img.png")).expect("remove");
std::fs::write(dir.path().join("new file.md"), b"# new\n").expect("write");
commit_all(&repo, "changes");
let output = Command::new("git")
.current_dir(dir.path())
.env("GIT_AUTHOR_NAME", "Test Author")
.env("GIT_AUTHOR_EMAIL", "test@example.com")
.env("GIT_COMMITTER_NAME", "Test Author")
.env("GIT_COMMITTER_EMAIL", "test@example.com")
.args(["format-patch", "-1", "--stdout"])
.output()
.expect("spawn git format-patch");
assert!(output.status.success(), "git format-patch failed");
let patch = String::from_utf8(output.stdout).expect("patch is utf-8");
let diff = patch_diffs(&patch).expect("parse real format-patch output");
let by_path = |path: &str| {
diff.files
.iter()
.find(|file| file.path == path)
.unwrap_or_else(|| panic!("missing file {path:?}"))
};
// Space in the name makes git quote the path in the header.
let file = by_path("my file.txt");
assert_eq!(file.status, DiffStatus::Modified);
assert_eq!(file.insertions, 1);
// UTF-8 names are emitted as octal escapes.
let file = by_path("\u{8bf4}\u{660e}.md");
assert_eq!(file.status, DiffStatus::Modified);
assert_eq!(file.insertions, 1);
let file = by_path("src/main.rs");
assert_eq!(file.status, DiffStatus::Modified);
assert_eq!(file.insertions, 2);
assert_eq!(file.deletions, 1);
assert!(!file.hunks.is_empty());
let file = by_path("new file.md");
assert_eq!(file.status, DiffStatus::Added);
assert_eq!(file.insertions, 1);
// A binary deletion emits no `---` or `+++` lines.
// Only the mode line and the `Binary files` marker remain.
let file = by_path("img.png");
assert_eq!(file.status, DiffStatus::Deleted);
assert!(file.binary);
assert!(file.hunks.is_empty());
}
#[test]
fn worktree_dirty_tracks_changes_and_untracked_files() {
let (dir, repo) = fixture(&[("tracked.txt", b"one")]);
commit_all(&repo, "initial");
let workdir = dir.path();
assert!(!worktree_dirty(workdir));
// A modified tracked file is dirty.
std::fs::write(workdir.join("tracked.txt"), b"two").expect("write");
assert!(worktree_dirty(workdir));
// After restoring, an untracked file alone is dirty as well.
git_run(workdir, &["checkout", "--", "tracked.txt"]);
assert!(!worktree_dirty(workdir));
std::fs::write(workdir.join("untracked.txt"), b"new").expect("write");
assert!(worktree_dirty(workdir));
// A staged change counts too.
git_run(workdir, &["rm", "--cached", "tracked.txt"]);
assert!(worktree_dirty(workdir));
// A missing directory is clean, not an error.
assert!(!worktree_dirty(&dir.path().join("missing")));
}
#[test]
fn worktree_dirty_reports_unborn_worktrees_with_files() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("repo");
let status = Command::new("git")
.args(["init", "-q"])
.arg(&path)
.status()
.expect("spawn git init");
assert!(status.success());
// No commits and no files: porcelain is empty.
assert!(!worktree_dirty(&path));
// An unborn repository holding files is dirty.
std::fs::write(path.join("README.md"), "# hello\n").expect("write");
assert!(worktree_dirty(&path));
}
#[test]
fn worktree_commits_ahead_counts_branch_only_commits() {
let (dir, repo) = fixture(&[("a.txt", b"one")]);
commit_all(&repo, "initial");
let path = dir.path();
git_run(path, &["checkout", "-q", "-b", "feature"]);
std::fs::write(path.join("f.txt"), b"f\n").expect("write");
commit_all(&gix::open(path).expect("open"), "feature work");
assert_eq!(worktree_commits_ahead(path, "main", "feature"), 1);
assert_eq!(worktree_commits_ahead(path, "feature", "main"), 0);
git_run(path, &["checkout", "-q", "main"]);
assert_eq!(worktree_current_branch(path).as_deref(), Some("main"));
assert!(worktree_ref_exists(path, "refs/heads/feature"));
assert!(!worktree_ref_exists(path, "refs/heads/nope"));
assert_eq!(worktree_commits_ahead(path, "main", "feature"), 1);
}
Reference in New Issue View Git Blame Copy Permalink