const std = @import("std");
const managed = @import("zit").managed;
const artifact = @import("zit").artifact;
const support = @import("support.zig");
const addManaged = support.addManaged;
const checkinHash = support.checkinHash;
const corruptSection = support.corruptSection;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectFileContent = support.expectFileContent;
const expectManaged = support.expectManaged;
const fileExists = support.fileExists;
const findF = support.findF;
const freeResult = support.freeResult;
const illegal_new_names = support.illegal_new_names;
const initRepo = support.initRepo;
const parseCheckin = support.parseCheckin;
const readFile = support.readFile;
const runCommitEnv = support.runCommitEnv;
const runShell = support.runShell;
const runZit = support.runZit;
const seedFossilMadeName = support.seedFossilMadeName;
const touch = support.touch;
const writeFile = support.writeFile;
test "cli mv: a new name with illegal characters or a reserved name is refused, exit 1, nothing moves" {
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", "a\n");
try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
try tmp.dir.createDirPath(io, "sub");
const targets = illegal_new_names ++ [_][]const u8{ "sub/_FOSSIL_", "sub/.fslckout" };
for (targets) |name| {
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "a.txt", name });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
for (res.stderr) |b| try std.testing.expect(b == '\n' or (b >= ' ' and b != 0x7f));
try expectManaged(gpa, io, tmp.dir, &.{"a.txt"});
const kept = try readFile(gpa, io, tmp.dir, "a.txt");
defer gpa.free(kept);
try std.testing.expectEqualStrings("a\n", kept);
}
}
// ==========================================================================
// `zit mv OLD NEW` end-to-end tests (contracts/mv.md B-mv-1..18; derived
// manifest bytes from artifact §4.7.6/§4.6). Each spawns the REAL binary in an
// isolated, pinned environment, asserts exit code + exact stdout/stderr, and
// reads `.zit-managed`/the working tree/the minted manifest back through the
// library to prove the state the mv (and the following commit) produced.
// ==========================================================================
/// An independent transcription of contracts/mv.md §Help. Kept separate from the
/// binary's own `mv_help` so the e2e compares two hand-made copies — drift in
/// either is caught (B-mv-12).
const mv_help_expected =
\\usage: zit mv [-n|--dry-run] [--soft|--hard] OLD... NEW|DIR
\\
\\Rename tracked files: move each working file on disk, swap the
\\tracked-name entries, and record every rename so your next `zit commit`
\\records the new name with the old one as its former name.
\\
\\With two operands and NEW not a directory, OLD becomes NEW. When the last
\\operand is a directory (on disk, or a tracked prefix, or '.'), or there are
\\more than two operands, each OLD moves into it keeping its base name. An
\\OLD that is a tracked directory moves as a unit, every file beneath it
\\recorded as its own rename.
\\
\\Every OLD must be tracked and present; no NEW may already be tracked or
\\exist on disk. The whole request is checked before anything moves, and
\\nothing overwrites. mv is not undone by `zit undo`; to reverse a rename,
\\run `zit mv NEW OLD`.
\\
\\options:
\\ -n, --dry-run print 'would rename OLD -> NEW' per file; change nothing
\\ --soft record the renames without touching the working tree (the
\\ files stay at OLD; status then shows NEW missing until
\\ you move them)
\\ --hard move the files too (the default)
\\ -h, --help show this help and exit
\\
\\exit status:
\\ 0 the files were renamed
\\ 1 an OLD is not tracked or missing, a NEW is already tracked or on
\\ disk, or this is not a zit repository
\\ 2 usage error (fewer than two operands, or an unknown option)
\\
\\aliases: rename
\\
;
test "cli mv B-mv-1: happy path moves the file, swaps the managed entry, exit 0" {
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, "old.txt", "contents\n");
try addManaged(gpa, io, tmp.dir, &.{"old.txt"});
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "old.txt", "new.txt" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings("RENAME old.txt new.txt\n", res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
// On disk: OLD gone, NEW present with the moved bytes.
try std.testing.expect(!fileExists(io, tmp.dir, "old.txt"));
try std.testing.expect(fileExists(io, tmp.dir, "new.txt"));
const moved = try readFile(gpa, io, tmp.dir, "new.txt");
defer gpa.free(moved);
try std.testing.expectEqualStrings("contents\n", moved);
// Managed set: OLD dropped, NEW gained.
try expectManaged(gpa, io, tmp.dir, &.{"new.txt"});
}
test "cli mv B-mv-2: the managed set names NEW and the file is at NEW (end state consistent)" {
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", "x\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "a", "b" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
// The persisted managed set names NEW and NOT OLD, and the file sits at NEW —
// the write-then-move end state (the crash seam is covered by managed unit
// tests); the two never disagree.
var set = try managed.ManagedSet.read(gpa, io, tmp.dir);
defer set.deinit();
try std.testing.expect(set.contains("b"));
try std.testing.expect(!set.contains("a"));
try std.testing.expect(fileExists(io, tmp.dir, "b"));
try std.testing.expect(!fileExists(io, tmp.dir, "a"));
}
test "cli mv B-mv-3: OLD not tracked refuses, exit 1, nothing moves" {
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, "loose", "y\n"); // on disk but never added
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "loose", "dest" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit mv: 'loose' is not tracked\n", res.stderr);
// Untouched: source still there, dest never created, set still empty.
try std.testing.expect(fileExists(io, tmp.dir, "loose"));
try std.testing.expect(!fileExists(io, tmp.dir, "dest"));
try expectManaged(gpa, io, tmp.dir, &.{});
}
test "cli mv B-mv-4: NEW already tracked refuses, exit 1" {
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", "1\n");
try writeFile(io, tmp.dir, "b", "2\n");
try addManaged(gpa, io, tmp.dir, &.{ "a", "b" });
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "a", "b" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit mv: 'b' is already tracked\n", res.stderr);
// No clobber: both still tracked, both files intact with original bytes.
try expectManaged(gpa, io, tmp.dir, &.{ "a", "b" });
const bb = try readFile(gpa, io, tmp.dir, "b");
defer gpa.free(bb);
try std.testing.expectEqualStrings("2\n", bb);
}
test "cli mv B-mv-5: NEW exists on disk refuses, exit 1, OLD unmoved" {
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", "src\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
try writeFile(io, tmp.dir, "b", "untracked-but-present\n"); // NEW exists on disk, not tracked
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "a", "b" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit mv: 'b' already exists on disk\n", res.stderr);
// OLD unmoved and still tracked; NEW file untouched (never overwritten).
try expectManaged(gpa, io, tmp.dir, &.{"a"});
const bb = try readFile(gpa, io, tmp.dir, "b");
defer gpa.free(bb);
try std.testing.expectEqualStrings("untracked-but-present\n", bb);
}
test "cli mv B-mv-6: status after mv reports NEW tracked, OLD absent" {
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, "old", "z\n");
try addManaged(gpa, io, tmp.dir, &.{"old"});
var mvres = try runZit(gpa, io, tmp.dir, &.{ "mv", "old", "new" });
defer freeResult(gpa, &mvres);
try expectExit(mvres.term, 0);
var st = try runZit(gpa, io, tmp.dir, &.{"status"});
defer freeResult(gpa, &st);
try expectExit(st.term, 0);
// status reads the same managed set mv wrote: NEW appears, OLD does not.
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "new") != null);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "old") == null);
}
test "cli mv §4.7.6 B-mv-7: mv then commit emits the four-token old-name F card, sorted under NEW" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
// A straddling file "mike" sits alphabetically between OLD ("alpha") and NEW
// ("yankee"), so the sort order distinguishes current-name from old-name.
try writeFile(io, tmp.dir, "alpha", "alpha bytes\n");
try writeFile(io, tmp.dir, "mike", "mike bytes\n");
try addManaged(gpa, io, tmp.dir, &.{ "alpha", "mike" });
var root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &root);
try expectExit(root.term, 0);
var mvres = try runZit(gpa, io, tmp.dir, &.{ "mv", "alpha", "yankee" });
defer freeResult(gpa, &mvres);
try expectExit(mvres.term, 0);
var rec = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "rename" });
defer freeResult(gpa, &rec);
try expectExit(rec.term, 0);
const child_hash = try checkinHash(rec.stdout);
var mc = try parseCheckin(gpa, io, tmp.dir, child_hash);
defer mc.deinit();
const f = findF(mc.m, "yankee") orelse return error.MissingFCard;
// §4.7.6: NEW filename, an explicit `w` perm token (regular-file SHOULD-w so
// old-name stays in the fourth field), OLD as the fourth (old-name) token,
// and a `w` token yields regular-file behavior (contains no x/l).
try std.testing.expectEqualStrings("yankee", f.filename);
try std.testing.expectEqualStrings("w", f.perm.?);
try std.testing.expectEqualStrings("alpha", f.old_name.?);
try std.testing.expectEqual(artifact.FileMode.regular, f.mode);
// Hash is over the moved (unchanged) bytes now at NEW (§4.7.1 artifact name).
var namebuf: [64]u8 = undefined;
const expected_hash = artifact.artifactName(.sha3_256, "alpha bytes\n", &namebuf);
try std.testing.expectEqualStrings(expected_hash, f.hash.?);
// §4.6 strict-ascending-by-current-filename: mike (straddle) sorts BEFORE
// yankee — proving the entry sorts under NEW, not OLD ("alpha").
try std.testing.expectEqual(@as(usize, 2), mc.m.f.len);
try std.testing.expectEqualStrings("mike", mc.m.f[0].filename);
try std.testing.expectEqualStrings("yankee", mc.m.f[1].filename);
}
test "cli mv B-mv-8: the record is one-shot — a later commit emits NEW three-token" {
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, "alpha", "a\n");
try writeFile(io, tmp.dir, "mike", "m\n");
try addManaged(gpa, io, tmp.dir, &.{ "alpha", "mike" });
var root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &root);
try expectExit(root.term, 0);
var mvres = try runZit(gpa, io, tmp.dir, &.{ "mv", "alpha", "yankee" });
defer freeResult(gpa, &mvres);
try expectExit(mvres.term, 0);
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "rename" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
// A second commit with NO further mv (a change elsewhere forces a non-no-op).
try writeFile(io, tmp.dir, "mike", "m edited\n");
var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "edit mike" });
defer freeResult(gpa, &c2);
try expectExit(c2.term, 0);
const h2 = try checkinHash(c2.stdout);
var mc = try parseCheckin(gpa, io, tmp.dir, h2);
defer mc.deinit();
const f = findF(mc.m, "yankee") orelse return error.MissingFCard;
// The record was consumed + cleared by the first commit: NEW is now a plain
// current-name card — no perm, no old-name (§4.7.6 optional positions omitted).
try std.testing.expectEqual(@as(?[]const u8, null), f.perm);
try std.testing.expectEqual(@as(?[]const u8, null), f.old_name);
}
test "cli mv B-mv-9: with no rename pending, a commit is byte-identical to a fresh non-mv repo" {
const gpa = std.testing.allocator;
const io = std.testing.io;
// Repo A: a plain add+commit, no mv anywhere.
var ta = std.testing.tmpDir(.{});
defer ta.cleanup();
try initRepo(gpa, io, ta.dir);
try writeFile(io, ta.dir, "f", "same bytes\n");
try addManaged(gpa, io, ta.dir, &.{"f"});
var ca = try runCommitEnv(gpa, io, ta.dir, .{ .user = "u" }, &.{ "commit", "-m", "msg" });
defer freeResult(gpa, &ca);
try expectExit(ca.term, 0);
const ha = try gpa.dupe(u8, try checkinHash(ca.stdout));
defer gpa.free(ha);
// Repo B: identical inputs. Same pinned epoch/user ⇒ identical manifest bytes
// ⇒ identical check-in hash, proving the no-rename F card is unchanged (three
// tokens: `F <name> <hash>`), since the mv mechanism never touched this path.
var tb = std.testing.tmpDir(.{});
defer tb.cleanup();
try initRepo(gpa, io, tb.dir);
try writeFile(io, tb.dir, "f", "same bytes\n");
try addManaged(gpa, io, tb.dir, &.{"f"});
var cb = try runCommitEnv(gpa, io, tb.dir, .{ .user = "u" }, &.{ "commit", "-m", "msg" });
defer freeResult(gpa, &cb);
try expectExit(cb.term, 0);
const hb = try checkinHash(cb.stdout);
try std.testing.expectEqualStrings(ha, hb);
// And the F card really is three-token (no perm, no old-name).
var mc = try parseCheckin(gpa, io, ta.dir, ha);
defer mc.deinit();
const f = findF(mc.m, "f") orelse return error.MissingFCard;
try std.testing.expectEqual(@as(?[]const u8, null), f.perm);
try std.testing.expectEqual(@as(?[]const u8, null), f.old_name);
}
test "cli mv B-mv-10: an uncommitted edit to OLD is preserved and hashed at NEW" {
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, "alpha", "v1\n");
try addManaged(gpa, io, tmp.dir, &.{"alpha"});
var root = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
defer freeResult(gpa, &root);
try expectExit(root.term, 0);
// Edit OLD after the check-in, THEN rename it.
try writeFile(io, tmp.dir, "alpha", "v2 edited\n");
var mvres = try runZit(gpa, io, tmp.dir, &.{ "mv", "alpha", "yankee" });
defer freeResult(gpa, &mvres);
try expectExit(mvres.term, 0);
var rec = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "rename" });
defer freeResult(gpa, &rec);
try expectExit(rec.term, 0);
const child_hash = try checkinHash(rec.stdout);
var mc = try parseCheckin(gpa, io, tmp.dir, child_hash);
defer mc.deinit();
const f = findF(mc.m, "yankee") orelse return error.MissingFCard;
// The commit captures the CURRENT bytes at NEW (the edit is preserved), with
// OLD as the old-name token — mv moves, it never reverts or snapshots content.
var namebuf: [64]u8 = undefined;
const expected_hash = artifact.artifactName(.sha3_256, "v2 edited\n", &namebuf);
try std.testing.expectEqualStrings(expected_hash, f.hash.?);
try std.testing.expectEqualStrings("alpha", f.old_name.?);
try std.testing.expectEqualStrings("w", f.perm.?);
}
test "cli mv B-mv-11: mv OLD OLD is a refusal, not a self-clobber" {
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, "f", "same\n");
try addManaged(gpa, io, tmp.dir, &.{"f"});
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "f", "f" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1); // caught by the already-tracked / on-disk checks
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings("zit mv: 'f' is already tracked\n", res.stderr);
// Nothing changed: still tracked, file intact.
try expectManaged(gpa, io, tmp.dir, &.{"f"});
const ff = try readFile(gpa, io, tmp.dir, "f");
defer gpa.free(ff);
try std.testing.expectEqualStrings("same\n", ff);
}
test "cli mv B-mv-12: -h and --help print the verbatim help, exit 0, change nothing" {
const gpa = std.testing.allocator;
const io = std.testing.io;
inline for (.{ "-h", "--help" }) |flag| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a", "x\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
// -h/--help win even over otherwise-valid positionals (B-mv-12).
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", flag, "a", "b" });
defer freeResult(gpa, &res);
try expectExit(res.term, 0);
try std.testing.expectEqualStrings(mv_help_expected, res.stdout);
try std.testing.expectEqualStrings("", res.stderr);
// No mutation: 'a' still tracked and on disk, 'b' never created.
try expectManaged(gpa, io, tmp.dir, &.{"a"});
try std.testing.expect(fileExists(io, tmp.dir, "a"));
try std.testing.expect(!fileExists(io, tmp.dir, "b"));
}
}
test "cli mv: several files into a directory, a directory rename, -n previews, --soft records without moving, and the commit carries every old name" {
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 tmp.dir.createDirPath(io, "d");
try tmp.dir.createDirPath(io, "dest");
try writeFile(io, tmp.dir, "a", "a\n");
try writeFile(io, tmp.dir, "b", "b\n");
try writeFile(io, tmp.dir, "d/x", "x\n");
try writeFile(io, tmp.dir, "d/y", "y\n");
try writeFile(io, tmp.dir, "dest/.keep", "");
try addManaged(gpa, io, tmp.dir, &.{ "a", "b", "d/x", "d/y" });
var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c1" });
defer freeResult(gpa, &c1);
try expectExit(c1.term, 0);
// -n names every move and touches nothing.
var dry = try runZit(gpa, io, tmp.dir, &.{ "mv", "-n", "a", "b", "dest" });
defer freeResult(gpa, &dry);
try expectExitDiag(dry.term, 0, dry);
try std.testing.expectEqualStrings("would rename a -> dest/a\nwould rename b -> dest/b\n", dry.stdout);
try expectManaged(gpa, io, tmp.dir, &.{ "a", "b", "d/x", "d/y" });
try expectFileContent(gpa, io, tmp.dir, "a", "a\n");
// Two files into an existing directory, then a tracked directory as a unit.
var into = try runZit(gpa, io, tmp.dir, &.{ "mv", "a", "b", "dest" });
defer freeResult(gpa, &into);
try expectExitDiag(into.term, 0, into);
try expectManaged(gpa, io, tmp.dir, &.{ "d/x", "d/y", "dest/a", "dest/b" });
try expectFileContent(gpa, io, tmp.dir, "dest/b", "b\n");
var dir = try runZit(gpa, io, tmp.dir, &.{ "mv", "d", "e" });
defer freeResult(gpa, &dir);
try expectExitDiag(dir.term, 0, dir);
try expectManaged(gpa, io, tmp.dir, &.{ "dest/a", "dest/b", "e/x", "e/y" });
try expectFileContent(gpa, io, tmp.dir, "e/y", "y\n");
try std.testing.expectError(error.FileNotFound, tmp.dir.access(io, "d/x", .{}));
// The commit records all four renames: every new name carries its old one.
var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "moves" });
defer freeResult(gpa, &c2);
try expectExitDiag(c2.term, 0, c2);
const child_hash = try checkinHash(c2.stdout);
var mc = try parseCheckin(gpa, io, tmp.dir, child_hash);
defer mc.deinit();
for ([_][]const u8{ "dest/a", "dest/b", "e/x", "e/y" }, [_][]const u8{ "a", "b", "d/x", "d/y" }) |new_name, old_name| {
const f = findF(mc.m, new_name) orelse return error.MissingFCard;
try std.testing.expectEqualStrings(old_name, f.old_name.?);
}
var st = try runZit(gpa, io, tmp.dir, &.{"status"});
defer freeResult(gpa, &st);
try std.testing.expect(std.mem.indexOf(u8, st.stdout, "nothing to report") != null);
// --soft records the rename and leaves the file where it was.
var soft = try runZit(gpa, io, tmp.dir, &.{ "mv", "--soft", "e/x", "e/z" });
defer freeResult(gpa, &soft);
try expectExitDiag(soft.term, 0, soft);
try expectManaged(gpa, io, tmp.dir, &.{ "dest/a", "dest/b", "e/y", "e/z" });
try expectFileContent(gpa, io, tmp.dir, "e/x", "x\n");
try std.testing.expectError(error.FileNotFound, tmp.dir.access(io, "e/z", .{}));
}
test "cli mv B-mv-13: an unknown option is a usage error, exit 2, stderr only" {
const gpa = std.testing.allocator;
const io = std.testing.io;
inline for (.{
&[_][]const u8{ "mv", "--force", "a", "b" },
&[_][]const u8{ "mv", "-f", "a", "b" },
}) |argv| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
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, "unknown option '" ++ argv[1] ++ "'") != null);
try std.testing.expect(std.mem.indexOf(u8, res.stderr, "try 'zit mv --help'") != null);
}
}
test "cli mv B-mv-14: the wrong operand count is a usage error, exit 2, no mutation" {
const gpa = std.testing.allocator;
const io = std.testing.io;
inline for (.{
&[_][]const u8{"mv"}, // zero operands
&[_][]const u8{ "mv", "a" }, // one operand
}) |argv| {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try initRepo(gpa, io, tmp.dir);
try writeFile(io, tmp.dir, "a", "x\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
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 mv --help'") != null);
// No mutation regardless of which count failed.
try expectManaged(gpa, io, tmp.dir, &.{"a"});
}
}
test "cli mv B-mv-15: outside a repository is an expected failure, exit 1" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try touch(io, tmp.dir, "a"); // a file, but no repo anywhere above
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "a", "b" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings(
"zit: no zit checkout here (looked for .zit-checkout in this directory and its parents)\n" ++
"if this is a bare repository, name it with -R, or run 'zit open' to create a working tree\n",
res.stderr,
);
}
test "cli mv B-mv-16: a corrupt .zit-managed fails cleanly before any move, exit 1" {
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", "x\n");
try corruptSection(io, tmp.dir, .managed);
var res = try runZit(gpa, io, tmp.dir, &.{ "mv", "a", "b" });
defer freeResult(gpa, &res);
try expectExit(res.term, 1);
try std.testing.expectEqualStrings("", res.stdout);
try std.testing.expectEqualStrings(
"zit mv: cannot read tracked files: .zit-checkout is corrupt\n",
res.stderr,
);
// Nothing moved: source intact, dest never created.
try std.testing.expect(fileExists(io, tmp.dir, "a"));
try std.testing.expect(!fileExists(io, tmp.dir, "b"));
}
test "cli mv B-mv-17: streams stay separated under redirection (success vs refusal)" {
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", "x\n");
try addManaged(gpa, io, tmp.dir, &.{"a"});
// Success: the confirmation goes to stdout only; stderr stays empty.
var ok = try runShell(gpa, io, tmp.dir, "\"$ZIT\" mv a b > out.txt 2> err.txt");
defer freeResult(gpa, &ok);
try expectExit(ok.term, 0);
const ok_out = try readFile(gpa, io, tmp.dir, "out.txt");
defer gpa.free(ok_out);
const ok_err = try readFile(gpa, io, tmp.dir, "err.txt");
defer gpa.free(ok_err);
try std.testing.expectEqualStrings("RENAME a b\n", ok_out);
try std.testing.expectEqualStrings("", ok_err);
// Refusal: the diagnostic goes to stderr only; stdout stays empty.
var bad = try runShell(gpa, io, tmp.dir, "\"$ZIT\" mv missing dest > out2.txt 2> err2.txt");
defer freeResult(gpa, &bad);
try expectExit(bad.term, 1);
const bad_out = try readFile(gpa, io, tmp.dir, "out2.txt");
defer gpa.free(bad_out);
const bad_err = try readFile(gpa, io, tmp.dir, "err2.txt");
defer gpa.free(bad_err);
try std.testing.expectEqualStrings("", bad_out);
try std.testing.expectEqualStrings("zit mv: 'missing' is not tracked\n", bad_err);
}
test "cli mv: a fossil-made name with a control byte can be renamed to a good one" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try seedFossilMadeName(gpa, io, tmp.dir);
var mv = try runZit(gpa, io, tmp.dir, &.{ "mv", "c\x01d", "cd.txt" });
defer freeResult(gpa, &mv);
try expectExitDiag(mv.term, 0, mv);
try expectManaged(gpa, io, tmp.dir, &.{ "cd.txt", "ok.txt" });
}