Files
luxe/crates/luxe-core/tests/file_diff.rs
Evan Whittaker a0666d6c81 luxe 0.1.4: remembered models, wheel-driven lists, and a steadier phone app
- luxe starts on the model you last chose in this project, then the last one anywhere. Signing in
  opens the model picker instead of choosing for you.
- Every list in a modal takes the mouse wheel and a draggable scrollbar.
- The phone app shows reasoning in full, stays put while you read back through a long session, and
  shows a question's answer on its card.
- On Windows, luxe update replaces the running luxe, and a signed-in install no longer sees setup
  again.
- The file tree no longer shows "engine busy" in a large project, loop output is easier to follow,
  and the name is written lowercase.

The CHANGELOG has the full list.
2026-10-20 13:51:34 -05:00

294 lines
13 KiB
Rust

//! One file's change, captured against a real repository.
//!
//! The unit tests in `luxe_core::file_diff` cover the pure parts; these run git, because the whole
//! point of the module is what git says about a path in each of the states a working tree puts it
//! in — tracked, staged, brand new, renamed, gone, or never a repository at all.
use luxe_core::external_work::ExternalBaseline;
use luxe_core::file_diff::{capture, capture_external, FileDiffFailure};
use std::path::Path;
use std::process::Command;
/// Runs one git command in `root`, failing the test with git's own complaint.
fn git(root: &Path, arguments: &[&str]) {
let output = Command::new("git")
.args(arguments)
.current_dir(root)
.output()
.unwrap_or_else(|error| panic!("could not run git {arguments:?}: {error}"));
assert!(
output.status.success(),
"git {arguments:?} failed: {}",
String::from_utf8_lossy(&output.stderr)
);
}
/// A repository with one committed file, and identity set so committing works anywhere.
fn repository() -> tempfile::TempDir {
let project = tempfile::tempdir().unwrap();
let root = project.path();
git(root, &["init", "--quiet"]);
git(root, &["config", "user.name", "luxe Tests"]);
git(root, &["config", "user.email", "tests@luxe.invalid"]);
std::fs::create_dir_all(root.join("src")).unwrap();
std::fs::write(root.join("src/lib.rs"), "one\ntwo\nthree\n").unwrap();
git(root, &["add", "."]);
git(root, &["commit", "--quiet", "-m", "initial"]);
project
}
#[tokio::test]
async fn a_worktree_edit_is_described_without_staging_it() {
let project = repository();
std::fs::write(project.path().join("src/lib.rs"), "one\nTWO\nthree\n").unwrap();
let diff = capture(project.path(), "src/lib.rs").await.unwrap();
let file = diff.file.expect("an edited file has a change");
assert!(!diff.untracked);
assert_eq!(file.additions, Some(1));
assert_eq!(file.deletions, Some(1));
assert_eq!(file.new_path.as_deref(), Some(Path::new("src/lib.rs")));
let lines: Vec<&str> = file.hunks[0].lines.iter().map(|line| line.text.as_str()).collect();
assert_eq!(lines, vec!["one", "two", "TWO", "three"]);
}
/// `HEAD`, not the index: a reader who clicked a row wants the file as it stands, not a lesson in
/// which of git's two waiting rooms the edit is sitting in.
#[tokio::test]
async fn a_staged_change_and_an_unstaged_one_are_both_shown() {
let project = repository();
std::fs::write(project.path().join("src/lib.rs"), "one\nSTAGED\nthree\n").unwrap();
git(project.path(), &["add", "src/lib.rs"]);
std::fs::write(project.path().join("src/lib.rs"), "one\nSTAGED\nWORKTREE\n").unwrap();
let file = capture(project.path(), "src/lib.rs").await.unwrap().file.expect("a change");
let added: Vec<&str> = file.hunks[0]
.lines
.iter()
.filter(|line| line.kind == luxe_core::guided_review::ReviewLineKind::Addition)
.map(|line| line.text.as_str())
.collect();
assert_eq!(added, vec!["STAGED", "WORKTREE"]);
}
/// The common case in an agent session: a file that did not exist an hour ago. Git has no diff for
/// it, so without this fallback the pane would open on an empty surface for every new file.
#[tokio::test]
async fn an_untracked_file_is_shown_as_every_line_added() {
let project = repository();
std::fs::write(project.path().join("src/new.rs").as_path(), "fn main() {}\n").unwrap();
let diff = capture(project.path(), "src/new.rs").await.unwrap();
let file = diff.file.expect("an untracked file is all addition");
assert!(diff.untracked);
assert_eq!(file.status, luxe_core::guided_review::ReviewFileStatus::Added);
assert_eq!(file.additions, Some(1));
assert_eq!(file.hunks[0].lines[0].text, "fn main() {}");
}
#[tokio::test]
async fn a_deleted_file_still_has_a_change_to_show() {
let project = repository();
std::fs::remove_file(project.path().join("src/lib.rs")).unwrap();
let file = capture(project.path(), "src/lib.rs").await.unwrap().file.expect("a deletion");
assert_eq!(file.status, luxe_core::guided_review::ReviewFileStatus::Deleted);
assert_eq!(file.deletions, Some(3));
}
/// A rename is one record under two names, and the pane may be asked for either — the dock lists
/// the new path, a stale click carries the old one.
#[tokio::test]
async fn a_rename_answers_to_both_of_its_names() {
let project = repository();
git(project.path(), &["mv", "src/lib.rs", "src/renamed.rs"]);
let by_new = capture(project.path(), "src/renamed.rs").await.unwrap();
let by_old = capture(project.path(), "src/lib.rs").await.unwrap();
assert_eq!(
by_new.file.expect("the new name").new_path.as_deref(),
Some(Path::new("src/renamed.rs"))
);
assert_eq!(
by_old.file.expect("the old name").old_path.as_deref(),
Some(Path::new("src/lib.rs"))
);
}
/// A diff is a rendering, and a person's `~/.gitconfig` is entitled to change it. Every path in
/// the parsed record comes back wrong under `diff.mnemonicprefix`, which is a real setting real
/// people have — it was set on the machine this was written on.
#[tokio::test]
async fn a_hostile_local_git_configuration_cannot_change_the_output() {
let project = repository();
git(project.path(), &["config", "diff.mnemonicprefix", "true"]);
git(project.path(), &["config", "diff.noprefix", "true"]);
std::fs::write(project.path().join("src/lib.rs"), "one\nTWO\nthree\n").unwrap();
let file = capture(project.path(), "src/lib.rs").await.unwrap().file.expect("a change");
assert_eq!(file.new_path.as_deref(), Some(Path::new("src/lib.rs")));
assert_eq!(file.old_path.as_deref(), Some(Path::new("src/lib.rs")));
}
/// "No change" and "no answer" are different facts, and collapsing them would have the pane
/// report a clean file as an error.
#[tokio::test]
async fn an_unchanged_file_reports_no_change_rather_than_a_failure() {
let project = repository();
let diff = capture(project.path(), "src/lib.rs").await.unwrap();
assert!(diff.file.is_none());
assert!(!diff.untracked);
}
#[tokio::test]
async fn a_repository_with_no_commits_yet_still_describes_its_files() {
let project = tempfile::tempdir().unwrap();
git(project.path(), &["init", "--quiet"]);
std::fs::write(project.path().join("first.txt"), "hello\n").unwrap();
let diff = capture(project.path(), "first.txt").await.unwrap();
assert!(diff.untracked, "nothing is tracked before the first commit");
assert_eq!(diff.file.expect("a change").additions, Some(1));
}
#[tokio::test]
async fn a_path_outside_the_project_is_refused_before_git_is_run() {
let project = repository();
for escape in ["../etc/passwd", "/etc/passwd", ""] {
assert_eq!(
capture(project.path(), escape).await.unwrap_err(),
FileDiffFailure::UnsafePath,
"{escape:?} should not be reachable"
);
}
}
#[tokio::test]
async fn a_directory_that_is_not_a_repository_says_so() {
let plain = tempfile::tempdir().unwrap();
std::fs::write(plain.path().join("notes.md"), "hello\n").unwrap();
assert_eq!(capture(plain.path(), "notes.md").await.unwrap_err(), FileDiffFailure::NotAWorktree);
}
/// The path a peek asks with is the path it gets back, whatever git called the file internally.
///
/// The pane discards a capture whose path is not the one it is looking at, so a worktree answer
/// that came back under its own root-relative name would be thrown away by the surface that asked
/// for it — a click that quietly did nothing.
#[tokio::test]
async fn a_file_in_another_worktree_is_diffed_against_that_worktrees_head() {
let elsewhere = repository();
let file = elsewhere.path().join("src/lib.rs");
std::fs::write(&file, "one\nTWO\nthree\n").unwrap();
let requested = file.to_string_lossy().into_owned();
let diff = capture_external(&requested, None).await.unwrap();
assert_eq!(diff.path, requested, "answered under the name it was asked for");
let change = diff.file.expect("another worktree answers the same question the project does");
assert_eq!((change.additions, change.deletions), (Some(1), Some(1)));
// Nothing was kept about this file and nothing had to be: Git is the witness here.
let lines: Vec<&str> = change.hunks[0].lines.iter().map(|line| line.text.as_str()).collect();
assert_eq!(lines, vec!["one", "two", "TWO", "three"]);
}
/// A file in no repository has no `HEAD` to be measured against, so the copy the session retained
/// before it first wrote there is the only honest base.
#[tokio::test]
async fn a_loose_file_is_measured_against_what_the_session_first_saw() {
let directory = tempfile::tempdir().unwrap();
let file = directory.path().join("ghostty.config");
std::fs::write(&file, "font-size = 13\ntheme = nord\n").unwrap();
let requested = file.to_string_lossy().into_owned();
let baseline = ExternalBaseline::Text { content: "font-size = 12\ntheme = nord\n".into() };
let diff = capture_external(&requested, Some(&baseline)).await.unwrap();
assert_eq!(diff.path, requested);
let change = diff.file.expect("a retained copy is something to compare against");
assert_eq!((change.additions, change.deletions), (Some(1), Some(1)));
let lines: Vec<&str> = change.hunks[0].lines.iter().map(|line| line.text.as_str()).collect();
assert_eq!(lines, vec!["font-size = 12", "font-size = 13", "theme = nord"]);
}
/// The three other states a loose file can be in, each of which means something different.
#[tokio::test]
async fn a_loose_files_other_states_each_read_as_themselves() {
use luxe_core::guided_review::ReviewFileStatus;
let directory = tempfile::tempdir().unwrap();
let created = directory.path().join("created.toml");
std::fs::write(&created, "new = true\n").unwrap();
let gone = directory.path().join("gone.toml");
let requested = |path: &Path| path.to_string_lossy().into_owned();
// Created by this session: every line of it is an addition.
let addition = capture_external(&requested(&created), Some(&ExternalBaseline::Absent))
.await
.unwrap()
.file
.expect("a file the session created");
assert_eq!(addition.status, ReviewFileStatus::Added);
assert_eq!(addition.hunks[0].lines[0].text, "new = true");
// Removed by this session: all that is left of it is what was retained.
let held = ExternalBaseline::Text { content: "was = here\nand = gone\n".into() };
let deletion = capture_external(&requested(&gone), Some(&held))
.await
.unwrap()
.file
.expect("a file the session removed");
assert_eq!(deletion.status, ReviewFileStatus::Deleted);
assert_eq!(deletion.deletions, Some(2));
// Touched and left exactly as it was found: not a change, and not a failure either.
let same = ExternalBaseline::Text { content: "new = true\n".into() };
assert!(capture_external(&requested(&created), Some(&same)).await.unwrap().file.is_none());
// Created and removed again inside one session: the filesystem is where it started.
let vanished =
capture_external(&requested(&gone), Some(&ExternalBaseline::Absent)).await.unwrap().file;
assert!(vanished.is_none());
}
/// A file too large or too binary to retain, and one luxe never saw, are the same answer: it
/// cannot say what changed, so it must not present the file as new.
#[tokio::test]
async fn a_loose_file_with_no_retained_copy_refuses_to_guess() {
let directory = tempfile::tempdir().unwrap();
let file = directory.path().join("huge.log");
std::fs::write(&file, "a line\n").unwrap();
let requested = file.to_string_lossy().into_owned();
for baseline in [None, Some(&ExternalBaseline::Unretained)] {
assert_eq!(
capture_external(&requested, baseline).await.unwrap_err(),
FileDiffFailure::NoBaseline
);
}
}
#[tokio::test]
async fn an_external_peek_refuses_a_path_that_is_not_absolute_and_plain() {
for escape in ["src/lib.rs", "", "/tmp/../etc/passwd"] {
assert_eq!(
capture_external(escape, Some(&ExternalBaseline::Absent)).await.unwrap_err(),
FileDiffFailure::UnsafePath,
"{escape:?} should not be reachable"
);
}
}
/// Binary content has no lines, and inventing some would be worse than saying so.
#[tokio::test]
async fn a_binary_change_is_reported_as_a_non_text_record() {
let project = repository();
std::fs::write(project.path().join("logo.png"), [0u8, 1, 2, 3]).unwrap();
git(project.path(), &["add", "logo.png"]);
git(project.path(), &["commit", "--quiet", "-m", "add binary"]);
std::fs::write(project.path().join("logo.png"), [9u8, 9, 9, 9]).unwrap();
let file = capture(project.path(), "logo.png").await.unwrap().file.expect("a binary change");
assert!(!file.is_text());
assert!(file.non_text.is_some(), "the reason is named rather than rendered as zero lines");
}