const std = @import("std");
const checkout = @import("zit").checkout;
const zit = @import("zit");
const support = @import("support.zig");
const addManaged = support.addManaged;
const adoptStore = support.adoptStore;
const appendArtifact = support.appendArtifact;
const checkinHash = support.checkinHash;
const checkoutVersionAlloc = support.checkoutVersionAlloc;
const commitHashDup = support.commitHashDup;
const expectCheckout = support.expectCheckout;
const expectCheckoutVersion = support.expectCheckoutVersion;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectFileContent = support.expectFileContent;
const fileExists = support.fileExists;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const leafSubManifest = support.leafSubManifest;
const parseCheckin = support.parseCheckin;
const readFile = support.readFile;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const seedCheckout = support.seedCheckout;
const sha3HexAlloc = support.sha3HexAlloc;
const shunDigestInRepo = support.shunDigestInRepo;
const spawnServe = support.spawnServe;
const waitForListen = support.waitForListen;
const withZCard = support.withZCard;
const writeFile = support.writeFile;
test "cli sparse cone P4: open --cone scopes materialization, tracking, extras, and add refusal" {
// Goal: one sparse checkout exercises the section 4.1 surface end to end:
// only the cone materializes; the managed set is in-cone; an uncovered
// on-disk file is invisible to extras; an explicit add outside the cone
// refuses naming the mechanism (never "no such file"/"corrupt"); status
// stays clean. Method: build a two-directory repo, adopt its store into a
// fresh dir, open --cone=src, then probe each verb.
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 writeFile(io, tmp_a.dir, "rootfile.txt", "root\n");
try tmp_a.dir.createDir(io, "src", .default_dir);
try tmp_a.dir.createDir(io, "tools", .default_dir);
try writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
try writeFile(io, tmp_a.dir, "src/b.zig", "b\n");
try writeFile(io, tmp_a.dir, "tools/t.sh", "t\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "rootfile.txt", "src/a.zig", "src/b.zig", "tools/t.sh" });
const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(head);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
try initRepo(gpa, io, tmp_b.dir);
try adoptStore(gpa, io, tmp_a.dir, tmp_b.dir);
var opened = try runZit(gpa, io, tmp_b.dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &opened);
try expectExitDiag(opened.term, 0, opened);
try expectCheckoutVersion(io, tmp_b.dir, head);
// Positive space: the cone materialized. Negative space: nothing else did.
try std.testing.expect(fileExists(io, tmp_b.dir, "src/a.zig"));
try std.testing.expect(fileExists(io, tmp_b.dir, "src/b.zig"));
try std.testing.expect(!fileExists(io, tmp_b.dir, "rootfile.txt"));
try std.testing.expect(!fileExists(io, tmp_b.dir, "tools/t.sh"));
// A sparse checkout is CLEAN: the out-of-cone entries live in the record,
// not the managed set, and status compares cone against cone.
var st = try runZit(gpa, io, tmp_b.dir, &.{"status"});
defer freeResult(gpa, &st);
try expectExitDiag(st.term, 0, st);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "removed") == null);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "missing") == null);
// An uncovered on-disk file is NOT an extra (section 4.1).
try writeFile(io, tmp_b.dir, "stray.txt", "outside\n");
try writeFile(io, tmp_b.dir, "src/new.zig", "inside\n");
var ex = try runZit(gpa, io, tmp_b.dir, &.{"extras"});
defer freeResult(gpa, &ex);
try expectExitDiag(ex.term, 0, ex);
try std.testing.expectEqualStrings("src/new.zig\n", ex.stdout);
// Explicit add outside the cone: exit 1, names the mechanism and both
// remedies, whole-stderr asserted so wording changes come through here.
var ad = try runZit(gpa, io, tmp_b.dir, &.{ "add", "stray.txt" });
defer freeResult(gpa, &ad);
try expectExit(ad.term, 1);
try std.testing.expectEqualStrings(
"zit add: 'stray.txt' is outside this checkout's sparse cone\n" ++
"widen it with 'zit update --cone=stray.txt' or return to dense with 'zit update --dense'\n",
ad.stderr,
);
try std.testing.expect(std.mem.indexOf(u8, ad.stderr, "no such file") == null);
try std.testing.expect(std.mem.indexOf(u8, ad.stderr, "corrupt") == null);
// In-cone add works; `add .` expands to the cone only.
var ad2 = try runZit(gpa, io, tmp_b.dir, &.{ "add", "." });
defer freeResult(gpa, &ad2);
try expectExitDiag(ad2.term, 0, ad2);
try std.testing.expect(std.mem.indexOf(u8, ad2.stdout, "src/new.zig") != null);
try std.testing.expect(std.mem.indexOf(u8, ad2.stdout, "stray.txt") == null);
}
test "cli sparse cone P4: update --dense rematerializes the full tree and re-scopes extras" {
// Goal: section 5.4's ultimate widening -- dropping the cone -- restores
// every out-of-cone file and returns the verbs to dense behavior. Method:
// sparse open as above, then `update --dense` at the same check-in.
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 writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
try writeFile(io, tmp_a.dir, "tools/t.sh", "t\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh" });
const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(head);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
try initRepo(gpa, io, tmp_b.dir);
try adoptStore(gpa, io, tmp_a.dir, tmp_b.dir);
var opened = try runZit(gpa, io, tmp_b.dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &opened);
try expectExitDiag(opened.term, 0, opened);
try std.testing.expect(!fileExists(io, tmp_b.dir, "tools/t.sh"));
var up = try runZit(gpa, io, tmp_b.dir, &.{ "update", "--dense", head });
defer freeResult(gpa, &up);
try expectExitDiag(up.term, 0, up);
try std.testing.expect(fileExists(io, tmp_b.dir, "tools/t.sh"));
try std.testing.expect(fileExists(io, tmp_b.dir, "src/a.zig"));
// Dense again: a stray file is an extra once more.
try writeFile(io, tmp_b.dir, "stray.txt", "outside\n");
var ex = try runZit(gpa, io, tmp_b.dir, &.{"extras"});
defer freeResult(gpa, &ex);
try expectExitDiag(ex.term, 0, ex);
try std.testing.expectEqualStrings("stray.txt\n", ex.stdout);
}
test "cli sparse cone P5 keystone: a sparse commit is indistinguishable from the dense commit of the same change" {
// Goal: RFC section 4.2's central claim. Two clones of one repo make the
// SAME logical change -- edit src/a.zig, add src/new.zig -- one densely,
// one through a src-only cone. The minted check-ins must agree on their
// complete file sets (out-of-cone entries carried verbatim, R card and
// all), the sparse one must reopen densely elsewhere with every file
// intact, and verify must be clean. Method: byte-compare `zit ls` output
// and per-file `zit cat` across the two results.
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 writeFile(io, tmp_a.dir, "src/a.zig", "a v1\n");
try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
try writeFile(io, tmp_a.dir, "README", "readme\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh", "README" });
const base = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(base);
// Dense arm: ordinary checkout, make the change, commit.
var dense = std.testing.tmpDir(.{});
defer dense.cleanup();
try initRepo(gpa, io, dense.dir);
try adoptStore(gpa, io, tmp_a.dir, dense.dir);
var od = try runZit(gpa, io, dense.dir, &.{"open"});
defer freeResult(gpa, &od);
try expectExitDiag(od.term, 0, od);
try writeFile(io, dense.dir, "src/a.zig", "a v2\n");
try writeFile(io, dense.dir, "src/new.zig", "new\n");
var ad = try runZit(gpa, io, dense.dir, &.{ "add", "src/new.zig" });
defer freeResult(gpa, &ad);
try expectExitDiag(ad.term, 0, ad);
var cd = try runZit(gpa, io, dense.dir, &.{ "commit", "-m", "same change", "--user", "e2e" });
defer freeResult(gpa, &cd);
try expectExitDiag(cd.term, 0, cd);
// Sparse arm: src-only cone, the same change, commit.
var sparse = std.testing.tmpDir(.{});
defer sparse.cleanup();
try initRepo(gpa, io, sparse.dir);
try adoptStore(gpa, io, tmp_a.dir, sparse.dir);
var os_ = try runZit(gpa, io, sparse.dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &os_);
try expectExitDiag(os_.term, 0, os_);
try std.testing.expect(!fileExists(io, sparse.dir, "tools/t.sh"));
try writeFile(io, sparse.dir, "src/a.zig", "a v2\n");
try writeFile(io, sparse.dir, "src/new.zig", "new\n");
var as_ = try runZit(gpa, io, sparse.dir, &.{ "add", "src/new.zig" });
defer freeResult(gpa, &as_);
try expectExitDiag(as_.term, 0, as_);
var cs = try runZit(gpa, io, sparse.dir, &.{ "commit", "-m", "same change", "--user", "e2e" });
defer freeResult(gpa, &cs);
try expectExitDiag(cs.term, 0, cs);
// The two tips enumerate identical COMPLETE file sets: `ls` output must
// be byte-equal, and it must still contain the out-of-cone files.
var ls_dense = try runZit(gpa, io, dense.dir, &.{"ls"});
defer freeResult(gpa, &ls_dense);
try expectExitDiag(ls_dense.term, 0, ls_dense);
var ls_sparse = try runZit(gpa, io, sparse.dir, &.{"ls"});
defer freeResult(gpa, &ls_sparse);
try expectExitDiag(ls_sparse.term, 0, ls_sparse);
try std.testing.expectEqualStrings(ls_dense.stdout, ls_sparse.stdout);
try std.testing.expect(std.mem.indexOf(u8, ls_sparse.stdout, "tools/t.sh") != null);
try std.testing.expect(std.mem.indexOf(u8, ls_sparse.stdout, "README") != null);
// Out-of-cone content carried verbatim: cat from the sparse store.
var cat_tool = try runZit(gpa, io, sparse.dir, &.{ "cat", "tools/t.sh" });
defer freeResult(gpa, &cat_tool);
try expectExitDiag(cat_tool.term, 0, cat_tool);
try std.testing.expectEqualStrings("tool\n", cat_tool.stdout);
// The sparse store verifies clean, and a fresh DENSE open of it
// materializes the full tree including the sparse-committed change.
var ver = try runZit(gpa, io, sparse.dir, &.{"verify"});
defer freeResult(gpa, &ver);
try expectExitDiag(ver.term, 0, ver);
var reader = std.testing.tmpDir(.{});
defer reader.cleanup();
try initRepo(gpa, io, reader.dir);
try adoptStore(gpa, io, sparse.dir, reader.dir);
var or_ = try runZit(gpa, io, reader.dir, &.{"open"});
defer freeResult(gpa, &or_);
try expectExitDiag(or_.term, 0, or_);
const a2 = try readFile(gpa, io, reader.dir, "src/a.zig");
defer gpa.free(a2);
try std.testing.expectEqualStrings("a v2\n", a2);
const t2 = try readFile(gpa, io, reader.dir, "tools/t.sh");
defer gpa.free(t2);
try std.testing.expectEqualStrings("tool\n", t2);
}
test "cli sparse cone P5: in-cone deletion commits as a deletion; out-of-cone files never deleted by absence" {
// Goal: the sparse snapshot's negative space -- rm of an in-cone file is
// a real deletion, while every out-of-cone file (absent from the sparse
// worktree by definition) survives the commit untouched. This is the
// data-loss trap the compose carry exists to prevent.
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 writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
try writeFile(io, tmp_a.dir, "src/b.zig", "b\n");
try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "src/b.zig", "tools/t.sh" });
const base = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(base);
var sp = std.testing.tmpDir(.{});
defer sp.cleanup();
try initRepo(gpa, io, sp.dir);
try adoptStore(gpa, io, tmp_a.dir, sp.dir);
var op = try runZit(gpa, io, sp.dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &op);
try expectExitDiag(op.term, 0, op);
var rm = try runZit(gpa, io, sp.dir, &.{ "rm", "src/b.zig" });
defer freeResult(gpa, &rm);
try expectExitDiag(rm.term, 0, rm);
sp.dir.deleteFile(io, "src/b.zig") catch {};
var cm = try runZit(gpa, io, sp.dir, &.{ "commit", "-m", "drop b", "--user", "e2e" });
defer freeResult(gpa, &cm);
try expectExitDiag(cm.term, 0, cm);
var ls = try runZit(gpa, io, sp.dir, &.{"ls"});
defer freeResult(gpa, &ls);
try expectExitDiag(ls.term, 0, ls);
try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/b.zig") == null); // deleted
try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/a.zig") != null); // kept
try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "tools/t.sh") != null); // CARRIED
}
test "cli sparse cone P6: narrowing dematerializes; status and vstat stay correct, never wrong" {
// Goal: RFC section 3.1 mutability + the cache-key audit (PLAN Task 6) --
// a cone change on an existing checkout costs a flatten, never a wrong
// answer. Narrowing from dense removes out-of-cone files from the tree
// (the record keeps them); status is clean before and after; widening
// back restores them.
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 writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh" });
const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(head);
var wt = std.testing.tmpDir(.{});
defer wt.cleanup();
try initRepo(gpa, io, wt.dir);
try adoptStore(gpa, io, tmp_a.dir, wt.dir);
var op = try runZit(gpa, io, wt.dir, &.{"open"});
defer freeResult(gpa, &op);
try expectExitDiag(op.term, 0, op);
try std.testing.expect(fileExists(io, wt.dir, "tools/t.sh"));
// Narrow: dense -> src cone at the same check-in.
var nr = try runZit(gpa, io, wt.dir, &.{ "update", "--cone=src", head });
defer freeResult(gpa, &nr);
try expectExitDiag(nr.term, 0, nr);
try std.testing.expect(!fileExists(io, wt.dir, "tools/t.sh")); // dematerialized
try std.testing.expect(fileExists(io, wt.dir, "src/a.zig"));
var st = try runZit(gpa, io, wt.dir, &.{"status"});
defer freeResult(gpa, &st);
try expectExitDiag(st.term, 0, st);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "removed") == null);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "missing") == null);
// Widen back to dense: everything returns, still clean.
var wd = try runZit(gpa, io, wt.dir, &.{ "update", "--dense", head });
defer freeResult(gpa, &wd);
try expectExitDiag(wd.term, 0, wd);
try std.testing.expect(fileExists(io, wt.dir, "tools/t.sh"));
var st2 = try runZit(gpa, io, wt.dir, &.{"status"});
defer freeResult(gpa, &st2);
try expectExitDiag(st2.term, 0, st2);
try std.testing.expect(std.mem.indexOf(u8, st2.stdout, "removed") == null);
}
test "cli sparse commit reconstructs missing structural siblings or refuses without publishing" {
const gpa = std.testing.allocator;
const io = std.testing.io;
const Case = enum { no_remote, complete_peer, incomplete_peer, corrupt_sibling, shunned_sibling, delta_peer };
for (std.meta.tags(Case)) |case| {
const complete_peer = case == .complete_peer or case == .delta_peer;
var source = std.testing.tmpDir(.{});
defer source.cleanup();
try initRepo(gpa, io, source.dir);
var enabled = try runZit(gpa, io, source.dir, &.{ "submanifest", "enable", "--k", "1" });
defer freeResult(gpa, &enabled);
try expectExitDiag(enabled.term, 0, enabled);
const src_leaf = try leafSubManifest(gpa, &.{"src/a"});
defer gpa.free(src_leaf);
const tools_leaf = if (case == .corrupt_sibling)
try gpa.dupe(u8, "malformed sibling\n")
else
try leafSubManifest(gpa, &.{"tools/b"});
defer gpa.free(tools_leaf);
const src_hash = try appendArtifact(gpa, io, source.dir, src_leaf);
defer gpa.free(src_hash);
const tools_hash = try sha3HexAlloc(gpa, tools_leaf);
defer gpa.free(tools_hash);
const src_blob = try appendArtifact(gpa, io, source.dir, "src/a");
defer gpa.free(src_blob);
const body = try std.fmt.allocPrint(gpa, "C base\nD 2026-10-20T12:00:00.000\nS src/a {s}\nS tools/b {s}\nT *branch * trunk\nT *sym-trunk *\nU e2e\n", .{ src_hash, tools_hash });
defer gpa.free(body);
const tree = try withZCard(gpa, body);
defer gpa.free(tree);
const tree_base = try appendArtifact(gpa, io, source.dir, tree);
defer gpa.free(tree_base);
const base = if (case == .delta_peer) blk: {
const delta_body = try std.fmt.allocPrint(gpa, "B {s}\nC delta-parent\nD 2026-10-20T12:00:01.000\nP {s}\nU e2e\n", .{ tree_base, tree_base });
defer gpa.free(delta_body);
const delta_bytes = try withZCard(gpa, delta_body);
defer gpa.free(delta_bytes);
break :blk try appendArtifact(gpa, io, source.dir, delta_bytes);
} else try gpa.dupe(u8, tree_base);
defer gpa.free(base);
var sparse = std.testing.tmpDir(.{});
defer sparse.cleanup();
try initRepo(gpa, io, sparse.dir);
try adoptStore(gpa, io, source.dir, sparse.dir);
// Model an already-materialized sparse checkout after its opaque
// sibling payload was elided; opening a new checkout needs the tree.
try sparse.dir.createDir(io, "src", .default_dir);
try writeFile(io, sparse.dir, "src/a", "src/a");
try addManaged(gpa, io, sparse.dir, &.{"src/a"});
try seedCheckout(io, sparse.dir, base, "trunk");
var store_cone = try zit.cone.Cone.init(gpa, &.{"src"}, &.{});
defer store_cone.deinit(gpa);
const cone_payload = try store_cone.serialize(gpa);
defer gpa.free(cone_payload);
try checkout.updateSections(io, sparse.dir, &.{.{ .tag = .cone, .payload = cone_payload }});
zit.repocache.writeStoreCone(gpa, io, sparse.dir, &store_cone);
try writeFile(io, sparse.dir, "src/a", "edited\n");
if (case == .corrupt_sibling or case == .shunned_sibling) {
const bad = try appendArtifact(gpa, io, sparse.dir, tools_leaf);
gpa.free(bad);
}
if (case == .shunned_sibling) {
var digest: [32]u8 = undefined;
_ = try std.fmt.hexToBytes(&digest, tools_hash);
try shunDigestInRepo(gpa, io, sparse.dir, &digest);
}
if (complete_peer or case == .shunned_sibling) {
const got = try appendArtifact(gpa, io, source.dir, tools_leaf);
defer gpa.free(got);
try std.testing.expectEqualStrings(tools_hash, got);
const blob = try appendArtifact(gpa, io, source.dir, "tools/b");
defer gpa.free(blob);
}
const port = try freshLoopbackPort(io);
var server: ?std.process.Child = null;
defer if (server) |*s| s.kill(io);
if (complete_peer or case == .incomplete_peer or case == .shunned_sibling) {
server = try spawnServe(gpa, io, source.dir, port);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
var remote = try runZit(gpa, io, sparse.dir, &.{ "remote", url });
defer freeResult(gpa, &remote);
try expectExitDiag(remote.term, 0, remote);
}
const before = try readFile(gpa, io, sparse.dir, ".zit");
defer gpa.free(before);
const checkout_before = try readFile(gpa, io, sparse.dir, ".zit-checkout");
defer gpa.free(checkout_before);
if (complete_peer) {
var preview = try runZit(gpa, io, sparse.dir, &.{ "commit", "--no-sync", "--dry-run", "--user", "e2e" });
defer freeResult(gpa, &preview);
try expectExitDiag(preview.term, 1, preview);
try std.testing.expect(std.mem.indexOf(u8, preview.stderr, "before a dry-run commit") != null);
try expectFileContent(gpa, io, sparse.dir, ".zit", before);
try expectFileContent(gpa, io, sparse.dir, ".zit-checkout", checkout_before);
}
var committed = try runZit(gpa, io, sparse.dir, &.{ "commit", "--no-sync", "-m", "edit", "--user", "e2e" });
defer freeResult(gpa, &committed);
if (!complete_peer) {
try expectExitDiag(committed.term, 1, committed);
try expectCheckout(io, sparse.dir, base, "trunk");
try expectFileContent(gpa, io, sparse.dir, "src/a", "edited\n");
const checkout_after = try readFile(gpa, io, sparse.dir, ".zit-checkout");
defer gpa.free(checkout_after);
try std.testing.expectEqualSlices(u8, checkout_before, checkout_after);
if (case == .no_remote or case == .corrupt_sibling or case == .shunned_sibling) {
const after = try readFile(gpa, io, sparse.dir, ".zit");
defer gpa.free(after);
try std.testing.expectEqualSlices(u8, before, after);
}
if (case == .no_remote) {
try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "sparse cone and no remote") != null);
} else if (case == .incomplete_peer) {
try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "required structural content") != null);
try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "refusing to commit") != null);
try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, committed.stderr, "fetching required structural"));
} else {
try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "parent check-in is corrupt") != null);
try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "fetching required") == null);
}
} else {
try expectExitDiag(committed.term, 0, committed);
try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "fetching required structural") != null);
_ = try checkinHash(committed.stdout);
var retained = zit.repocache.readStoreCone(gpa, io, sparse.dir).?;
defer retained.deinit(gpa);
try std.testing.expect(retained.covers("src/a"));
try std.testing.expect(!retained.covers("tools/b"));
try std.testing.expect(!fileExists(io, sparse.dir, "tools/b"));
var dense = std.testing.tmpDir(.{});
defer dense.cleanup();
try initRepo(gpa, io, dense.dir);
try adoptStore(gpa, io, source.dir, dense.dir);
var dense_open = try runZit(gpa, io, dense.dir, &.{"open"});
defer freeResult(gpa, &dense_open);
try expectExitDiag(dense_open.term, 0, dense_open);
try writeFile(io, dense.dir, "src/a", "edited\n");
var dense_commit = try runZit(gpa, io, dense.dir, &.{ "commit", "--no-sync", "-m", "edit", "--user", "e2e" });
defer freeResult(gpa, &dense_commit);
try expectExitDiag(dense_commit.term, 0, dense_commit);
var dense_ls = try runZit(gpa, io, dense.dir, &.{ "ls", "--long" });
defer freeResult(gpa, &dense_ls);
var sparse_ls = try runZit(gpa, io, sparse.dir, &.{ "ls", "--long" });
defer freeResult(gpa, &sparse_ls);
try expectExitDiag(dense_ls.term, 0, dense_ls);
try expectExitDiag(sparse_ls.term, 0, sparse_ls);
try std.testing.expect(std.mem.indexOf(u8, sparse_ls.stdout, "tools/b") != null);
const dense_tip = try checkoutVersionAlloc(gpa, io, dense.dir);
defer gpa.free(dense_tip);
const sparse_tip = try checkoutVersionAlloc(gpa, io, sparse.dir);
defer gpa.free(sparse_tip);
var dense_tree = try parseCheckin(gpa, io, dense.dir, dense_tip);
defer dense_tree.deinit();
var sparse_tree = try parseCheckin(gpa, io, sparse.dir, sparse_tip);
defer sparse_tree.deinit();
try std.testing.expectEqualDeep(dense_tree.m.s, sparse_tree.m.s);
try std.testing.expectEqualDeep(dense_tree.m.f, sparse_tree.m.f);
const blob_hash = try sha3HexAlloc(gpa, "tools/b");
defer gpa.free(blob_hash);
var elided = try runZit(gpa, io, sparse.dir, &.{ "artifact", blob_hash });
defer freeResult(gpa, &elided);
try expectExitDiag(elided.term, 1, elided);
}
}
}
test "cli sparse cone P6: the keystone holds on a submanifest-enabled repository" {
// Goal: the tree-dialect half of reader-indistinguishability (RFC 4.2).
// Same shape as the P5 keystone, but the source repo emits S-card tree
// manifests, so the sparse commit's composed F-set drives the tree
// construction and untouched out-of-cone subtrees reproduce their node
// hashes by construction over the dense store. Method: enable
// sub-manifests before the base commit, then dense-vs-sparse the same
// change and byte-compare the enumerated file sets.
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);
var en = try runZit(gpa, io, tmp_a.dir, &.{ "submanifest", "enable", "--k", "3" });
defer freeResult(gpa, &en);
try expectExitDiag(en.term, 0, en);
try tmp_a.dir.createDir(io, "src", .default_dir);
try tmp_a.dir.createDir(io, "tools", .default_dir);
try writeFile(io, tmp_a.dir, "src/a.zig", "a v1\n");
try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
try writeFile(io, tmp_a.dir, "README", "readme\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh", "README" });
const base = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(base);
var dense = std.testing.tmpDir(.{});
defer dense.cleanup();
try initRepo(gpa, io, dense.dir);
try adoptStore(gpa, io, tmp_a.dir, dense.dir);
var od = try runZit(gpa, io, dense.dir, &.{"open"});
defer freeResult(gpa, &od);
try expectExitDiag(od.term, 0, od);
try writeFile(io, dense.dir, "src/a.zig", "a v2\n");
var cd = try runZit(gpa, io, dense.dir, &.{ "commit", "-m", "edit", "--user", "e2e" });
defer freeResult(gpa, &cd);
try expectExitDiag(cd.term, 0, cd);
var sparse = std.testing.tmpDir(.{});
defer sparse.cleanup();
try initRepo(gpa, io, sparse.dir);
try adoptStore(gpa, io, tmp_a.dir, sparse.dir);
var os_ = try runZit(gpa, io, sparse.dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &os_);
try expectExitDiag(os_.term, 0, os_);
try writeFile(io, sparse.dir, "src/a.zig", "a v2\n");
var cs = try runZit(gpa, io, sparse.dir, &.{ "commit", "-m", "edit", "--user", "e2e" });
defer freeResult(gpa, &cs);
try expectExitDiag(cs.term, 0, cs);
var ls_dense = try runZit(gpa, io, dense.dir, &.{"ls"});
defer freeResult(gpa, &ls_dense);
try expectExitDiag(ls_dense.term, 0, ls_dense);
var ls_sparse = try runZit(gpa, io, sparse.dir, &.{"ls"});
defer freeResult(gpa, &ls_sparse);
try expectExitDiag(ls_sparse.term, 0, ls_sparse);
try std.testing.expectEqualStrings(ls_dense.stdout, ls_sparse.stdout);
try std.testing.expect(std.mem.indexOf(u8, ls_sparse.stdout, "tools/t.sh") != null);
var ver = try runZit(gpa, io, sparse.dir, &.{"verify"});
defer freeResult(gpa, &ver);
try expectExitDiag(ver.term, 0, ver);
}
test "cli sparse cone exclusions: open --cone-not carves a subtree out, re-inclusion survives" {
// Goal: section 3.2 exclusions end to end over the local surface: an
// excluded subtree neither materializes nor tracks; a deeper
// re-inclusion under the exclusion does; `zit cone` shows the exclusion
// in the cone-file grammar; a dead exclusion refuses with the rule.
// Method: adopt a store, open with --cone/--cone-not, probe the tree.
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, "src/vendor", .default_dir);
try tmp_a.dir.createDir(io, "src/vendor/keep", .default_dir);
try writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
try writeFile(io, tmp_a.dir, "src/vendor/big.bin", "vendored\n");
try writeFile(io, tmp_a.dir, "src/vendor/keep/gem.txt", "kept\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "src/vendor/big.bin", "src/vendor/keep/gem.txt" });
const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(head);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
try initRepo(gpa, io, tmp_b.dir);
try adoptStore(gpa, io, tmp_a.dir, tmp_b.dir);
var opened = try runZit(gpa, io, tmp_b.dir, &.{
"open", "--cone=src", "--cone-not=src/vendor", "--cone=src/vendor/keep",
});
defer freeResult(gpa, &opened);
try expectExitDiag(opened.term, 0, opened);
try expectCheckoutVersion(io, tmp_b.dir, head);
// Positive space: the inclusion and the re-inclusion. Negative space:
// the excluded interior.
try std.testing.expect(fileExists(io, tmp_b.dir, "src/a.zig"));
try std.testing.expect(fileExists(io, tmp_b.dir, "src/vendor/keep/gem.txt"));
try std.testing.expect(!fileExists(io, tmp_b.dir, "src/vendor/big.bin"));
// The cone verb prints exclusions in the cone-file grammar.
var show = try runZit(gpa, io, tmp_b.dir, &.{"cone"});
defer freeResult(gpa, &show);
try expectExitDiag(show.term, 0, show);
try std.testing.expectEqualStrings("src\nsrc/vendor/keep\n!src/vendor\n", show.stdout);
// The excluded file is not an extra when it appears on disk, and a
// commit round-trip keeps it in the record (reader indistinguishability
// extends to exclusion boundaries).
try writeFile(io, tmp_b.dir, "src/b.zig", "b\n");
var ad = try runZit(gpa, io, tmp_b.dir, &.{ "add", "src/b.zig" });
defer freeResult(gpa, &ad);
try expectExitDiag(ad.term, 0, ad);
var c2 = try runCommitEnv(gpa, io, tmp_b.dir, .{ .user = "u" }, &.{ "commit", "-m", "sparse add" });
defer freeResult(gpa, &c2);
try expectExit(c2.term, 0);
var ls = try runZit(gpa, io, tmp_b.dir, &.{ "ls", "tip" });
defer freeResult(gpa, &ls);
try expectExitDiag(ls.term, 0, ls);
try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/vendor/big.bin") != null);
try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/b.zig") != null);
// A dead exclusion refuses with the rule, not a guess.
var tmp_c = std.testing.tmpDir(.{});
defer tmp_c.cleanup();
try initRepo(gpa, io, tmp_c.dir);
try adoptStore(gpa, io, tmp_a.dir, tmp_c.dir);
var dead = try runZit(gpa, io, tmp_c.dir, &.{ "open", "--cone=src", "--cone-not=tools" });
defer freeResult(gpa, &dead);
try expectExit(dead.term, 1);
try std.testing.expect(std.mem.indexOf(u8, dead.stderr, "dead rule") != null);
}