const std = @import("std");
const support = @import("support.zig");
const buildMergeDiamond = support.buildMergeDiamond;
const expectExit = support.expectExit;
const freeResult = support.freeResult;
const readFile = support.readFile;
const runZit = support.runZit;
const writeFile = support.writeFile;
test "cli precedent: a resolution is remembered at commit and replayed on the same conflict" {
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);
// 1. The conflict, and the pending precedent it records.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
}
{
var res = try runZit(gpa, io, tmp.dir, &.{ "precedent", "list" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
// Named as pending, not shown as an empty resolution.
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "poem pending") != null);
}
// 2. Resolve by hand and commit: the resolution is learned only here, from
// bytes that passed the same unresolved-marker gate the check-in did.
try writeFile(io, tmp.dir, "poem", "A\nRESOLVED\nC\n");
{
var res = try runZit(gpa, io, tmp.dir, &.{ "commit", "-m", "resolve", "--user", "t" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "remembered 1 conflict resolution") != null);
}
// 3. Reproduce the identical conflict: the resolution is replayed, the
// merge is clean, and the replay is NAMED rather than merely counted.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "update", fx.current });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
}
{
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other });
defer freeResult(gpa, &res);
try expectExit(res.term, 0); // no longer a conflict
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "poem resolved from precedent") != null);
}
const poem = try readFile(gpa, io, tmp.dir, "poem");
defer gpa.free(poem);
try std.testing.expectEqualStrings("A\nRESOLVED\nC\n", poem);
// The replay wrote a resolution, not markers.
try std.testing.expect(std.mem.indexOf(u8, poem, "<<<<<<< ") == null);
}
test "cli precedent: --no-precedent declines replay without forgetting; forget restores the conflict" {
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);
}
try writeFile(io, tmp.dir, "poem", "A\nRESOLVED\nC\n");
{
var res = try runZit(gpa, io, tmp.dir, &.{ "commit", "-m", "resolve", "--user", "t" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
}
{
var res = try runZit(gpa, io, tmp.dir, &.{ "update", fx.current });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
}
// Declining behaves as it did before the feature existed: a conflict.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "merge", fx.other, "--no-precedent" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "resolved from precedent") == null);
}
// Declining is not forgetting: the precedent is still there.
{
var res = try runZit(gpa, io, tmp.dir, &.{ "precedent", "list" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "poem") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stdout, "pending") == null);
}
// Forgetting does forget: the next such merge conflicts normally again.
{
var res = try runZit(gpa, io, tmp.dir, &.{"undo"});
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
}
{
var res = try runZit(gpa, io, tmp.dir, &.{ "precedent", "forget", "--all" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
}
{
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, "resolved from precedent") == null);
}
}
test "cli precedent: the sidecar is never an extra, so it cannot become an artifact" {
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); // writes .zit-precedent
}
var res = try runZit(gpa, io, tmp.dir, &.{"extras"});
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
// A reserved name: invisible to `extras`, so `addremove` can never sweep it
// into the tracked set and no check-in can carry it.
try std.testing.expect(std.mem.indexOf(u8, res.stdout, ".zit-precedent") == null);
}