const std = @import("std");
const support = @import("support.zig");
const checkinHash = support.checkinHash;
const expectExit = support.expectExit;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const spawnServe = support.spawnServe;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;
test "cli modules: sync clones a zit module to its pin, status names it off pin, and pin records where it is" {
const gpa = std.testing.allocator;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
// The module: a repository of its own with two check-ins.
try tmp.dir.createDirPath(io, "lib");
var lib = try tmp.dir.openDir(io, "lib", .{});
defer lib.close(io);
try initRepo(gpa, io, lib);
try writeFile(io, lib, "lib.txt", "one\n");
var add_lib = try runZit(gpa, io, lib, &.{ "add", "lib.txt" });
defer freeResult(gpa, &add_lib);
try expectExit(add_lib.term, 0);
var first = try runCommitEnv(gpa, io, lib, .{ .user = "u" }, &.{ "commit", "-m", "one", "--no-warnings" });
defer freeResult(gpa, &first);
try expectExit(first.term, 0);
const pin1 = try gpa.dupe(u8, try checkinHash(first.stdout));
defer gpa.free(pin1);
try writeFile(io, lib, "lib.txt", "two\n");
var second = try runCommitEnv(gpa, io, lib, .{ .user = "u" }, &.{ "commit", "-m", "two", "--no-warnings" });
defer freeResult(gpa, &second);
try expectExit(second.term, 0);
const pin2 = try gpa.dupe(u8, try checkinHash(second.stdout));
defer gpa.free(pin2);
const port = try freshLoopbackPort(io);
var server = try spawnServe(gpa, io, lib, 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);
// The parent pins the module at its first check-in, and a Git module.
try tmp.dir.createDirPath(io, "app");
var app = try tmp.dir.openDir(io, "app", .{});
defer app.close(io);
try initRepo(gpa, io, app);
const ledger = try std.fmt.allocPrint(gpa, "lib zit {s} {s}\nvendor git - 1111111111111111111111111111111111111111\n", .{ url, pin1 });
defer gpa.free(ledger);
try writeFile(io, app, ".zit-modules", ledger);
var add_app = try runZit(gpa, io, app, &.{ "add", ".zit-modules" });
defer freeResult(gpa, &add_app);
try expectExit(add_app.term, 0);
var commit_app = try runCommitEnv(gpa, io, app, .{ .user = "u" }, &.{ "commit", "-m", "pin lib", "--no-warnings" });
defer freeResult(gpa, &commit_app);
try expectExit(commit_app.term, 0);
var listed = try runZit(gpa, io, app, &.{"modules"});
defer freeResult(gpa, &listed);
try expectExit(listed.term, 0);
try std.testing.expect(std.mem.indexOf(u8, listed.stdout, "lib zit ") != null);
try std.testing.expect(std.mem.indexOf(u8, listed.stdout, "not synced") != null);
try std.testing.expect(std.mem.indexOf(u8, listed.stdout, "vendor git 111111111111 git commit") != null);
// A git module is named and left alone; the zit one syncs.
var git_only = try runZit(gpa, io, app, &.{ "modules", "sync", "vendor" });
defer freeResult(gpa, &git_only);
try expectExit(git_only.term, 1);
try std.testing.expect(std.mem.indexOf(u8, git_only.stderr, "import-git --with-submodules") != null);
var synced = try runZit(gpa, io, app, &.{ "modules", "sync", "lib" });
defer freeResult(gpa, &synced);
try expectExit(synced.term, 0);
var module = try app.openDir(io, "lib", .{});
defer module.close(io);
const content = try module.readFileAlloc(io, "lib.txt", gpa, .limited(64));
defer gpa.free(content);
try std.testing.expectEqualStrings("one\n", content);
var at_pin = try runZit(gpa, io, app, &.{"modules"});
defer freeResult(gpa, &at_pin);
try std.testing.expect(std.mem.indexOf(u8, at_pin.stdout, "at pin") != null);
// The nested checkout is not the parent's to list or add.
var extras = try runZit(gpa, io, app, &.{"extras"});
defer freeResult(gpa, &extras);
try std.testing.expect(std.mem.indexOf(u8, extras.stdout, "lib.txt") == null);
var clean_status = try runZit(gpa, io, app, &.{"status"});
defer freeResult(gpa, &clean_status);
try std.testing.expect(std.mem.indexOf(u8, clean_status.stdout, "MODULE") == null);
// Moved off its pin, status says so, and pin records the new check-in.
var moved = try runZit(gpa, io, module, &.{ "update", pin2 });
defer freeResult(gpa, &moved);
try expectExit(moved.term, 0);
var off = try runZit(gpa, io, app, &.{"status"});
defer freeResult(gpa, &off);
const want_line = try std.fmt.allocPrint(gpa, "MODULE lib at {s}, pinned {s}\n", .{ pin2[0..12], pin1[0..12] });
defer gpa.free(want_line);
try std.testing.expect(std.mem.indexOf(u8, off.stdout, want_line) != null);
var pinned = try runZit(gpa, io, app, &.{ "modules", "pin", "lib" });
defer freeResult(gpa, &pinned);
try expectExit(pinned.term, 0);
const after = try app.readFileAlloc(io, ".zit-modules", gpa, .limited(1 << 12));
defer gpa.free(after);
const want_ledger = try std.fmt.allocPrint(gpa, "lib zit {s} {s}\nvendor git - 1111111111111111111111111111111111111111\n", .{ url, pin2 });
defer gpa.free(want_ledger);
try std.testing.expectEqualStrings(want_ledger, after);
var back_on = try runZit(gpa, io, app, &.{"status"});
defer freeResult(gpa, &back_on);
try std.testing.expect(std.mem.indexOf(u8, back_on.stdout, "MODULE") == null);
// Back at the old pin, sync updates the module straight to it.
var old_pin = try runZit(gpa, io, module, &.{ "update", pin1 });
defer freeResult(gpa, &old_pin);
try expectExit(old_pin.term, 0);
var resync = try runZit(gpa, io, app, &.{ "modules", "sync", "lib" });
defer freeResult(gpa, &resync);
try expectExit(resync.term, 0);
const synced_again = try module.readFileAlloc(io, "lib.txt", gpa, .limited(64));
defer gpa.free(synced_again);
try std.testing.expectEqualStrings("two\n", synced_again);
}