Lutra/crates/vcs/tests/repo.rs
danny 4bdfe521f2 F1: remote checkout without a remote, git.lastMessage, shared git status store
- vcs: checking out a remote-tracking branch reads remote.<name>.fetch;
  without a matching refspec it creates the local branch with --no-track
  instead of leaving a dirty tree after git fails to set up tracking.
- vcs + engine: git.lastMessage returns HEAD's full message (null before
  the first commit); the Changes window prefills Amend with it.
- ui: stores/vcsStatus.ts is the only git.status caller; the Changes
  window, tree/tab colours and the branch item read its snapshot, so a
  gitChanged costs one status query. RepoSummary carries upstream,
  ahead and behind.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 17:16:53 +01:00

533 lines
18 KiB
Rust

//! The Git backend against real repositories created in temp folders:
//! an initial repository without HEAD, commits, renames, CRLF, untracked
//! files, a detached HEAD, Unicode paths, a file over the cap, binary
//! files, a failing hook, branches and a project inside a repository.
//! Every test skips with a message when git is not installed.
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::indexing_slicing
)]
use std::path::Path;
use std::process::Command;
use std::time::{Duration, Instant};
use lutra_vcs::{FILE_CAP, FileState, Git, Repo, RepoWatch, Rev, VcsError};
/// The installed git, or `None` (with a message) when there is none.
fn installed() -> Option<Git> {
match Git::detect("") {
Ok(git) => Some(git),
Err(e) => {
eprintln!("skipped: no usable git installed ({e})");
None
}
}
}
/// Runs git in `dir` for test setup and asserts it succeeded.
fn git(dir: &Path, args: &[&str]) -> String {
let out = Command::new("git")
.args(args)
.current_dir(dir)
.env_remove("GIT_DIR")
.env_remove("GIT_WORK_TREE")
.env_remove("GIT_INDEX_FILE")
.output()
.unwrap();
assert!(
out.status.success(),
"git {args:?}: {}",
String::from_utf8_lossy(&out.stderr)
);
String::from_utf8_lossy(&out.stdout).trim().to_string()
}
/// A new repository on branch `main` with a local identity, no signing,
/// no line-ending conversion and its own hooks folder.
fn init(dir: &Path) {
git(dir, &["init", "-q", "-b", "main"]);
for (key, value) in [
("user.name", "Lutra Test"),
("user.email", "test@lutra.invalid"),
("commit.gpgsign", "false"),
("core.autocrlf", "false"),
("core.hooksPath", ".git/hooks"),
] {
git(dir, &["config", key, value]);
}
}
/// Writes a file, creating its folders.
fn write(dir: &Path, path: &str, text: impl AsRef<[u8]>) {
let full = dir.join(path);
std::fs::create_dir_all(full.parent().unwrap()).unwrap();
std::fs::write(full, text).unwrap();
}
/// Opens the repository at `dir`.
fn open(git: &Git, dir: &Path) -> Repo {
git.open(dir).unwrap().expect("a repository")
}
/// The states of `path` in a status, or `None` if it is not listed.
fn states(repo: &Repo, path: &str) -> Option<(FileState, FileState)> {
repo.status()
.unwrap()
.files
.into_iter()
.find(|f| f.path == path)
.map(|f| (f.index, f.worktree))
}
#[test]
fn folders_outside_a_repository_have_none() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
assert!(cli.open(dir.path()).unwrap().is_none());
}
#[test]
fn a_missing_executable_is_not_found() {
let err = Git::detect("C:/no/such/git-binary-for-lutra").unwrap_err();
assert!(matches!(err, VcsError::NotFound(_)), "{err:?}");
}
#[test]
fn initial_repository_stages_unstages_and_commits() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(dir.path(), "src/a.php", "<?php\necho 1;\n");
let repo = open(&cli, dir.path());
let status = repo.status().unwrap();
assert_eq!(status.head.branch.as_deref(), Some("main"));
assert_eq!(status.head.head, None);
assert!(!status.head.detached);
assert_eq!(
states(&repo, "src/a.php"),
Some((FileState::Untracked, FileState::Untracked))
);
repo.stage(&["src/a.php".into()]).unwrap();
assert_eq!(
states(&repo, "src/a.php"),
Some((FileState::Added, FileState::Unmodified))
);
assert_eq!(
repo.show("src/a.php", Rev::Index).unwrap().text.as_deref(),
Some("<?php\necho 1;\n")
);
assert_eq!(repo.show("src/a.php", Rev::Head).unwrap().text, None);
repo.unstage(&["src/a.php".into()]).unwrap();
assert_eq!(
states(&repo, "src/a.php"),
Some((FileState::Untracked, FileState::Untracked))
);
repo.stage(&["src/a.php".into()]).unwrap();
assert_eq!(repo.commit(" \n", false), Err(VcsError::EmptyMessage));
let commit = repo.commit("#1 first commit\n\nbody", false).unwrap();
assert_eq!(commit.summary, "#1 first commit");
assert_eq!(commit.commit, git(dir.path(), &["rev-parse", "HEAD"]));
let status = repo.status().unwrap();
assert!(status.files.is_empty(), "{:?}", status.files);
assert_eq!(status.head.head.as_deref(), Some(commit.commit.as_str()));
}
#[test]
fn modified_deleted_renamed_and_amended() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(dir.path(), "a.php", "<?php // a\n");
write(
dir.path(),
"old.php",
"<?php // a file long enough to be found as a rename\n",
);
write(dir.path(), "gone.php", "<?php // gone\n");
git(dir.path(), &["add", "-A"]);
git(dir.path(), &["commit", "-q", "-m", "base"]);
let repo = open(&cli, dir.path());
write(dir.path(), "a.php", "<?php // changed\n");
std::fs::remove_file(dir.path().join("gone.php")).unwrap();
std::fs::rename(dir.path().join("old.php"), dir.path().join("new.php")).unwrap();
assert_eq!(
states(&repo, "a.php"),
Some((FileState::Unmodified, FileState::Modified))
);
assert_eq!(
states(&repo, "gone.php"),
Some((FileState::Unmodified, FileState::Deleted))
);
repo.stage(&[
"a.php".into(),
"gone.php".into(),
"old.php".into(),
"new.php".into(),
])
.unwrap();
let status = repo.status().unwrap();
let renamed = status.files.iter().find(|f| f.path == "new.php").unwrap();
assert_eq!(renamed.index, FileState::Renamed);
assert_eq!(renamed.orig_path.as_deref(), Some("old.php"));
assert_eq!(
states(&repo, "gone.php"),
Some((FileState::Deleted, FileState::Unmodified))
);
assert_eq!(
repo.show("a.php", Rev::Head).unwrap().text.as_deref(),
Some("<?php // a\n")
);
assert_eq!(
repo.show("a.php", Rev::Index).unwrap().text.as_deref(),
Some("<?php // changed\n")
);
repo.unstage(&["new.php".into(), "old.php".into()]).unwrap();
assert_eq!(
states(&repo, "new.php"),
Some((FileState::Untracked, FileState::Untracked))
);
let first = repo.commit("second", false).unwrap();
let amended = repo.commit("second, amended", true).unwrap();
assert_ne!(first.commit, amended.commit);
assert_eq!(amended.summary, "second, amended");
assert_eq!(git(dir.path(), &["rev-list", "--count", "HEAD"]), "2");
}
#[test]
fn crlf_work_trees_with_autocrlf_are_clean() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
git(dir.path(), &["config", "core.autocrlf", "true"]);
write(dir.path(), "crlf.php", "<?php\r\necho 1;\r\n");
git(dir.path(), &["add", "-A"]);
git(dir.path(), &["commit", "-q", "-m", "crlf"]);
let repo = open(&cli, dir.path());
assert!(repo.status().unwrap().files.is_empty());
assert_eq!(
repo.show("crlf.php", Rev::Head).unwrap().text.as_deref(),
Some("<?php\necho 1;\n"),
"the blob as stored, without line-ending conversion"
);
}
#[test]
fn unicode_and_space_paths_round_trip() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
let name = "Ünïcode dir/€ file \"quoted\" ü.php";
let name = if cfg!(windows) {
"Ünïcode dir/€ file 'quoted' ü.php"
} else {
name
};
write(dir.path(), name, "<?php\n");
let repo = open(&cli, dir.path());
assert_eq!(
states(&repo, name),
Some((FileState::Untracked, FileState::Untracked))
);
repo.stage(&[name.to_string()]).unwrap();
assert_eq!(
states(&repo, name),
Some((FileState::Added, FileState::Unmodified))
);
#[cfg(unix)]
{
use std::os::unix::ffi::OsStrExt;
write(dir.path(), "star*.php", "<?php\n");
write(dir.path(), "starX.php", "<?php\n");
repo.stage(&["star*.php".into()]).unwrap();
assert_eq!(
states(&repo, "starX.php"),
Some((FileState::Untracked, FileState::Untracked)),
"paths are literal, not patterns"
);
let raw = std::ffi::OsStr::from_bytes(b"caf\xe9.php");
std::fs::write(dir.path().join(raw), "<?php\n").unwrap();
assert_eq!(
states(&repo, "caf\u{fffd}.php"),
Some((FileState::Untracked, FileState::Untracked)),
"a non-UTF-8 name is listed lossily instead of failing the status"
);
}
assert_eq!(
repo.show(name, Rev::Index).unwrap().text.as_deref(),
Some("<?php\n")
);
}
#[test]
fn detached_head_and_branches() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(dir.path(), "a.php", "<?php // main\n");
git(dir.path(), &["add", "-A"]);
git(dir.path(), &["commit", "-q", "-m", "base"]);
let repo = open(&cli, dir.path());
repo.create_branch("feature/x", None, false).unwrap();
for bad in ["bad..name", "-x", "@{-1}", "with space", ""] {
let err = repo.create_branch(bad, None, false).unwrap_err();
assert!(matches!(err, VcsError::InvalidName(_)), "{bad}: {err:?}");
}
assert!(repo.create_branch("feature/x", None, false).is_err());
let branches = repo.branches().unwrap();
assert_eq!(branches.current.as_deref(), Some("main"));
let names: Vec<_> = branches.local.iter().map(|b| b.name.as_str()).collect();
assert_eq!(names, vec!["feature/x", "main"]);
repo.checkout("feature/x").unwrap();
assert_eq!(
repo.status().unwrap().head.branch.as_deref(),
Some("feature/x")
);
write(dir.path(), "a.php", "<?php // feature\n");
repo.stage(&["a.php".into()]).unwrap();
repo.commit("feature", false).unwrap();
repo.checkout("main").unwrap();
write(dir.path(), "a.php", "<?php // dirty on main\n");
let err = repo.checkout("feature/x").unwrap_err();
assert!(
matches!(&err, VcsError::Git(m) if m.contains("overwritten")),
"{err:?}"
);
assert!(matches!(
repo.checkout("nope").unwrap_err(),
VcsError::Git(_)
));
git(dir.path(), &["checkout", "-q", "--", "a.php"]);
repo.create_branch("topic", Some("feature/x"), true)
.unwrap();
assert_eq!(repo.branches().unwrap().current.as_deref(), Some("topic"));
git(dir.path(), &["checkout", "-q", "--detach", "HEAD"]);
let head = repo.head().unwrap();
assert!(head.detached);
assert_eq!(head.branch, None);
assert!(head.head.is_some());
assert_eq!(repo.branches().unwrap().current, None);
}
#[test]
fn remote_branches_are_listed_and_checked_out_as_tracking_branches() {
let Some(cli) = installed() else { return };
let upstream = tempfile::tempdir().unwrap();
init(upstream.path());
write(upstream.path(), "a.php", "<?php\n");
git(upstream.path(), &["add", "-A"]);
git(upstream.path(), &["commit", "-q", "-m", "base"]);
git(upstream.path(), &["branch", "remote-only"]);
let clone = tempfile::tempdir().unwrap();
git(
clone.path(),
&["clone", "-q", upstream.path().to_str().unwrap(), "."],
);
let repo = open(&cli, clone.path());
let branches = repo.branches().unwrap();
let remote: Vec<_> = branches.remote.iter().map(|b| b.name.as_str()).collect();
assert_eq!(remote, vec!["origin/main", "origin/remote-only"]);
assert_eq!(branches.local[0].upstream.as_deref(), Some("origin/main"));
let status = repo.status().unwrap();
assert_eq!(status.head.upstream.as_deref(), Some("origin/main"));
assert_eq!((status.head.ahead, status.head.behind), (Some(0), Some(0)));
repo.checkout("origin/remote-only").unwrap();
let branches = repo.branches().unwrap();
assert_eq!(branches.current.as_deref(), Some("remote-only"));
let local = branches.local.iter().find(|b| b.name == "remote-only");
assert_eq!(
local.and_then(|b| b.upstream.as_deref()),
Some("origin/remote-only")
);
}
#[test]
fn remote_branches_without_a_configured_remote_check_out_untracked_and_clean() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(dir.path(), "a.php", "<?php\n");
git(dir.path(), &["add", "-A"]);
git(dir.path(), &["commit", "-q", "-m", "base"]);
git(dir.path(), &["checkout", "-q", "-b", "gone"]);
write(dir.path(), "b.php", "<?php // only on gone\n");
git(dir.path(), &["add", "-A"]);
git(dir.path(), &["commit", "-q", "-m", "gone"]);
git(dir.path(), &["checkout", "-q", "main"]);
git(dir.path(), &["update-ref", "refs/remotes/old/gone", "gone"]);
git(dir.path(), &["branch", "-q", "-D", "gone"]);
let repo = open(&cli, dir.path());
repo.checkout("old/gone").unwrap();
let status = repo.status().unwrap();
assert_eq!(status.head.branch.as_deref(), Some("gone"));
assert_eq!(status.head.upstream, None);
assert!(status.files.is_empty(), "{:?}", status.files);
assert!(dir.path().join("b.php").exists());
repo.checkout("main").unwrap();
let err = repo.checkout("old/gone").unwrap_err();
assert!(matches!(err, VcsError::Git(_)), "{err:?}");
let status = repo.status().unwrap();
assert_eq!(status.head.branch.as_deref(), Some("main"));
assert!(status.files.is_empty(), "{:?}", status.files);
}
#[test]
fn the_last_message_prefills_an_amend() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
let repo = open(&cli, dir.path());
assert_eq!(repo.last_message().unwrap(), None);
write(dir.path(), "a.php", "<?php\n");
repo.stage(&["a.php".into()]).unwrap();
repo.commit("Subject line\n\n# kept\nBody ü\n\n", false)
.unwrap();
assert_eq!(
repo.last_message().unwrap().as_deref(),
Some("Subject line\n\n# kept\nBody ü")
);
}
#[test]
fn large_and_binary_files() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(dir.path(), "big.txt", vec![b'a'; FILE_CAP + 1]);
write(dir.path(), "image.png", b"\x89PNG\r\n\x1a\n\0\0\0");
write(dir.path(), "latin1.php", b"<?php // caf\xe9\n");
write(dir.path(), "bom.php", b"\xEF\xBB\xBF<?php\n");
git(dir.path(), &["add", "-A"]);
let repo = open(&cli, dir.path());
let big = repo.show("big.txt", Rev::Index).unwrap();
assert!(big.too_large && big.text.is_none());
let image = repo.show("image.png", Rev::Index).unwrap();
assert!(image.binary && image.text.is_none());
assert!(repo.show("latin1.php", Rev::Index).unwrap().binary);
assert_eq!(
repo.show("bom.php", Rev::Index).unwrap().text.as_deref(),
Some("<?php\n")
);
assert_eq!(
repo.show("src", Rev::Index).unwrap().text,
None,
"a missing path"
);
}
#[test]
fn a_failing_hook_reports_its_output() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(
dir.path(),
".git/hooks/pre-commit",
"#!/bin/sh\necho 'lint failed: bad.php line 3' >&2\nexit 1\n",
);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let hook = dir.path().join(".git/hooks/pre-commit");
std::fs::set_permissions(hook, std::fs::Permissions::from_mode(0o755)).unwrap();
}
write(dir.path(), "a.php", "<?php\n");
let repo = open(&cli, dir.path());
repo.stage(&["a.php".into()]).unwrap();
let err = repo.commit("blocked", false).unwrap_err();
assert!(
matches!(&err, VcsError::Git(m) if m.contains("lint failed: bad.php line 3")),
"{err:?}"
);
assert_eq!(repo.status().unwrap().head.head, None, "nothing committed");
}
#[test]
fn nothing_staged_is_refused_with_gits_message() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
let repo = open(&cli, dir.path());
assert!(matches!(
repo.commit("empty", false).unwrap_err(),
VcsError::Git(_)
));
}
#[test]
fn a_project_inside_a_repository_sees_its_own_files() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(dir.path(), "outside.php", "<?php\n");
write(dir.path(), "app/inside.php", "<?php\n");
let project = dir.path().join("app");
let repo = open(&cli, &project);
assert_eq!(repo.prefix(), "app/");
let paths: Vec<_> = repo
.status()
.unwrap()
.files
.into_iter()
.map(|f| f.path)
.collect();
assert_eq!(paths, vec!["inside.php"]);
repo.stage(&["inside.php".into()]).unwrap();
assert_eq!(
states(&repo, "inside.php"),
Some((FileState::Added, FileState::Unmodified))
);
for bad in ["../outside.php", "/etc/passwd", "", "a\nb"] {
let err = repo.stage(&[bad.into()]).unwrap_err();
assert!(matches!(err, VcsError::InvalidPath(_)), "{bad}: {err:?}");
}
}
#[test]
fn the_watch_sees_outside_changes_and_skips_rebased_ones() {
let Some(cli) = installed() else { return };
let dir = tempfile::tempdir().unwrap();
init(dir.path());
write(dir.path(), "a.php", "<?php\n");
let repo = open(&cli, dir.path());
let watch = RepoWatch::start(repo.git_dir(), repo.common_dir(), Duration::from_millis(20));
std::thread::sleep(Duration::from_millis(60));
assert!(!watch.changed());
git(dir.path(), &["add", "-A"]);
let deadline = Instant::now() + Duration::from_secs(5);
while !watch.changed() {
assert!(Instant::now() < deadline, "the change was not seen");
std::thread::sleep(Duration::from_millis(10));
}
git(dir.path(), &["commit", "-q", "-m", "x"]);
watch.rebase();
std::thread::sleep(Duration::from_millis(100));
let _ = watch.changed();
git(dir.path(), &["branch", "other"]);
let deadline = Instant::now() + Duration::from_secs(5);
while !watch.changed() {
assert!(Instant::now() < deadline, "the new branch was not seen");
std::thread::sleep(Duration::from_millis(10));
}
}