const std = @import("std");
const support = @import("support.zig");
const addManaged = support.addManaged;
const checkinHash = support.checkinHash;
const expectExit = support.expectExit;
const freeResult = support.freeResult;
const initRepo = support.initRepo;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const writeFile = support.writeFile;
// ==========================================================================
// `zit cat` end-to-end. Emits one file's uncompressed content at a resolved
// check-in, byte-for-byte on stdout. The content oracle is the exact bytes the
// test wrote before committing — never captured from zit or Fossil. Whether a
// blob is stored full or as a delta is a storage detail cat must see through:
// its output is always the uncompressed bytes, hash-verified against the F card
// (artifact §7.2).
// ==========================================================================
test "cli cat §7.2/delta §4: emits the reconstructed uncompressed bytes for a file stored as a delta chain" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// A large file whose second version differs in one byte: commit stores the
// child's blob as a profitable delta against the parent's blob for the same
// path (§4.1/§7.2 storage), so one of the two versions is reconstructed by
// walking a delta frame — cat must emit the exact uncompressed bytes either
// way, and blob reconstruction re-verifies the §7.2 hash.
var v1: std.ArrayList(u8) = .empty;
defer v1.deinit(gpa);
for (0..300) |_| try v1.appendSlice(gpa, "the quick brown fox jumps over\n");
var v2: std.ArrayList(u8) = .empty;
defer v2.deinit(gpa);
try v2.appendSlice(gpa, v1.items);
v2.items[1500] = 'X'; // a single-byte change deep in the middle
try writeFile(io, tmp.dir, "big.txt", v1.items);
try addManaged(gpa, io, tmp.dir, &.{"big.txt"});
var root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "v1" });
defer freeResult(gpa, &root);
try expectExit(root.term, 0);
const root_hash = try gpa.dupe(u8, try checkinHash(root.stdout));
defer gpa.free(root_hash);
try writeFile(io, tmp.dir, "big.txt", v2.items);
var child = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "v2" });
defer freeResult(gpa, &child);
try expectExit(child.term, 0);
// Current checkout (child) → v2; the explicit root check-in → v1. Both
// reconstruct their stored blob (one of them across the delta chain).
var cur = try runZit(gpa, io, tmp.dir, &.{ "cat", "big.txt" });
defer freeResult(gpa, &cur);
try expectExit(cur.term, 0);
try std.testing.expectEqualStrings(v2.items, cur.stdout);
try std.testing.expectEqualStrings("", cur.stderr);
var old = try runZit(gpa, io, tmp.dir, &.{ "cat", "big.txt", root_hash });
defer freeResult(gpa, &old);
try expectExit(old.term, 0);
try std.testing.expectEqualStrings(v1.items, old.stdout);
try std.testing.expectEqualStrings("", old.stderr);
}
test "cli cat §8.2: resolves FILE within a check-in's effective set — the unchanged and the changed file each read correctly across two commits" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// Root {a:"a0", b:"b0"}; child changes only a → "a1". At the child check-in
// the effective set (§8.2) is {a:"a1", b:"b0"}: cat of the untouched file
// yields its original bytes, cat of the changed file yields the new bytes.
try writeFile(io, tmp.dir, "a.txt", "a0\n");
try writeFile(io, tmp.dir, "b.txt", "b0\n");
try addManaged(gpa, io, tmp.dir, &.{ "a.txt", "b.txt" });
var root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &root);
try expectExit(root.term, 0);
try writeFile(io, tmp.dir, "a.txt", "a1\n");
var child = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "edit a" });
defer freeResult(gpa, &child);
try expectExit(child.term, 0);
var ca = try runZit(gpa, io, tmp.dir, &.{ "cat", "a.txt" });
defer freeResult(gpa, &ca);
try expectExit(ca.term, 0);
try std.testing.expectEqualStrings("a1\n", ca.stdout); // the changed file
var cb = try runZit(gpa, io, tmp.dir, &.{ "cat", "b.txt" });
defer freeResult(gpa, &cb);
try expectExit(cb.term, 0);
try std.testing.expectEqualStrings("b0\n", cb.stdout); // carried forward unchanged
try std.testing.expectEqualStrings("", cb.stderr);
}
test "cli cat §8.2: a file removed at a check-in is absent from its effective set — not found, exit 1" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// Root tracks a and b; the child stops tracking b (`zit rm`) and commits, so
// b is not in the child's effective set. cat of b at the child reports
// not-found on stderr, exit 1, empty stdout (cli-stream-separation).
try writeFile(io, tmp.dir, "a.txt", "a\n");
try writeFile(io, tmp.dir, "b.txt", "b\n");
try addManaged(gpa, io, tmp.dir, &.{ "a.txt", "b.txt" });
var root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &root);
try expectExit(root.term, 0);
var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "b.txt" });
defer freeResult(gpa, &rm);
try expectExit(rm.term, 0);
var child = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "drop b", "--user", "e2e" });
defer freeResult(gpa, &child);
try expectExit(child.term, 0);
var res = try runZit(gpa, io, tmp.dir, &.{ "cat", "b.txt" });
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, "not in the check-in") != null);
// a is still tracked, so it reads back its content.
var ca = try runZit(gpa, io, tmp.dir, &.{ "cat", "a.txt" });
defer freeResult(gpa, &ca);
try expectExit(ca.term, 0);
try std.testing.expectEqualStrings("a\n", ca.stdout);
}
test "cli cat §7.2: binary content with embedded NUL is emitted verbatim — no truncation, no added newline" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// Every byte value 0..255 twice, so a NUL sits well before the end and the
// content has no trailing LF. cat MUST pass all bytes through unchanged — the
// content path is []const u8 (NUL-legal), and cat adds no framing.
var content: [512]u8 = undefined;
for (&content, 0..) |*b, i| b.* = @intCast(i % 256);
try writeFile(io, tmp.dir, "blob.bin", &content);
try addManaged(gpa, io, tmp.dir, &.{"blob.bin"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "binary" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
var res = try runZit(gpa, io, tmp.dir, &.{ "cat", "blob.bin" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualSlices(u8, &content, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
test "cli cat: no FILE is a usage error (exit 2); an unborn checkout and an unresolvable VERSION each fail (exit 1)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// (a) `zit cat` with no FILE is a usage error: exit 2, diagnostic on stderr,
// empty stdout.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
var res = try runZit(gpa, io, tmp.dir, &.{"cat"});
defer freeResult(gpa, &res);
try expectExit(res.term, 2);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "no file given") != null);
}
// (b) A fresh repository's checkout is unborn (§7.5): bare `zit cat FILE` has
// no check-in to read — exit 1, diagnostic on stderr, empty stdout.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
var res = try runZit(gpa, io, tmp.dir, &.{ "cat", "a.txt" });
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, "unborn") != null);
}
// (c) A name no check-in carries is a §8.3 resolution failure (NotFound):
// exit 1, the resolve diagnostic on stderr, empty stdout.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a.txt", "root\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
var res = try runZit(gpa, io, tmp.dir, &.{ "cat", "a.txt", "nosuch" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit cat: check-in 'nosuch' not found\n", res.stderr);
}
}