const std = @import("std");
const checkout = @import("zit").checkout;
const artifact = @import("zit").artifact;
const cli = @import("zit").cli;
const File = std.Io.File;
const support = @import("support.zig");
const addManaged = support.addManaged;
const appendArtifact = support.appendArtifact;
const appendDiffManifest = support.appendDiffManifest;
const appendTagControl = support.appendTagControl;
const checkinHash = support.checkinHash;
const commitHashDup = support.commitHashDup;
const expectCheckoutVersion = support.expectCheckoutVersion;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectFileContent = support.expectFileContent;
const expectManaged = support.expectManaged;
const expectNoDiagnostic = support.expectNoDiagnostic;
const fileExists = support.fileExists;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const readFile = support.readFile;
const readManagedImage = support.readManagedImage;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const sectionExists = support.sectionExists;
const spawnServe = support.spawnServe;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;
test "cli update and stash apply --merge: adjacent edits merge cleanly" {
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 first = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
defer freeResult(gpa, &first);
try expectExit(first.term, 0);
const older = try checkinHash(first.stdout);
try writeFile(io, tmp.dir, "f", "a\nb\nC\n");
var second = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "tip" });
defer freeResult(gpa, &second);
try expectExit(second.term, 0);
const tip = try checkinHash(second.stdout);
// Uncommitted work on the older check-in, next to the tip's edit.
var back = try runZit(gpa, io, tmp.dir, &.{ "update", older });
defer freeResult(gpa, &back);
try expectExit(back.term, 0);
try writeFile(io, tmp.dir, "f", "a\nB\nc\n");
var joined = try runZit(gpa, io, tmp.dir, &.{ "update", tip });
defer freeResult(gpa, &joined);
try expectExitDiag(joined.term, 0, joined);
try expectCheckoutVersion(io, tmp.dir, tip);
try expectFileContent(gpa, io, tmp.dir, "f", "a\nB\nC\n");
// A stashed edit folded into a dirty file next to the working edit.
var rv = try runZit(gpa, io, tmp.dir, &.{"revert"});
defer freeResult(gpa, &rv);
try expectExit(rv.term, 0);
try writeFile(io, tmp.dir, "f", "A\nb\nC\n");
var snap = try runZit(gpa, io, tmp.dir, &.{ "stash", "snapshot", "-m", "snap" });
defer freeResult(gpa, &snap);
try expectExitDiag(snap.term, 0, snap);
try writeFile(io, tmp.dir, "f", "a\nB\nC\n");
var folded = try runZit(gpa, io, tmp.dir, &.{ "stash", "apply", "--merge" });
defer freeResult(gpa, &folded);
try expectExitDiag(folded.term, 0, folded);
try expectFileContent(gpa, io, tmp.dir, "f", "A\nB\nC\n");
}
/// Writes a control artifact that flips `target`'s branch tag — the branch-only
/// wrapper the update tests already rely on.
fn appendBranchControl(
gpa: std.mem.Allocator,
io: std.Io,
dir: std.Io.Dir,
timestamp: []const u8,
sign: artifact.TSign,
target: []const u8,
value: ?[]const u8,
) ![]u8 {
return appendTagControl(gpa, io, dir, timestamp, sign, "branch", target, value);
}
// ==========================================================================
// `zit update CHECKIN` end-to-end. These tests exercise the public command
// against real check-ins and synthetic delta fixtures without reaching into
// the update implementation.
// ==========================================================================
test "cli update: a clean canonical target restores earlier content and checkout ID" {
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", "earlier\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
defer freeResult(gpa, &root_commit);
try expectExit(root_commit.term, 0);
const root = try checkinHash(root_commit.stdout);
try writeFile(io, tmp.dir, "tracked.txt", "later\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
const restored = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(restored);
try std.testing.expectEqualStrings("earlier\n", restored);
try expectCheckoutVersion(io, tmp.dir, root);
try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}
test "cli update: a non-manifest target leaves the clean checkout unchanged" {
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", "kept\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "kept" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
const non_manifest = try appendArtifact(gpa, io, tmp.dir, "not a manifest\n");
defer gpa.free(non_manifest);
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);
const before_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(before_content);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", non_manifest });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
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);
const after_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after_content);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expectEqualSlices(u8, before_content, after_content);
try expectCheckoutVersion(io, tmp.dir, current);
try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}
// The shape that made `zit update` accuse an intact fossil clone of corruption:
// a store that also holds an anonymous wiki edit (cards D L W Z, no U). The
// artifact parses and is well-framed, but §5.2 requires a U card on a WIKI
// artifact, so classification declines with MissingRequiredCard; its bytes
// still hash to the name it is stored under, so the repository is undamaged and
// the artifact is opaque to state. `update` derives state over the whole log
// and so meets that artifact, exactly as `timeline`/`ls`/`info`/`branch` do.
//
// This pins the general form of the defect (Repository State erratum
// `repo-state-00-s4-unclassifiable-artifact`): no read verb may succeed on a
// store where `update` fails for a reason the reader tolerated. Pre-fix, update
// exited 1 while every read verb read the same store fine; post-fix, all agree.
test "cli update: an unclassifiable artifact in the store is tolerated, and update agrees with the read verbs" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// Two real check-ins: `root` (earlier) is the update target, and a later
// commit is the current tip, so `update root` is a genuine backward update.
try writeFile(io, tmp.dir, "tracked.txt", "earlier\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
defer freeResult(gpa, &root_commit);
try expectExit(root_commit.term, 0);
const root = try checkinHash(root_commit.stdout);
try writeFile(io, tmp.dir, "tracked.txt", "later\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
// Inject the anonymous wiki artifact under its true hash (appendArtifact
// names it by content), so it is unclassifiable yet undamaged.
const wiki_body = "D 2008-11-24T02:18:26\nL RockShoxBugs\nW 12\nhello, world\n";
var sum_buf: [32]u8 = undefined;
const sum = artifact.selfChecksum(wiki_body, &sum_buf);
const wiki_bytes = try std.fmt.allocPrint(gpa, "{s}Z {s}\n", .{ wiki_body, sum });
defer gpa.free(wiki_bytes);
const wiki_name = try appendArtifact(gpa, io, tmp.dir, wiki_bytes);
defer gpa.free(wiki_name);
// The fix: update tolerates the verified-but-unclassifiable artifact and
// restores the target. Pre-fix this exited 1 (Corrupt).
var update_res = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &update_res);
try expectExit(update_res.term, 0);
const restored = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(restored);
try std.testing.expectEqualStrings("earlier\n", restored);
try expectCheckoutVersion(io, tmp.dir, root);
// Read/assembly agreement: every read verb reads the same store — the one
// update just tolerated — and must also exit 0.
const read_verbs = [_][]const []const u8{
&.{"timeline"},
&.{"branch"},
&.{ "info", root },
&.{ "ls", root },
};
for (read_verbs) |argv| {
var res = try runZit(gpa, io, tmp.dir, argv);
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
}
}
test "cli update: a moved tip under uncommitted work joins without forking" {
// The issue's own reproduction, end to end. Every exit used to be closed:
// `commit` refused with "run 'zit update' to join it", `update` refused
// because the tree was dirty, `merge` refused for the same reason, and
// `stash pop` cannot replay onto a check-in other than the one it was taken
// from. The only way to keep the work was `commit --allow-fork` — so the
// guard that exists to keep forks deliberate was manufacturing them.
//
// The fork guard is NOT relaxed here; it still refuses a non-leaf parent.
// What changed is that its advice is now followable.
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", "base\n");
try addManaged(gpa, io, tmp.dir, &.{"f.txt"});
var first = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
defer freeResult(gpa, &first);
try expectExit(first.term, 0);
const older = try checkinHash(first.stdout);
try writeFile(io, tmp.dir, "f.txt", "base\ntheirs\n");
var second = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
defer freeResult(gpa, &second);
try expectExit(second.term, 0);
const tip = try checkinHash(second.stdout);
// Go back to the older check-in and start uncommitted work there — the
// state an operator lands in when a shared branch moves under them.
var back = try runZit(gpa, io, tmp.dir, &.{ "update", older });
defer freeResult(gpa, &back);
try expectExit(back.term, 0);
try writeFile(io, tmp.dir, "f.txt", "mine\nbase\n");
// `commit` still refuses, and still says to update. That is the guard doing
// its job — the fork must stay deliberate.
var blocked = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "blocked" });
defer freeResult(gpa, &blocked);
try expectExit(blocked.term, 1);
try std.testing.expect(std.mem.indexOf(u8, blocked.stderr, "run 'zit update' to join it") != null);
// Following that advice now works: the edits are merged onto the tip rather
// than the update being refused. Disjoint regions merge without markers.
var joined = try runZit(gpa, io, tmp.dir, &.{ "update", tip });
defer freeResult(gpa, &joined);
try expectExit(joined.term, 0);
try expectCheckoutVersion(io, tmp.dir, tip);
const merged = try readFile(gpa, io, tmp.dir, "f.txt");
defer gpa.free(merged);
try std.testing.expectEqualStrings("mine\nbase\ntheirs\n", merged);
// And the commit that follows is an ordinary child of the tip: one leaf,
// no `--allow-fork`, no repair check-in.
var done = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "joined" });
defer freeResult(gpa, &done);
try expectExit(done.term, 0);
const head = try checkinHash(done.stdout);
var leaves = try runZit(gpa, io, tmp.dir, &.{"leaves"});
defer freeResult(gpa, &leaves);
try expectExit(leaves.term, 0);
try std.testing.expect(std.mem.indexOf(u8, leaves.stdout, cli.shortHash(head)) != null);
// Exactly one leaf line: a fork would show two.
try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, leaves.stdout, "\n"));
}
test "cli update: a dirty checkout moves and three-way merges, marking conflicts" {
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", "earlier\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
defer freeResult(gpa, &root_commit);
try expectExit(root_commit.term, 0);
const root = try checkinHash(root_commit.stdout);
try writeFile(io, tmp.dir, "tracked.txt", "committed later\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
try writeFile(io, tmp.dir, "tracked.txt", "uncommitted change\n");
// All three sides differ, so the merge cannot decide the file and writes an
// envelope. That is a conflict (exit 1), NOT a refusal: this used to refuse
// outright, which left an operator whose branch tip had moved under
// uncommitted work with no way to join it at all.
var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expect(std.mem.indexOf(u8, update.stderr, "conflict in tracked.txt") != null);
// The checkout MOVED — that is the whole point. A dirty tree is no longer a
// reason to stay behind the tip.
try expectCheckoutVersion(io, tmp.dir, root);
try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
// Both sides survive in the working file: the operator's uncommitted text
// and the check-in being joined. Neither is silently discarded.
const after_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after_content);
try std.testing.expect(std.mem.indexOf(u8, after_content, "uncommitted change") != null);
try std.testing.expect(std.mem.indexOf(u8, after_content, "earlier") != null);
try std.testing.expect(std.mem.indexOf(u8, after_content, "<<<<<<< current") != null);
}
test "cli update: a delta target materializes content inherited from its baseline" {
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, "inherited.txt", "current content\n");
try addManaged(gpa, io, tmp.dir, &.{"inherited.txt"});
var current_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "current" });
defer freeResult(gpa, ¤t_commit);
try expectExit(current_commit.term, 0);
const inherited = "inherited baseline content\n";
const blob = try appendArtifact(gpa, io, tmp.dir, inherited);
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, "baseline", null, &files);
defer gpa.free(baseline);
const delta = try appendDiffManifest(gpa, io, tmp.dir, "delta", baseline, &.{});
defer gpa.free(delta);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", delta });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
const materialized = try readFile(gpa, io, tmp.dir, "inherited.txt");
defer gpa.free(materialized);
try std.testing.expectEqualStrings(inherited, materialized);
try expectCheckoutVersion(io, tmp.dir, delta);
try expectManaged(gpa, io, tmp.dir, &.{"inherited.txt"});
}
test "cli update: non-ancestor control branch records set then cancel the target branch" {
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", "content\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "target" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const target = try checkinHash(commit.stdout);
try writeFile(io, tmp.dir, "tracked.txt", "child content\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "child" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
const child = try checkinHash(child_commit.stdout);
const set_control_id = try appendBranchControl(
gpa,
io,
tmp.dir,
"2020-01-01T00:00:00",
.propagate,
target,
"feature",
);
defer gpa.free(set_control_id);
var set_update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
defer freeResult(gpa, &set_update);
try expectExit(set_update.term, 0);
try expectNoDiagnostic(set_update.stderr); // the receipt lives on stderr
{
var checkout_buf: [checkout.max_ck_payload + 1]u8 = undefined;
const current = (try checkout.read(io, tmp.dir, &checkout_buf)).?;
try std.testing.expectEqualStrings(target, current.version);
try std.testing.expectEqualStrings("feature", current.branch);
}
var reset = try runZit(gpa, io, tmp.dir, &.{ "update", child });
defer freeResult(gpa, &reset);
try expectExit(reset.term, 0);
try expectNoDiagnostic(reset.stderr); // the receipt lives on stderr
try expectCheckoutVersion(io, tmp.dir, child);
const cancel_control_id = try appendBranchControl(
gpa,
io,
tmp.dir,
"2020-01-02T00:00:00",
.cancel,
target,
null,
);
defer gpa.free(cancel_control_id);
var cancel_update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
defer freeResult(gpa, &cancel_update);
try expectExit(cancel_update.term, 0);
try expectNoDiagnostic(cancel_update.stderr); // the receipt lives on stderr
{
var checkout_buf: [checkout.max_ck_payload + 1]u8 = undefined;
const current = (try checkout.read(io, tmp.dir, &checkout_buf)).?;
try std.testing.expectEqualStrings(target, current.version);
try std.testing.expectEqualStrings("trunk", current.branch);
}
}
test "cli update: unsafe and root-control target paths leave the checkout and outside sentinel unchanged" {
const gpa = std.testing.allocator;
const io = std.testing.io;
inline for (.{ ".zit", ".zit-checkout", ".zit-cache", "../outside/sentinel" }) |target_name| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try tmp.dir.createDir(io, "repo", .default_dir);
try tmp.dir.createDir(io, "outside", .default_dir);
var repo = try tmp.dir.openDir(io, "repo", .{});
defer repo.close(io);
var outside = try tmp.dir.openDir(io, "outside", .{});
defer outside.close(io);
try initRepo(gpa, io, repo);
try writeFile(io, repo, "tracked.txt", "current\n");
try addManaged(gpa, io, repo, &.{"tracked.txt"});
var commit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "current" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
try writeFile(io, outside, "sentinel", "outside must survive\n");
const payload = try appendArtifact(gpa, io, repo, "target content\n");
defer gpa.free(payload);
const files = [_]artifact.FCard{.{
.filename = target_name,
.hash = payload,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const target = try appendDiffManifest(gpa, io, repo, "unsafe target", null, &files);
defer gpa.free(target);
const before_log = try readFile(gpa, io, repo, ".zit");
defer gpa.free(before_log);
const before_checkout = try readFile(gpa, io, repo, ".zit-checkout");
defer gpa.free(before_checkout);
const before_managed = try readManagedImage(gpa, io, repo);
defer gpa.free(before_managed);
const before_tracked = try readFile(gpa, io, repo, "tracked.txt");
defer gpa.free(before_tracked);
const before_sentinel = try readFile(gpa, io, outside, "sentinel");
defer gpa.free(before_sentinel);
var update = try runZit(gpa, io, repo, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expectEqualStrings("", update.stdout);
const after_log = try readFile(gpa, io, repo, ".zit");
defer gpa.free(after_log);
const after_checkout = try readFile(gpa, io, repo, ".zit-checkout");
defer gpa.free(after_checkout);
const after_managed = try readManagedImage(gpa, io, repo);
defer gpa.free(after_managed);
const after_tracked = try readFile(gpa, io, repo, "tracked.txt");
defer gpa.free(after_tracked);
const after_sentinel = try readFile(gpa, io, outside, "sentinel");
defer gpa.free(after_sentinel);
try std.testing.expectEqualSlices(u8, before_log, after_log);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
try std.testing.expectEqualSlices(u8, before_sentinel, after_sentinel);
try expectCheckoutVersion(io, repo, current);
try expectManaged(gpa, io, repo, &.{"tracked.txt"});
}
}
test "cli update: a target F-card cannot replace a symlink with an outside target" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try tmp.dir.createDir(io, "repo", .default_dir);
try tmp.dir.createDir(io, "outside", .default_dir);
var repo = try tmp.dir.openDir(io, "repo", .{});
defer repo.close(io);
var outside = try tmp.dir.openDir(io, "outside", .{});
defer outside.close(io);
try initRepo(gpa, io, repo);
try writeFile(io, repo, "tracked.txt", "current\n");
try addManaged(gpa, io, repo, &.{"tracked.txt"});
var commit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "current" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
try writeFile(io, outside, "sentinel", "outside must survive\n");
try repo.symLink(io, "../outside/sentinel", "link", .{});
const payload = try appendArtifact(gpa, io, repo, "target content\n");
defer gpa.free(payload);
const files = [_]artifact.FCard{.{
.filename = "link",
.hash = payload,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const target = try appendDiffManifest(gpa, io, repo, "symlink target", null, &files);
defer gpa.free(target);
const before_checkout = try readFile(gpa, io, repo, ".zit-checkout");
defer gpa.free(before_checkout);
const before_managed = try readManagedImage(gpa, io, repo);
defer gpa.free(before_managed);
const before_tracked = try readFile(gpa, io, repo, "tracked.txt");
defer gpa.free(before_tracked);
const before_sentinel = try readFile(gpa, io, outside, "sentinel");
defer gpa.free(before_sentinel);
var update = try runZit(gpa, io, repo, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expectEqualStrings("", update.stdout);
const after_checkout = try readFile(gpa, io, repo, ".zit-checkout");
defer gpa.free(after_checkout);
const after_managed = try readManagedImage(gpa, io, repo);
defer gpa.free(after_managed);
const after_tracked = try readFile(gpa, io, repo, "tracked.txt");
defer gpa.free(after_tracked);
const after_link = try readFile(gpa, io, repo, "link");
defer gpa.free(after_link);
const after_sentinel = try readFile(gpa, io, outside, "sentinel");
defer gpa.free(after_sentinel);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
try std.testing.expectEqualSlices(u8, before_sentinel, after_link);
try std.testing.expectEqualSlices(u8, before_sentinel, after_sentinel);
try expectCheckoutVersion(io, repo, current);
try expectManaged(gpa, io, repo, &.{"tracked.txt"});
}
test "cli update: a symlink ancestor is rejected without following it outside the repository" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try tmp.dir.createDir(io, "repo", .default_dir);
try tmp.dir.createDir(io, "outside", .default_dir);
var repo = try tmp.dir.openDir(io, "repo", .{});
defer repo.close(io);
var outside = try tmp.dir.openDir(io, "outside", .{});
defer outside.close(io);
try initRepo(gpa, io, repo);
try writeFile(io, repo, "tracked.txt", "current\n");
try addManaged(gpa, io, repo, &.{"tracked.txt"});
var commit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "current" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
try writeFile(io, outside, "sentinel", "outside must survive\n");
try repo.symLink(io, "../outside", "link", .{});
const payload = try appendArtifact(gpa, io, repo, "target content\n");
defer gpa.free(payload);
const files = [_]artifact.FCard{.{
.filename = "link/sentinel",
.hash = payload,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const target = try appendDiffManifest(gpa, io, repo, "symlink ancestor", null, &files);
defer gpa.free(target);
const before_checkout = try readFile(gpa, io, repo, ".zit-checkout");
defer gpa.free(before_checkout);
const before_managed = try readManagedImage(gpa, io, repo);
defer gpa.free(before_managed);
const before_tracked = try readFile(gpa, io, repo, "tracked.txt");
defer gpa.free(before_tracked);
const before_sentinel = try readFile(gpa, io, outside, "sentinel");
defer gpa.free(before_sentinel);
var update = try runZit(gpa, io, repo, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expectEqualStrings("", update.stdout);
const after_checkout = try readFile(gpa, io, repo, ".zit-checkout");
defer gpa.free(after_checkout);
const after_managed = try readManagedImage(gpa, io, repo);
defer gpa.free(after_managed);
const after_tracked = try readFile(gpa, io, repo, "tracked.txt");
defer gpa.free(after_tracked);
const after_sentinel = try readFile(gpa, io, outside, "sentinel");
defer gpa.free(after_sentinel);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
try std.testing.expectEqualSlices(u8, before_sentinel, after_sentinel);
try expectCheckoutVersion(io, repo, current);
try expectManaged(gpa, io, repo, &.{"tracked.txt"});
}
test "cli update: file-to-directory transition round-trips through undo and redo" {
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, "node", "old file\n");
try addManaged(gpa, io, tmp.dir, &.{"node"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "file" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
const child_content = "new child\n";
const blob = try appendArtifact(gpa, io, tmp.dir, child_content);
defer gpa.free(blob);
const files = [_]artifact.FCard{.{
.filename = "node/child.txt",
.hash = blob,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const target = try appendDiffManifest(gpa, io, tmp.dir, "file to directory", null, &files);
defer gpa.free(target);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
const child = try readFile(gpa, io, tmp.dir, "node/child.txt");
defer gpa.free(child);
try std.testing.expectEqualStrings(child_content, child);
try expectCheckoutVersion(io, tmp.dir, target);
try expectManaged(gpa, io, tmp.dir, &.{"node/child.txt"});
var undo_res = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &undo_res);
try expectExit(undo_res.term, 0);
try expectNoDiagnostic(undo_res.stderr); // the receipt lives on stderr
const restored = try readFile(gpa, io, tmp.dir, "node");
defer gpa.free(restored);
try std.testing.expectEqualStrings("old file\n", restored);
try std.testing.expect(!fileExists(io, tmp.dir, "node/child.txt"));
try expectCheckoutVersion(io, tmp.dir, current);
try expectManaged(gpa, io, tmp.dir, &.{"node"});
var redo_res = try runZit(gpa, io, tmp.dir, &.{"redo"});
defer freeResult(gpa, &redo_res);
try expectExit(redo_res.term, 0);
try expectNoDiagnostic(redo_res.stderr); // the receipt lives on stderr
const redone = try readFile(gpa, io, tmp.dir, "node/child.txt");
defer gpa.free(redone);
try std.testing.expectEqualStrings(child_content, redone);
try expectCheckoutVersion(io, tmp.dir, target);
try expectManaged(gpa, io, tmp.dir, &.{"node/child.txt"});
}
test "cli update: a clean managed directory can become a 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);
try tmp.dir.createDir(io, "node", .default_dir);
try writeFile(io, tmp.dir, "node/child.txt", "old child\n");
try addManaged(gpa, io, tmp.dir, &.{"node/child.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "directory" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const file_content = "new file\n";
const blob = try appendArtifact(gpa, io, tmp.dir, file_content);
defer gpa.free(blob);
const files = [_]artifact.FCard{.{
.filename = "node",
.hash = blob,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const target = try appendDiffManifest(gpa, io, tmp.dir, "directory to file", null, &files);
defer gpa.free(target);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
const node = try readFile(gpa, io, tmp.dir, "node");
defer gpa.free(node);
try std.testing.expectEqualStrings(file_content, node);
try std.testing.expect(!fileExists(io, tmp.dir, "node/child.txt"));
try expectCheckoutVersion(io, tmp.dir, target);
try expectManaged(gpa, io, tmp.dir, &.{"node"});
}
test "cli update: directory-to-file transition undo/redo treats descendants below restored file as absent" {
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.createDir(io, "a", .default_dir);
try writeFile(io, tmp.dir, "a/b", "old child\n");
try addManaged(gpa, io, tmp.dir, &.{"a/b"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "directory" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
const file_content = "new file\n";
const blob = try appendArtifact(gpa, io, tmp.dir, file_content);
defer gpa.free(blob);
const files = [_]artifact.FCard{.{
.filename = "a",
.hash = blob,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const target = try appendDiffManifest(gpa, io, tmp.dir, "directory to file", null, &files);
defer gpa.free(target);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
try std.testing.expect(sectionExists(gpa, io, tmp.dir, .undo));
var undo_res = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &undo_res);
try expectExit(undo_res.term, 0);
try std.testing.expect(std.mem.endsWith(u8, undo_res.stdout, "undo: working tree restored\n"));
try expectNoDiagnostic(undo_res.stderr); // the receipt lives on stderr
const restored = try readFile(gpa, io, tmp.dir, "a/b");
defer gpa.free(restored);
try std.testing.expectEqualStrings("old child\n", restored);
try expectCheckoutVersion(io, tmp.dir, current);
try expectManaged(gpa, io, tmp.dir, &.{"a/b"});
var redo_res = try runZit(gpa, io, tmp.dir, &.{"redo"});
defer freeResult(gpa, &redo_res);
try expectExit(redo_res.term, 0);
try std.testing.expect(std.mem.endsWith(u8, redo_res.stdout, "redo: working tree restored\n"));
try expectNoDiagnostic(redo_res.stderr); // the receipt lives on stderr
const redone = try readFile(gpa, io, tmp.dir, "a");
defer gpa.free(redone);
try std.testing.expectEqualStrings(file_content, redone);
try std.testing.expect(!fileExists(io, tmp.dir, "a/b"));
try expectCheckoutVersion(io, tmp.dir, target);
try expectManaged(gpa, io, tmp.dir, &.{"a"});
try std.testing.expect(sectionExists(gpa, io, tmp.dir, .undo));
var second_redo = try runZit(gpa, io, tmp.dir, &.{"redo"});
defer freeResult(gpa, &second_redo);
try expectExit(second_redo.term, 1);
try std.testing.expectEqualStrings("", second_redo.stdout);
try std.testing.expectEqualStrings("zit redo: nothing to redo\n", second_redo.stderr);
const final_content = try readFile(gpa, io, tmp.dir, "a");
defer gpa.free(final_content);
try std.testing.expectEqualSlices(u8, redone, final_content);
}
test "cli update: an unmanaged descendant blocks a directory-to-file transition without mutation" {
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.createDir(io, "node", .default_dir);
try writeFile(io, tmp.dir, "node/tracked.txt", "managed child\n");
try addManaged(gpa, io, tmp.dir, &.{"node/tracked.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "directory" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
try writeFile(io, tmp.dir, "node/unmanaged.txt", "must survive\n");
const blob = try appendArtifact(gpa, io, tmp.dir, "would replace directory\n");
defer gpa.free(blob);
const files = [_]artifact.FCard{.{
.filename = "node",
.hash = blob,
.perm = null,
.old_name = null,
.mode = .regular,
}};
const target = try appendDiffManifest(gpa, io, tmp.dir, "blocked directory to file", null, &files);
defer gpa.free(target);
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);
const before_tracked = try readFile(gpa, io, tmp.dir, "node/tracked.txt");
defer gpa.free(before_tracked);
const before_unmanaged = try readFile(gpa, io, tmp.dir, "node/unmanaged.txt");
defer gpa.free(before_unmanaged);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expectEqualStrings("", update.stdout);
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);
const after_tracked = try readFile(gpa, io, tmp.dir, "node/tracked.txt");
defer gpa.free(after_tracked);
const after_unmanaged = try readFile(gpa, io, tmp.dir, "node/unmanaged.txt");
defer gpa.free(after_unmanaged);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
try std.testing.expectEqualSlices(u8, before_unmanaged, after_unmanaged);
try expectCheckoutVersion(io, tmp.dir, current);
try expectManaged(gpa, io, tmp.dir, &.{"node/tracked.txt"});
}
test "cli update: an executable F-card materializes an executable regular file" {
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);
try writeFile(io, tmp.dir, "script", "old\n");
try addManaged(gpa, io, tmp.dir, &.{"script"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "regular" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const script_content = "#!/bin/sh\necho updated\n";
const blob = try appendArtifact(gpa, io, tmp.dir, script_content);
defer gpa.free(blob);
const files = [_]artifact.FCard{.{
.filename = "script",
.hash = blob,
.perm = "x",
.old_name = null,
.mode = .executable,
}};
const target = try appendDiffManifest(gpa, io, tmp.dir, "executable target", null, &files);
defer gpa.free(target);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
const script = try readFile(gpa, io, tmp.dir, "script");
defer gpa.free(script);
try std.testing.expectEqualStrings(script_content, script);
var script_file = try tmp.dir.openFile(io, "script", .{ .mode = .read_only });
defer script_file.close(io);
try std.testing.expect((try script_file.stat(io)).permissions.toMode() & 0o111 != 0);
try expectCheckoutVersion(io, tmp.dir, target);
try expectManaged(gpa, io, tmp.dir, &.{"script"});
}
test "cli update: a locally added file rides across the move" {
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", "earlier\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
defer freeResult(gpa, &root_commit);
try expectExit(root_commit.term, 0);
const root = try checkinHash(root_commit.stdout);
try writeFile(io, tmp.dir, "tracked.txt", "later\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
try writeFile(io, tmp.dir, "added.txt", "new membership\n");
try addManaged(gpa, io, tmp.dir, &.{"added.txt"});
// `added.txt` exists on neither check-in, so no side of the merge has an
// opinion about it and it simply stays — staged, with its content intact.
// Membership drift used to be a flat refusal.
var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try std.testing.expect(std.mem.indexOf(u8, update.stdout, "carried 1 local change") != null);
try expectCheckoutVersion(io, tmp.dir, root);
const after_added = try readFile(gpa, io, tmp.dir, "added.txt");
defer gpa.free(after_added);
try std.testing.expectEqualStrings("new membership\n", after_added);
// The clean file took the target's content, exactly as a clean update.
const after_tracked = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after_tracked);
try std.testing.expectEqualStrings("earlier\n", after_tracked);
try expectManaged(gpa, io, tmp.dir, &.{ "added.txt", "tracked.txt" });
}
test "cli update: with no CHECKIN a bare update moves to the current branch's newest check-in, as Fossil's does" {
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", "one\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c1" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
const c1_hash = try checkinHash(c1.stdout);
try writeFile(io, tmp.dir, "a", "two\n");
var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c2" });
defer freeResult(gpa, &c2);
try expectExit(c2.term, 0);
const c2_hash = try checkinHash(c2.stdout);
var back = try runZit(gpa, io, tmp.dir, &.{ "update", c1_hash });
defer freeResult(gpa, &back);
try expectExitDiag(back.term, 0, back);
try expectFileContent(gpa, io, tmp.dir, "a", "one\n");
var bare = try runZit(gpa, io, tmp.dir, &.{"update"});
defer freeResult(gpa, &bare);
try expectExitDiag(bare.term, 0, bare);
try expectFileContent(gpa, io, tmp.dir, "a", "two\n");
var st = try runZit(gpa, io, tmp.dir, &.{"status"});
defer freeResult(gpa, &st);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, cli.shortHash(c2_hash)) != null);
}
test "cli update: a missing managed file preserves the current checkout" {
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", "earlier\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
defer freeResult(gpa, &root_commit);
try expectExit(root_commit.term, 0);
const root = try checkinHash(root_commit.stdout);
try writeFile(io, tmp.dir, "tracked.txt", "later\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
const child = try checkinHash(child_commit.stdout);
try tmp.dir.deleteFile(io, "tracked.txt");
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 update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expectEqualStrings("", update.stdout);
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_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expect(!fileExists(io, tmp.dir, "tracked.txt"));
try expectCheckoutVersion(io, tmp.dir, child);
try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}
test "cli update: executable-mode drift is carried onto the new content" {
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);
try writeFile(io, tmp.dir, "script", "earlier\n");
try addManaged(gpa, io, tmp.dir, &.{"script"});
var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
defer freeResult(gpa, &root_commit);
try expectExit(root_commit.term, 0);
const root = try checkinHash(root_commit.stdout);
try writeFile(io, tmp.dir, "script", "later\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
{
var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_write });
defer script.close(io);
try script.setPermissions(io, File.Permissions.executable_file);
}
// The bytes are unchanged locally, so the target's content wins; the local
// MODE is the local change, and B-merge-23 keeps the working file's side of
// it. Mode drift used to refuse the update outright.
var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &update);
try expectExit(update.term, 0);
try expectCheckoutVersion(io, tmp.dir, root);
const after_script = try readFile(gpa, io, tmp.dir, "script");
defer gpa.free(after_script);
try std.testing.expectEqualStrings("earlier\n", after_script);
var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_only });
defer script.close(io);
try std.testing.expect((try script.stat(io)).permissions.toMode() & 0o111 != 0);
try expectManaged(gpa, io, tmp.dir, &.{"script"});
}
test "cli update: managed type drift preserves the current checkout" {
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", "earlier\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked"});
var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
defer freeResult(gpa, &root_commit);
try expectExit(root_commit.term, 0);
const root = try checkinHash(root_commit.stdout);
try writeFile(io, tmp.dir, "tracked", "later\n");
var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
defer freeResult(gpa, &child_commit);
try expectExit(child_commit.term, 0);
const child = try checkinHash(child_commit.stdout);
try tmp.dir.deleteFile(io, "tracked");
try tmp.dir.createDir(io, "tracked", .default_dir);
try writeFile(io, tmp.dir, "tracked/nested.txt", "type drift\n");
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);
const before_nested = try readFile(gpa, io, tmp.dir, "tracked/nested.txt");
defer gpa.free(before_nested);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expectEqualStrings("", update.stdout);
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);
const after_nested = try readFile(gpa, io, tmp.dir, "tracked/nested.txt");
defer gpa.free(after_nested);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expectEqualSlices(u8, before_nested, after_nested);
try expectCheckoutVersion(io, tmp.dir, child);
try expectManaged(gpa, io, tmp.dir, &.{"tracked"});
}
test "cli update: unresolvable check-in names do not mutate a repository" {
const gpa = std.testing.allocator;
const io = std.testing.io;
const Case = struct {
id: []const u8,
diagnostic: []const u8,
};
const cases = [_]Case{
// CHANGED EXPECTATION (was "invalid check-in ID"): SF1 made `update`'s
// argument a check-in NAME resolved through the shared §8.3 procedure,
// so a non-hex string is no longer malformed by construction — it is a
// symbolic name that resolves to nothing. The property this test exists
// for is unchanged and still asserted below: exit 1, a `zit update: `
// diagnostic, and a byte-identical repository.
.{ .id = "not-an-id", .diagnostic = "not found" },
.{
.id = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
.diagnostic = "not found",
},
};
inline for (cases) |case| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "tracked.txt", "current\n");
try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "current" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const current = try checkinHash(commit.stdout);
const before_log = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(before_log);
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);
const before_tracked = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(before_tracked);
var update = try runZit(gpa, io, tmp.dir, &.{ "update", case.id });
defer freeResult(gpa, &update);
try expectExit(update.term, 1);
try std.testing.expectEqualStrings("", update.stdout);
try std.testing.expect(std.mem.startsWith(u8, update.stderr, "zit update: "));
try std.testing.expect(std.mem.indexOf(u8, update.stderr, case.diagnostic) != null);
try std.testing.expect(std.mem.endsWith(u8, update.stderr, "\n"));
const after_log = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(after_log);
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);
const after_tracked = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after_tracked);
try std.testing.expectEqualSlices(u8, before_log, after_log);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
try std.testing.expectEqualSlices(u8, before_managed, after_managed);
try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
try expectCheckoutVersion(io, tmp.dir, current);
try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}
}
test "cli update: direct and routed help agree, and missing, extra, and invalid arguments are usage errors" {
const gpa = std.testing.allocator;
const io = std.testing.io;
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var direct = try runZit(gpa, io, tmp.dir, &.{ "update", "--help" });
defer freeResult(gpa, &direct);
try expectExit(direct.term, 0);
try std.testing.expect(std.mem.startsWith(u8, direct.stdout, "usage: zit update "));
try std.testing.expectEqualStrings("", direct.stderr);
var routed = try runZit(gpa, io, tmp.dir, &.{ "help", "update" });
defer freeResult(gpa, &routed);
try expectExit(routed.term, 0);
try std.testing.expectEqualSlices(u8, direct.stdout, routed.stdout);
try std.testing.expectEqualStrings("", routed.stderr);
}
const Case = struct {
argv: []const []const u8,
stderr: []const u8,
};
const cases = [_]Case{
.{
.argv = &.{ "update", "a", "extra" },
.stderr = "zit update: unexpected argument 'extra'\ntry 'zit update --help'\n",
},
.{
.argv = &.{ "update", "-x" },
.stderr = "zit update: unknown option '-x'\ntry 'zit update --help'\n",
},
};
inline for (cases) |case| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var res = try runZit(gpa, io, tmp.dir, case.argv);
defer freeResult(gpa, &res);
try expectExit(res.term, 2);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings(case.stderr, res.stderr);
}
}
test "cli update --cone widens a sparse store through the saved remote" {
// Sparse-cone RFC section 6.4, update's half: widening the cone past the
// store's holdings rewrites store policy and pulls the newly covered
// content; --dense densifies the same way. The narrow request needs no
// fetch at all.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try tmp_a.dir.createDir(io, "src", .default_dir);
try tmp_a.dir.createDir(io, "tools", .default_dir);
try tmp_a.dir.createDir(io, "docs", .default_dir);
try writeFile(io, tmp_a.dir, "src/a.zig", "src\n");
try writeFile(io, tmp_a.dir, "tools/t.bin", "tools\n");
try writeFile(io, tmp_a.dir, "docs/d.md", "docs\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.bin", "docs/d.md" });
const head = try commitHashDup(gpa, io, tmp_a.dir, "seed");
defer gpa.free(head);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--no-open", "--cone=src", url, "repo" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
defer b_dir.close(io);
var op = try runZit(gpa, io, b_dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &op);
try expectExitDiag(op.term, 0, op);
try std.testing.expect(!fileExists(io, b_dir, "tools/t.bin"));
// Widen: src -> src+tools. The store lacks tools' blob; the fetch fires.
var widen = try runZit(gpa, io, b_dir, &.{ "update", "--cone=src", "--cone=tools", head });
defer freeResult(gpa, &widen);
try expectExitDiag(widen.term, 0, widen);
try std.testing.expect(std.mem.indexOf(u8, widen.stderr, "fetching from the saved remote") != null);
const tools_content = try readFile(gpa, io, b_dir, "tools/t.bin");
defer gpa.free(tools_content);
try std.testing.expectEqualStrings("tools\n", tools_content);
try std.testing.expect(!fileExists(io, b_dir, "docs/d.md")); // still outside the cone
// Densify: --dense fetches the remainder.
var dense = try runZit(gpa, io, b_dir, &.{ "update", "--dense", head });
defer freeResult(gpa, &dense);
try expectExitDiag(dense.term, 0, dense);
const docs_content = try readFile(gpa, io, b_dir, "docs/d.md");
defer gpa.free(docs_content);
try std.testing.expectEqualStrings("docs\n", docs_content);
}
test "cli update: the receipt names every moved file and the check-ins, -n changes nothing, --latest names the branch tip" {
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, "gone.txt", "x\n");
try addManaged(gpa, io, tmp.dir, &.{ "a.txt", "gone.txt" });
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
defer freeResult(gpa, &c1);
try expectExitDiag(c1.term, 0, c1);
const base = try checkinHash(c1.stdout);
try writeFile(io, tmp.dir, "a.txt", "two\n");
try writeFile(io, tmp.dir, "new.txt", "n\n");
var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "--hard", "gone.txt" });
defer freeResult(gpa, &rm);
try expectExitDiag(rm.term, 0, rm);
try addManaged(gpa, io, tmp.dir, &.{"new.txt"});
var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
defer freeResult(gpa, &c2);
try expectExitDiag(c2.term, 0, c2);
const second = try checkinHash(c2.stdout);
// Dry run: the same receipt, nothing written.
var dry = try runZit(gpa, io, tmp.dir, &.{ "update", "-n", base });
defer freeResult(gpa, &dry);
try expectExitDiag(dry.term, 0, dry);
try std.testing.expectEqualStrings("", dry.stdout);
try std.testing.expect(std.mem.indexOf(u8, dry.stderr, "UPDATE a.txt\nADD gone.txt\nREMOVE new.txt\n") != null);
try std.testing.expect(std.mem.indexOf(u8, dry.stderr, "(dry run: nothing was changed)") != null);
const nt = try readFile(gpa, io, tmp.dir, "new.txt"); // still there, untouched
defer gpa.free(nt);
try std.testing.expectEqualStrings("n\n", nt);
var still = try runZit(gpa, io, tmp.dir, &.{"status"});
defer freeResult(gpa, &still);
try std.testing.expect(std.mem.indexOf(u8, still.stdout, cli.shortHash(second)) != null);
// The real move: per-file lines, the from/to block, the undo hint — all on stderr.
var up = try runZit(gpa, io, tmp.dir, &.{ "update", base });
defer freeResult(gpa, &up);
try expectExitDiag(up.term, 0, up);
try std.testing.expectEqualStrings("", up.stdout);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, "UPDATE a.txt\nADD gone.txt\nREMOVE new.txt\n") != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, "updated-from: " ++ "") != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, second[0..12]) != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, "updated-to: ") != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, base[0..12]) != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, "tags: trunk") != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, "comment: base (user: u)") != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, "changes: 1 file modified, 1 added, 1 removed.") != null);
try std.testing.expect(std.mem.indexOf(u8, up.stderr, "\"zit undo\" is available") != null);
// Already there: the block says so, no per-file lines, no undo hint.
var noop = try runZit(gpa, io, tmp.dir, &.{ "update", base });
defer freeResult(gpa, &noop);
try expectExitDiag(noop.term, 0, noop);
try std.testing.expect(std.mem.indexOf(u8, noop.stderr, "changes: none. Already up-to-date.") != null);
try std.testing.expect(std.mem.indexOf(u8, noop.stderr, "UPDATE") == null);
try std.testing.expect(std.mem.indexOf(u8, noop.stderr, "zit undo") == null);
// --latest: the branch tip, by name, in place of CHECKIN; -v lists the unchanged.
var latest = try runZit(gpa, io, tmp.dir, &.{ "update", "--latest", "-v" });
defer freeResult(gpa, &latest);
try expectExitDiag(latest.term, 0, latest);
try std.testing.expect(std.mem.indexOf(u8, latest.stderr, "updated-to: " ++ "") != null);
try std.testing.expect(std.mem.indexOf(u8, latest.stderr, second[0..12]) != null);
try std.testing.expect(std.mem.indexOf(u8, latest.stderr, "UPDATE a.txt") != null);
var both = try runZit(gpa, io, tmp.dir, &.{ "update", "--latest", base });
defer freeResult(gpa, &both);
try expectExit(both.term, 2);
// A carried local edit is reported as MERGE (or CONFLICT when the
// three-way merge cannot decide); either way the receipt names it.
try writeFile(io, tmp.dir, "a.txt", "two\nlocal\n");
var carried = try runZit(gpa, io, tmp.dir, &.{ "update", base });
defer freeResult(gpa, &carried);
switch (carried.term) {
.exited => |c| try std.testing.expect(c == 0 or c == 1),
else => return error.TestUnexpectedExitCode,
}
try std.testing.expect(std.mem.indexOf(u8, carried.stderr, "MERGE a.txt") != null or std.mem.indexOf(u8, carried.stderr, "CONFLICT a.txt") != null);
try std.testing.expect(std.mem.indexOf(u8, carried.stderr, "\"zit undo\" is available") != null);
}