const std = @import("std");
const repeat = @import("zit").repeat;
const checkout = @import("zit").checkout;
const support = @import("support.zig");
const addManaged = support.addManaged;
const bareStoreOf = support.bareStoreOf;
const buildMergeDiamond = support.buildMergeDiamond;
const buildMergeFan = support.buildMergeFan;
const checkinHash = support.checkinHash;
const chmodFile = support.chmodFile;
const commitFile = support.commitFile;
const commitForkDup = support.commitForkDup;
const commitHashDup = support.commitHashDup;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectFileContent = support.expectFileContent;
const expectMergeState = support.expectMergeState;
const expectNonzeroExit = support.expectNonzeroExit;
const fileExists = support.fileExists;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const isExecutableFile = support.isExecutableFile;
const parentCards = support.parentCards;
const parseCheckin = support.parseCheckin;
const readFile = support.readFile;
const runCommitEnv = support.runCommitEnv;
const runShell = support.runShell;
const runZit = support.runZit;
const sectionExists = support.sectionExists;
const seedContentMergeable = support.seedContentMergeable;
const spawnServe = support.spawnServe;
const statusMergeLines = support.statusMergeLines;
const tipHashOf = support.tipHashOf;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;
// ==========================================================================
// `zit merge` end-to-end tests (contracts/merge.md B-merge-1..29). Each spawns
// the REAL binary in an isolated, pinned environment and builds its DAG through
// real check-ins (commit → update → commit forks a diamond), then drives
// `zit merge` and asserts exit code + stdout/stderr + on-disk state read back
// through the library. Cases that need the commit P-card extension (the next,
// separate component) — B-merge-8/9/10/11/12 — are deferred to that slice.
// ==========================================================================
/// The verbatim `zit merge` help — must match `main.zig`'s `merge_help`
/// byte-for-byte (drift fails B-merge-25).
const merge_help_expected =
\\usage: zit merge [-X ours|theirs] [--no-sync] [--no-precedent]
\\ [--baseline B] [--integrate] [NAME]
\\ zit merge --probe|-n|--dry-run NAME... [--into TARGET]
\\ zit merge --cherrypick NAME
\\ zit merge --backout NAME
\\
\\Merge the check-in NAME into the working tree with a three-way merge and
\\record it as a pending merge parent. NAME resolves like 'zit info' — a full
\\or abbreviated artifact ID, a branch, or a tag; with no NAME, the one
\\other open leaf is merged (several is an error naming them). This does
\\not create a check-in; run 'zit commit' to record the merge. Conflicts are written into
\\the working files with conflict markers and listed on stderr — resolve them
\\and commit, or run 'zit undo' to abandon the merge.
\\
\\Uncommitted work does not block the merge: your working file is the merge's
\\own "current" side, so a region only you changed stays yours and a region
\\only NAME changed is applied around it. Where the two collide you get
\\markers, the same as any other conflict, and 'zit undo' restores the
\\uncommitted bytes.
\\
\\Merges stack, as in Fossil: a merge, cherrypick or backout made while
\\others are pending is added to them, 'zit status' lists each, and the
\\commit names every merged check-in as a parent in the order merged. A
\\plain merge's base then counts the pending merges as well as the
\\check-out. 'zit undo' takes back only the last one.
\\
\\-X resolves every CONTENT conflict in favour of one side instead of writing
\\markers: 'ours' keeps the working tree's version wherever the two sides
\\disagree, 'theirs' takes NAME's. Regions only one side changed are still
\\that side's either way -- -X answers only what the merge could not, so it
\\is not "discard their work", it is "stop asking me". The mechanical cases
\\are what it is for: a regenerated lockfile, a vendored tree taken whole
\\from upstream.
\\
\\--probe answers "would this merge cleanly?" and writes NOTHING -- no merge,
\\no working tree touched, no autosync. It prints one line, `merges` followed
\\by clean, up-to-date, unrelated, or conflict (N), and then one
\\`conflict PATH` line per unresolvable path. Exit status is 0 in every one
\\of those cases: "has conflicts" is an answer, not a failure, so a caller
\\reads the line rather than the status.
\\
\\Given several NAMEs, --probe answers a STACK: each NAME against TARGET
\\with the NAMEs before it already landed, in memory, in order. One line
\\per NAME -- `merges NAME` and its verdict -- with `conflict PATH` lines
\\under the one that stops, and `not-reached` for every NAME after it: a
\\merge that did not complete leaves nothing to continue from. This is
\\not the same as probing each NAME against the one below it: that says
\\nothing about what TARGET changed meanwhile, so it can call a rung
\\clean that stops the landing.
\\
\\Being a read, --probe takes -R and needs no checkout -- but then there is
\\no current check-in to merge into, so --into TARGET is required. In a
\\checkout it defaults to the check-in you are on, exactly as a real merge
\\takes its other side. A real merge refuses -R: it writes a working tree.
\\
\\-X ours IS NOT --backout. --backout reverses NAME's change; -X ours keeps
\\your side where the two collide and reverses nothing. They read alike and
\\do different things, which is the misread worth avoiding.
\\
\\One case -X deliberately does not answer: a file one side modified and the
\\other deleted. That is a disagreement about whether the file should exist,
\\not about its contents, and either reading silently destroys work -- so it
\\stays a conflict for you to settle, with or without -X.
\\
\\--cherrypick and --backout are special merges that pick an alternate
\\baseline instead of the common ancestor: --cherrypick applies only NAME's
\\own change onto the working tree, --backout reverses it. 'zit commit' then
\\records the operation as a cherry-pick/backout, not as a merge parent.
\\
\\options:
\\ -h, --help show this help and exit
\\ -X, --strategy ours|theirs
\\ resolve content conflicts in favour of one side
\\ --no-sync skip the autosync pull for this invocation
\\ --no-precedent do not replay remembered conflict resolutions for
\\ this merge (see 'zit precedent'); nothing is
\\ forgotten, only declined
\\ --cherrypick NAME apply only NAME's own change onto the working tree
\\ --backout NAME reverse NAME's change on the working tree
\\ -n, --dry-run the same as --probe
\\ --baseline B use check-in B as the common ancestor instead of
\\ the computed merge base
\\ --integrate close NAME's leaf when this merge is committed
\\
\\exit status:
\\ 0 success
\\ 1 operational failure (not a repository, unreadable state, a refused
\\ action) — the diagnostic on stderr names it
\\ 2 usage error (an unknown option or unexpected argument)
\\
;
test "cli merge B-merge-1/-2/-3: clean disjoint merge lands both sides, records the parent, mints no check-in" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Disjoint edits: current changed line 1, other changed line 3.
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nB\nC1\n", "A1\nB\nC\n");
defer fx.deinit(gpa);
// B-merge-2 oracle: `.zit` is byte-identical across the merge — no blob and
// no manifest is appended, so the merge is provably not a check-in.
const zit_before = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_before);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
// B-merge-1: the three-way result lands byte-for-byte, exit 0, one line to
// stdout naming the other side and the changed-file count; stderr empty.
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("A1\nB\nC1\n", poem);
var line_buf: [256]u8 = undefined;
const want_line = try std.fmt.bufPrint(&line_buf, "merged {s} into the working tree (1 file(s) changed)\n", .{fx.other});
try std.testing.expectEqualStrings(want_line, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
// B-merge-1: the merge parent is recorded; the version is unchanged (no
// advance — merge does not mint).
try expectMergeState(io, tmp.dir, fx.current, fx.other);
// B-merge-2: `.zit` unchanged.
const zit_after = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_after);
try std.testing.expectEqualSlices(u8, zit_before, zit_after);
// B-merge-3: the undo journal is armed (present after the merge).
try std.testing.expect(sectionExists(gpa, io, tmp.dir, .undo));
}
test "cli merge B-merge-5: a disjoint add/delete file set merges from the §8.2 walk" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Root with two files. Other adds `their`; current adds `ours`. The merge
// must union both additions (each added on exactly one side).
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "shared", "base\n");
try addManaged(gpa, io, tmp.dir, &.{"shared"});
const base = try commitHashDup(gpa, io, tmp.dir, "root");
defer gpa.free(base);
try writeFile(io, tmp.dir, "their", "theirs\n");
try addManaged(gpa, io, tmp.dir, &.{"their"});
const other = try commitHashDup(gpa, io, tmp.dir, "other-adds");
defer gpa.free(other);
var up = try runZit(gpa, io, tmp.dir, &.{ "update", base });
defer freeResult(gpa, &up);
try expectExit(up.term, 0);
try writeFile(io, tmp.dir, "ours", "ours\n");
try addManaged(gpa, io, tmp.dir, &.{"ours"});
const current = try commitForkDup(gpa, io, tmp.dir, "current-adds");
defer gpa.free(current);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", other });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
// `their` materialized from the other side; `ours`/`shared` retained.
const their = try readFile(gpa, io, tmp.dir, "their");
defer gpa.free(their);
try std.testing.expectEqualStrings("theirs\n", their);
try std.testing.expect(fileExists(io, tmp.dir, "ours"));
try std.testing.expect(fileExists(io, tmp.dir, "shared"));
try expectMergeState(io, tmp.dir, current, other);
}
test "cli merge B-merge-7: an overlapping edit conflicts — markers in-tree, path on stderr, exit 1, parent recorded" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Both sides change the SAME line differently → a content conflict.
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nY\nC\n", "A\nX\nC\n");
defer fx.deinit(gpa);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
// Conflict surfacing: stdout empty; each conflicted path plus a summary on
// stderr.
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "zit merge: conflict in poem\n") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "1 conflict(s); resolve and commit, or run 'zit undo'") != null);
// The file carries fossil-style diff3 markers.
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expect(std.mem.indexOf(u8, poem, "<<<<<<< current\n") != null);
try std.testing.expect(std.mem.indexOf(u8, poem, "||||||| base\n") != null);
try std.testing.expect(std.mem.indexOf(u8, poem, "=======\n") != null);
try std.testing.expect(std.mem.indexOf(u8, poem, ">>>>>>> other\n") != null);
// The merge is NOT abandoned — the parent is recorded despite the conflict.
try expectMergeState(io, tmp.dir, fx.current, fx.other);
}
test "cli merge: an edit next to the other side's edit merges cleanly, as Fossil's merge does" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Current edits b, other edits the line after it. Fossil's merge3 takes
// each edit inside lines the other side left alone; no line both sides
// kept separates them, and that is not needed for a clean merge.
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "a\nb\nc\n", "a\nb\nC\n", "a\nB\nc\n");
defer fx.deinit(gpa);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExitDiag(res.term, 0, res);
try expectFileContent(gpa, io, tmp.dir, "poem", "a\nB\nC\n");
try expectMergeState(io, tmp.dir, fx.current, fx.other);
}
test "cli merge B-merge-19: delete-vs-modify is a whole-file conflict" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Root has `poem`. Other modifies it; current deletes it (rm + commit).
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "poem", "A\nB\nC\n");
try addManaged(gpa, io, tmp.dir, &.{"poem"});
const base = try commitHashDup(gpa, io, tmp.dir, "root");
defer gpa.free(base);
try writeFile(io, tmp.dir, "poem", "A\nB\nMODIFIED\n");
const other = try commitHashDup(gpa, io, tmp.dir, "other-modifies");
defer gpa.free(other);
var up = try runZit(gpa, io, tmp.dir, &.{ "update", base });
defer freeResult(gpa, &up);
try expectExit(up.term, 0);
var rmres = try runZit(gpa, io, tmp.dir, &.{ "rm", "--hard", "poem" });
defer freeResult(gpa, &rmres);
try expectExit(rmres.term, 0);
const current = try commitForkDup(gpa, io, tmp.dir, "current-deletes");
defer gpa.free(current);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", other });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "zit merge: conflict in poem\n") != null);
// The conflicting path is written with markers (never silently resolved).
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expect(std.mem.indexOf(u8, poem, "<<<<<<< current\n") != null);
try expectMergeState(io, tmp.dir, current, other);
}
test "cli merge B-merge-13: undo restores the pre-merge files and clears the merge parent" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nY\nC\n", "A\nX\nC\n");
defer fx.deinit(gpa);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExit(res.term, 1); // a conflict merge, but still recorded
var undo = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &undo);
try expectExit(undo.term, 0);
// The working file is back to the pre-merge current content, and the merge
// parent is cleared — the tree is indistinguishable from before the merge.
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("A\nX\nC\n", poem);
try expectMergeState(io, tmp.dir, fx.current, "");
}
test "cli merge: a mode the other side alone changed is merged, as Fossil does" {
// The merge decided each path by blob hash and then always kept the
// target's mode, so a branch that made a script executable merged as
// "nothing changed". Fossil applies it: EXECUTABLE run.sh.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "run.sh", "echo hi\n");
try writeFile(io, tmp.dir, "a.txt", "a\n");
try addManaged(gpa, io, tmp.dir, &.{ "run.sh", "a.txt" });
var root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &root);
try expectExitDiag(root.term, 0, root);
try chmodFile(io, tmp.dir, "run.sh", 0o755);
var feat = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "exec", "--branch", "feat" });
defer freeResult(gpa, &feat);
try expectExitDiag(feat.term, 0, feat);
var back = try runZit(gpa, io, tmp.dir, &.{ "update", "trunk" });
defer freeResult(gpa, &back);
try expectExitDiag(back.term, 0, back);
try std.testing.expect(!try isExecutableFile(io, tmp.dir, "run.sh"));
try writeFile(io, tmp.dir, "a.txt", "a\nb\n");
var edit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "trunk edit" });
defer freeResult(gpa, &edit);
try expectExitDiag(edit.term, 0, edit);
var merged = try runZit(gpa, io, tmp.dir, &.{ "merge", "feat" });
defer freeResult(gpa, &merged);
try expectExitDiag(merged.term, 0, merged);
try std.testing.expect(try isExecutableFile(io, tmp.dir, "run.sh"));
const a_now = try readFile(gpa, io, tmp.dir, "a.txt");
defer gpa.free(a_now);
try std.testing.expectEqualStrings("a\nb\n", a_now);
// And it is what the merge check-in records.
var ci = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "merge feat" });
defer freeResult(gpa, &ci);
try expectExitDiag(ci.term, 0, ci);
var away = try runZit(gpa, io, tmp.dir, &.{ "update", "feat" });
defer freeResult(gpa, &away);
var again = try runZit(gpa, io, tmp.dir, &.{ "update", "trunk" });
defer freeResult(gpa, &again);
try expectExitDiag(again.term, 0, again);
try std.testing.expect(try isExecutableFile(io, tmp.dir, "run.sh"));
}
test "cli merge: a dirty working tree merges into, and the local edit survives" {
// Was B-merge-14, which refused a dirty tree outright. It refused because
// the merge computed over the checkout's EFFECTIVE content — what the
// check-in says is on disk — and a dirty tree contradicts that. Making the
// current side the working tree removes the contradiction rather than
// carving an exception around it.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Five lines so the three contributions can occupy genuinely separate
// regions: the current check-in changes line 1, the other side line 5, and
// the uncommitted edit line 3. Adjacent edits legitimately conflict, so a
// test for the CLEAN case has to keep them apart.
var fx = try buildMergeDiamond(
gpa,
io,
tmp.dir,
"A\nB\nC\nD\nE\n",
"A\nB\nC\nD\nE1\n",
"A1\nB\nC\nD\nE\n",
);
defer fx.deinit(gpa);
// An uncommitted edit makes the tree dirty, in a region neither check-in
// touched.
try writeFile(io, tmp.dir, "poem", "A1\nB\nDIRTY\nD\nE\n");
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("", res.stderr);
// The merge parent is recorded exactly as a clean merge records it.
try expectMergeState(io, tmp.dir, fx.current, fx.other);
// All three contributions survive: the current check-in's A1, the other
// side's E1, and the uncommitted DIRTY line that used to block the merge.
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("A1\nB\nDIRTY\nD\nE1\n", poem);
}
test "cli merge: a dirty region the other side also changed conflicts, and keeps both" {
// The other half: carrying the edit is not the same as preferring it. Where
// the uncommitted work and the merged branch touch the same region, the
// merge writes an envelope rather than silently choosing.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fx = try buildMergeDiamond(
gpa,
io,
tmp.dir,
"A\nB\nC\nD\nE\n",
"A\nB\nC\nD\nE1\n",
"A1\nB\nC\nD\nE\n",
);
defer fx.deinit(gpa);
// Uncommitted work on the SAME line the other side changed.
try writeFile(io, tmp.dir, "poem", "A1\nB\nC\nD\nMINE\n");
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "conflict in poem") != null);
// Pending merge still recorded, so `zit undo` can abandon it (B-merge-3/7/35).
try expectMergeState(io, tmp.dir, fx.current, fx.other);
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expect(std.mem.indexOf(u8, poem, "MINE") != null);
try std.testing.expect(std.mem.indexOf(u8, poem, "E1") != null);
// `undo` puts the uncommitted bytes back — the merge is fully abandonable
// even though it started from a dirty tree.
var undo = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &undo);
try expectExit(undo.term, 0);
const restored = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(restored);
try std.testing.expectEqualStrings("A1\nB\nC\nD\nMINE\n", restored);
}
test "cli merge stacked: two and then three merges accumulate; the commit's P card names each in merge order" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fan = try buildMergeFan(gpa, io, tmp.dir);
defer fan.deinit(gpa);
// Merge in DESCENDING hash order, so a P card that sorted its merge
// parents (instead of keeping the order they were merged) would differ.
var order = [_][]const u8{ fan.x, fan.y, fan.z };
std.mem.sort([]const u8, &order, {}, struct {
fn gt(_: void, a: []const u8, b: []const u8) bool {
return std.mem.order(u8, a, b) == .gt;
}
}.gt);
var want_status: std.ArrayList(u8) = .empty;
defer want_status.deinit(gpa);
for (order, 0..) |h, i| {
var mg = try runZit(gpa, io, tmp.dir, &.{ "merge", h });
defer freeResult(gpa, &mg);
try expectExitDiag(mg.term, 0, mg);
// Status lists every pending merge.
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
for (order[0 .. i + 1]) |p| {
var line_buf: [96]u8 = undefined;
const line = try std.fmt.bufPrint(&line_buf, "MERGED_WITH {s}\n", .{p});
try std.testing.expect(std.mem.indexOf(u8, listed, line) != null);
}
try std.testing.expectEqual(i + 1, std.mem.count(u8, listed, "MERGED_WITH "));
}
for ([_][2][]const u8{ .{ "a", "a" }, .{ "b", "b" }, .{ "c", "c" }, .{ "d", "d" } }) |want| {
const got = try readFile(gpa, io, tmp.dir, want[0]);
defer gpa.free(got);
try std.testing.expectEqualStrings(want[1], got);
}
const merged = try commitHashDup(gpa, io, tmp.dir, "three-way stack");
defer gpa.free(merged);
const cards = try parentCards(gpa, io, tmp.dir, merged);
defer gpa.free(cards);
const want = try std.fmt.allocPrint(gpa, "P {s} {s} {s} {s}\n", .{ fan.current, order[0], order[1], order[2] });
defer gpa.free(want);
try std.testing.expectEqualStrings(want, cards);
// The commit consumed every pending merge.
const after = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(after);
try std.testing.expectEqualStrings("", after);
}
test "cli merge stacked: a conflicting second merge keeps both pending; the resolved commit names both" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// root A..E; other edits line 3 to X; current edits line 1; a third fork
// y edits line 3 to Y, so y collides with what `other` already brought in.
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\nD\nE\n", "A\nB\nX\nD\nE\n", "A1\nB\nC\nD\nE\n");
defer fx.deinit(gpa);
var up = try runZit(gpa, io, tmp.dir, &.{ "update", fx.base });
defer freeResult(gpa, &up);
try expectExit(up.term, 0);
try writeFile(io, tmp.dir, "poem", "A\nB\nY\nD\nE\n");
const y = try commitForkDup(gpa, io, tmp.dir, "y");
defer gpa.free(y);
var back = try runZit(gpa, io, tmp.dir, &.{ "update", fx.current });
defer freeResult(gpa, &back);
try expectExit(back.term, 0);
var first = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &first);
try expectExitDiag(first.term, 0, first);
var second = try runZit(gpa, io, tmp.dir, &.{ "merge", y });
defer freeResult(gpa, &second);
try expectExit(second.term, 1);
try std.testing.expect(std.mem.indexOf(u8, second.stderr, "conflict in poem") != null);
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expect(std.mem.indexOf(u8, poem, "X") != null);
try std.testing.expect(std.mem.indexOf(u8, poem, "Y") != null);
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
try std.testing.expectEqual(@as(usize, 2), std.mem.count(u8, listed, "MERGED_WITH "));
try writeFile(io, tmp.dir, "poem", "A1\nB\nXY\nD\nE\n");
const merged = try commitHashDup(gpa, io, tmp.dir, "resolved");
defer gpa.free(merged);
const cards = try parentCards(gpa, io, tmp.dir, merged);
defer gpa.free(cards);
const want = try std.fmt.allocPrint(gpa, "P {s} {s} {s}\n", .{ fx.current, fx.other, y });
defer gpa.free(want);
try std.testing.expectEqualStrings(want, cards);
}
test "cli merge stacked: the base of a stacked merge counts the pending merges, as Fossil's pivot does" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// root A..E -> x (line 3 = X) -> y (line 3 = Y); current forks root and
// edits line 1. With x pending, y's base is x itself, so y's X->Y is a
// clean change. A base that ignored the pending merge would be root, and
// line 3 would conflict (C->X here, C->Y there).
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\nD\nE\n", "A\nB\nX\nD\nE\n", "A1\nB\nC\nD\nE\n");
defer fx.deinit(gpa);
var up = try runZit(gpa, io, tmp.dir, &.{ "update", fx.other });
defer freeResult(gpa, &up);
try expectExit(up.term, 0);
try writeFile(io, tmp.dir, "poem", "A\nB\nY\nD\nE\n");
const y = try commitHashDup(gpa, io, tmp.dir, "y");
defer gpa.free(y);
var back = try runZit(gpa, io, tmp.dir, &.{ "update", fx.current });
defer freeResult(gpa, &back);
try expectExit(back.term, 0);
var first = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &first);
try expectExitDiag(first.term, 0, first);
var second = try runZit(gpa, io, tmp.dir, &.{ "merge", y });
defer freeResult(gpa, &second);
try expectExitDiag(second.term, 0, second);
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("A1\nB\nY\nD\nE\n", poem);
}
test "cli merge stacked: merging a check-in already pending is not refused and records it once" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fan = try buildMergeFan(gpa, io, tmp.dir);
defer fan.deinit(gpa);
var first = try runZit(gpa, io, tmp.dir, &.{ "merge", fan.x });
defer freeResult(gpa, &first);
try expectExitDiag(first.term, 0, first);
var again = try runZit(gpa, io, tmp.dir, &.{ "merge", fan.x });
defer freeResult(gpa, &again);
try expectExitDiag(again.term, 0, again);
const b = try readFile(gpa, io, tmp.dir, "b");
defer gpa.free(b);
try std.testing.expectEqualStrings("b", b);
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
const want_line = try std.fmt.allocPrint(gpa, "MERGED_WITH {s}\n", .{fan.x});
defer gpa.free(want_line);
try std.testing.expectEqualStrings(want_line, listed);
const merged = try commitHashDup(gpa, io, tmp.dir, "once");
defer gpa.free(merged);
const cards = try parentCards(gpa, io, tmp.dir, merged);
defer gpa.free(cards);
const want = try std.fmt.allocPrint(gpa, "P {s} {s}\n", .{ fan.current, fan.x });
defer gpa.free(want);
try std.testing.expectEqualStrings(want, cards);
}
test "cli merge stacked: a cherrypick and a backout on a pending merge commit as P plus sorted Q cards" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fan = try buildMergeFan(gpa, io, tmp.dir);
defer fan.deinit(gpa);
// Backing out y once it is merged takes its edit of `c` back out.
const steps = [_][]const []const u8{
&.{ "merge", fan.x },
&.{ "merge", "--cherrypick", fan.z },
&.{ "merge", fan.y },
&.{ "merge", "--backout", fan.y },
};
for (steps) |argv| {
var r = try runZit(gpa, io, tmp.dir, argv);
defer freeResult(gpa, &r);
try expectExitDiag(r.term, 0, r);
}
for ([_][2][]const u8{ .{ "a", "a" }, .{ "b", "b" }, .{ "c", "base\n" }, .{ "d", "d" } }) |want| {
const got = try readFile(gpa, io, tmp.dir, want[0]);
defer gpa.free(got);
try std.testing.expectEqualStrings(want[1], got);
}
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
try std.testing.expectEqual(@as(usize, 2), std.mem.count(u8, listed, "MERGED_WITH "));
try std.testing.expect(std.mem.indexOf(u8, listed, "pending cherrypick of ") != null);
try std.testing.expect(std.mem.indexOf(u8, listed, "pending backout of ") != null);
const merged = try commitHashDup(gpa, io, tmp.dir, "stack with picks");
defer gpa.free(merged);
const cards = try parentCards(gpa, io, tmp.dir, merged);
defer gpa.free(cards);
// Fossil's order: merge parents as merged; Q cards sorted, '+' before '-'.
const want = try std.fmt.allocPrint(gpa, "P {s} {s} {s}\nQ +{s}\nQ -{s}\n", .{ fan.current, fan.x, fan.y, fan.z, fan.y });
defer gpa.free(want);
try std.testing.expectEqualStrings(want, cards);
}
test "cli merge B-merge-16: NAME is the checkout or an ancestor is up to date, exit 1" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nB\nC1\n", "A1\nB\nC\n");
defer fx.deinit(gpa);
// base is a proper ancestor of the current checkout.
var anc = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.base });
defer freeResult(gpa, &anc);
try expectExit(anc.term, 1);
try std.testing.expectEqualStrings("", anc.stdout);
try std.testing.expectEqualStrings("zit merge: already up to date; nothing to merge\n", anc.stderr);
try expectMergeState(io, tmp.dir, fx.current, "");
// The checkout itself is trivially up to date.
var self = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.current });
defer freeResult(gpa, &self);
try expectExit(self.term, 1);
try std.testing.expectEqualStrings("zit merge: already up to date; nothing to merge\n", self.stderr);
}
test "cli merge B-merge-16: a proper ancestor the merge-base mtime rule skips is still up to date, exit 1" {
// The bug the `base == other` proxy missed: a linear chain root <- mid <- tip
// whose event.mtimes are NON-monotone in DAG order (root carries the greatest
// mtime). Merging `mid` — a proper ancestor of the checkout `tip` — must be
// refused. But `mergeBaseOf(tip, mid)` selects the greatest-mtime common
// ancestor, which is `root`, NOT `mid`; so `base == other` (mid) is false and
// the old refusal wrongly let the merge proceed, recording an ancestor as a
// merge parent. The mtime-independent `isAncestorOf` gate catches it.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "poem", "A\n");
try addManaged(gpa, io, tmp.dir, &.{"poem"});
// root: the LATEST mtime, so it wins mergeBaseOf's greatest-mtime selection.
var c_root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u", .epoch = "2000000000" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &c_root);
try expectExit(c_root.term, 0);
try writeFile(io, tmp.dir, "poem", "A\nB\n");
// mid: an EARLIER mtime than its own parent — a proper ancestor of tip that
// the merge-base walk therefore never selects.
var c_mid = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u", .epoch = "1000000000" }, &.{ "commit", "-m", "mid" });
defer freeResult(gpa, &c_mid);
try expectExit(c_mid.term, 0);
const mid = try gpa.dupe(u8, try checkinHash(c_mid.stdout));
defer gpa.free(mid);
try writeFile(io, tmp.dir, "poem", "A\nB\nC\n");
var c_tip = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u", .epoch = "3000000000" }, &.{ "commit", "-m", "tip" });
defer freeResult(gpa, &c_tip);
try expectExit(c_tip.term, 0);
const tip = try gpa.dupe(u8, try checkinHash(c_tip.stdout));
defer gpa.free(tip);
// Merge the proper ancestor `mid`: up to date, refuse, mutate nothing.
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", mid });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit merge: already up to date; nothing to merge\n", res.stderr);
// No merge parent recorded; checkout still at tip; working tree untouched.
try expectMergeState(io, tmp.dir, tip, "");
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("A\nB\nC\n", poem);
}
test "cli merge B-merge-18: an unresolvable NAME fails with the resolver diagnostic, exit 1" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nB\nC1\n", "A1\nB\nC\n");
defer fx.deinit(gpa);
const absent = repeat("deadbeef", 8); // 64 hex, no such check-in
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", absent });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "not found") != null);
// Nothing mutated.
try expectMergeState(io, tmp.dir, fx.current, "");
}
test "cli merge B-merge-25: -h and --help print the verbatim help, exit 0, change nothing" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
for ([_][]const u8{ "-h", "--help" }) |flag| {
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", flag });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings(merge_help_expected, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
// help wins even over an otherwise-invalid trailing token.
var win = try runZit(gpa, io, tmp.dir, &.{ "merge", "--help", "-z" });
defer freeResult(gpa, &win);
try expectExit(win.term, 0);
try std.testing.expectEqualStrings(merge_help_expected, win.stdout);
}
test "cli merge B-merge-26: a missing NAME, an unknown option, or a second positional is a usage error, exit 2" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
const cases = [_][]const []const u8{
&.{ "merge", "--probe" }, // a probe needs NAME (a bare merge takes the sole other leaf)
&.{ "merge", "-x" }, // unknown option
&.{ "merge", "--force" }, // no override flag exists
&.{ "merge", "a", "b" }, // second positional
};
for (cases) |argv| {
var res = try runZit(gpa, io, tmp.dir, argv);
defer freeResult(gpa, &res);
try expectExit(res.term, 2);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "try 'zit merge --help'") != null);
}
}
test "cli merge B-merge-27: outside a repository fails with the not-a-repo diagnostic, exit 1" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{}); // NOT initialized
defer tmp.cleanup();
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "trunk" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "no zit checkout here") != null);
}
test "cli merge B-merge-28/-29: streams stay separated and the verb is wired into help" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// B-merge-29: the top-level help names the merge verb.
{
var help = try runZit(gpa, io, tmp.dir, &.{"help"});
defer freeResult(gpa, &help);
try expectExit(help.term, 0);
try std.testing.expect(std.mem.indexOf(u8, help.stdout, "\n merge ") != null);
}
// B-merge-28: a clean merge writes the confirmation to stdout only.
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nB\nC1\n", "A1\nB\nC\n");
defer fx.deinit(gpa);
{
var script_buf: [128]u8 = undefined;
const script = try std.fmt.bufPrint(&script_buf, "\"$ZIT\" merge {s} > out.txt 2> err.txt", .{fx.other});
var ok = try runShell(gpa, io, tmp.dir, script);
defer freeResult(gpa, &ok);
try expectExit(ok.term, 0);
const out = try readFile(gpa, io, tmp.dir, "out.txt");
defer gpa.free(out);
const err = try readFile(gpa, io, tmp.dir, "err.txt");
defer gpa.free(err);
try std.testing.expect(std.mem.startsWith(u8, out, "merged "));
try std.testing.expectEqualStrings("", err);
}
// B-merge-28: a conflict merge writes diagnostics to stderr only. Fresh repo.
var tmp2 = std.testing.tmpDir(.{});
defer tmp2.cleanup();
var fx2 = try buildMergeDiamond(gpa, io, tmp2.dir, "A\nB\nC\n", "A\nY\nC\n", "A\nX\nC\n");
defer fx2.deinit(gpa);
{
var script_buf: [128]u8 = undefined;
const script = try std.fmt.bufPrint(&script_buf, "\"$ZIT\" merge {s} > out.txt 2> err.txt", .{fx2.other});
var bad = try runShell(gpa, io, tmp2.dir, script);
defer freeResult(gpa, &bad);
try expectExit(bad.term, 1);
const out = try readFile(gpa, io, tmp2.dir, "out.txt");
defer gpa.free(out);
const err = try readFile(gpa, io, tmp2.dir, "err.txt");
defer gpa.free(err);
try std.testing.expectEqualStrings("", out);
try std.testing.expect(std.mem.indexOf(u8, err, "zit merge: conflict in poem\n") != null);
}
}
// ==========================================================================
// `zit merge --cherrypick / --backout` end-to-end tests (contracts/
// merge-flags.md B-merge-30..41). Special merges are alternate baseline choices
// inside the SAME merge machinery — no new verb. Each builds its DAG through
// real check-ins and asserts exit code + streams + on-disk state (working file
// bytes, the `.zit-checkout` special_op field, and the minted Q card) read back
// through the library.
// ==========================================================================
/// Reads `.zit-checkout` and asserts version, an EMPTY merge_parent (a special
/// merge is never a plain merge), and the pending special_op (sign + REV hash).
fn expectSpecialState(io: std.Io, dir: std.Io.Dir, version: []const u8, special_op: []const u8) !void {
var ckbuf: [checkout.max_ck_payload + 1]u8 = undefined;
const ck = (try checkout.read(io, dir, &ckbuf)).?;
try std.testing.expectEqualStrings(version, ck.version);
try std.testing.expectEqualStrings("", ck.merge_parent);
try std.testing.expectEqualStrings(special_op, ck.special_op);
}
test "cli merge: no NAME merges the sole other open leaf, -n probes, --integrate closes the leaf at commit, --baseline names the ancestor" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a", "a\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c1" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
const c1_hash = try checkinHash(c1.stdout);
try writeFile(io, tmp.dir, "b", "b\n");
try addManaged(gpa, io, tmp.dir, &.{"b"});
var feat = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "feat", "--branch", "feat" });
defer freeResult(gpa, &feat);
try expectExitDiag(feat.term, 0, feat);
var back = try runZit(gpa, io, tmp.dir, &.{ "update", "trunk" });
defer freeResult(gpa, &back);
try expectExitDiag(back.term, 0, back);
// -n is --probe: one answer line, nothing written.
var probe = try runZit(gpa, io, tmp.dir, &.{ "merge", "-n", "feat" });
defer freeResult(gpa, &probe);
try expectExitDiag(probe.term, 0, probe);
try std.testing.expect(std.mem.startsWith(u8, probe.stdout, "merges"));
try std.testing.expectError(error.FileNotFound, tmp.dir.access(io, "b", .{}));
// No NAME: feat is the one other open leaf.
var bare = try runZit(gpa, io, tmp.dir, &.{"merge"});
defer freeResult(gpa, &bare);
try expectExitDiag(bare.term, 0, bare);
try std.testing.expect(std.mem.startsWith(u8, bare.stdout, "merged "));
try expectFileContent(gpa, io, tmp.dir, "b", "b\n");
var un = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un);
try expectExit(un.term, 0);
// --baseline with the true merge base changes nothing; --integrate makes
// the commit close feat's leaf.
var integ = try runZit(gpa, io, tmp.dir, &.{ "merge", "--integrate", "--baseline", c1_hash, "feat" });
defer freeResult(gpa, &integ);
try expectExitDiag(integ.term, 0, integ);
var cm = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "land feat" });
defer freeResult(gpa, &cm);
try expectExitDiag(cm.term, 0, cm);
try std.testing.expect(std.mem.indexOf(u8, cm.stdout, "(integrated)") != null);
var closed = try runZit(gpa, io, tmp.dir, &.{ "branch", "-c" });
defer freeResult(gpa, &closed);
try expectExitDiag(closed.term, 0, closed);
try std.testing.expect(std.mem.indexOf(u8, closed.stdout, "feat") != null);
// Nothing left to merge without a name.
var none = try runZit(gpa, io, tmp.dir, &.{"merge"});
defer freeResult(gpa, &none);
try expectExit(none.term, 1);
try std.testing.expect(std.mem.indexOf(u8, none.stderr, "no other open leaf") != null);
}
test "cli merge B-merge-30/-36: cherrypick lands REV's own change, preserves current's edit, records +REV" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// R0 root; R1 changes line 3 (C->Z) — its OWN change relative to its parent.
// A fork off R0 (current, R2) changes a DISJOINT line 1 (A->Q).
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "poem", "A\nB\nC\n");
try addManaged(gpa, io, tmp.dir, &.{"poem"});
const r0 = try commitHashDup(gpa, io, tmp.dir, "root");
defer gpa.free(r0);
try writeFile(io, tmp.dir, "poem", "A\nB\nZ\n");
const r1 = try commitHashDup(gpa, io, tmp.dir, "rev");
defer gpa.free(r1);
var up = try runZit(gpa, io, tmp.dir, &.{ "update", r0 });
defer freeResult(gpa, &up);
try expectExit(up.term, 0);
try writeFile(io, tmp.dir, "poem", "Q\nB\nC\n");
const r2 = try commitForkDup(gpa, io, tmp.dir, "fork");
defer gpa.free(r2);
const zit_before = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_before);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
// Exactly REV's edit (line 3) is applied; current's own edit (line 1) is
// preserved — a three-way merge, not a copy.
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("Q\nB\nZ\n", poem);
var line_buf: [256]u8 = undefined;
const want_line = try std.fmt.bufPrint(&line_buf, "cherry-picked {s} into the working tree (1 file(s) changed)\n", .{r1});
try std.testing.expectEqualStrings(want_line, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
// The pending +REV op is recorded; version unchanged (no advance).
var sbuf: [70]u8 = undefined;
const want_op = try std.fmt.bufPrint(&sbuf, "+{s}", .{r1});
try expectSpecialState(io, tmp.dir, r2, want_op);
// Mints nothing: `.zit` byte-identical (B-merge-30). B-merge-36: the undo
// journal is armed (present) — durability ordering inherited from applyMerge.
const zit_after = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_after);
try std.testing.expectEqualSlices(u8, zit_before, zit_after);
try std.testing.expect(sectionExists(gpa, io, tmp.dir, .undo));
}
test "cli merge B-merge-32: backout reverses REV's change, records -REV" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// R0 root; R1 changes line 3 (C->Z). Checkout sits at R1; backing out R1
// reverses its change onto the working tree (base = R1, other = R1's parent).
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "poem", "A\nB\nC\n");
try addManaged(gpa, io, tmp.dir, &.{"poem"});
const r0 = try commitHashDup(gpa, io, tmp.dir, "root");
defer gpa.free(r0);
try writeFile(io, tmp.dir, "poem", "A\nB\nZ\n");
const r1 = try commitHashDup(gpa, io, tmp.dir, "rev");
defer gpa.free(r1);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--backout", r1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("A\nB\nC\n", poem); // line 3 reverted Z->C
var line_buf: [256]u8 = undefined;
const want_line = try std.fmt.bufPrint(&line_buf, "backed out {s} into the working tree (1 file(s) changed)\n", .{r1});
try std.testing.expectEqualStrings(want_line, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
var sbuf: [70]u8 = undefined;
const want_op = try std.fmt.bufPrint(&sbuf, "-{s}", .{r1});
try expectSpecialState(io, tmp.dir, r1, want_op);
}
test "cli merge B-merge-31: a plain merge mints NO Q card (negative-space regression)" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nB\nC1\n", "A1\nB\nC\n");
defer fx.deinit(gpa);
var mg = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &mg);
try expectExit(mg.term, 0);
// The plain merge records a merge_parent, never a special_op.
var ckbuf: [checkout.max_ck_payload + 1]u8 = undefined;
const ck = (try checkout.read(io, tmp.dir, &ckbuf)).?;
try std.testing.expectEqualStrings(fx.other, ck.merge_parent);
try std.testing.expectEqualStrings("", ck.special_op);
const commit = try commitHashDup(gpa, io, tmp.dir, "plain merge");
defer gpa.free(commit);
var stored = try parseCheckin(gpa, io, tmp.dir, commit);
defer stored.deinit();
// Two-token P card, NO Q card — the shipped merge surface, byte-unchanged.
try std.testing.expectEqual(@as(usize, 2), stored.m.p[0].count);
try std.testing.expectEqual(@as(usize, 0), stored.m.q.len);
}
test "cli merge B-merge-35: a cherrypick conflict writes markers, refuses commit, undo unwinds the pending Q state" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// R1 and R2 both change line 3 differently (Z vs W) → overlapping edit.
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "poem", "A\nB\nC\n");
try addManaged(gpa, io, tmp.dir, &.{"poem"});
const r0 = try commitHashDup(gpa, io, tmp.dir, "root");
defer gpa.free(r0);
try writeFile(io, tmp.dir, "poem", "A\nB\nZ\n");
const r1 = try commitHashDup(gpa, io, tmp.dir, "rev");
defer gpa.free(r1);
var up = try runZit(gpa, io, tmp.dir, &.{ "update", r0 });
defer freeResult(gpa, &up);
try expectExit(up.term, 0);
try writeFile(io, tmp.dir, "poem", "A\nB\nW\n");
const r2 = try commitForkDup(gpa, io, tmp.dir, "fork");
defer gpa.free(r2);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "zit merge: conflict in poem\n") != null);
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expect(std.mem.indexOf(u8, poem, "<<<<<<< current\n") != null);
// The pending op is recorded despite the conflict (not abandoned).
var sbuf: [70]u8 = undefined;
const want_op = try std.fmt.bufPrint(&sbuf, "+{s}", .{r1});
try expectSpecialState(io, tmp.dir, r2, want_op);
// commit REFUSES over the unresolved marker, minting nothing.
var bad = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "x" });
defer freeResult(gpa, &bad);
try expectExit(bad.term, 1);
try std.testing.expect(std.mem.indexOf(u8, bad.stderr, "unresolved conflict in poem") != null);
// undo unwinds the working file AND the pending Q state.
var un = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &un);
try expectExit(un.term, 0);
const restored = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(restored);
try std.testing.expectEqualStrings("A\nB\nW\n", restored);
var ckbuf: [checkout.max_ck_payload + 1]u8 = undefined;
const ck = (try checkout.read(io, tmp.dir, &ckbuf)).?;
try std.testing.expectEqualStrings("", ck.special_op);
try std.testing.expectEqualStrings(r2, ck.version);
}
test "cli merge B-merge-37: cherrypick of a root applies its adds; backout of a root deletes them" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// Cherrypick of a root: base = EMPTY parent set, other = the root's tree.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a", "hello\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
const r0 = try commitHashDup(gpa, io, tmp.dir, "root adds a");
defer gpa.free(r0);
// A child deletes `a`; the checkout then has no `a`.
var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "--hard", "a" });
defer freeResult(gpa, &rm);
try expectExit(rm.term, 0);
const r1 = try commitHashDup(gpa, io, tmp.dir, "child deletes a");
defer gpa.free(r1);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r0 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
const a = try readFile(gpa, io, tmp.dir, "a");
defer gpa.free(a);
try std.testing.expectEqualStrings("hello\n", a); // the root's add applied
}
// Backout of a root: base = the root's tree, other = EMPTY → its adds deleted.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a", "hello\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
const r0 = try commitHashDup(gpa, io, tmp.dir, "root adds a");
defer gpa.free(r0);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--backout", r0 });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(!fileExists(io, tmp.dir, "a")); // the root's add reversed
}
}
test "cli merge B-merge-38: an unresolvable REV refuses; a dirty tree and a pending op merge" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// Shared fork DAG: R0 root, R1 edits line 3, R2 forks off R0.
const build = struct {
fn dag(g: std.mem.Allocator, i: std.Io, d: std.Io.Dir, r: *[3][]const u8) !void {
try initRepo(g, i, d);
try writeFile(i, d, "poem", "A\nB\nC\n");
try addManaged(g, i, d, &.{"poem"});
r[0] = try commitHashDup(g, i, d, "root");
try writeFile(i, d, "poem", "A\nB\nZ\n");
r[1] = try commitHashDup(g, i, d, "rev");
var up = try runZit(g, i, d, &.{ "update", r[0] });
defer freeResult(g, &up);
try expectExit(up.term, 0);
try writeFile(i, d, "poem", "Q\nB\nC\n");
r[2] = try commitForkDup(g, i, d, "fork");
}
};
// (a) a dirty working tree is merged into, not refused. A special
// merge picks an alternate baseline but runs the same classifier, so it
// inherits the working-tree current side along with everything else.
// Here the uncommitted edit replaces the whole file, which collides with
// what the cherrypick wants to apply — a conflict, not a refusal.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var r: [3][]const u8 = undefined;
try build.dag(gpa, io, tmp.dir, &r);
defer for (r) |h| gpa.free(h);
try writeFile(io, tmp.dir, "poem", "dirty\n"); // uncommitted edit
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r[1] });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "conflict in poem") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "working tree is not clean") == null);
// The uncommitted bytes are still reachable in the envelope.
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expect(std.mem.indexOf(u8, poem, "dirty") != null);
}
// (b) a pending op does not refuse a second one (Fossil stacks them): a
// second cherrypick of the SAME change re-merges cleanly and is
// recorded once.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var r: [3][]const u8 = undefined;
try build.dag(gpa, io, tmp.dir, &r);
defer for (r) |h| gpa.free(h);
var first = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r[1] });
defer freeResult(gpa, &first);
try expectExit(first.term, 0);
var second = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r[1] });
defer freeResult(gpa, &second);
try expectExitDiag(second.term, 0, second);
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, listed, "pending cherrypick of "));
}
// (c) a plain merge stacks on a pending cherrypick.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var r: [3][]const u8 = undefined;
try build.dag(gpa, io, tmp.dir, &r);
defer for (r) |h| gpa.free(h);
var first = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r[1] });
defer freeResult(gpa, &first);
try expectExit(first.term, 0);
var plain = try runZit(gpa, io, tmp.dir, &.{ "merge", r[1] });
defer freeResult(gpa, &plain);
try expectExitDiag(plain.term, 0, plain);
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
try std.testing.expect(std.mem.indexOf(u8, listed, "pending cherrypick of ") != null);
try std.testing.expect(std.mem.indexOf(u8, listed, "MERGED_WITH ") != null);
}
// (d) a cherrypick stacks on a pending PLAIN merge -- here one that
// already brought the change in, so it re-merges cleanly.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var fx = try buildMergeDiamond(gpa, io, tmp.dir, "A\nB\nC\n", "A\nB\nC1\n", "A1\nB\nC\n");
defer fx.deinit(gpa);
var plain = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &plain);
try expectExit(plain.term, 0);
var cp = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", fx.other });
defer freeResult(gpa, &cp);
try expectExitDiag(cp.term, 0, cp);
const listed = try statusMergeLines(gpa, io, tmp.dir);
defer gpa.free(listed);
try std.testing.expect(std.mem.indexOf(u8, listed, "pending cherrypick of ") != null);
try std.testing.expect(std.mem.indexOf(u8, listed, "MERGED_WITH ") != null);
}
// (e) an unresolvable REV fails with the resolver diagnostic (B-merge-18).
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var r: [3][]const u8 = undefined;
try build.dag(gpa, io, tmp.dir, &r);
defer for (r) |h| gpa.free(h);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", "nope-not-a-rev" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "not found") != null);
}
}
test "cli merge B-merge-39: a cherrypick already contained in the checkout refuses, nothing mutated" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Checkout sits at R1 itself; cherrypicking R1 there classifies to zero
// entries (the change is already present) → "nothing to apply".
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "poem", "A\nB\nC\n");
try addManaged(gpa, io, tmp.dir, &.{"poem"});
const r0 = try commitHashDup(gpa, io, tmp.dir, "root");
defer gpa.free(r0);
try writeFile(io, tmp.dir, "poem", "A\nB\nZ\n");
const r1 = try commitHashDup(gpa, io, tmp.dir, "rev");
defer gpa.free(r1);
const zit_before = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_before);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", r1 });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "nothing to apply") != null);
// Nothing mutated: no pending op recorded, `.zit` untouched.
var ckbuf: [checkout.max_ck_payload + 1]u8 = undefined;
const ck = (try checkout.read(io, tmp.dir, &ckbuf)).?;
try std.testing.expectEqualStrings("", ck.special_op);
try std.testing.expectEqualStrings(r1, ck.version);
const zit_after = try readFile(gpa, io, tmp.dir, ".zit");
defer gpa.free(zit_after);
try std.testing.expectEqualSlices(u8, zit_before, zit_after);
}
test "cli merge B-merge-40: usage errors — both flags, a flag with no REV, an extra positional, unknown option" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
const cases = [_][]const []const u8{
&.{ "merge", "--cherrypick", "--backout", "rev" }, // mutually exclusive
&.{ "merge", "--cherrypick" }, // a flag with no REV
&.{ "merge", "--backout", "a", "b" }, // an extra positional beyond REV
&.{ "merge", "--bogus", "rev" }, // unknown option
};
for (cases) |argv| {
var res = try runZit(gpa, io, tmp.dir, argv);
defer freeResult(gpa, &res);
try expectExit(res.term, 2);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "try 'zit merge --help'") != null);
}
// The combined-flags diagnostic names the conflict.
var both = try runZit(gpa, io, tmp.dir, &.{ "merge", "--cherrypick", "--backout", "rev" });
defer freeResult(gpa, &both);
try std.testing.expect(std.mem.indexOf(u8, both.stderr, "--cherrypick and --backout cannot be combined") != null);
// B-merge-40: the help text carries the two flag lines.
var help = try runZit(gpa, io, tmp.dir, &.{ "merge", "--help" });
defer freeResult(gpa, &help);
try expectExit(help.term, 0);
try std.testing.expect(std.mem.indexOf(u8, help.stdout, "--cherrypick NAME") != null);
try std.testing.expect(std.mem.indexOf(u8, help.stdout, "--backout NAME") != null);
}
test "cli merge -X: ours and theirs resolve content conflicts, and neither is --backout" {
// The whole point of `-X` is the MECHANICAL conflict — a
// regenerated lockfile, a vendored tree taken from upstream — where
// resolving by hand is where mistakes enter. What it must NOT do is behave
// like "discard the other side": a region only one side touched is still
// that side's, whichever way -X points, and this pins that.
const gpa = std.testing.allocator;
const io = std.testing.io;
inline for (.{ "ours", "theirs" }) |strategy| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// f.txt: a middle line both sides rewrite (the conflict), plus a first
// line only CURRENT changes and a last line only OTHER changes. The
// unchanged filler between them is load-bearing: diff3 resolves per
// REGION between sync points, so edits on adjacent lines land in one
// region and the one-sided change is swallowed by the conflict. Spacing
// them apart is what makes "only one side changed it" a separate
// question the strategy must leave alone.
try writeFile(io, tmp.dir, "f.txt", "first\nq\nr\ncollide\ns\nt\nlast\n");
try addManaged(gpa, io, tmp.dir, &.{"f.txt"});
const base = try commitHashDup(gpa, io, tmp.dir, "base");
defer gpa.free(base);
try writeFile(io, tmp.dir, "f.txt", "first\nq\nr\nFROM_OTHER\ns\nt\nOTHER_ONLY\n");
const other = try commitHashDup(gpa, io, tmp.dir, "other");
defer gpa.free(other);
{
var up = try runZit(gpa, io, tmp.dir, &.{ "update", base });
defer freeResult(gpa, &up);
try expectExitDiag(up.term, 0, up);
}
try writeFile(io, tmp.dir, "f.txt", "CURRENT_ONLY\nq\nr\nFROM_CURRENT\ns\nt\nlast\n");
var cur = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "current", "--allow-fork" });
defer freeResult(gpa, &cur);
try expectExitDiag(cur.term, 0, cur);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "-X", strategy, other });
defer freeResult(gpa, &res);
try expectExitDiag(res.term, 0, res); // resolved: not a conflict exit
try std.testing.expectEqualStrings("", res.stderr);
const merged = try readFile(gpa, io, tmp.dir, "f.txt");
defer gpa.free(merged);
// No markers survive a resolving strategy.
try std.testing.expect(std.mem.indexOf(u8, merged, "<<<<<<<") == null);
// The collided line goes to the named side...
const want = if (std.mem.eql(u8, strategy, "ours")) "FROM_CURRENT" else "FROM_OTHER";
const unwanted = if (std.mem.eql(u8, strategy, "ours")) "FROM_OTHER" else "FROM_CURRENT";
try std.testing.expect(std.mem.indexOf(u8, merged, want) != null);
try std.testing.expect(std.mem.indexOf(u8, merged, unwanted) == null);
// ...while BOTH one-sided changes survive either way. `-X ours` that
// dropped OTHER_ONLY would be `--backout` wearing a different name.
try std.testing.expect(std.mem.indexOf(u8, merged, "CURRENT_ONLY") != null);
try std.testing.expect(std.mem.indexOf(u8, merged, "OTHER_ONLY") != null);
}
}
test "cli merge -X: a modify-versus-delete still conflicts, and bad values are usage errors" {
// -X answers "whose CONTENT wins". It does not answer "should this file
// exist", and either reading of that silently destroys work — so the one
// case it declines to guess is pinned here rather than left to drift.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "g.txt", "keep\n");
try addManaged(gpa, io, tmp.dir, &.{"g.txt"});
const base = try commitHashDup(gpa, io, tmp.dir, "base");
defer gpa.free(base);
var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "--hard", "g.txt" });
defer freeResult(gpa, &rm);
try expectExitDiag(rm.term, 0, rm);
const other = try commitHashDup(gpa, io, tmp.dir, "deleted");
defer gpa.free(other);
{
var up = try runZit(gpa, io, tmp.dir, &.{ "update", base });
defer freeResult(gpa, &up);
try expectExitDiag(up.term, 0, up);
}
try writeFile(io, tmp.dir, "g.txt", "keep\nedited\n");
var cur = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "edited", "--allow-fork" });
defer freeResult(gpa, &cur);
try expectExitDiag(cur.term, 0, cur);
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", "-X", "ours", other });
defer freeResult(gpa, &res);
try expectNonzeroExit(res.term);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "g.txt") != null);
// A strategy that is neither ours nor theirs, and a dangling -X, are usage
// errors rather than a silent fallback to leaving markers — which would
// look exactly like a strategy that had been applied and found nothing.
const bad = [_][]const []const u8{
&.{ "merge", "-X", "sideways", "tip" },
&.{ "merge", "-X" },
};
for (bad) |argv| {
var r = try runZit(gpa, io, tmp.dir, argv);
defer freeResult(gpa, &r);
try expectExit(r.term, 2);
try std.testing.expectEqualStrings("", r.stdout);
try std.testing.expect(std.mem.indexOf(u8, r.stderr, "ours or theirs") != null);
}
// The help must distinguish -X ours from --backout, which is the misread
// the flag is most exposed to.
var help = try runZit(gpa, io, tmp.dir, &.{ "merge", "--help" });
defer freeResult(gpa, &help);
try expectExitDiag(help.term, 0, help);
try std.testing.expect(std.mem.indexOf(u8, help.stdout, "-X ours IS NOT --backout") != null);
}
test "cli merge under a structural horizon: the hint for a branch below it names a remedy that works" {
// Horizon draft section 5.5: neither a name nor a full hash below a
// structural horizon resolves, so the hint must not send the user to
// the hash; it names the clones that hold the branch.
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp_a = std.testing.tmpDir(.{});
defer tmp_a.cleanup();
try initRepo(gpa, io, tmp_a.dir);
try writeFile(io, tmp_a.dir, "a", "a1\n");
try addManaged(gpa, io, tmp_a.dir, &.{"a"});
const h1 = try commitHashDup(gpa, io, tmp_a.dir, "one");
defer gpa.free(h1);
try writeFile(io, tmp_a.dir, "a", "a2\n");
const h2 = try commitHashDup(gpa, io, tmp_a.dir, "two");
defer gpa.free(h2);
var back = try runZit(gpa, io, tmp_a.dir, &.{ "update", h1 });
defer freeResult(gpa, &back);
try expectExitDiag(back.term, 0, back);
try writeFile(io, tmp_a.dir, "feat", "feature\n");
try addManaged(gpa, io, tmp_a.dir, &.{"feat"});
var cf = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "--branch", "feature", "-m", "feat" });
defer freeResult(gpa, &cf);
try expectExitDiag(cf.term, 0, cf);
const feature = try tipHashOf(gpa, io, tmp_a.dir, "feature");
defer gpa.free(feature);
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}", .{h2});
defer gpa.free(horizon_arg);
var tmp_b = std.testing.tmpDir(.{});
defer tmp_b.cleanup();
var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", horizon_arg, "--structural", 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);
for ([_][]const u8{ "feature", feature }) |name| {
var run = try runZit(gpa, io, b_dir, &.{ "merge", name });
defer freeResult(gpa, &run);
try expectExitDiag(run.term, 1, run);
try std.testing.expect(std.mem.indexOf(u8, run.stderr, "by hash") == null);
try std.testing.expect(std.mem.indexOf(u8, run.stderr, "re-clone with --horizon-rule=leaves") != null);
}
}
test "cli merge across the cone: theirs-only changes apply to the record; both-changed refuses" {
// Sparse-cone RFC section 4.4, record-level application. A dense
// contributor edits tools/ on a side branch; a src-coned checkout merges
// it: the out-of-cone change resolves at hash level into the merge
// overlay, the commit composes it, and a dense reader sees theirs'
// content -- nothing materialized out-of-cone, nothing lost. When BOTH
// sides changed the same out-of-cone file, the merge refuses naming it.
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 v1\n");
try writeFile(io, tmp_a.dir, "tools/t.bin", "tool v1\n");
try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.bin" });
const base = try commitHashDup(gpa, io, tmp_a.dir, "base");
defer gpa.free(base);
// The side branch: a dense edit to tools/t.bin.
try writeFile(io, tmp_a.dir, "tools/t.bin", "tool v2 from the side\n");
const side = try commitHashDup(gpa, io, tmp_a.dir, "side edit");
defer gpa.free(side);
// Rewind the dense tree to base so trunk and side diverge.
var back = try runZit(gpa, io, tmp_a.dir, &.{ "update", base });
defer freeResult(gpa, &back);
try expectExitDiag(back.term, 0, back);
try writeFile(io, tmp_a.dir, "src/a.zig", "src v2 on trunk\n");
// Diverging from base while `side` holds the leaf: a deliberate fork,
// so the fork guard asks for the flag.
var trunk_commit = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "trunk edit", "--allow-fork" });
defer freeResult(gpa, &trunk_commit);
try expectExitDiag(trunk_commit.term, 0, trunk_commit);
const trunk_tip = try gpa.dupe(u8, try checkinHash(trunk_commit.stdout));
defer gpa.free(trunk_tip);
// Sparse participant: cone=src, positioned at trunk_tip.
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", trunk_tip });
defer freeResult(gpa, &op);
try expectExitDiag(op.term, 0, op);
// The record-level merge: theirs' tools edit lands in the overlay.
var mg = try runZit(gpa, io, b_dir, &.{ "merge", side });
defer freeResult(gpa, &mg);
try expectExitDiag(mg.term, 0, mg);
try std.testing.expect(std.mem.indexOf(u8, mg.stdout, "1 out-of-cone change(s) applied to the record") != null);
try std.testing.expect(!fileExists(io, b_dir, "tools/t.bin")); // never materialized
var merge_commit = try runCommitEnv(gpa, io, b_dir, .{ .user = "u" }, &.{ "commit", "-m", "merge side" });
defer freeResult(gpa, &merge_commit);
try expectExitDiag(merge_commit.term, 0, merge_commit);
const merged = try gpa.dupe(u8, try checkinHash(merge_commit.stdout));
defer gpa.free(merged);
var push = try runZit(gpa, io, b_dir, &.{"push"});
defer freeResult(gpa, &push);
try expectExitDiag(push.term, 0, push);
// A dense reader of the merged check-in sees theirs' tools content.
var reader = std.testing.tmpDir(.{});
defer reader.cleanup();
var rc = try runZit(gpa, io, reader.dir, &.{ "clone", "--no-open", url, "repo" });
defer freeResult(gpa, &rc);
try expectExitDiag(rc.term, 0, rc);
var r_dir = try reader.dir.openDir(io, "repo", .{});
defer r_dir.close(io);
var ro = try runZit(gpa, io, r_dir, &.{ "open", merged });
defer freeResult(gpa, &ro);
try expectExitDiag(ro.term, 0, ro);
const tool_bytes = try readFile(gpa, io, r_dir, "tools/t.bin");
defer gpa.free(tool_bytes);
try std.testing.expectEqualStrings("tool v2 from the side\n", tool_bytes);
const src_bytes = try readFile(gpa, io, r_dir, "src/a.zig");
defer gpa.free(src_bytes);
try std.testing.expectEqualStrings("src v2 on trunk\n", src_bytes);
// Both-changed arm: trunk ALSO edits tools/t.bin; a fresh sparse
// checkout at the new trunk tip merging `side` must refuse by name.
server.kill(io);
var fwd = try runZit(gpa, io, tmp_a.dir, &.{ "update", trunk_tip });
defer freeResult(gpa, &fwd);
try expectExitDiag(fwd.term, 0, fwd);
try writeFile(io, tmp_a.dir, "tools/t.bin", "tool v2 on trunk too\n");
// The pushed merge holds trunk's leaf now; this divergence is the
// point of the arm, so fork deliberately.
var tool_commit = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "trunk tool edit", "--allow-fork" });
defer freeResult(gpa, &tool_commit);
try expectExitDiag(tool_commit.term, 0, tool_commit);
const trunk_tool = try gpa.dupe(u8, try checkinHash(tool_commit.stdout));
defer gpa.free(trunk_tool);
server = try spawnServe(gpa, io, tmp_a.dir, port);
try waitForListen(io, port);
var tmp_c = std.testing.tmpDir(.{});
defer tmp_c.cleanup();
var clone2 = try runZit(gpa, io, tmp_c.dir, &.{ "clone", "--no-open", "--cone=src", url, "repo" });
defer freeResult(gpa, &clone2);
try expectExitDiag(clone2.term, 0, clone2);
var c_dir = try tmp_c.dir.openDir(io, "repo", .{});
defer c_dir.close(io);
var oc = try runZit(gpa, io, c_dir, &.{ "open", "--cone=src", trunk_tool });
defer freeResult(gpa, &oc);
try expectExitDiag(oc.term, 0, oc);
var mg2 = try runZit(gpa, io, c_dir, &.{ "merge", side });
defer freeResult(gpa, &mg2);
try expectExit(mg2.term, 1);
try std.testing.expect(std.mem.indexOf(u8, mg2.stderr, "changed on both sides, starting with 'tools/t.bin'") != null);
try std.testing.expect(std.mem.indexOf(u8, mg2.stderr, "widen the cone") != null);
}
// --- merge --probe ----------------------------------------------------------
//
// A consumer that keeps its own index of records should not have to scan a
// store to ask about a pair of check-ins it already knows. `landing show`
// answers the same question but must FIND the record first, which is linear in
// store bytes; here the caller names both sides and pays only for the merge.
test "cli merge: --probe over a stack lands each rung on the ones before it, and finds the stop a pairwise probe misses" {
// r1 -> r2 -> r3 -> r4 are stacked, each built on the last, while trunk
// moved on its own. Probed against the rung below, r3 is clean: relative
// to r2 only r3 touched line 5. Landed in order, it collides with trunk's
// own line-5 edit. The chain answers the landing's question.
//
// r2 is the widened-base check. Once r1 has landed its base is r1, and r2
// only rewrote what r1 wrote: clean. Merging the landed tree (which holds
// r1's line) against the OLD fork point would see both sides change line
// 2 and call r2 a conflict with its own parent.
const gpa = std.testing.allocator;
const io = std.testing.io;
const t_ = std.testing;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
var root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
_ = try commitFile(gpa, io, tmp.dir, "f.txt", "L1\nL2\nL3\nL4\nL5\n", "root", &root_c);
const Rung = struct { branch: []const u8, content: ?[]const u8, extra: ?[]const u8 };
const rungs = [_]Rung{
.{ .branch = "r1", .content = "L1\nR1\nL3\nL4\nL5\n", .extra = null },
.{ .branch = "r2", .content = "L1\nR2\nL3\nL4\nL5\n", .extra = null },
.{ .branch = "r3", .content = "L1\nR2\nL3\nL4\nX5\n", .extra = null },
.{ .branch = "r4", .content = null, .extra = "h.txt" },
};
for (rungs) |r| {
if (r.content) |c| try writeFile(io, tmp.dir, "f.txt", c);
if (r.extra) |x| {
try writeFile(io, tmp.dir, x, "h\n");
try addManaged(gpa, io, tmp.dir, &.{x});
}
var c = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", r.branch, "--branch", r.branch });
defer freeResult(gpa, &c);
try expectExitDiag(c.term, 0, c);
}
// Trunk moves on a line no rung touches until r3.
var back = try runZit(gpa, io, tmp.dir, &.{ "update", "trunk" });
defer freeResult(gpa, &back);
try expectExitDiag(back.term, 0, back);
try writeFile(io, tmp.dir, "f.txt", "L1\nL2\nL3\nL4\nT5\n");
var tm = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "trunk moves" });
defer freeResult(gpa, &tm);
try expectExitDiag(tm.term, 0, tm);
var away = std.testing.tmpDir(.{});
defer away.cleanup();
try bareStoreOf(gpa, io, tmp.dir, away.dir, "store");
var store_dir = try away.dir.openDir(io, "store", .{});
defer store_dir.close(io);
const before = try store_dir.readFileAlloc(io, ".zit", gpa, .limited(64 * 1024 * 1024));
defer gpa.free(before);
var chain = try runZit(gpa, io, away.dir, &.{ "merge", "--probe", "--into", "trunk", "r1", "r2", "r3", "r4", "-R", "store" });
defer freeResult(gpa, &chain);
try expectExitDiag(chain.term, 0, chain);
try t_.expectEqualStrings(
\\merges r1 clean
\\merges r2 clean
\\merges r3 conflict (1)
\\conflict f.txt
\\merges r4 not-reached
\\
, chain.stdout);
// The pairwise question gets the pairwise answer — clean — which is why
// the chain exists. And the first rung alone reads exactly as it always has.
var alone = try runZit(gpa, io, away.dir, &.{ "merge", "--probe", "r3", "--into", "r2", "-R", "store" });
defer freeResult(gpa, &alone);
try expectExitDiag(alone.term, 0, alone);
try t_.expectEqualStrings("merges clean\n", alone.stdout);
var first = try runZit(gpa, io, away.dir, &.{ "merge", "--probe", "r1", "--into", "trunk", "-R", "store" });
defer freeResult(gpa, &first);
try t_.expectEqualStrings("merges clean\n", first.stdout);
// A rung already inside the landed tree is up-to-date and the chain goes on.
var again = try runZit(gpa, io, away.dir, &.{ "merge", "--probe", "--into", "trunk", "r2", "r1", "-R", "store" });
defer freeResult(gpa, &again);
try expectExitDiag(again.term, 0, again);
try t_.expectEqualStrings("merges r2 clean\nmerges r1 up-to-date\n", again.stdout);
// A real merge still takes one NAME.
var two = try runZit(gpa, io, tmp.dir, &.{ "merge", "r1", "r2" });
defer freeResult(gpa, &two);
try expectExit(two.term, 2);
const after = try store_dir.readFileAlloc(io, ".zit", gpa, .limited(64 * 1024 * 1024));
defer gpa.free(after);
try t_.expectEqualSlices(u8, before, after);
}
test "cli merge: --probe answers from a bare store, writes nothing, and exits 0 either way" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
var root_c: std.process.RunResult = undefined;
defer freeResult(gpa, &root_c);
_ = try commitFile(gpa, io, tmp.dir, "f.txt", "top\nMID\nbottom\n", "root", &root_c);
// A branch that merges cleanly at CONTENT level (different regions).
try writeFile(io, tmp.dir, "f.txt", "top\nMID\nBOTTOM\n");
var ok_b = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "b", "--branch", "feat/ok" });
defer freeResult(gpa, &ok_b);
var back = try runZit(gpa, io, tmp.dir, &.{ "update", "trunk" });
defer freeResult(gpa, &back);
try writeFile(io, tmp.dir, "f.txt", "TOP\nMID\nbottom\n");
var t1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "t" });
defer freeResult(gpa, &t1);
// ...and one that genuinely conflicts (add/add, differing).
try writeFile(io, tmp.dir, "g.txt", "BRANCH\n");
try addManaged(gpa, io, tmp.dir, &.{"g.txt"});
var bad_b = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "g", "--branch", "feat/bad" });
defer freeResult(gpa, &bad_b);
var back2 = try runZit(gpa, io, tmp.dir, &.{ "update", "trunk" });
defer freeResult(gpa, &back2);
try writeFile(io, tmp.dir, "g.txt", "TRUNK\n");
try addManaged(gpa, io, tmp.dir, &.{"g.txt"});
var t2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "g2" });
defer freeResult(gpa, &t2);
var away = std.testing.tmpDir(.{});
defer away.cleanup();
try bareStoreOf(gpa, io, tmp.dir, away.dir, "store");
var store_dir = try away.dir.openDir(io, "store", .{});
defer store_dir.close(io);
const before = try store_dir.readFileAlloc(io, ".zit", gpa, .limited(64 * 1024 * 1024));
defer gpa.free(before);
var clean = try runZit(gpa, io, away.dir, &.{ "merge", "--probe", "feat/ok", "--into", "trunk", "-R", "store" });
defer freeResult(gpa, &clean);
try expectExitDiag(clean.term, 0, clean);
try std.testing.expect(std.mem.indexOf(u8, clean.stdout, "merges clean") != null);
// "Has conflicts" is an ANSWER, not a failure: exit 0, and the paths are
// on stdout as data. A caller reads the line, not the status.
var bad = try runZit(gpa, io, away.dir, &.{ "merge", "--probe", "feat/bad", "--into", "trunk", "-R", "store" });
defer freeResult(gpa, &bad);
try expectExitDiag(bad.term, 0, bad);
try std.testing.expect(std.mem.indexOf(u8, bad.stdout, "merges conflict (1)") != null);
try std.testing.expect(std.mem.indexOf(u8, bad.stdout, "conflict g.txt") != null);
// Asking changed nothing. A probe that writes is not a probe.
const after = try store_dir.readFileAlloc(io, ".zit", gpa, .limited(64 * 1024 * 1024));
defer gpa.free(after);
try std.testing.expectEqualSlices(u8, before, after);
// -R needs --into: there is no checkout to supply the other side, and
// guessing one would answer a question nobody asked.
var no_into = try runZit(gpa, io, away.dir, &.{ "merge", "--probe", "feat/ok", "-R", "store" });
defer freeResult(gpa, &no_into);
try expectExit(no_into.term, 1);
try std.testing.expect(std.mem.indexOf(u8, no_into.stderr, "--into") != null);
// A REAL merge still refuses -R, and says so by name rather than failing as
// a discovery miss that tells you to pass the flag you just passed.
var real = try runZit(gpa, io, away.dir, &.{ "merge", "feat/ok", "-R", "store" });
defer freeResult(gpa, &real);
try expectExit(real.term, 1);
try std.testing.expect(std.mem.indexOf(u8, real.stderr, "no working tree to merge into") != null);
}
test "cli merge: --probe agrees with the merge engine, and with landing show" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try seedContentMergeable(gpa, io, tmp.dir);
// In a checkout, --into defaults to the current check-in, exactly as a
// real merge takes its other side.
var probe = try runZit(gpa, io, tmp.dir, &.{ "merge", "--probe", "feat/x" });
defer freeResult(gpa, &probe);
try expectExitDiag(probe.term, 0, probe);
try std.testing.expect(std.mem.indexOf(u8, probe.stdout, "merges clean") != null);
// `landing show` must give the same verdict: one probe, two callers.
var opened = try runZit(gpa, io, tmp.dir, &.{ "landing", "open", "--branch", "feat/x", "-m", "m", "--user", "u" });
defer freeResult(gpa, &opened);
var shown = try runZit(gpa, io, tmp.dir, &.{ "landing", "show", opened.stdout[0..12] });
defer freeResult(gpa, &shown);
try std.testing.expect(std.mem.indexOf(u8, shown.stdout, "merges clean") != null);
// And the engine agrees with both.
var merged = try runZit(gpa, io, tmp.dir, &.{ "merge", "feat/x" });
defer freeResult(gpa, &merged);
try expectExit(merged.term, 0);
}