const std = @import("std");
const checkout = @import("zit").checkout;
const managed = @import("zit").managed;
const artifact = @import("zit").artifact;
const File = std.Io.File;
const support = @import("support.zig");
const addManaged = support.addManaged;
const appendArtifactAs = support.appendArtifactAs;
const appendDiffManifest = support.appendDiffManifest;
const commitHashDup = support.commitHashDup;
const corruptSection = support.corruptSection;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const fileExists = support.fileExists;
const findF = support.findF;
const freeResult = support.freeResult;
const initRepo = support.initRepo;
const parseCheckin = support.parseCheckin;
const readFile = support.readFile;
const readManagedImage = support.readManagedImage;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const seedCheckout = support.seedCheckout;
const tipHashOf = support.tipHashOf;
const writeFile = support.writeFile;
// ==========================================================================
// `zit diff` end-to-end. The public surface is deliberately a compact
// metadata report, not a text patch: only managed paths participate, compared
// with the checkout's resolved F-set. Each invocation must be read-only.
// ==========================================================================
test "cli diff --by, timeline -F html, ui: static renders land, the ui verb explains itself" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "f", "a\nb\nc\n");
try addManaged(gpa, io, tmp.dir, &.{"f"});
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "first <one>" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
try writeFile(io, tmp.dir, "f", "a\nB\nc\nd\n");
// --by writes a page and names it; no terminal, so nothing is opened.
var by = try runZit(gpa, io, tmp.dir, &.{ "diff", "--by" });
defer freeResult(gpa, &by);
try expectExitDiag(by.term, 0, by);
try std.testing.expect(std.mem.startsWith(u8, by.stdout, "wrote "));
const page_path = std.mem.trimEnd(u8, by.stdout["wrote ".len..], "\n");
const page = try std.Io.Dir.cwd().readFileAlloc(io, page_path, gpa, .limited(1 << 20));
defer gpa.free(page);
defer std.Io.Dir.cwd().deleteFile(io, page_path) catch {};
try std.testing.expect(std.mem.indexOf(u8, page, "<table class=\"sbs\">") != null);
try std.testing.expect(std.mem.indexOf(u8, page, "<tr class=\"chg\">") != null);
try std.testing.expect(std.mem.indexOf(u8, page, "<tr class=\"ins\">") != null);
try std.testing.expect(std.mem.indexOf(u8, page, "<h2>f</h2>") != null);
// -F html: a table on stdout, text escaped.
var tl = try runZit(gpa, io, tmp.dir, &.{ "timeline", "-F", "html" });
defer freeResult(gpa, &tl);
try expectExitDiag(tl.term, 0, tl);
try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "<table class=\"timeline\">") != null);
try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "first <one>") != null);
try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "class=\"current\"") != null);
// ui: reserved; says whose view it is and exits 1; help is exit 0.
var ui = try runZit(gpa, io, tmp.dir, &.{"ui"});
defer freeResult(gpa, &ui);
try expectExit(ui.term, 1);
try std.testing.expect(std.mem.indexOf(u8, ui.stderr, "quarry") != null);
var uh = try runZit(gpa, io, tmp.dir, &.{ "ui", "--help" });
defer freeResult(gpa, &uh);
try expectExit(uh.term, 0);
try std.testing.expect(std.mem.startsWith(u8, uh.stdout, "usage: zit ui"));
}
test "cli diff: PATH operands narrow, --numstat counts, --invert swaps, --checkin and --branch pick the pair" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try tmp.dir.createDirPath(io, "sub");
try writeFile(io, tmp.dir, "f", "a\nb\n");
try writeFile(io, tmp.dir, "sub/g", "x\n");
try addManaged(gpa, io, tmp.dir, &.{ "f", "sub/g" });
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c1" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
try writeFile(io, tmp.dir, "f", "a\nc\nd\n");
try writeFile(io, tmp.dir, "sub/g", "x\ny\n");
var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c2" });
defer freeResult(gpa, &c2);
try expectExit(c2.term, 0);
var side = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "side", "--branch", "side", "--allow-empty" });
defer freeResult(gpa, &side);
try expectExitDiag(side.term, 0, side);
try writeFile(io, tmp.dir, "sub/g", "x\ny\nz\n");
var s2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "s2" });
defer freeResult(gpa, &s2);
try expectExit(s2.term, 0);
// Working tree: one edit; numstat counts it, a PATH operand narrows.
try writeFile(io, tmp.dir, "f", "q\n");
var ns = try runZit(gpa, io, tmp.dir, &.{ "diff", "--numstat" });
defer freeResult(gpa, &ns);
try expectExitDiag(ns.term, 0, ns);
try std.testing.expectEqualStrings("1\t3\tf\n", ns.stdout);
var only_sub = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "sub" });
defer freeResult(gpa, &only_sub);
try expectExitDiag(only_sub.term, 0, only_sub);
try std.testing.expectEqualStrings("", only_sub.stdout);
var only_f = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "f" });
defer freeResult(gpa, &only_f);
try std.testing.expectEqualStrings("M f\n", only_f.stdout);
try tmp.dir.deleteFile(io, "f");
var inv = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--invert" });
defer freeResult(gpa, &inv);
try std.testing.expectEqualStrings("A f\n", inv.stdout);
var rv = try runZit(gpa, io, tmp.dir, &.{ "revert", "f" });
defer freeResult(gpa, &rv);
try expectExit(rv.term, 0);
// --checkin V is V against its parent; --branch B is B's tip against its fork point.
var ck = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "trunk", "--numstat" });
defer freeResult(gpa, &ck);
try expectExitDiag(ck.term, 0, ck);
try std.testing.expectEqualStrings("2\t1\tf\n1\t0\tsub/g\n", ck.stdout);
var br = try runZit(gpa, io, tmp.dir, &.{ "diff", "--branch", "side", "--numstat" });
defer freeResult(gpa, &br);
try expectExitDiag(br.term, 0, br);
try std.testing.expectEqualStrings("1\t0\tsub/g\n", br.stdout);
var both = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "trunk", "--branch", "side" });
defer freeResult(gpa, &both);
try expectExit(both.term, 2);
}
test "cli diff: an unborn managed regular file is added" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "new.txt", "new\n");
try addManaged(gpa, io, tmp.dir, &.{"new.txt"});
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("A new.txt\n", res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
test "cli diff: default output is unified hunks — worktree edits, rev-to-rev, added and deleted files, all through one renderer" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a.txt", "one\ntwo\nthree\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
const c1 = try commitHashDup(gpa, io, tmp.dir, "first");
defer gpa.free(c1);
// Worktree hunks: one changed line, three context... file too short for
// full context — the hunk covers what exists.
try writeFile(io, tmp.dir, "a.txt", "one\nTWO\nthree\n");
{
var res = try runZit(gpa, io, tmp.dir, &.{"diff"});
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings(
"Index: a.txt\n==================================================================\n--- a.txt\n+++ a.txt\n@@ -1,3 +1,3 @@\n one\n-two\n+TWO\n three\n",
res.stdout,
);
}
// Rev-to-rev hunks with an added file: /dev/null headers on the new side.
try writeFile(io, tmp.dir, "b.txt", "born\n");
try addManaged(gpa, io, tmp.dir, &.{"b.txt"});
const c2 = try commitHashDup(gpa, io, tmp.dir, "second");
defer gpa.free(c2);
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings(
"Index: a.txt\n==================================================================\n--- a.txt\n+++ a.txt\n@@ -1,3 +1,3 @@\n one\n-two\n+TWO\n three\n" ++
"Index: b.txt\n==================================================================\n--- /dev/null\n+++ b.txt\n@@ -0,0 +1 @@\n+born\n",
res.stdout,
);
}
// Reversed: the added file renders as a deletion against /dev/null.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c2, "--to", c1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "Index: b.txt\n==================================================================\n--- b.txt\n+++ /dev/null\n@@ -1 +0,0 @@\n-born\n") != null);
}
}
test "cli diff -w: whitespace-only changes vanish from hunks and from --brief, in both modes" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "ws.txt", "alpha\nbeta\n");
try writeFile(io, tmp.dir, "real.txt", "keep\n");
try addManaged(gpa, io, tmp.dir, &.{ "ws.txt", "real.txt" });
const c1 = try commitHashDup(gpa, io, tmp.dir, "first");
defer gpa.free(c1);
// Reindent ws.txt only: a real byte change that is entirely whitespace.
try writeFile(io, tmp.dir, "ws.txt", " alpha\nbeta\t\n");
// Worktree, hunks: visible without -w, gone with it.
{
var res = try runZit(gpa, io, tmp.dir, &.{"diff"});
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") != null);
}
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "-w" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("", res.stdout);
}
// Worktree, --brief: the file must not be listed at all under -w, and the
// long spelling reaches the same path.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") != null);
}
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--ignore-whitespace" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("", res.stdout);
}
// A genuine edit alongside the whitespace one: -w must still report it,
// and must report ONLY it. This is what stops -w from being "show nothing".
try writeFile(io, tmp.dir, "real.txt", "changed\n");
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "-w" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "real.txt") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") == null);
}
// Rev-to-rev: same two questions across a commit boundary.
const c2 = try commitHashDup(gpa, io, tmp.dir, "second");
defer gpa.free(c2);
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2, "-w" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "real.txt") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") == null);
}
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2, "--brief", "-w" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("M real.txt\n", res.stdout);
}
// Without -w the same brief pair lists both files, so the assertions above
// are about the flag and not about the fixture.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2, "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "real.txt") != null);
}
}
test "cli diff: --from/--to compares two check-ins by name-status, in both directions; a lone flag is a usage error" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a.txt", "one\n");
try writeFile(io, tmp.dir, "b.txt", "gone later\n");
try addManaged(gpa, io, tmp.dir, &.{ "a.txt", "b.txt" });
const c1 = try commitHashDup(gpa, io, tmp.dir, "first");
defer gpa.free(c1);
try writeFile(io, tmp.dir, "a.txt", "two\n");
try writeFile(io, tmp.dir, "c.txt", "new\n");
try addManaged(gpa, io, tmp.dir, &.{"c.txt"});
{
var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "b.txt" });
defer freeResult(gpa, &rm);
try expectExit(rm.term, 0);
}
const c2 = try commitHashDup(gpa, io, tmp.dir, "second");
defer gpa.free(c2);
// Forward: modified, deleted, added — in canonical path order.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--from", c1, "--to", c2 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("M a.txt\nD b.txt\nA c.txt\n", res.stdout);
}
// Reversed operands: A and D swap, M stays.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--from", c2, "--to", c1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("M a.txt\nA b.txt\nD c.txt\n", res.stdout);
}
// Identical operands: silence.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--from", c1, "--to", c1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("", res.stdout);
}
// The pair is required together.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 2);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "--from and --to must be given together") != null);
}
}
test "cli diff: a clean committed file is silent and arbitrary untracked paths are omitted" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "tracked.txt", "same\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
try writeFile(io, tmp.dir, "untracked.txt", "ignored\n");
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
test "cli diff: a changed committed managed file is modified and leaves repository metadata byte-identical" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a.txt", "before\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
try writeFile(io, tmp.dir, "a.txt", "after\n");
const before_zit = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(before_zit);
const before_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
defer gpa.free(before_checkout);
const before_managed = try readManagedImage(gpa, io, tmp.dir);
defer gpa.free(before_managed);
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("M a.txt\n", res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
const after_zit = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(after_zit);
const after_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
defer gpa.free(after_checkout);
const after_managed = try readManagedImage(gpa, io, tmp.dir);
defer gpa.free(after_managed);
try std.testing.expectEqualSlices(u8, before_zit, after_zit);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
}
test "cli diff: a baseline file removed from management is deleted and mixed changes are path-sorted" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a", "a0\n");
try writeFile(io, tmp.dir, "b", "b0\n");
try addManaged(gpa, io, tmp.dir, &.{ "a", "b" });
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
try writeFile(io, tmp.dir, "a", "a1\n");
try writeFile(io, tmp.dir, "c", "c0\n");
try addManaged(gpa, io, tmp.dir, &.{"c"});
var remove = try runZit(gpa, io, tmp.dir, &.{ "rm", "b" });
defer freeResult(gpa, &remove);
try expectExit(remove.term, 0);
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("M a\nD b\nA c\n", res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
try std.testing.expect(fileExists(io, tmp.dir, "b")); // `rm` forgets, it does not unlink
}
test "cli diff: a managed filename uses section 4.3 escapes" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
const filename = "a b\tc\\d";
try writeFile(io, tmp.dir, filename, "new\n");
// `zit add` refuses a tab or backslash in a new name, but a checkout of a
// manifest that carries one still tracks it; plant it the way that does.
{
var set = try managed.ManagedSet.read(gpa, io, tmp.dir);
defer set.deinit();
_ = try set.insert(filename);
try set.write(io, tmp.dir);
}
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("A a\\sb\\tc\\\\d\n", res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
test "cli diff: a lowercase SHA-1 baseline is clean unchanged and modified when altered" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
const original = "same\n";
try writeFile(io, tmp.dir, "sha1.txt", original);
try addManaged(gpa, io, tmp.dir, &.{"sha1.txt"});
const blob = try appendArtifactAs(gpa, io, tmp.dir, .sha1, original);
defer gpa.free(blob);
const f = [_]artifact.FCard{.{
.filename = "sha1.txt",
.hash = blob,
.perm = null,
.old_name = null,
.mode = .regular,
}};
var manifest: artifact.Manifest = .{
.arena_state = std.heap.ArenaAllocator.init(gpa),
.kind = .manifest,
.a = null,
.b = null,
.c = .{ .comment = "sha1-root" },
.d = .{ .timestamp = "2020-01-01T00:00:00" },
.e = null,
.g = null,
.h = null,
.i = null,
.k = null,
.l = null,
.n = null,
.r = null,
.u = .{ .login = "u" },
.z = null,
.w = null,
.f = &f,
.j = &.{},
.m = &.{},
.p = &.{},
.q = &.{},
.t = &.{},
};
defer manifest.deinit();
const manifest_bytes = try artifact.create(&manifest, gpa);
defer gpa.free(manifest_bytes);
const checkin = try appendArtifactAs(gpa, io, tmp.dir, .sha1, manifest_bytes);
defer gpa.free(checkin);
try std.testing.expectEqual(@as(usize, 40), checkin.len);
for (checkin) |ch| try std.testing.expect(std.ascii.isHex(ch) and !std.ascii.isUpper(ch));
try seedCheckout(io, tmp.dir, checkin, "trunk");
var clean = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &clean);
try expectExit(clean.term, 0);
try std.testing.expectEqualStrings("", clean.stdout);
try std.testing.expectEqualStrings("", clean.stderr);
try writeFile(io, tmp.dir, "sha1.txt", "changed\n");
var changed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &changed);
try expectExit(changed.term, 0);
try std.testing.expectEqualStrings("M sha1.txt\n", changed.stdout);
try std.testing.expectEqualStrings("", changed.stderr);
}
test "cli diff: a managed path replaced by a symlink is deleted without following its target" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "target", "same\n");
try writeFile(io, tmp.dir, "link", "same\n");
try addManaged(gpa, io, tmp.dir, &.{"link"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
try tmp.dir.deleteFile(io, "link");
try tmp.dir.symLink(io, "target", "link", .{});
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("D link\n", res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
test "cli diff: executable-bit-only change to a managed regular file is modified" {
if (comptime !File.Permissions.has_executable_bit) return error.SkipZigTest;
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
const original = "#!/bin/zit\nsame\n";
try writeFile(io, tmp.dir, "script", original);
try addManaged(gpa, io, tmp.dir, &.{"script"});
{
var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_write });
defer script.close(io);
try script.setPermissions(io, File.Permissions.executable_file);
}
const blob = try appendArtifactAs(gpa, io, tmp.dir, .sha1, original);
defer gpa.free(blob);
const files = [_]artifact.FCard{.{
.filename = "script",
.hash = blob,
.perm = "x",
.old_name = null,
.mode = .executable,
}};
const baseline = try appendDiffManifest(gpa, io, tmp.dir, "executable-root", null, &files);
defer gpa.free(baseline);
var stored_baseline = try parseCheckin(gpa, io, tmp.dir, baseline);
defer stored_baseline.deinit();
try std.testing.expectEqual(artifact.FileMode.executable, (findF(stored_baseline.m, "script") orelse return error.MissingFCard).mode);
try seedCheckout(io, tmp.dir, baseline, "trunk");
var clean = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &clean);
try expectExit(clean.term, 0);
try std.testing.expectEqualStrings("", clean.stdout);
try std.testing.expectEqualStrings("", clean.stderr);
{
var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_write });
defer script.close(io);
try script.setPermissions(io, File.Permissions.default_file);
}
var changed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &changed);
try expectExit(changed.term, 0);
try std.testing.expectEqualStrings("M script\n", changed.stdout);
try std.testing.expectEqualStrings("", changed.stderr);
}
test "cli diff: a delta checkout resolves inherited managed files through its B-card" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
const original = "same\n";
try writeFile(io, tmp.dir, "inherited.txt", original);
try addManaged(gpa, io, tmp.dir, &.{"inherited.txt"});
const blob = try appendArtifactAs(gpa, io, tmp.dir, .sha1, original);
defer gpa.free(blob);
const files = [_]artifact.FCard{.{
.filename = "inherited.txt",
.hash = blob,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const baseline = try appendDiffManifest(gpa, io, tmp.dir, "full-root", null, &files);
defer gpa.free(baseline);
const delta = try appendDiffManifest(gpa, io, tmp.dir, "delta", baseline, &.{});
defer gpa.free(delta);
var stored_delta = try parseCheckin(gpa, io, tmp.dir, delta);
defer stored_delta.deinit();
try std.testing.expectEqualStrings(baseline, stored_delta.m.b.?.hash);
try std.testing.expectEqual(@as(usize, 0), stored_delta.m.f.len);
try seedCheckout(io, tmp.dir, delta, "trunk");
var clean = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &clean);
try expectExit(clean.term, 0);
try std.testing.expectEqualStrings("", clean.stdout);
try std.testing.expectEqualStrings("", clean.stderr);
try writeFile(io, tmp.dir, "inherited.txt", "changed\n");
var changed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &changed);
try expectExit(changed.term, 0);
try std.testing.expectEqualStrings("M inherited.txt\n", changed.stdout);
try std.testing.expectEqualStrings("", changed.stderr);
}
test "cli diff: outside a repository fails with the shared discovery diagnostic" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings(
"zit: no zit checkout here (looked for .zit-checkout in this directory and its parents)\n" ++
"if this is a bare repository, name it with -R, or run 'zit open' to create a working tree\n",
res.stderr,
);
}
test "cli diff: a corrupt .zit-checkout fails without a partial diff" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
{
var f = try tmp.dir.createFile(io, checkout.filename, .{});
defer f.close(io);
try f.writePositionalAll(io, &.{ 0xff, 0xff, 0xaa }, 0);
}
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings(
"zit diff: cannot read checkout state: .zit-checkout is corrupt\n",
res.stderr,
);
}
test "cli diff: a corrupt .zit-managed fails without a partial diff" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try corruptSection(io, tmp.dir, .managed);
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings(
"zit diff: cannot read tracked files: .zit-checkout is corrupt\n",
res.stderr,
);
}
test "cli diff: a current delta checkout with an absent B-card baseline fails without a partial diff" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
const absent_baseline = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
const delta = try appendDiffManifest(gpa, io, tmp.dir, "missing-baseline", absent_baseline, &.{});
defer gpa.free(delta);
try seedCheckout(io, tmp.dir, delta, "trunk");
var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit diff: cannot resolve baseline\n", res.stderr);
}
test "cli diff: help is the sole option and invalid arguments are usage errors" {
const gpa = std.testing.allocator;
const io = std.testing.io;
inline for (.{ "--help", "-h" }) |flag| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var help = try runZit(gpa, io, tmp.dir, &.{ "diff", flag });
defer freeResult(gpa, &help);
try expectExit(help.term, 0);
try std.testing.expect(std.mem.startsWith(u8, help.stdout, "usage: zit diff [--brief|--numstat|--by|-F json] [-w|-Z] [-c N] [--invert]\n [-N] [--from CHECKIN --to CHECKIN | --checkin V | --branch B]\n"));
try std.testing.expect(std.mem.indexOf(u8, help.stdout, "--exit-code") == null);
try std.testing.expectEqualStrings("", help.stderr);
}
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var unknown = try runZit(gpa, io, tmp.dir, &.{ "diff", "-x" });
defer freeResult(gpa, &unknown);
try expectExit(unknown.term, 2);
try std.testing.expectEqualStrings("", unknown.stdout);
try std.testing.expectEqualStrings(
"zit diff: unknown option '-x'\ntry 'zit diff --help'\n",
unknown.stderr,
);
}
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var positional = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from" }); // a value-less flag; bare words are PATH operands now
defer freeResult(gpa, &positional);
try expectExit(positional.term, 2);
try std.testing.expectEqualStrings("", positional.stdout);
try std.testing.expectEqualStrings(
"zit diff: unknown option '--from'\ntry 'zit diff --help'\n",
positional.stderr,
);
}
}
test "cli diff -F json: a two-check-in comparison in Fossil's field names, every kind of change, binary marked" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "n.md", "one\ntwo\n");
try writeFile(io, tmp.dir, "b.bin", "x\x00y");
try writeFile(io, tmp.dir, "g.md", "gone\n");
try addManaged(gpa, io, tmp.dir, &.{ "n.md", "b.bin", "g.md" });
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "first" });
defer freeResult(gpa, &c1);
try expectExitDiag(c1.term, 0, c1);
try writeFile(io, tmp.dir, "n.md", "one\nTWO\n");
try writeFile(io, tmp.dir, "b.bin", "x\x00z");
var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "g.md" });
defer freeResult(gpa, &rm);
try expectExitDiag(rm.term, 0, rm);
try writeFile(io, tmp.dir, "new.md", "hi\n");
try addManaged(gpa, io, tmp.dir, &.{"new.md"});
var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
defer freeResult(gpa, &c2);
try expectExitDiag(c2.term, 0, c2);
var d = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "tip", "-F", "json" });
defer freeResult(gpa, &d);
try expectExitDiag(d.term, 0, d);
var doc = try std.json.parseFromSlice(std.json.Value, gpa, d.stdout, .{});
defer doc.deinit();
const root = doc.value.object;
try std.testing.expectEqual(@as(i64, 1), root.get("schema_version").?.integer);
try std.testing.expect(root.get("from").? == .string and root.get("to").? == .string);
const files = root.get("files").?.array.items;
try std.testing.expectEqual(@as(usize, 4), files.len);
const want = [_]struct { name: []const u8, state: []const u8, binary: bool, diff: ?[]const u8 }{
.{ .name = "b.bin", .state = "modified", .binary = true, .diff = null },
.{ .name = "g.md", .state = "removed", .binary = false, .diff = "@@ -1 +0,0 @@\n-gone\n" },
.{ .name = "n.md", .state = "modified", .binary = false, .diff = "@@ -1,2 +1,2 @@\n one\n-two\n+TWO\n" },
.{ .name = "new.md", .state = "added", .binary = false, .diff = "@@ -0,0 +1 @@\n+hi\n" },
};
for (files, want) |f, w| {
const o = f.object;
try std.testing.expectEqualStrings(w.name, o.get("name").?.string);
try std.testing.expectEqualStrings(w.state, o.get("state").?.string);
try std.testing.expectEqual(w.binary, o.get("binary").?.bool);
if (w.diff) |text| try std.testing.expectEqualStrings(text, o.get("diff").?.string) else try std.testing.expect(o.get("diff").? == .null);
try std.testing.expectEqual(std.mem.eql(u8, w.state, "removed"), o.get("uuid").? == .null);
try std.testing.expectEqual(std.mem.eql(u8, w.state, "added"), o.get("parent").? == .null);
}
var wt = try runZit(gpa, io, tmp.dir, &.{ "diff", "-F", "json" });
defer freeResult(gpa, &wt);
try expectExit(wt.term, 2);
var mixed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "tip", "-F", "json", "--brief" });
defer freeResult(gpa, &mixed);
try expectExit(mixed.term, 2);
}
test "cli diff: a version whose content was shunned is refused, never shown as an emptied file" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
var hashes: [3][]u8 = undefined;
var made: usize = 0;
defer for (hashes[0..made]) |h| gpa.free(h);
for ([_][]const u8{ "v1\n", "v2\n", "v3\n" }, 0..) |body, i| {
try writeFile(io, tmp.dir, "n.md", body);
if (i == 0) try addManaged(gpa, io, tmp.dir, &.{"n.md"});
var c = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", body });
defer freeResult(gpa, &c);
try expectExitDiag(c.term, 0, c);
hashes[i] = try tipHashOf(gpa, io, tmp.dir, "trunk");
made += 1;
}
var v2_digest: [32]u8 = undefined;
std.crypto.hash.sha3.Sha3_256.hash("v2\n", &v2_digest, .{});
const v2_blob = std.fmt.bytesToHex(v2_digest, .lower);
var sh = try runZit(gpa, io, tmp.dir, &.{ "shun", "--force", &v2_blob });
defer freeResult(gpa, &sh);
try expectExitDiag(sh.term, 0, sh);
for ([_][2][]const u8{ .{ hashes[0], hashes[1] }, .{ hashes[1], hashes[2] } }) |pair| {
var d = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", pair[0], "--to", pair[1] });
defer freeResult(gpa, &d);
// Exit 8: absent by policy, told apart from damage (exit 1).
try expectExitDiag(d.term, 8, d);
try std.testing.expect(std.mem.indexOf(u8, d.stdout, "@@") == null);
try std.testing.expect(std.mem.indexOf(u8, d.stderr, "is shunned in this repository") != null);
}
// Versions on either side of the shunned one still compare.
var d13 = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", hashes[0], "--to", hashes[2] });
defer freeResult(gpa, &d13);
try expectExitDiag(d13.term, 0, d13);
try std.testing.expect(std.mem.indexOf(u8, d13.stdout, "+v3") != null);
}
test "cli diff -R: the check-in pair works from a bare store, worktree mode still refuses" {
// Goal: `diff --from A --to B` touches no working tree, so
// -R serves it from a bare store (hunks and --brief both); the worktree
// comparison keeps refusing -R with the works-in-a-checkout diagnostic.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "f.txt", "alpha\n");
try addManaged(gpa, io, tmp.dir, &.{"f.txt"});
const c1 = try commitHashDup(gpa, io, tmp.dir, "one");
defer gpa.free(c1);
try writeFile(io, tmp.dir, "f.txt", "alpha\nbeta\n");
const c2 = try commitHashDup(gpa, io, tmp.dir, "two");
defer gpa.free(c2);
var away = std.testing.tmpDir(.{}); // no checkout anywhere in sight
defer away.cleanup();
const cwd = try std.process.currentPathAlloc(io, gpa);
defer gpa.free(cwd);
const store_abs = try std.fs.path.join(gpa, &.{ cwd, ".zig-cache", "tmp", &tmp.sub_path });
defer gpa.free(store_abs);
var hunks = try runZit(gpa, io, away.dir, &.{ "diff", "-R", store_abs, "--from", c1, "--to", c2 });
defer freeResult(gpa, &hunks);
try expectExitDiag(hunks.term, 0, hunks);
try std.testing.expect(std.mem.indexOf(u8, hunks.stdout, "+beta") != null);
var brief = try runZit(gpa, io, away.dir, &.{ "diff", "-R", store_abs, "--brief", "--from", c1, "--to", c2 });
defer freeResult(gpa, &brief);
try expectExitDiag(brief.term, 0, brief);
try std.testing.expectEqualStrings("M f.txt\n", brief.stdout);
// In-checkout from/to with -R agrees byte-for-byte with the plain form.
var plain = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2 });
defer freeResult(gpa, &plain);
try expectExitDiag(plain.term, 0, plain);
try std.testing.expectEqualStrings(plain.stdout, hunks.stdout);
// The worktree comparison refuses -R, naming the remedy.
var wt = try runZit(gpa, io, away.dir, &.{ "diff", "-R", store_abs });
defer freeResult(gpa, &wt);
try expectExit(wt.term, 1);
try std.testing.expectEqualStrings("", wt.stdout);
try std.testing.expect(std.mem.indexOf(u8, wt.stderr, "needs --from/--to, --checkin or --branch") != null);
}