Skip to content
zit Artifact [dabe3fc8f2]
Login

Artifact [dabe3fc8f2]

Artifact dabe3fc8f2b3f6005cd5bf2a006cca0137bcd47069950ba44d761da7426e55eb:


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);
}