Skip to content
zit Artifact [fd7a45a94a]
Login

Artifact [fd7a45a94a]

Artifact fd7a45a94aae5a81ed3786309c487f18e5d4a8d395508752bc56e252e6219530:


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