const std = @import("std");
const cli = @import("zit").cli;
const support = @import("support.zig");
const addManaged = support.addManaged;
const appendClosedControl = support.appendClosedControl;
const appendSyntheticCheckin = support.appendSyntheticCheckin;
const buildFork = support.buildFork;
const checkinHash = support.checkinHash;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const freeResult = support.freeResult;
const initRepo = support.initRepo;
const lineCount = support.lineCount;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const writeDefaultBranch = support.writeDefaultBranch;
const writeFile = support.writeFile;
test "cli info: with no NAME a bare info describes the check-in the tree is on; revert names only the files it changes" {
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 writeFile(io, tmp.dir, "b", "b\n");
try addManaged(gpa, io, tmp.dir, &.{ "a", "b" });
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);
var info = try runZit(gpa, io, tmp.dir, &.{"info"});
defer freeResult(gpa, &info);
try expectExitDiag(info.term, 0, info);
try std.testing.expect(std.mem.indexOf(u8, info.stdout, cli.shortHash(c1_hash)) != null);
try std.testing.expect(std.mem.indexOf(u8, info.stdout, "check-ins: 1\n") != null);
try writeFile(io, tmp.dir, "a", "edited\n");
var rv = try runZit(gpa, io, tmp.dir, &.{"revert"});
defer freeResult(gpa, &rv);
try expectExitDiag(rv.term, 0, rv);
try std.testing.expectEqualStrings("REVERT a\n", rv.stdout); // b was already clean
}
// ==========================================================================
// `zit info NAME` end-to-end (repo-state §3/§6/§7/§8/§9/§10 + CLI discipline).
// `info` resolves NAME through the §8.3 procedure and describes the check-in it
// names. The load-bearing property is that resolution is recency-based (§8.2),
// NOT open-leaf enumeration (§8.5/§10): a name can name a closed or non-leaf
// check-in that `leaves` would omit. These cases re-observe that divergence
// through the CLI so the wiring itself is proven.
// ==========================================================================
/// An independent transcription of `info`'s §Help block (must match
/// `help.zig`'s `info_help` byte-for-byte; drift fails the test).
const info_help_expected =
\\usage: zit info [NAME... | --imported-head] [-F text|json] [--no-cache]
\\
\\With no NAME, describe the check-in the working tree is on (Fossil's
\\bare 'info'); NAME is any check-in name.
\\
\\Resolve each NAME to a single check-in and describe it. NAME may be a
\\full 40- or 64-character artifact ID, a unique ID prefix, a branch or
\\tag name, a reserved form, or a timestamp — 'zit help names' states the
\\full procedure. Resolution follows recency, not open-leaf status: a
\\name can resolve to a closed or non-leaf check-in that 'zit leaves'
\\would not list.
\\
\\Several NAMEs share one repository open; their blocks are separated by
\\a blank line. A NAME of '-' reads names from stdin, one per line. A
\\name that does not resolve is reported and the rest are still
\\described; the exit status is then 1.
\\
\\options:
\\ --imported-head
\\ describe the exact head recorded by the last successful Git
\\ import for its pinned default branch (initial source HEAD or
\\ --default-branch), not the date-based trunk name. It does not
\\ contact Git; a failed import leaves the previous head intact.
\\ No NAMEs may accompany it. JSON name is heads/<branch>;
\\ hash is the full check-in ID. Missing, damaged, or stale
\\ metadata or a ref absent from that metadata fails with exit 1,
\\ never a trunk fallback.
\\ -F, --format <f>
\\ text (default): the block above per check-in.
\\ json: one object per NAME, in the order given, with the
\\ keys name, hash, branch, leaf, parent (null for a root),
\\ merge, cherrypick, backout (arrays), and comment, user,
\\ date when an amend override is active; a name that does
\\ not resolve is {"name":..., "error":...}.
\\ --no-cache bypass every derived sidecar (the cache AND the rebuild
\\ checkpoint) and re-derive from the full log, re-verifying
\\ whole-log integrity (the cache is refreshed)
\\ -R, --repo <path>
\\ read this repository instead of the one found from the
\\ current directory; <path> is the directory holding '.zit'
\\ (or the '.zit' file itself). No working tree is required.
\\ -h, --help show this help and exit
\\
\\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 info §10.2/§8.5: on a fork whose newer sibling is closed, info trunk names the newer closed check-in while leaves surfaces the older open one" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// child1 (mtime 1e9, open) and child2 (mtime 2e9, the checkout). Close the
// newer sibling child2 (§7.4 control artifact).
const fork = try buildFork(gpa, io, tmp.dir);
defer gpa.free(fork.child1);
defer gpa.free(fork.child2);
const ctl = try appendClosedControl(gpa, io, tmp.dir, "2020-01-01T00:00:00", fork.child2);
defer gpa.free(ctl);
// §8.2 max-mtime: `info trunk` resolves child2 — its closed state and
// leaf-table membership are immaterial to the selection (§8.5, §9.3).
var info = try runZit(gpa, io, tmp.dir, &.{ "info", "trunk" });
defer freeResult(gpa, &info);
try expectExit(info.term, 0);
try std.testing.expectEqualStrings("", info.stderr);
var pbuf: [200]u8 = undefined;
const prefix = try std.fmt.bufPrint(&pbuf, "{s}\nbranch: trunk\nleaf: closed\nparent: ", .{fork.child2});
try std.testing.expect(std.mem.startsWith(u8, info.stdout, prefix));
try std.testing.expect(std.mem.endsWith(u8, info.stdout, "\n"));
// §7.4/§7.7: the default `leaves` view surfaces only the older OPEN leaf
// child1 — the divergence that proves name resolution is NOT open-leaf
// enumeration (§8.1-not-conflated, §8.5-not-openleaf-substitute).
var leaves = try runZit(gpa, io, tmp.dir, &.{"leaves"});
defer freeResult(gpa, &leaves);
try expectExit(leaves.term, 0);
var lbuf: [128]u8 = undefined;
_ = &lbuf;
try std.testing.expectEqual(@as(usize, 1), lineCount(leaves.stdout));
try std.testing.expect(std.mem.indexOf(u8, leaves.stdout, cli.shortHash(fork.child1)) != null);
// info named child2; leaves named child1 — the two answers genuinely differ.
try std.testing.expect(!std.mem.eql(u8, fork.child1, fork.child2));
}
test "cli info §10.1: on a fork with the older sibling closed, info trunk and leaves agree on the open newer leaf" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
const fork = try buildFork(gpa, io, tmp.dir);
defer gpa.free(fork.child1);
defer gpa.free(fork.child2);
// Close the OLDER sibling child1; the newer child2 stays open.
const ctl = try appendClosedControl(gpa, io, tmp.dir, "2020-01-01T00:00:00", fork.child1);
defer gpa.free(ctl);
// §8.2: `info trunk` resolves child2 (max mtime, open leaf here).
var info = try runZit(gpa, io, tmp.dir, &.{ "info", "trunk" });
defer freeResult(gpa, &info);
try expectExit(info.term, 0);
try std.testing.expectEqualStrings("", info.stderr);
var pbuf: [200]u8 = undefined;
const prefix = try std.fmt.bufPrint(&pbuf, "{s}\nbranch: trunk\nleaf: open\nparent: ", .{fork.child2});
try std.testing.expect(std.mem.startsWith(u8, info.stdout, prefix));
// §7.4: `leaves` lists only the open child2 — so here info and leaves AGREE.
var leaves = try runZit(gpa, io, tmp.dir, &.{"leaves"});
defer freeResult(gpa, &leaves);
try expectExit(leaves.term, 0);
var lbuf: [128]u8 = undefined;
_ = &lbuf;
try std.testing.expectEqual(@as(usize, 1), lineCount(leaves.stdout));
try std.testing.expect(std.mem.indexOf(u8, leaves.stdout, cli.shortHash(fork.child2)) != null);
try std.testing.expect(std.mem.indexOf(u8, leaves.stdout, "*CURRENT*") != null);
}
test "cli info §6.1: a check-in on trunk reports branch: trunk" {
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.txt", "root\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const root = try checkinHash(commit.stdout);
// §6.1: the root carries the active branch=trunk tag, so branchOf is trunk.
// A lone root check-in is an open leaf with no parent line.
var info = try runZit(gpa, io, tmp.dir, &.{ "info", root });
defer freeResult(gpa, &info);
try expectExit(info.term, 0);
try std.testing.expectEqualStrings("", info.stderr);
var want: [128]u8 = undefined;
const expected = try std.fmt.bufPrint(&want, "{s}\nbranch: trunk\nleaf: open\n", .{root});
try std.testing.expectEqualStrings(expected, info.stdout);
}
test "cli info §6.4/§9: a tagless check-in reports the configured main-branch, not literal trunk" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// §6.4: set main-branch to a non-default name, then add a check-in with NO
// branch tag. Its branch is the CONFIGURED value, never the literal "trunk".
try writeDefaultBranch(gpa, io, tmp.dir, "main");
const id = try appendSyntheticCheckin(gpa, io, tmp.dir, "tagless", null);
defer gpa.free(id);
var info = try runZit(gpa, io, tmp.dir, &.{ "info", id });
defer freeResult(gpa, &info);
try expectExit(info.term, 0);
try std.testing.expectEqualStrings("", info.stderr);
// §7.3: with no branch tag it is never a leaf candidate, so not a leaf.
var want: [128]u8 = undefined;
const expected = try std.fmt.bufPrint(&want, "{s}\nbranch: main\nleaf: no\n", .{id});
try std.testing.expectEqualStrings(expected, info.stdout);
}
test "cli info §7.1/§7.4: leaf status renders open, closed, and no" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// (a) a lone check-in is an open leaf; (b) closing it makes it a closed
// leaf-table member (§7.4) — still a leaf, so 'closed', not 'no'.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a.txt", "root\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
const root = try gpa.dupe(u8, try checkinHash(commit.stdout));
defer gpa.free(root);
var open_info = try runZit(gpa, io, tmp.dir, &.{ "info", root });
defer freeResult(gpa, &open_info);
try expectExit(open_info.term, 0);
var want_open: [128]u8 = undefined;
const expect_open = try std.fmt.bufPrint(&want_open, "{s}\nbranch: trunk\nleaf: open\n", .{root});
try std.testing.expectEqualStrings(expect_open, open_info.stdout);
const ctl = try appendClosedControl(gpa, io, tmp.dir, "2020-01-01T00:00:00", root);
defer gpa.free(ctl);
var closed_info = try runZit(gpa, io, tmp.dir, &.{ "info", root });
defer freeResult(gpa, &closed_info);
try expectExit(closed_info.term, 0);
var want_closed: [128]u8 = undefined;
const expect_closed = try std.fmt.bufPrint(&want_closed, "{s}\nbranch: trunk\nleaf: closed\n", .{root});
try std.testing.expectEqualStrings(expect_closed, closed_info.stdout);
}
// (c) a check-in with a same-branch child is not a leaf at all: 'no'.
{
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a.txt", "root\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
var c_root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u", .epoch = "1000000000" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &c_root);
try expectExit(c_root.term, 0);
const root = try gpa.dupe(u8, try checkinHash(c_root.stdout));
defer gpa.free(root);
try writeFile(io, tmp.dir, "a.txt", "edit\n");
var c_child = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u", .epoch = "2000000000" }, &.{ "commit", "-m", "child" });
defer freeResult(gpa, &c_child);
try expectExit(c_child.term, 0);
const child = try gpa.dupe(u8, try checkinHash(c_child.stdout));
defer gpa.free(child);
var root_info = try runZit(gpa, io, tmp.dir, &.{ "info", root });
defer freeResult(gpa, &root_info);
try expectExit(root_info.term, 0);
var want_no: [128]u8 = undefined;
const expect_no = try std.fmt.bufPrint(&want_no, "{s}\nbranch: trunk\nleaf: no\n", .{root});
try std.testing.expectEqualStrings(expect_no, root_info.stdout);
}
}
test "cli info §3.2/§3.3: renders the primary parent and each merge parent; a root has none" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// Two independent roots and a merge child whose P card lists p1 then p2.
const p1 = try appendSyntheticCheckin(gpa, io, tmp.dir, "p1", null);
defer gpa.free(p1);
const p2 = try appendSyntheticCheckin(gpa, io, tmp.dir, "p2", null);
defer gpa.free(p2);
var parents_buf: [129]u8 = undefined;
const parents = try std.fmt.bufPrint(&parents_buf, "{s} {s}", .{ p1, p2 });
const merge = try appendSyntheticCheckin(gpa, io, tmp.dir, "merge", parents);
defer gpa.free(merge);
// §3.2: p1 (first P-card token) is the primary parent; §3.3: p2 is a merge
// parent, shown on its own line. None of the three carries a branch tag,
// so none is a leaf candidate (§7.3).
var mi = try runZit(gpa, io, tmp.dir, &.{ "info", merge });
defer freeResult(gpa, &mi);
try expectExit(mi.term, 0);
try std.testing.expectEqualStrings("", mi.stderr);
var want_merge: [320]u8 = undefined;
const expect_merge = try std.fmt.bufPrint(
&want_merge,
"{s}\nbranch: trunk\nleaf: no\nparent: {s}\nmerge: {s}\n",
.{ merge, p1, p2 },
);
try std.testing.expectEqualStrings(expect_merge, mi.stdout);
// A root has no parent line (and, having a same-branch child, is not a leaf).
var pi = try runZit(gpa, io, tmp.dir, &.{ "info", p1 });
defer freeResult(gpa, &pi);
try expectExit(pi.term, 0);
var want_root: [128]u8 = undefined;
const expect_root = try std.fmt.bufPrint(&want_root, "{s}\nbranch: trunk\nleaf: no\n", .{p1});
try std.testing.expectEqualStrings(expect_root, pi.stdout);
}
test "cli info §8.1: help lists info and did-you-mean suggests it" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// The top-level command list names the verb (discoverability).
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, "info") != null);
// A single-substitution typo maps uniquely to 'info' (distance 1; every
// other verb is farther), so did-you-mean suggests it.
var typo = try runZit(gpa, io, tmp.dir, &.{"infp"});
defer freeResult(gpa, &typo);
try expectExit(typo.term, 2);
try std.testing.expect(std.mem.indexOf(u8, typo.stderr, "did you mean 'info'?") != null);
}
test "cli info §8.1/§8.5: -h/--help and 'help info' print the verbatim help on stdout, exit 0" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
for ([_][]const u8{ "--help", "-h" }) |flag| {
var res = try runZit(gpa, io, tmp.dir, &.{ "info", flag });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings(info_help_expected, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
}
var routed = try runZit(gpa, io, tmp.dir, &.{ "help", "info" });
defer freeResult(gpa, &routed);
try expectExit(routed.term, 0);
try std.testing.expectEqualStrings(info_help_expected, routed.stdout);
}
test "cli info §8.1: a bad -F value and an unknown option each exit 2 to stderr" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// Missing NAME — detected before any repo discovery, so no repo is needed.
// A bare `info` describes the current check-in (Fossil's shape); the
// usage errors are an unknown option and an extra positional.
var no_name = try runZit(gpa, io, tmp.dir, &.{ "info", "--bogus" });
defer freeResult(gpa, &no_name);
try expectExit(no_name.term, 2);
try std.testing.expectEqualStrings("", no_name.stdout);
try std.testing.expectEqualStrings(
"zit info: unknown option '--bogus'\ntry 'zit info --help'\n",
no_name.stderr,
);
// A format that is neither text nor json. A second positional
// is not an error any more: it is another name to describe.
var extra = try runZit(gpa, io, tmp.dir, &.{ "info", "-F", "yaml", "a" });
defer freeResult(gpa, &extra);
try expectExit(extra.term, 2);
try std.testing.expectEqualStrings("", extra.stdout);
try std.testing.expectEqualStrings(
"zit info: unknown option 'yaml'\ntry 'zit info --help'\n",
extra.stderr,
);
// An unknown option.
var opt = try runZit(gpa, io, tmp.dir, &.{ "info", "--bogus" });
defer freeResult(gpa, &opt);
try expectExit(opt.term, 2);
try std.testing.expectEqualStrings("", opt.stdout);
try std.testing.expectEqualStrings(
"zit info: unknown option '--bogus'\ntry 'zit info --help'\n",
opt.stderr,
);
}
test "cli info §8.3: an unresolved name exits 1 with the diagnostic on stderr only" {
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.txt", "root\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &commit);
try expectExit(commit.term, 0);
// A name no check-in carries is a resolution failure (§8.3 NotFound): exit 1,
// diagnostic on stderr, nothing on stdout (cli-stream-separation).
var res = try runZit(gpa, io, tmp.dir, &.{ "info", "nosuch" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit info: check-in 'nosuch' not found\n", res.stderr);
}