const std = @import("std");
const support = @import("support.zig");
const addManaged = support.addManaged;
const commitFile = support.commitFile;
const expectExit = support.expectExit;
const freeResult = support.freeResult;
const initRepo = support.initRepo;
const readFile = support.readFile;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const writeFile = support.writeFile;
// ---------------------------------------------------------------------------
// zit checkpoint: the durable rebuild checkpoint's CLI surface, driven over
// real fixture repositories through the built binary.
// ---------------------------------------------------------------------------
test "cli checkpoint: help exits 0, usage errors exit 2, and show reports absence" {
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 help = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "--help" });
defer freeResult(gpa, &help);
try expectExit(help.term, 0);
try std.testing.expect(std.mem.indexOf(u8, help.stdout, "usage: zit checkpoint") != null);
var bad = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "--bogus" });
defer freeResult(gpa, &bad);
try expectExit(bad.term, 2);
var extra = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "verify", "deadbeef" });
defer freeResult(gpa, &extra);
try expectExit(extra.term, 2);
var show = try runZit(gpa, io, tmp.dir, &.{"checkpoint"});
defer freeResult(gpa, &show);
try expectExit(show.term, 0);
try std.testing.expect(std.mem.indexOf(u8, show.stdout, "none") != null);
}
test "cli checkpoint: witness build on an emission-off repository leaves .zit byte-identical, then verify and drop close the loop" {
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 c1: std.process.RunResult = undefined;
defer freeResult(gpa, &c1);
_ = try commitFile(gpa, io, tmp.dir, "a.txt", "one\n", "first", &c1);
var c2: std.process.RunResult = undefined;
defer freeResult(gpa, &c2);
_ = try commitFile(gpa, io, tmp.dir, "b.txt", "two\n", "second", &c2);
const zit_before = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_before);
var build = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "build" });
defer freeResult(gpa, &build);
try expectExit(build.term, 0);
try std.testing.expect(std.mem.indexOf(u8, build.stdout, "checkpoint: built at") != null);
const zit_after = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_after);
try std.testing.expectEqualSlices(u8, zit_before, zit_after); // zero artifacts
var show = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "show" });
defer freeResult(gpa, &show);
try expectExit(show.term, 0);
try std.testing.expect(std.mem.indexOf(u8, show.stdout, "witness") != null);
try std.testing.expect(std.mem.indexOf(u8, show.stdout, "validates against the live log") != null);
var ver = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "verify" });
defer freeResult(gpa, &ver);
try expectExit(ver.term, 0);
try std.testing.expect(std.mem.indexOf(u8, ver.stdout, "verified ok") != null);
var drop1 = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "drop" });
defer freeResult(gpa, &drop1);
try expectExit(drop1.term, 0);
var drop2 = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "drop" });
defer freeResult(gpa, &drop2);
try expectExit(drop2.term, 0); // absence is success
}
test "cli checkpoint: reads answer identically across build, growth, corruption, and --no-cache" {
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 c1: std.process.RunResult = undefined;
defer freeResult(gpa, &c1);
_ = try commitFile(gpa, io, tmp.dir, "a.txt", "one\n", "first", &c1);
var build = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "build" });
defer freeResult(gpa, &build);
try expectExit(build.term, 0);
// Growth after the checkpoint: a later commit and its read.
var c2: std.process.RunResult = undefined;
defer freeResult(gpa, &c2);
const tip = try commitFile(gpa, io, tmp.dir, "b.txt", "two\n", "second", &c2);
var reference: ?[]u8 = null;
defer if (reference) |s| gpa.free(s);
// The same read, four ways: warm, cold-cache (checkpoint resumes),
// corrupted sidecar (full derive), and --no-cache (paranoid) — one answer.
for (0..4) |variant| {
switch (variant) {
0 => {},
1 => tmp.dir.deleteFile(io, ".zit-cache/repo") catch {},
2 => {
tmp.dir.deleteFile(io, ".zit-cache/repo") catch {};
try writeFile(io, tmp.dir, ".zit-cache/checkpoint", "garbage over the sidecar");
},
3 => {},
else => unreachable,
}
const args: []const []const u8 = if (variant == 3)
&.{ "leaves", "--no-cache" }
else
&.{"leaves"};
var res = try runZit(gpa, io, tmp.dir, args);
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, tip[0..12]) != null);
if (reference) |want| {
try std.testing.expectEqualStrings(want, res.stdout);
} else {
reference = try gpa.dupe(u8, res.stdout);
}
}
}
test "cli checkpoint: build on an emission-enabled repository is still sidecar-only and verifies" {
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 commit_out: std.process.RunResult = undefined;
defer freeResult(gpa, &commit_out);
for (0..12) |i| {
var name_buf: [32]u8 = undefined;
const name = try std.fmt.bufPrint(&name_buf, "{c}{d}.txt", .{ @as(u8, 'a') + @as(u8, @intCast(i * 2)), i });
try writeFile(io, tmp.dir, name, "content\n");
try addManaged(gpa, io, tmp.dir, &.{name});
}
commit_out = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "wide" });
try expectExit(commit_out.term, 0);
var enable = try runZit(gpa, io, tmp.dir, &.{ "submanifest", "enable", "--k", "1" });
defer freeResult(gpa, &enable);
try expectExit(enable.term, 0);
const zit_before = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_before);
var build = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "build" });
defer freeResult(gpa, &build);
try expectExit(build.term, 0);
try std.testing.expect(std.mem.indexOf(u8, build.stdout, "checkpoint: built at") != null);
// Sidecar only, even with emission enabled: the store never moves.
const zit_after = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_after);
try std.testing.expectEqualSlices(u8, zit_before, zit_after);
var ver = try runZit(gpa, io, tmp.dir, &.{ "checkpoint", "verify" });
defer freeResult(gpa, &ver);
try expectExit(ver.term, 0);
try std.testing.expect(std.mem.indexOf(u8, ver.stdout, "verified ok") != null);
}