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