Skip to content
zit Artifact [916158da35]
Login

Artifact [916158da35]

Artifact 916158da35c16e0c0123e1b2d00b7231d3f5a5149a4feba3836e117caa95f54c:


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