const std = @import("std");
const support = @import("support.zig");
const addManaged = support.addManaged;
const adoptStore = support.adoptStore;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectParentsCheckout = support.expectParentsCheckout;
const fileExists = support.fileExists;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const parentsFixture = support.parentsFixture;
const readFile = support.readFile;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const runZitStdin = support.runZitStdin;
const seedHorizonConeOrigin = support.seedHorizonConeOrigin;
const spawnServe = support.spawnServe;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;
test "cli cone: show, add fetches through the saved remote, remove narrows" {
// Wave 5 sugar over the section 6.4 machinery: `zit cone` lists members,
// `cone add` unions + fetches newly covered content, `cone remove`
// narrows and dematerializes. One code path with update --cone.
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", "src\n");
try writeFile(io, tmp_a.dir, "tools/t.bin", "tools\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.bin" });
var c1 = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--no-open", "--cone=src", url, "repo" });
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
defer b_dir.close(io);
var op = try runZit(gpa, io, b_dir, &.{ "open", "--cone=src" });
defer freeResult(gpa, &op);
try expectExitDiag(op.term, 0, op);
var show1 = try runZit(gpa, io, b_dir, &.{"cone"});
defer freeResult(gpa, &show1);
try expectExitDiag(show1.term, 0, show1);
try std.testing.expectEqualStrings("src\n", show1.stdout);
var add = try runZit(gpa, io, b_dir, &.{ "cone", "add", "tools" });
defer freeResult(gpa, &add);
try expectExitDiag(add.term, 0, add);
const tools_content = try readFile(gpa, io, b_dir, "tools/t.bin");
defer gpa.free(tools_content);
try std.testing.expectEqualStrings("tools\n", tools_content);
var show2 = try runZit(gpa, io, b_dir, &.{"cone"});
defer freeResult(gpa, &show2);
try expectExitDiag(show2.term, 0, show2);
try std.testing.expectEqualStrings("src\ntools\n", show2.stdout);
var rm = try runZit(gpa, io, b_dir, &.{ "cone", "remove", "tools" });
defer freeResult(gpa, &rm);
try expectExitDiag(rm.term, 0, rm);
try std.testing.expect(!fileExists(io, b_dir, "tools/t.bin"));
var show3 = try runZit(gpa, io, b_dir, &.{"cone"});
defer freeResult(gpa, &show3);
try expectExitDiag(show3.term, 0, show3);
try std.testing.expectEqualStrings("src\n", show3.stdout);
}
test "cli cone add on a horizon clone with a path cone widens the paths and keeps the horizon" {
// Horizon draft section 5.7: widening the paths keeps the store's
// horizon. The widening fetches the new member's content for the held
// history only, so nothing below the horizon arrives.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const seeded = try seedHorizonConeOrigin(gpa, io, tmp_a.dir);
defer gpa.free(seeded.h1);
defer gpa.free(seeded.h2);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, tmp_a.dir, port);
defer server.kill(io);
try waitForListen(io, port);
const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
defer gpa.free(url);
const horizon_arg = try std.fmt.allocPrint(gpa, "--horizon={s}", .{seeded.h2});
defer gpa.free(horizon_arg);
for ([_]bool{ false, true }) |structural| {
errdefer std.debug.print("structural: {}\n", .{structural});
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
const clone_args: []const []const u8 = if (structural)
&.{ "clone", horizon_arg, "--structural", "--cone=src", url, "repo" }
else
&.{ "clone", horizon_arg, "--cone=src", url, "repo" };
var clone = try runZit(gpa, io, tmp_b.dir, clone_args);
defer freeResult(gpa, &clone);
try expectExitDiag(clone.term, 0, clone);
var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
defer b_dir.close(io);
try std.testing.expect(!fileExists(io, b_dir, "tools/t"));
var add = try runZit(gpa, io, b_dir, &.{ "cone", "add", "tools" });
defer freeResult(gpa, &add);
try expectExitDiag(add.term, 0, add);
try std.testing.expect(std.mem.indexOf(u8, add.stderr, "mirror metadata") == null);
const tools = try readFile(gpa, io, b_dir, "tools/t");
defer gpa.free(tools);
try std.testing.expectEqualStrings("t3\n", tools);
var show = try runZit(gpa, io, b_dir, &.{"cone"});
defer freeResult(gpa, &show);
try expectExitDiag(show.term, 0, show);
try std.testing.expectEqualStrings("src\ntools\n", show.stdout);
// The horizon stayed where it was.
var ver = try runZit(gpa, io, b_dir, &.{"verify"});
defer freeResult(gpa, &ver);
try expectExitDiag(ver.term, 0, ver);
const want = try std.fmt.allocPrint(gpa, "cone of 2 members and horizon at {s}", .{seeded.h2});
defer gpa.free(want);
try std.testing.expect(std.mem.indexOf(u8, ver.stdout, want) != null);
}
}
/// One `zit cone test` output line, split back into its three columns.
const ConeTestLine = struct {
verdict: []const u8,
path: []const u8,
/// Byte offset of the third column, so alignment is checked as the
/// property it is rather than by transcribing one instance's spaces.
reason_at: usize,
reason: []const u8,
};
fn parseConeTestLine(line: []const u8) !ConeTestLine {
const v_end = std.mem.indexOfScalar(u8, line, ' ') orelse return error.NoVerdict;
var i = v_end;
while (i < line.len and line[i] == ' ') i += 1;
const p_start = i;
const p_end = std.mem.indexOfScalarPos(u8, line, p_start, ' ') orelse return error.NoPath;
i = p_end;
while (i < line.len and line[i] == ' ') i += 1;
return .{
.verdict = line[0..v_end],
.path = line[p_start..p_end],
.reason_at = i,
.reason = line[i..],
};
}
test "cli cone test: names the deciding member, and the exit status is a predicate" {
// Goal: `cone test` end to end. The verdict alone cannot answer "why isn't this
// file here" under longest match, so each line names the member that
// decided it -- bare, because the verdict column already carries the
// polarity and the token has to paste into `zit cone remove`. Method:
// the same nested cone as the exclusions test above (an inclusion, an
// exclusion inside it, a re-inclusion inside that), probed for all three
// outcomes plus the exit codes, stdin, --quiet, and --store.
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, "README", "readme\n");
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, &.{
"README", "src/a.zig", "src/vendor/big.bin", "src/vendor/keep/gem.txt",
});
var c1 = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
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);
// All four outcomes in one call, so the alignment is exercised across
// paths of very different lengths.
var all = try runZit(gpa, io, tmp_b.dir, &.{
"cone", "test", "src/a.zig",
"src/vendor/big.bin", "src/vendor/keep/gem.txt", "README",
});
defer freeResult(gpa, &all);
// Something is elided, so the predicate says so.
try expectExitDiag(all.term, 1, all);
var lines = std.mem.splitScalar(u8, std.mem.trimEnd(u8, all.stdout, "\n"), '\n');
const l1 = try parseConeTestLine(lines.next().?);
try std.testing.expectEqualStrings("covered", l1.verdict);
try std.testing.expectEqualStrings("src/a.zig", l1.path);
try std.testing.expectEqualStrings("src", l1.reason);
// The exclusion is LONGER than the inclusion containing it, so it
// decides -- the case a last-match-wins reading of the member list gets
// wrong, and the reason this column exists.
const l2 = try parseConeTestLine(lines.next().?);
try std.testing.expectEqualStrings("elided", l2.verdict);
try std.testing.expectEqualStrings("src/vendor/big.bin", l2.path);
try std.testing.expectEqualStrings("src/vendor", l2.reason);
// Re-inclusion deeper still: the longest member wins again, and the line
// names it rather than the exclusion it overrode.
const l3 = try parseConeTestLine(lines.next().?);
try std.testing.expectEqualStrings("covered", l3.verdict);
try std.testing.expectEqualStrings("src/vendor/keep/gem.txt", l3.path);
try std.testing.expectEqualStrings("src/vendor/keep", l3.reason);
// The one verdict with no member to name.
const l4 = try parseConeTestLine(lines.next().?);
try std.testing.expectEqualStrings("elided", l4.verdict);
try std.testing.expectEqualStrings("README", l4.path);
try std.testing.expectEqualStrings("(no member covers)", l4.reason);
try std.testing.expect(lines.next() == null);
// The member column lines up: the property, not one instance's spaces.
try std.testing.expectEqual(l1.reason_at, l2.reason_at);
try std.testing.expectEqual(l1.reason_at, l3.reason_at);
try std.testing.expectEqual(l1.reason_at, l4.reason_at);
// ...and it clears the longest path rather than merely the first.
try std.testing.expect(l1.reason_at > l3.path.len);
// Every path covered: exit 0, so `zit cone test X && ...` is usable.
var ok = try runZit(gpa, io, tmp_b.dir, &.{
"cone", "test", "src/a.zig", "src/vendor/keep/gem.txt",
});
defer freeResult(gpa, &ok);
try expectExitDiag(ok.term, 0, ok);
// --quiet leaves only the status.
var quiet = try runZit(gpa, io, tmp_b.dir, &.{ "cone", "test", "--quiet", "README" });
defer freeResult(gpa, &quiet);
try expectExit(quiet.term, 1);
try std.testing.expectEqualStrings("", quiet.stdout);
// `-` reads the path list from stdin, one per line.
try writeFile(io, tmp_b.dir, "paths.txt", "src/a.zig\nsrc/vendor/big.bin\n");
var piped = try runZitStdin(gpa, io, tmp_b.dir, "paths.txt", &.{ "cone", "test", "-" });
defer freeResult(gpa, &piped);
try expectExitDiag(piped.term, 1, piped);
try std.testing.expect(std.mem.indexOf(u8, piped.stdout, "src/a.zig") != null);
try std.testing.expect(std.mem.indexOf(u8, piped.stdout, "src/vendor") != null);
// A path that could never be tracked is a usage error (2), not a silent
// `elided` -- the answer "no" would be true but useless.
var bad = try runZit(gpa, io, tmp_b.dir, &.{ "cone", "test", "../escape" });
defer freeResult(gpa, &bad);
try expectExit(bad.term, 2);
try std.testing.expect(std.mem.indexOf(u8, bad.stderr, "repository-relative") != null);
// --store asks the other question. This checkout adopted a dense store,
// so the store cone covers what the worktree cone elides -- which is the
// distinct condition the flag exists to expose.
var store = try runZit(gpa, io, tmp_b.dir, &.{ "cone", "test", "--store", "src/vendor/big.bin" });
defer freeResult(gpa, &store);
try expectExitDiag(store.term, 0, store);
try std.testing.expect(std.mem.indexOf(u8, store.stdout, "covered") != null);
try std.testing.expect(std.mem.indexOf(u8, store.stdout, "(dense)") != null);
}
test "cli cone --cone-parents: cone test names the parent directory, add keeps the flag, add DIR stays in the cone" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
const fx = try parentsFixture(gpa, io, tmp_a.dir);
defer gpa.free(fx.c1);
defer gpa.free(fx.c2);
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/foo", "--cone-parents" });
defer freeResult(gpa, &opened);
try expectExitDiag(opened.term, 0, opened);
try expectParentsCheckout(io, tmp_b.dir);
var t = try runZit(gpa, io, tmp_b.dir, &.{ "cone", "test", "README", "src/main.zig", "src/foo/a.zig", "src/bar/x.zig" });
defer freeResult(gpa, &t);
try expectExitDiag(t.term, 1, t);
try std.testing.expectEqualStrings(
"covered README (parent directory)\n" ++
"covered src/main.zig (parent directory)\n" ++
"covered src/foo/a.zig src/foo\n" ++
"elided src/bar/x.zig (no member covers)\n",
t.stdout,
);
// `add DIR` adds the in-cone part of the subtree only: src's own new
// file, never one under the sibling, which is refused by name.
try writeFile(io, tmp_b.dir, "src/extra.zig", "extra\n");
try tmp_b.dir.createDirPath(io, "src/bar");
try writeFile(io, tmp_b.dir, "src/bar/new.zig", "new\n");
var add_bar = try runZit(gpa, io, tmp_b.dir, &.{ "add", "src/bar" });
defer freeResult(gpa, &add_bar);
switch (add_bar.term) {
.exited => |code| try std.testing.expect(code != 0),
else => return error.TestUnexpectedResult,
}
try std.testing.expect(std.mem.indexOf(u8, add_bar.stderr, "cone") != null);
var add_src = try runZit(gpa, io, tmp_b.dir, &.{ "add", "src" });
defer freeResult(gpa, &add_src);
try expectExitDiag(add_src.term, 0, add_src);
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, "src/extra.zig") != null);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "src/bar/new.zig") == null);
var rm = try runZit(gpa, io, tmp_b.dir, &.{ "rm", "src/extra.zig" });
defer freeResult(gpa, &rm);
try expectExitDiag(rm.term, 0, rm);
// `cone add` keeps the property: the parent levels stay covered, and the
// new member's own levels join them.
var add = try runZit(gpa, io, tmp_b.dir, &.{ "cone", "add", "docs" });
defer freeResult(gpa, &add);
try expectExitDiag(add.term, 0, add);
try std.testing.expect(fileExists(io, tmp_b.dir, "docs/d.txt"));
try std.testing.expect(fileExists(io, tmp_b.dir, "README"));
try std.testing.expect(fileExists(io, tmp_b.dir, "src/main.zig"));
var t2 = try runZit(gpa, io, tmp_b.dir, &.{ "cone", "test", "build.zig" });
defer freeResult(gpa, &t2);
try expectExitDiag(t2.term, 0, t2);
try std.testing.expect(std.mem.indexOf(u8, t2.stdout, "(parent directory)") != null);
var rm_cone = try runZit(gpa, io, tmp_b.dir, &.{ "cone", "remove", "docs" });
defer freeResult(gpa, &rm_cone);
try expectExitDiag(rm_cone.term, 0, rm_cone);
try std.testing.expect(!fileExists(io, tmp_b.dir, "docs/d.txt"));
try std.testing.expect(fileExists(io, tmp_b.dir, "README"));
// Restating the cone without the flag replaces it whole.
var restate = try runZit(gpa, io, tmp_b.dir, &.{ "update", "--no-sync", "--cone=src/foo", fx.c2 });
defer freeResult(gpa, &restate);
try expectExitDiag(restate.term, 0, restate);
try std.testing.expect(!fileExists(io, tmp_b.dir, "README"));
try std.testing.expect(fileExists(io, tmp_b.dir, "src/foo/a.zig"));
// The flag states a property of a cone, so it needs one.
var bare = try runZit(gpa, io, tmp_b.dir, &.{ "update", "--no-sync", "--cone-parents", fx.c2 });
defer freeResult(gpa, &bare);
try expectExitDiag(bare.term, 1, bare);
try std.testing.expect(std.mem.indexOf(u8, bare.stderr, "--cone-parents needs --cone=PATH") != null);
}