scriptc/packages/runtime-darwin-arm64/test/archive.test.ts

import { chmod, mkdir, mkdtemp, readFile, rm, stat, utimes, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, describe, expect, test } from "vitest";
import { createDeterministicArchive } from "../scripts/archive.mjs";
import { installRuntimePack, withBuildLock } from "../scripts/build-state.mjs";

const dirs: string[] = [];

function memberMetadata(bytes: Buffer) {
  const entries: { timestamp: string; uid: string; gid: string; mode: string }[] = [];
  let offset = Buffer.byteLength("!<arch>\n");
  while (offset < bytes.length) {
    const size = Number(
      bytes
        .subarray(offset + 48, offset + 58)
        .toString("ascii")
        .trim(),
    );
    entries.push({
      timestamp: bytes
        .subarray(offset + 16, offset + 28)
        .toString("ascii")
        .trim(),
      uid: bytes
        .subarray(offset + 28, offset + 34)
        .toString("ascii")
        .trim(),
      gid: bytes
        .subarray(offset + 34, offset + 40)
        .toString("ascii")
        .trim(),
      mode: bytes
        .subarray(offset + 40, offset + 48)
        .toString("ascii")
        .trim(),
    });
    offset += 60 + size + (size % 2);
  }
  return entries;
}

afterEach(async () => {
  await Promise.all(dirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
});

describe.runIf(process.platform === "darwin")("runtime-pack archives", () => {
  test("serializes concurrent pack builders", async () => {
    const dir = await mkdtemp(join(tmpdir(), "scriptc-runtime-build-lock-"));
    dirs.push(dir);
    const lock = join(dir, "build.lock");
    const events: string[] = [];
    let releaseFirst!: () => void;
    const firstMayFinish = new Promise<void>((resolve) => {
      releaseFirst = resolve;
    });
    let firstStarted!: () => void;
    const firstDidStart = new Promise<void>((resolve) => {
      firstStarted = resolve;
    });
    const first = withBuildLock(
      lock,
      async () => {
        events.push("first:start");
        firstStarted();
        await firstMayFinish;
        events.push("first:end");
      },
      { retryMilliseconds: 5 },
    );
    await firstDidStart;
    const second = withBuildLock(
      lock,
      async () => {
        events.push("second:start");
        events.push("second:end");
      },
      { retryMilliseconds: 5 },
    );
    await new Promise((resolve) => setTimeout(resolve, 20));
    expect(events).toEqual(["first:start"]);
    releaseFirst();
    await Promise.all([first, second]);
    expect(events).toEqual(["first:start", "first:end", "second:start", "second:end"]);
  });

  test("installs a staged pack over the previous complete pair", async () => {
    const dir = await mkdtemp(join(tmpdir(), "scriptc-runtime-build-install-"));
    dirs.push(dir);
    const outputRoot = join(dir, "artifacts");
    const manifestPath = join(dir, "runtime-pack.json");
    const stagedOutputRoot = join(dir, "stage", "artifacts");
    const stagedManifestPath = join(dir, "stage", "runtime-pack.json");
    await Promise.all([mkdir(outputRoot), mkdir(stagedOutputRoot, { recursive: true })]);
    await Promise.all([
      writeFile(join(outputRoot, "runtime.o"), "old object"),
      writeFile(manifestPath, "old manifest"),
      writeFile(join(stagedOutputRoot, "runtime.o"), "new object"),
      writeFile(stagedManifestPath, "new manifest"),
    ]);

    await installRuntimePack({
      outputRoot,
      manifestPath,
      stagedOutputRoot,
      stagedManifestPath,
      backupRoot: join(dir, "artifacts.backup"),
      backupManifestPath: join(dir, "manifest.backup"),
    });

    expect(await readFile(join(outputRoot, "runtime.o"), "utf8")).toBe("new object");
    expect(await readFile(manifestPath, "utf8")).toBe("new manifest");
    expect(
      await stat(join(dir, "artifacts.backup")).then(
        () => true,
        () => false,
      ),
    ).toBe(false);
  });

  test("normalize timestamps, ownership, and modes", async () => {
    const dir = await mkdtemp(join(tmpdir(), "scriptc-runtime-archive-"));
    dirs.push(dir);
    const member = join(dir, "member.o");
    const first = join(dir, "first.a");
    const second = join(dir, "second.a");
    await writeFile(member, "runtime-pack archive member\n");

    await chmod(member, 0o600);
    await utimes(member, new Date(1_000), new Date(1_000));
    await createDeterministicArchive("ar", first, [member]);
    await utimes(member, new Date(2_000), new Date(2_000));
    await createDeterministicArchive("ar", second, [member]);

    const firstBytes = await readFile(first);
    expect(await readFile(second)).toEqual(firstBytes);
    const metadata = memberMetadata(firstBytes);
    expect(metadata.length).toBeGreaterThanOrEqual(1);
    expect(
      metadata.every(
        (entry) =>
          entry.timestamp === "0" &&
          entry.uid === "0" &&
          entry.gid === "0" &&
          entry.mode === "100644",
      ),
    ).toBe(true);
  });
});