Skip to content
zit Artifact [6a2894c139]
Login

Artifact [6a2894c139]

Artifact 6a2894c1393a0acec39d443c7895cee923c8deee971855e7fbcc8708d3a343b3:


const std = @import("std");
const support = @import("support.zig");
const addManaged = support.addManaged;
const chmodFile = support.chmodFile;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const freeResult = support.freeResult;
const initRepo = support.initRepo;
const isExecutableFile = support.isExecutableFile;
const readFile = support.readFile;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const storeBytesAlloc = support.storeBytesAlloc;
const writeFile = support.writeFile;

/// A repository in `repo/` with trunk and a branch `feat` that merge
/// cleanly: each side edits a different line of a.txt, feat also makes run.sh
/// executable, adds new.txt and removes gone.txt.
fn seedMergeTreeRepo(gpa: std.mem.Allocator, io: std.Io, repo: std.Io.Dir) !void {
    try initRepo(gpa, io, repo);
    try writeFile(io, repo, "a.txt", "one\ntwo\nthree\n");
    try writeFile(io, repo, "run.sh", "echo hi\n");
    try writeFile(io, repo, "keep.txt", "keep\n");
    try writeFile(io, repo, "gone.txt", "gone\n");
    try addManaged(gpa, io, repo, &.{ "a.txt", "run.sh", "keep.txt", "gone.txt" });
    var root = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &root);
    try expectExitDiag(root.term, 0, root);

    try writeFile(io, repo, "a.txt", "ONE\ntwo\nthree\n");
    try chmodFile(io, repo, "run.sh", 0o755);
    try writeFile(io, repo, "new.txt", "new\n");
    try addManaged(gpa, io, repo, &.{"new.txt"});
    var rm = try runZit(gpa, io, repo, &.{ "rm", "gone.txt" });
    defer freeResult(gpa, &rm);
    try expectExitDiag(rm.term, 0, rm);
    try repo.deleteFile(io, "gone.txt"); // rm untracks; the file stays, as in Fossil
    var feat = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "feat work", "--branch", "feat" });
    defer freeResult(gpa, &feat);
    try expectExitDiag(feat.term, 0, feat);

    var back = try runZit(gpa, io, repo, &.{ "update", "trunk" });
    defer freeResult(gpa, &back);
    try expectExitDiag(back.term, 0, back);
    try writeFile(io, repo, "a.txt", "one\ntwo\nTHREE\n");
    var edit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "trunk work" });
    defer freeResult(gpa, &edit);
    try expectExitDiag(edit.term, 0, edit);
}

/// `a` and `b` hold the same files: same names, bytes and execute bits.
fn expectSameTree(gpa: std.mem.Allocator, io: std.Io, a: std.Io.Dir, b: std.Io.Dir, names: []const []const u8) !void {
    for (names) |name| {
        const x = try readFile(gpa, io, a, name);
        defer gpa.free(x);
        const y = try readFile(gpa, io, b, name);
        defer gpa.free(y);
        std.testing.expectEqualStrings(x, y) catch |e| {
            std.debug.print("\ndiffers: {s}\n", .{name});
            return e;
        };
        try std.testing.expectEqual(try isExecutableFile(io, a, name), try isExecutableFile(io, b, name));
    }
}

test "cli merge-tree: a clean pair writes the tree zit merge leaves, modes included, and the store is unchanged" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedMergeTreeRepo(gpa, io, repo);
    const before = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(before);

    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--out", "mt", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExitDiag(mt.term, 0, mt);
    // Two runs of one pair give one archive, byte for byte.
    var tar1 = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--tar", "-R", "repo" });
    defer freeResult(gpa, &tar1);
    try expectExitDiag(tar1.term, 0, tar1);
    var tar2 = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--tar", "-R", "repo" });
    defer freeResult(gpa, &tar2);
    try std.testing.expectEqualSlices(u8, tar1.stdout, tar2.stdout);
    {
        const after = try storeBytesAlloc(gpa, io, repo);
        defer gpa.free(after);
        try std.testing.expectEqualSlices(u8, before, after);
    }

    // The same merge in a checkout of trunk.
    var merged = try runZit(gpa, io, repo, &.{ "merge", "feat" });
    defer freeResult(gpa, &merged);
    try expectExitDiag(merged.term, 0, merged);
    var out = try tmp.dir.openDir(io, "mt", .{ .iterate = true });
    defer out.close(io);
    const names = [_][]const u8{ "a.txt", "keep.txt", "new.txt", "run.sh" };
    try expectSameTree(gpa, io, repo, out, &names);
    try std.testing.expect(try isExecutableFile(io, out, "run.sh"));
    try std.testing.expectError(error.FileNotFound, out.statFile(io, "gone.txt", .{}));
    var count: usize = 0;
    var walk = out.iterate();
    while (try walk.next(io)) |_| count += 1;
    try std.testing.expectEqual(names.len, count);

    // The archive unpacks to the same tree.
    try writeFile(io, tmp.dir, "mt.tar.gz", tar1.stdout);
    try tmp.dir.createDir(io, "untar", .default_dir);
    var untar = try tmp.dir.openDir(io, "untar", .{});
    defer untar.close(io);
    var tar_x = try std.process.run(gpa, io, .{ .argv = &.{ "/usr/bin/tar", "-xzf", "../mt.tar.gz" }, .cwd = .{ .dir = untar } });
    defer freeResult(gpa, &tar_x);
    try expectExitDiag(tar_x.term, 0, tar_x);
    try expectSameTree(gpa, io, out, untar, &names);
}

test "cli merge-tree: a conflicting pair exits 5, lists every conflicting path, and writes nothing" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try initRepo(gpa, io, repo);
    try writeFile(io, repo, "a.txt", "base\n");
    try writeFile(io, repo, "b.txt", "base\n");
    try writeFile(io, repo, "c.txt", "base\n");
    try addManaged(gpa, io, repo, &.{ "a.txt", "b.txt", "c.txt" });
    var root = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &root);
    try expectExitDiag(root.term, 0, root);
    try writeFile(io, repo, "a.txt", "feat\n");
    try writeFile(io, repo, "b.txt", "feat\n");
    var feat = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "feat", "--branch", "feat" });
    defer freeResult(gpa, &feat);
    try expectExitDiag(feat.term, 0, feat);
    var back = try runZit(gpa, io, repo, &.{ "update", "trunk" });
    defer freeResult(gpa, &back);
    try expectExitDiag(back.term, 0, back);
    try writeFile(io, repo, "a.txt", "trunk\n");
    try writeFile(io, repo, "b.txt", "trunk\n");
    try writeFile(io, repo, "c.txt", "trunk\n");
    var edit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "trunk" });
    defer freeResult(gpa, &edit);
    try expectExitDiag(edit.term, 0, edit);
    const before = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(before);

    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--out", "mt", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExit(mt.term, 5);
    try std.testing.expectEqualStrings("a.txt\nb.txt\n", mt.stdout);
    try std.testing.expectError(error.FileNotFound, tmp.dir.statFile(io, "mt", .{}));
    var tar = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--tar", "-R", "repo" });
    defer freeResult(gpa, &tar);
    try expectExit(tar.term, 5);
    try std.testing.expectEqualStrings("a.txt\nb.txt\n", tar.stdout);
    const after = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(after);
    try std.testing.expectEqualSlices(u8, before, after);

    // Already in the target: the target's own tree, said on stderr.
    var root_in = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "feat", "--out", "same", "-R", "repo" });
    defer freeResult(gpa, &root_in);
    try expectExitDiag(root_in.term, 0, root_in);
    try std.testing.expect(std.mem.indexOf(u8, root_in.stderr, "already in") != null);
    var same = try tmp.dir.openDir(io, "same", .{});
    defer same.close(io);
    const a = try readFile(gpa, io, same, "a.txt");
    defer gpa.free(a);
    try std.testing.expectEqualStrings("feat\n", a);
}

/// A repository in `repo/` where trunk and `feat` conflict every way a path
/// can: w.go region by region (feat changes A and C, trunk changes C and
/// appends a function), logo.bin binary on both, old.txt deleted on feat and
/// edited on trunk, add.txt added by both.
fn seedConflictRepo(gpa: std.mem.Allocator, io: std.Io, repo: std.Io.Dir) !void {
    try initRepo(gpa, io, repo);
    try writeFile(io, repo, "w.go", "package w\ntype T struct {\n\tA int\n\tB int\n\tC int\n}\n");
    try writeFile(io, repo, "logo.bin", "\x00base");
    try writeFile(io, repo, "old.txt", "old\n");
    try writeFile(io, repo, "keep.txt", "keep\n");
    try addManaged(gpa, io, repo, &.{ "w.go", "logo.bin", "old.txt", "keep.txt" });
    var root = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &root);
    try expectExitDiag(root.term, 0, root);

    try writeFile(io, repo, "w.go", "package w\ntype T struct {\n\tA int64\n\tB int\n\tC bool\n}\n");
    try writeFile(io, repo, "logo.bin", "\x00feat");
    try writeFile(io, repo, "add.txt", "feat\n");
    try addManaged(gpa, io, repo, &.{"add.txt"});
    var rm = try runZit(gpa, io, repo, &.{ "rm", "old.txt" });
    defer freeResult(gpa, &rm);
    try expectExitDiag(rm.term, 0, rm);
    try repo.deleteFile(io, "old.txt");
    var feat = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "feat work", "--branch", "feat" });
    defer freeResult(gpa, &feat);
    try expectExitDiag(feat.term, 0, feat);

    var back = try runZit(gpa, io, repo, &.{ "update", "trunk" });
    defer freeResult(gpa, &back);
    try expectExitDiag(back.term, 0, back);
    try writeFile(io, repo, "w.go", "package w\ntype T struct {\n\tA int\n\tB int\n\tC string\n}\nfunc f() {}\n");
    try writeFile(io, repo, "logo.bin", "\x00trunk");
    try writeFile(io, repo, "old.txt", "old, edited\n");
    try writeFile(io, repo, "add.txt", "trunk\n");
    try addManaged(gpa, io, repo, &.{"add.txt"});
    var edit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "trunk work" });
    defer freeResult(gpa, &edit);
    try expectExitDiag(edit.term, 0, edit);
}

/// One region of the -F json document, as `[kind, base, current, other]`.
fn expectJsonRegion(v: std.json.Value, kind: []const u8, b: [2]i64, c: [2]i64, o: [2]i64) !void {
    try std.testing.expectEqualStrings(kind, v.object.get("kind").?.string);
    inline for (.{ "base", "current", "other" }, .{ b, c, o }) |side, want| {
        const arr = v.object.get(side).?.array.items;
        try std.testing.expectEqual(want[0], arr[0].integer);
        try std.testing.expectEqual(want[1], arr[1].integer);
    }
}

fn jsonFile(doc: std.json.Value, path: []const u8) ?std.json.Value {
    for (doc.object.get("files").?.array.items) |f| {
        if (std.mem.eql(u8, f.object.get("path").?.string, path)) return f;
    }
    return null;
}

test "cli merge-tree -F json: every conflicting file, its blobs and modes, and the regions the merge found" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedConflictRepo(gpa, io, repo);
    const before = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(before);

    // The author's direction: trunk merged into feat, so current is feat.
    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExit(mt.term, 5);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    const doc = parsed.value;
    try std.testing.expectEqualStrings("conflict", doc.object.get("verdict").?.string);
    for ([_][]const u8{ "base", "current", "other" }) |k| try std.testing.expectEqual(@as(usize, 64), doc.object.get(k).?.string.len);
    const files = doc.object.get("files").?.array.items;
    const want_paths = [_][]const u8{ "add.txt", "logo.bin", "old.txt", "w.go" };
    const want_kinds = [_][]const u8{ "add-add", "binary", "delete-modify", "text" };
    try std.testing.expectEqual(want_paths.len, files.len);
    for (files, want_paths, want_kinds) |f, p, k| {
        try std.testing.expectEqualStrings(p, f.object.get("path").?.string);
        try std.testing.expectEqualStrings(k, f.object.get("kind").?.string);
        try std.testing.expectEqual(std.mem.eql(u8, k, "text"), f.object.get("regions") != null);
    }
    const add = jsonFile(doc, "add.txt").?;
    try std.testing.expect(add.object.get("base").? == .null);
    try std.testing.expect(add.object.get("mode").?.object.get("base").? == .null);
    const old = jsonFile(doc, "old.txt").?;
    try std.testing.expect(old.object.get("current").? == .null);
    try std.testing.expectEqualStrings("regular", old.object.get("mode").?.object.get("other").?.string);
    const w = jsonFile(doc, "w.go").?;
    const regions = w.object.get("regions").?.array.items;
    try std.testing.expectEqual(@as(usize, 6), regions.len);
    try expectJsonRegion(regions[0], "same", .{ 0, 2 }, .{ 0, 2 }, .{ 0, 2 });
    try expectJsonRegion(regions[1], "current", .{ 2, 3 }, .{ 2, 3 }, .{ 2, 3 });
    try expectJsonRegion(regions[2], "same", .{ 3, 4 }, .{ 3, 4 }, .{ 3, 4 });
    try expectJsonRegion(regions[3], "conflict", .{ 4, 5 }, .{ 4, 5 }, .{ 4, 5 });
    try expectJsonRegion(regions[4], "same", .{ 5, 6 }, .{ 5, 6 }, .{ 5, 6 });
    try expectJsonRegion(regions[5], "other", .{ 6, 6 }, .{ 6, 6 }, .{ 6, 7 });
    // The blob hashes name the exact bytes.
    var cat = try runZit(gpa, io, tmp.dir, &.{ "artifact", w.object.get("other").?.string, "--raw", "-R", "repo" });
    defer freeResult(gpa, &cat);
    try expectExitDiag(cat.term, 0, cat);
    try std.testing.expectEqualStrings("package w\ntype T struct {\n\tA int\n\tB int\n\tC string\n}\nfunc f() {}\n", cat.stdout);

    // The other direction swaps the labels, never the boundaries.
    var sw = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &sw);
    try expectExit(sw.term, 5);
    const sw_parsed = try std.json.parseFromSlice(std.json.Value, gpa, sw.stdout, .{});
    defer sw_parsed.deinit();
    try std.testing.expectEqualStrings(doc.object.get("current").?.string, sw_parsed.value.object.get("other").?.string);
    try std.testing.expectEqualStrings("modify-delete", jsonFile(sw_parsed.value, "old.txt").?.object.get("kind").?.string);
    const sw_regions = jsonFile(sw_parsed.value, "w.go").?.object.get("regions").?.array.items;
    try expectJsonRegion(sw_regions[1], "other", .{ 2, 3 }, .{ 2, 3 }, .{ 2, 3 });
    try expectJsonRegion(sw_regions[5], "current", .{ 6, 6 }, .{ 6, 7 }, .{ 6, 6 });

    // Every verdict is a document.
    var same = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &same);
    try expectExitDiag(same.term, 0, same);
    const same_parsed = try std.json.parseFromSlice(std.json.Value, gpa, same.stdout, .{});
    defer same_parsed.deinit();
    try std.testing.expectEqualStrings("up-to-date", same_parsed.value.object.get("verdict").?.string);
    try std.testing.expect(same_parsed.value.object.get("base").? == .null);
    try std.testing.expectEqual(@as(usize, 0), same_parsed.value.object.get("files").?.array.items.len);

    var both = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "--tar", "-R", "repo" });
    defer freeResult(gpa, &both);
    try expectExit(both.term, 2);

    const after = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(after);
    try std.testing.expectEqualSlices(u8, before, after);
}

test "cli merge-tree -F json: a mode both sides changed is not a conflict, and binary on one side is" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try initRepo(gpa, io, repo);
    try writeFile(io, repo, "run.sh", "one\ntwo\nthree\n");
    try writeFile(io, repo, "pic.dat", "text\n");
    try addManaged(gpa, io, repo, &.{ "run.sh", "pic.dat" });
    var root = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &root);
    try expectExitDiag(root.term, 0, root);
    try writeFile(io, repo, "run.sh", "ONE\ntwo\nthree\n");
    try chmodFile(io, repo, "run.sh", 0o755);
    try writeFile(io, repo, "pic.dat", "\x00now binary\n");
    var feat = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "feat", "--branch", "feat" });
    defer freeResult(gpa, &feat);
    try expectExitDiag(feat.term, 0, feat);
    var back = try runZit(gpa, io, repo, &.{ "update", "trunk" });
    defer freeResult(gpa, &back);
    try expectExitDiag(back.term, 0, back);
    try writeFile(io, repo, "run.sh", "one\ntwo\nTHREE\n");
    try chmodFile(io, repo, "run.sh", 0o755);
    try writeFile(io, repo, "pic.dat", "text, edited\n");
    var edit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "trunk" });
    defer freeResult(gpa, &edit);
    try expectExitDiag(edit.term, 0, edit);

    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExit(mt.term, 5);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    const files = parsed.value.object.get("files").?.array.items;
    try std.testing.expectEqual(@as(usize, 1), files.len);
    try std.testing.expectEqualStrings("pic.dat", files[0].object.get("path").?.string);
    try std.testing.expectEqualStrings("binary", files[0].object.get("kind").?.string);
    try std.testing.expect(files[0].object.get("regions") == null);
}

test "cli merge-tree -F json: a clean pair is a clean document with its base" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedMergeTreeRepo(gpa, io, repo);
    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExitDiag(mt.term, 0, mt);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    try std.testing.expectEqualStrings("clean", parsed.value.object.get("verdict").?.string);
    try std.testing.expectEqual(@as(usize, 64), parsed.value.object.get("base").?.string.len);
    try std.testing.expectEqual(@as(usize, 0), parsed.value.object.get("files").?.array.items.len);
}

/// The resolutions both tests below give: w.go settled by hand, the binary
/// and the add/add taken from feat and trunk, old.txt deleted.
const conflict_resolution_w = "package w\ntype T struct {\n\tA int64\n\tB int\n\tC string\n}\nfunc f() {}\n";

fn writeConflictResolutions(io: std.Io, dir: std.Io.Dir) !void {
    try writeFile(io, dir, "w.go", conflict_resolution_w);
    try writeFile(io, dir, "logo.bin", "\x00feat");
    try writeFile(io, dir, "add.txt", "feat\ntrunk\n");
}

fn zitStdoutAlloc(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir, argv: []const []const u8) ![]u8 {
    var r = try runZit(gpa, io, dir, argv);
    defer freeResult(gpa, &r);
    try expectExitDiag(r.term, 0, r);
    return gpa.dupe(u8, r.stdout);
}

test "cli merge-tree --commit: records the merge with the caller's resolutions, as merge and commit in a checkout would" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedConflictRepo(gpa, io, repo);

    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExit(mt.term, 5);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    const cur = parsed.value.object.get("current").?.string;
    const oth = parsed.value.object.get("other").?.string;

    try tmp.dir.createDir(io, "res", .default_dir);
    var res = try tmp.dir.openDir(io, "res", .{});
    defer res.close(io);
    try writeConflictResolutions(io, res);
    const before = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(before);

    // Each refusal writes nothing.
    {
        // A page drawn against another pair.
        var stale = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "--commit", "--resolved", "res", "--delete", "old.txt", "-m", "settle", "--user", "jan", "--expect-current", oth, "--expect-other", oth, "-R", "repo" });
        defer freeResult(gpa, &stale);
        try expectExit(stale.term, 5);
        // A conflicting path left unanswered.
        var short = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "--commit", "--resolved", "res", "-m", "settle", "--user", "jan", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
        defer freeResult(gpa, &short);
        try expectExit(short.term, 1);
        try std.testing.expect(std.mem.indexOf(u8, short.stderr, "no resolution for 'old.txt'") != null);
        // An answer for a path that did not conflict.
        try writeFile(io, res, "keep.txt", "keep\n");
        var extra = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "--commit", "--resolved", "res", "--delete", "old.txt", "-m", "settle", "--user", "jan", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
        defer freeResult(gpa, &extra);
        try expectExit(extra.term, 1);
        try std.testing.expect(std.mem.indexOf(u8, extra.stderr, "'keep.txt' is not a conflicting path") != null);
        try res.deleteFile(io, "keep.txt");
        // An answer that is still a conflict.
        try writeFile(io, res, "w.go", "<<<<<<< current\nA\n=======\nB\n>>>>>>> other\n");
        var marked = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "--commit", "--resolved", "res", "--delete", "old.txt", "-m", "settle", "--user", "jan", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
        defer freeResult(gpa, &marked);
        try expectExit(marked.term, 1);
        try std.testing.expect(std.mem.indexOf(u8, marked.stderr, "'w.go' still holds a conflict") != null);
        try writeFile(io, res, "w.go", conflict_resolution_w);
        const after = try storeBytesAlloc(gpa, io, repo);
        defer gpa.free(after);
        try std.testing.expectEqualSlices(u8, before, after);
    }

    var ok = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "--commit", "--resolved", "res", "--delete", "old.txt", "-m", "settle", "--user", "jan", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
    defer freeResult(gpa, &ok);
    try expectExitDiag(ok.term, 0, ok);
    try std.testing.expect(std.mem.startsWith(u8, ok.stdout, "check-in "));
    try std.testing.expect(std.mem.endsWith(u8, ok.stdout, " on feat\n"));
    const merged = ok.stdout["check-in ".len..][0..64];
    // No working area is left behind.
    var listing = try tmp.dir.openDir(io, "repo", .{ .iterate = true });
    defer listing.close(io);
    var walk = listing.iterate();
    while (try walk.next(io)) |e| try std.testing.expect(!std.mem.startsWith(u8, e.name, ".zit-merge-tree-"));

    // The branch now holds trunk, and the landing direction merges cleanly.
    var again = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &again);
    try expectExitDiag(again.term, 0, again);
    try std.testing.expect(std.mem.indexOf(u8, again.stdout, "\"verdict\":\"up-to-date\"") != null);
    var land = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &land);
    try expectExitDiag(land.term, 0, land);
    try std.testing.expect(std.mem.indexOf(u8, land.stdout, "\"verdict\":\"clean\"") != null);

    // The same answers given by hand in a checkout of an identical history
    // record the same file set.
    try tmp.dir.createDir(io, "hand", .default_dir);
    var hand = try tmp.dir.openDir(io, "hand", .{});
    defer hand.close(io);
    try seedConflictRepo(gpa, io, hand);
    var up = try runZit(gpa, io, hand, &.{ "update", "feat" });
    defer freeResult(gpa, &up);
    try expectExitDiag(up.term, 0, up);
    var hm = try runZit(gpa, io, hand, &.{ "merge", "trunk" });
    defer freeResult(gpa, &hm);
    try expectExit(hm.term, 1);
    try writeConflictResolutions(io, hand);
    var hrm = try runZit(gpa, io, hand, &.{ "rm", "old.txt" });
    defer freeResult(gpa, &hrm);
    hand.deleteFile(io, "old.txt") catch {};
    var hc = try runCommitEnv(gpa, io, hand, .{ .user = "jan" }, &.{ "commit", "-m", "settle" });
    defer freeResult(gpa, &hc);
    try expectExitDiag(hc.term, 0, hc);
    const by_store = try zitStdoutAlloc(gpa, io, tmp.dir, &.{ "ls", merged, "--long", "-R", "repo" });
    defer gpa.free(by_store);
    const by_hand = try zitStdoutAlloc(gpa, io, hand, &.{ "ls", "--long" });
    defer gpa.free(by_hand);
    try std.testing.expectEqualStrings(by_hand, by_store);
    try std.testing.expect(std.mem.indexOf(u8, by_store, "old.txt") == null);
}

test "cli merge-tree --commit: a clean merge is recorded with no answers, as merge and commit in a checkout would" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedMergeTreeRepo(gpa, io, repo);

    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExitDiag(mt.term, 0, mt);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    try std.testing.expectEqualStrings("clean", parsed.value.object.get("verdict").?.string);
    const cur = parsed.value.object.get("current").?.string;
    const oth = parsed.value.object.get("other").?.string;
    const before = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(before);

    // Nothing conflicts, so any answer is for a path that does not, and the
    // expect checks still hold.
    {
        try tmp.dir.createDir(io, "res", .default_dir);
        var res = try tmp.dir.openDir(io, "res", .{});
        defer res.close(io);
        try writeFile(io, res, "a.txt", "mine\n");
        var extra = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--commit", "--resolved", "res", "-m", "merge feat", "--user", "u", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
        defer freeResult(gpa, &extra);
        try expectExit(extra.term, 1);
        try std.testing.expect(std.mem.indexOf(u8, extra.stderr, "'a.txt' is not a conflicting path") != null);
        var del = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--commit", "--delete", "keep.txt", "-m", "merge feat", "--user", "u", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
        defer freeResult(gpa, &del);
        try expectExit(del.term, 1);
        try std.testing.expect(std.mem.indexOf(u8, del.stderr, "'keep.txt' is not a conflicting path") != null);
        var stale = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "--commit", "-m", "merge feat", "--user", "u", "--expect-current", oth, "--expect-other", oth, "-R", "repo" });
        defer freeResult(gpa, &stale);
        try expectExit(stale.term, 5);
        const after = try storeBytesAlloc(gpa, io, repo);
        defer gpa.free(after);
        try std.testing.expectEqualSlices(u8, before, after);
    }

    // The source named by its hash, not a branch, as `zit merge` takes it.
    var ok = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", oth, "--into", "trunk", "--commit", "-m", "merge feat", "--user", "u", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
    defer freeResult(gpa, &ok);
    try expectExitDiag(ok.term, 0, ok);
    try std.testing.expect(std.mem.startsWith(u8, ok.stdout, "check-in "));
    try std.testing.expect(std.mem.endsWith(u8, ok.stdout, " on trunk\n"));
    const merged = ok.stdout["check-in ".len..][0..64];
    var listing = try tmp.dir.openDir(io, "repo", .{ .iterate = true });
    defer listing.close(io);
    var walk = listing.iterate();
    while (try walk.next(io)) |e| try std.testing.expect(!std.mem.startsWith(u8, e.name, ".zit-merge-tree-"));

    // The merge is recorded: feat is now in trunk.
    var again = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &again);
    try expectExitDiag(again.term, 0, again);
    try std.testing.expect(std.mem.indexOf(u8, again.stdout, "\"verdict\":\"up-to-date\"") != null);

    // The same merge by hand in a checkout of an identical history records
    // the same file set, modes included.
    try tmp.dir.createDir(io, "hand", .default_dir);
    var hand = try tmp.dir.openDir(io, "hand", .{});
    defer hand.close(io);
    try seedMergeTreeRepo(gpa, io, hand);
    var hm = try runZit(gpa, io, hand, &.{ "merge", "feat" });
    defer freeResult(gpa, &hm);
    try expectExitDiag(hm.term, 0, hm);
    var hc = try runCommitEnv(gpa, io, hand, .{ .user = "u" }, &.{ "commit", "-m", "merge feat" });
    defer freeResult(gpa, &hc);
    try expectExitDiag(hc.term, 0, hc);
    const by_store = try zitStdoutAlloc(gpa, io, tmp.dir, &.{ "ls", merged, "--long", "-R", "repo" });
    defer gpa.free(by_store);
    const by_hand = try zitStdoutAlloc(gpa, io, hand, &.{ "ls", "--long" });
    defer gpa.free(by_hand);
    try std.testing.expectEqualStrings(by_hand, by_store);
    try std.testing.expect(std.mem.indexOf(u8, by_store, "gone.txt") == null);
    try std.testing.expect(std.mem.indexOf(u8, by_store, "new.txt") != null);
}

/// A clean pair whose sides touch no file in common: feat adds h.txt, trunk
/// adds g.txt.
fn seedDisjointMergeRepo(gpa: std.mem.Allocator, io: std.Io, repo: std.Io.Dir) !void {
    try initRepo(gpa, io, repo);
    try writeFile(io, repo, "f.txt", "a\n");
    try addManaged(gpa, io, repo, &.{"f.txt"});
    var base = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "base" });
    defer freeResult(gpa, &base);
    try expectExitDiag(base.term, 0, base);
    try writeFile(io, repo, "h.txt", "h\n");
    try addManaged(gpa, io, repo, &.{"h.txt"});
    var feat = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "feat", "--branch", "feat" });
    defer freeResult(gpa, &feat);
    try expectExitDiag(feat.term, 0, feat);
    var back = try runZit(gpa, io, repo, &.{ "update", "trunk" });
    defer freeResult(gpa, &back);
    try expectExitDiag(back.term, 0, back);
    try writeFile(io, repo, "g.txt", "g\n");
    try addManaged(gpa, io, repo, &.{"g.txt"});
    var trunk = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "trunk" });
    defer freeResult(gpa, &trunk);
    try expectExitDiag(trunk.term, 0, trunk);
}

test "cli merge-tree --commit: a clean merge whose sides share no changed file is recorded" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedDisjointMergeRepo(gpa, io, repo);

    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "feat", "--into", "trunk", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExitDiag(mt.term, 0, mt);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    const cur = parsed.value.object.get("current").?.string;
    const oth = parsed.value.object.get("other").?.string;

    var ok = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "--into", "trunk", "--commit", "-m", "m", "--user", "u", "--expect-current", cur, "--expect-other", oth, "-R", "repo", "--", oth });
    defer freeResult(gpa, &ok);
    try expectExitDiag(ok.term, 0, ok);
    try std.testing.expect(std.mem.endsWith(u8, ok.stdout, " on trunk\n"));
    const merged = ok.stdout["check-in ".len..][0..64];

    // The same merge by hand in a checkout of an identical history.
    try tmp.dir.createDir(io, "hand", .default_dir);
    var hand = try tmp.dir.openDir(io, "hand", .{});
    defer hand.close(io);
    try seedDisjointMergeRepo(gpa, io, hand);
    var hm = try runZit(gpa, io, hand, &.{ "merge", "feat" });
    defer freeResult(gpa, &hm);
    try expectExitDiag(hm.term, 0, hm);
    var hc = try runCommitEnv(gpa, io, hand, .{ .user = "u" }, &.{ "commit", "-m", "m" });
    defer freeResult(gpa, &hc);
    try expectExitDiag(hc.term, 0, hc);
    const by_store = try zitStdoutAlloc(gpa, io, tmp.dir, &.{ "ls", merged, "--long", "-R", "repo" });
    defer gpa.free(by_store);
    const by_hand = try zitStdoutAlloc(gpa, io, hand, &.{ "ls", "--long" });
    defer gpa.free(by_hand);
    try std.testing.expectEqualStrings(by_hand, by_store);
    try std.testing.expect(std.mem.indexOf(u8, by_store, "g.txt") != null);
    try std.testing.expect(std.mem.indexOf(u8, by_store, "h.txt") != null);
}

test "cli merge-tree: a store without one side's content reports that file unreadable, and --commit refuses it" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedConflictRepo(gpa, io, repo);
    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExit(mt.term, 5);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    const cur = parsed.value.object.get("current").?.string;
    const oth = parsed.value.object.get("other").?.string;
    const w_feat = jsonFile(parsed.value, "w.go").?.object.get("current").?.string;

    // Take feat's w.go out of the store, as a store that never fetched it.
    var sh = try runZit(gpa, io, repo, &.{ "shun", "--force", w_feat });
    defer freeResult(gpa, &sh);
    try expectExitDiag(sh.term, 0, sh);

    var gone = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &gone);
    try expectExit(gone.term, 5);
    const doc = try std.json.parseFromSlice(std.json.Value, gpa, gone.stdout, .{});
    defer doc.deinit();
    const w = jsonFile(doc.value, "w.go").?;
    try std.testing.expectEqualStrings("unreadable", w.object.get("kind").?.string);
    try std.testing.expectEqualStrings(w_feat, w.object.get("current").?.string);
    try std.testing.expect(w.object.get("regions") == null);
    // The other conflicts are still reported as they were.
    try std.testing.expectEqualStrings("binary", jsonFile(doc.value, "logo.bin").?.object.get("kind").?.string);
    try std.testing.expectEqual(
        parsed.value.object.get("files").?.array.items.len,
        doc.value.object.get("files").?.array.items.len,
    );

    try tmp.dir.createDir(io, "res", .default_dir);
    var res = try tmp.dir.openDir(io, "res", .{});
    defer res.close(io);
    try writeConflictResolutions(io, res);
    const before = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(before);
    var refused = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "--commit", "--resolved", "res", "--delete", "old.txt", "-m", "settle", "--user", "jan", "--expect-current", cur, "--expect-other", oth, "-R", "repo" });
    defer freeResult(gpa, &refused);
    try expectExit(refused.term, 1);
    try std.testing.expect(std.mem.indexOf(u8, refused.stderr, "does not hold the content of 'w.go'") != null);
    const after = try storeBytesAlloc(gpa, io, repo);
    defer gpa.free(after);
    try std.testing.expectEqualSlices(u8, before, after);
}

test "cli merge-tree --commit: a path one side deleted is kept by resolving it" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    try seedConflictRepo(gpa, io, repo);
    var mt = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "-F", "json", "-R", "repo" });
    defer freeResult(gpa, &mt);
    try expectExit(mt.term, 5);
    const parsed = try std.json.parseFromSlice(std.json.Value, gpa, mt.stdout, .{});
    defer parsed.deinit();
    try tmp.dir.createDir(io, "res", .default_dir);
    var res = try tmp.dir.openDir(io, "res", .{});
    defer res.close(io);
    try writeConflictResolutions(io, res);
    try writeFile(io, res, "old.txt", "old, kept\n");
    var ok = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", "trunk", "--into", "feat", "--commit", "--resolved", "res", "-m", "keep it", "--user", "jan", "--expect-current", parsed.value.object.get("current").?.string, "--expect-other", parsed.value.object.get("other").?.string, "-R", "repo" });
    defer freeResult(gpa, &ok);
    try expectExitDiag(ok.term, 0, ok);
    const merged = ok.stdout["check-in ".len..][0..64];
    var mto = try runZit(gpa, io, tmp.dir, &.{ "merge-tree", merged, "--into", merged, "--out", "tree", "-R", "repo" });
    defer freeResult(gpa, &mto);
    try expectExitDiag(mto.term, 0, mto);
    var tree = try tmp.dir.openDir(io, "tree", .{});
    defer tree.close(io);
    const old = try readFile(gpa, io, tree, "old.txt");
    defer gpa.free(old);
    try std.testing.expectEqualStrings("old, kept\n", old);
}