const std = @import("std");
const checkout = @import("zit").checkout;
const support = @import("support.zig");
const buildMergeFan = support.buildMergeFan;
const commitFile = support.commitFile;
const commitHashDup = support.commitHashDup;
const corruptSection = support.corruptSection;
const expectCheckoutVersion = support.expectCheckoutVersion;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectManaged = support.expectManaged;
const expectNoDiagnostic = support.expectNoDiagnostic;
const freeResult = support.freeResult;
const initRepo = support.initRepo;
const parentCards = support.parentCards;
const readFile = support.readFile;
const runShell = support.runShell;
const runZit = support.runZit;
const sectionExists = support.sectionExists;
const statusMergeLines = support.statusMergeLines;
const writeFile = support.writeFile;
test "cli undo: undoing a stacked merge leaves the first merge pending; redo restacks it" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fan = try buildMergeFan(gpa, io, tmp.dir);
defer fan.deinit(gpa);
var first = try runZit(gpa, io, tmp.dir, &.{ "merge", fan.x });
defer freeResult(gpa, &first);
try expectExitDiag(first.term, 0, first);
var second = try runZit(gpa, io, tmp.dir, &.{ "merge", fan.y });
defer freeResult(gpa, &second);
try expectExitDiag(second.term, 0, second);
var un = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un);
try expectExitDiag(un.term, 0, un);
{
const b = try readFile(gpa, io, tmp.dir, "b");
defer gpa.free(b);
try std.testing.expectEqualStrings("b", b); // the first merge stands
const c = try readFile(gpa, io, tmp.dir, "c");
defer gpa.free(c);
try std.testing.expectEqualStrings("base\n", c); // the second is gone
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
const want = try std.fmt.allocPrint(gpa, "MERGED_WITH {s}\n", .{fan.x});
defer gpa.free(want);
try std.testing.expectEqualStrings(want, listed);
}
var re = try runZit(gpa, io, tmp.dir, &.{"redo"});
defer freeResult(gpa, &re);
try expectExitDiag(re.term, 0, re);
const c = try readFile(gpa, io, tmp.dir, "c");
defer gpa.free(c);
try std.testing.expectEqualStrings("c", c);
const merged = try commitHashDup(gpa, io, tmp.dir, "after redo");
defer gpa.free(merged);
const cards = try parentCards(gpa, io, tmp.dir, merged);
defer gpa.free(cards);
const want = try std.fmt.allocPrint(gpa, "P {s} {s} {s}\n", .{ fan.current, fan.x, fan.y });
defer gpa.free(want);
try std.testing.expectEqualStrings(want, cards);
}
// ==========================================================================
// `zit undo` / `zit redo` — single-level undo/redo (contracts/undo.md). The
// real binary is driven end to end; state is read back through the library.
// ==========================================================================
const undo_help_text =
\\usage: zit undo [-n|--dry-run] [-h|--help]
\\
\\Undo the last working-file change made by 'zit update' or 'zit revert',
\\restoring every affected file and the checkout record to their state before
\\that change. Single level: only the most recent change can be undone; a second
\\'zit undo' in a row has nothing left to undo.
\\
\\Use 'zit redo' to reapply a change you just undid. A new update or revert
\\clears the redo slot.
\\
\\options:
\\ -n, --dry-run name the files (and the checkout record) a undo would
\\ restore; change nothing
\\ -h, --help show this help and exit
\\
\\exit status:
\\ 0 the change was undone
\\ 1 nothing to undo, the journal is damaged, or this is not a zit repository
\\ 2 usage error (an unknown option or an unexpected argument)
\\
;
const redo_help_text =
\\usage: zit redo [-n|--dry-run] [-h|--help]
\\
\\Reapply the change you just undid with 'zit undo', restoring every affected
\\file and the checkout record to their state after that change. Single level:
\\redo is available only immediately after an undo; a new update or revert
\\clears it.
\\
\\options:
\\ -n, --dry-run name the files (and the checkout record) a redo would
\\ restore; change nothing
\\ -h, --help show this help and exit
\\
\\exit status:
\\ 0 the change was reapplied
\\ 1 nothing to redo, the journal is damaged, or this is not a zit repository
\\ 2 usage error (an unknown option or an unexpected argument)
\\
;
test "cli undo B-undo-1: update then undo restores working files and .zit-checkout byte-for-byte" {
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 root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
const root = try commitFile(gpa, io, tmp.dir, "tracked.txt", "earlier\n", "earlier", &root_c);
var child_c: std.process.RunResult = undefined;
defer freeResult(gpa, &child_c);
_ = try commitFile(gpa, io, tmp.dir, "tracked.txt", "later\n", "later", &child_c);
// Pre-update state (the child checkout): the exact bytes undo must
// restore. The checkout RECORD, not the container file — the container
// legitimately differs afterwards (its undo section then holds the redo
// image).
const before_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(before_content);
const before_checkout = (try checkout.readSectionAlloc(gpa, io, tmp.dir, .checkout)).?;
defer gpa.free(before_checkout);
var upd = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &upd);
try expectExit(upd.term, 0);
try expectCheckoutVersion(io, tmp.dir, root);
var un = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un);
try expectExit(un.term, 0);
try std.testing.expect(std.mem.endsWith(u8, un.stdout, "undo: working tree restored\n"));
try std.testing.expectEqualStrings("", un.stderr);
const after_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after_content);
const after_checkout = (try checkout.readSectionAlloc(gpa, io, tmp.dir, .checkout)).?;
defer gpa.free(after_checkout);
try std.testing.expectEqualStrings("later\n", after_content);
try std.testing.expectEqualSlices(u8, before_content, after_content);
try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
}
test "cli undo B-undo-2: revert then undo recovers the discarded working bytes" {
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 c: std.process.RunResult = undefined;
defer freeResult(gpa, &c);
_ = try commitFile(gpa, io, tmp.dir, "f.txt", "v1\n", "v1", &c);
// A dirty working edit revert will discard.
try writeFile(io, tmp.dir, "f.txt", "edited\n");
var rev = try runZit(gpa, io, tmp.dir, &.{"revert"});
defer freeResult(gpa, &rev);
try expectExit(rev.term, 0);
{
const restored = try readFile(gpa, io, tmp.dir, "f.txt");
defer gpa.free(restored);
try std.testing.expectEqualStrings("v1\n", restored); // revert restored the blob
}
var un = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un);
try expectExit(un.term, 0);
try std.testing.expect(std.mem.endsWith(u8, un.stdout, "undo: working tree restored\n"));
const recovered = try readFile(gpa, io, tmp.dir, "f.txt");
defer gpa.free(recovered);
try std.testing.expectEqualStrings("edited\n", recovered); // discarded edit recovered
}
test "cli undo B-undo-6: a second consecutive undo is exit 1, mutating nothing" {
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 root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
const root = try commitFile(gpa, io, tmp.dir, "tracked.txt", "earlier\n", "earlier", &root_c);
var child_c: std.process.RunResult = undefined;
defer freeResult(gpa, &child_c);
_ = try commitFile(gpa, io, tmp.dir, "tracked.txt", "later\n", "later", &child_c);
var upd = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &upd);
try expectExit(upd.term, 0);
var un1 = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un1);
try expectExit(un1.term, 0);
const after_first = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after_first);
var un2 = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un2);
try expectExit(un2.term, 1);
try std.testing.expectEqualStrings("", un2.stdout);
try std.testing.expectEqualStrings("zit undo: nothing to undo\n", un2.stderr);
const after_second = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after_second);
try std.testing.expectEqualSlices(u8, after_first, after_second); // no mutation
}
test "cli undo B-undo-8: with two updates, undo restores the last one's pre-image, not the earlier" {
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 root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
const root = try commitFile(gpa, io, tmp.dir, "tracked.txt", "earlier\n", "earlier", &root_c);
var child_c: std.process.RunResult = undefined;
defer freeResult(gpa, &child_c);
const child = try commitFile(gpa, io, tmp.dir, "tracked.txt", "later\n", "later", &child_c);
// update A (-> root/"earlier"), then update B (-> child/"later").
var ua = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &ua);
try expectExit(ua.term, 0);
var ub = try runZit(gpa, io, tmp.dir, &.{ "update", child });
defer freeResult(gpa, &ub);
try expectExit(ub.term, 0);
// undo restores B's pre-image (the post-A tree: "earlier"/root), NOT A's.
var un = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un);
try expectExit(un.term, 0);
const content = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(content);
try std.testing.expectEqualStrings("earlier\n", content);
try expectCheckoutVersion(io, tmp.dir, root);
}
test "cli undo B-undo-9: an empty journal is exit 1, stdout empty, no 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);
var res = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit undo: nothing to undo\n", res.stderr);
try std.testing.expect(!sectionExists(gpa, io, tmp.dir, .undo));
}
test "cli undo B-undo-11: a corrupt .zit-undo is exit 1 with no partial restore" {
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 root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
const root = try commitFile(gpa, io, tmp.dir, "tracked.txt", "earlier\n", "earlier", &root_c);
var child_c: std.process.RunResult = undefined;
defer freeResult(gpa, &child_c);
_ = try commitFile(gpa, io, tmp.dir, "tracked.txt", "later\n", "later", &child_c);
var upd = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &upd);
try expectExit(upd.term, 0);
const before = try readFile(gpa, io, tmp.dir, "tracked.txt"); // "earlier\n"
defer gpa.free(before);
// Overwrite the journal with garbage.
try corruptSection(io, tmp.dir, .undo);
var un = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un);
try expectExit(un.term, 1);
try std.testing.expectEqualStrings("", un.stdout);
try std.testing.expectEqualStrings("zit undo: the undo journal is damaged\n", un.stderr);
const after = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(after);
try std.testing.expectEqualSlices(u8, before, after); // byte-identical, no partial restore
}
test "cli undo B-undo-13: the journal's home '.zit-checkout' is refused; the retired name '.zit-undo' is ordinary content" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// The journal lives in the container now; that name stays untrackable.
var res = try runZit(gpa, io, tmp.dir, &.{ "add", ".zit-checkout" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings(
"zit add: '.zit-checkout' is a zit control file and cannot be tracked\n",
res.stderr,
);
// The legacy sibling name lost its reservation with the legacy tier: a
// user file spelled '.zit-undo' is admissible working-tree content (the
// container's fold never reads it once a container exists).
try writeFile(io, tmp.dir, ".zit-undo", "just a file\n");
var add = try runZit(gpa, io, tmp.dir, &.{ "add", ".zit-undo" });
defer freeResult(gpa, &add);
try expectExit(add.term, 0);
try expectManaged(gpa, io, tmp.dir, &.{".zit-undo"});
}
test "cli undo B-undo-14: update leaves its output/exit unchanged and the journal is invisible in its output" {
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 root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
const root = try commitFile(gpa, io, tmp.dir, "tracked.txt", "earlier\n", "earlier", &root_c);
var child_c: std.process.RunResult = undefined;
defer freeResult(gpa, &child_c);
_ = try commitFile(gpa, io, tmp.dir, "tracked.txt", "later\n", "later", &child_c);
var upd = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &upd);
try expectExit(upd.term, 0);
try std.testing.expectEqualStrings("", upd.stdout); // update's happy path is silent, as today
try expectNoDiagnostic(upd.stderr); // the receipt lives on stderr
// The one new observable: the journal exists, and update never named it.
try std.testing.expect(sectionExists(gpa, io, tmp.dir, .undo));
try std.testing.expect(std.mem.indexOf(u8, upd.stdout, ".zit-undo") == null);
try std.testing.expect(std.mem.indexOf(u8, upd.stderr, ".zit-undo") == null);
}
test "cli undo B-undo-15: update with no undo invoked reproduces today's tree and 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);
var root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
const root = try commitFile(gpa, io, tmp.dir, "tracked.txt", "earlier\n", "earlier", &root_c);
var child_c: std.process.RunResult = undefined;
defer freeResult(gpa, &child_c);
_ = try commitFile(gpa, io, tmp.dir, "tracked.txt", "later\n", "later", &child_c);
var upd = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &upd);
try expectExit(upd.term, 0);
// Exactly today's observable result (matches the pre-journal update e2e).
const content = try readFile(gpa, io, tmp.dir, "tracked.txt");
defer gpa.free(content);
try std.testing.expectEqualStrings("earlier\n", content);
try expectCheckoutVersion(io, tmp.dir, root);
try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}
test "cli undo B-undo-16: undo/redo -h/--help print the verbatim help to stdout, exit 0" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
const cases = [_]struct { verb: []const u8, text: []const u8 }{
.{ .verb = "undo", .text = undo_help_text },
.{ .verb = "redo", .text = redo_help_text },
};
for (cases) |case| {
for ([_][]const u8{ "--help", "-h" }) |flag| {
var res = try runZit(gpa, io, tmp.dir, &.{ case.verb, flag });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings(case.text, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
// `-h` wins over an otherwise-invalid trailing token.
var win = try runZit(gpa, io, tmp.dir, &.{ case.verb, "-h", "bogus" });
defer freeResult(gpa, &win);
try expectExit(win.term, 0);
try std.testing.expectEqualStrings(case.text, win.stdout);
// `zit help <verb>` teaches identical text (DX D4).
var routed = try runZit(gpa, io, tmp.dir, &.{ "help", case.verb });
defer freeResult(gpa, &routed);
try expectExit(routed.term, 0);
try std.testing.expectEqualStrings(case.text, routed.stdout);
}
}
test "cli undo B-undo-17: an unknown option is a usage error (exit 2, stderr try-help, no journal read)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
const cases = [_]struct { verb: []const u8, arg: []const u8 }{
.{ .verb = "undo", .arg = "--force" },
.{ .verb = "redo", .arg = "-x" },
};
for (cases) |case| {
var res = try runZit(gpa, io, tmp.dir, &.{ case.verb, case.arg });
defer freeResult(gpa, &res);
try expectExit(res.term, 2);
try std.testing.expectEqualStrings("", res.stdout);
var buf: [128]u8 = undefined;
const expected = try std.fmt.bufPrint(&buf, "zit {s}: unknown option '{s}'\ntry 'zit {s} --help'\n", .{ case.verb, case.arg, case.verb });
try std.testing.expectEqualStrings(expected, res.stderr);
}
}
test "cli undo B-undo-18: a positional or token after '--' is a usage error (exit 2)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// A bare positional, and a token after `--`, both reject with the try-help line.
const cases = [_]struct { verb: []const u8, args: []const []const u8, tok: []const u8 }{
.{ .verb = "undo", .args = &.{ "undo", "foo" }, .tok = "foo" },
.{ .verb = "redo", .args = &.{ "redo", "--", "3" }, .tok = "3" },
};
for (cases) |case| {
var res = try runZit(gpa, io, tmp.dir, case.args);
defer freeResult(gpa, &res);
try expectExit(res.term, 2);
try std.testing.expectEqualStrings("", res.stdout);
var buf: [128]u8 = undefined;
const expected = try std.fmt.bufPrint(&buf, "zit {s}: unexpected argument '{s}'\ntry 'zit {s} --help'\n", .{ case.verb, case.tok, case.verb });
try std.testing.expectEqualStrings(expected, res.stderr);
}
}
test "cli undo B-undo-19: outside a repository is exit 1, stdout empty" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
for ([_][]const u8{ "undo", "redo" }) |verb| {
var res = try runZit(gpa, io, tmp.dir, &.{verb});
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "no zit checkout here") != null);
}
}
test "cli undo B-undo-20: a redirected undo keeps stdout and stderr unmixed" {
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 root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
const root = try commitFile(gpa, io, tmp.dir, "tracked.txt", "earlier\n", "earlier", &root_c);
var child_c: std.process.RunResult = undefined;
defer freeResult(gpa, &child_c);
_ = try commitFile(gpa, io, tmp.dir, "tracked.txt", "later\n", "later", &child_c);
var upd = try runZit(gpa, io, tmp.dir, &.{ "update", root });
defer freeResult(gpa, &upd);
try expectExit(upd.term, 0);
// Success row to stdout only; the failed second undo's diagnostic to stderr
// only — the two files never cross-contaminate.
var sh = try runShell(gpa, io, tmp.dir, "\"$ZIT\" undo >out.txt 2>err.txt; \"$ZIT\" undo >out2.txt 2>err2.txt");
defer freeResult(gpa, &sh);
const out = try readFile(gpa, io, tmp.dir, "out.txt");
defer gpa.free(out);
const err = try readFile(gpa, io, tmp.dir, "err.txt");
defer gpa.free(err);
try std.testing.expect(std.mem.endsWith(u8, out, "undo: working tree restored\n"));
try std.testing.expectEqualStrings("", err);
const out2 = try readFile(gpa, io, tmp.dir, "out2.txt");
defer gpa.free(out2);
const err2 = try readFile(gpa, io, tmp.dir, "err2.txt");
defer gpa.free(err2);
try std.testing.expectEqualStrings("", out2);
try std.testing.expectEqualStrings("zit undo: nothing to undo\n", err2);
}
test "cli undo B-undo-21: undo and redo are listed in the top-level help" {
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, &.{"help"});
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "\n undo undo the last update or revert\n") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "\n redo reapply an undone change\n") != null);
}