Skip to content
zit Artifact [ca1484e421]
Login

Artifact [ca1484e421]

Artifact ca1484e421eab66d55d99367d7d0d4beb2f9936fe8dda948a7877da2071cd803:


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