scriptc/packages/compiler/src/native/executable-cache.test.ts

import { spawnSync } from "node:child_process";
import {
  mkdirSync,
  mkdtempSync,
  readFileSync,
  readdirSync,
  renameSync,
  rmSync,
  statSync,
  symlinkSync,
  utimesSync,
  writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, expect, test, vi } from "vitest";
import { contentDigest, NativeCache } from "./cache.js";
import { NativeExecutableCache } from "./executable-cache.js";

vi.mock("node:child_process", async (original) => ({
  ...(await original<typeof import("node:child_process")>()),
  spawnSync: vi.fn(),
}));

const directories: string[] = [];
afterEach(() => {
  vi.resetAllMocks();
  for (const path of directories.splice(0)) rmSync(path, { recursive: true, force: true });
});

function fixture(debug = false) {
  const root = mkdtempSync(join(tmpdir(), "scriptc-native-executable-"));
  directories.push(root);
  const inputs = join(root, "inputs");
  const sdk = join(root, "sdk");
  const stage = join(root, "stage");
  const restored = join(root, "restored");
  for (const directory of [inputs, sdk, stage, restored]) mkdirSync(directory);
  const runtime = join(inputs, "runtime.o");
  const library = join(sdk, "libSystem.tbd");
  writeFileSync(runtime, "runtime");
  writeFileSync(library, "system library");
  const cache = new NativeCache(join(root, "cache"));
  const key = contentDigest("llvm and options");
  const open = () => new NativeExecutableCache(cache, key, "clang", debug, [runtime]);
  vi.mocked(spawnSync).mockReturnValue({
    pid: 1,
    status: 0,
    signal: null,
    output: [],
    stdout: library + "\n",
    stderr: "",
  });
  const output = join(stage, "program");
  writeFileSync(output, Buffer.from([0, 128, 255, 10]));
  if (debug) {
    const contents = join(output + ".dSYM", "Contents");
    mkdirSync(join(contents, "Resources", "DWARF"), { recursive: true });
    writeFileSync(join(contents, "Info.plist"), "property list");
    writeFileSync(join(contents, "Resources", "DWARF", "program"), "debug information");
  }
  const publish = () => {
    const entry = open();
    expect(entry.trace(["-o", output], stage)).toBe(true);
    entry.publish(output);
  };
  return {
    root,
    inputs,
    sdk,
    stage,
    output,
    destination: join(restored, "program"),
    runtime,
    library,
    cache,
    key,
    open,
    publish,
  };
}

test.each([false, true])(
  "restores a complete executable and its debug information (%s)",
  (debug) => {
    const f = fixture(debug);
    f.publish();
    vi.mocked(spawnSync).mockClear();
    expect(f.open().restore(f.destination)).toBe(true);
    expect(readFileSync(f.destination)).toEqual(readFileSync(f.output));
    if (process.platform !== "win32") expect(statSync(f.destination).mode & 0o111).toBe(0o111);
    expect(spawnSync).not.toHaveBeenCalled();
    if (debug) {
      expect(
        readFileSync(join(f.destination + ".dSYM/Contents/Resources/DWARF/program"), "utf8"),
      ).toBe("debug information");
      expect(readFileSync(join(f.destination + ".dSYM/Contents/Info.plist"), "utf8")).toBe(
        "property list",
      );
    }
  },
);

test.each(["runtime", "library"] as const)(
  "invalidates %s replacement even with restored size and mtime",
  (input) => {
    const f = fixture();
    f.publish();
    const before = statSync(f[input]);
    writeFileSync(f[input] + ".new", "x".repeat(before.size));
    utimesSync(f[input] + ".new", before.atime, before.mtime);
    renameSync(f[input] + ".new", f[input]);
    expect(f.open().restore(f.destination)).toBe(false);
  },
);

test("adding a new SDK library search candidate invalidates the previous link", () => {
  const f = fixture();
  f.publish();
  writeFileSync(join(f.sdk, "libSystem.dylib"), "new candidate");
  expect(f.open().restore(f.destination)).toBe(false);
});

test("a library search change during tracing prevents publication", () => {
  const f = fixture();
  vi.mocked(spawnSync).mockImplementation(() => {
    if (vi.mocked(spawnSync).mock.calls.length === 2)
      writeFileSync(join(f.sdk, "new-library.tbd"), "library");
    return { pid: 1, status: 0, signal: null, output: [], stdout: f.library + "\n", stderr: "" };
  });
  const entry = f.open();
  expect(entry.trace([], f.stage)).toBe(false);
  entry.publish(f.output);
  expect(f.open().restore(f.destination)).toBe(false);
});

test.skipIf(process.platform === "win32")(
  "retargeting an input symlink invalidates the previous link",
  () => {
    const f = fixture();
    const link = join(f.inputs, "current.o");
    symlinkSync(f.runtime, link);
    const open = () => new NativeExecutableCache(f.cache, f.key, "clang", false, [link]);
    const entry = open();
    expect(entry.trace([], f.stage)).toBe(true);
    entry.publish(f.output);
    expect(open().restore(f.destination)).toBe(true);
    const replacement = join(f.inputs, "replacement.o");
    writeFileSync(replacement, "runtime");
    rmSync(link);
    symlinkSync(replacement, link);
    expect(open().restore(f.destination)).toBe(false);
  },
);

test.each(["executable", "binary", "dsym"])("corrupt %s payloads are misses", (family) => {
  const f = fixture(true);
  f.publish();
  const directory = join(f.cache.root, family);
  const key = readdirSync(directory).find((name) => /^[0-9a-f]{64}$/.test(name))!;
  writeFileSync(join(directory, key), "corrupt");
  expect(f.open().restore(f.destination)).toBe(false);
});

test("invalid cache metadata is rejected even with a matching integrity digest", () => {
  const f = fixture();
  f.publish();
  const bytes = f.cache.read("executable", f.key)!;
  const entry = JSON.parse(bytes.toString());
  entry.inputs = [];
  f.cache.write("executable", f.key, JSON.stringify(entry));
  expect(f.open().restore(f.destination)).toBe(false);
});

test("changing an input during emission prevents cache publication", () => {
  const f = fixture();
  const entry = f.open();
  expect(entry.trace([], f.stage)).toBe(true);
  writeFileSync(f.runtime, "replacement runtime");
  entry.publish(f.output);
  expect(f.open().restore(f.destination)).toBe(false);
});

test("metadata cannot omit a required runtime input", () => {
  const f = fixture();
  f.publish();
  const bytes = f.cache.read("executable", f.key)!;
  const entry = JSON.parse(bytes.toString());
  entry.inputs = entry.inputs.filter((input: { path: string }) => input.path !== f.runtime);
  f.cache.write("executable", f.key, JSON.stringify(entry));
  expect(f.open().restore(f.destination)).toBe(false);
});

test("a failed or empty link trace cannot publish a completed executable", () => {
  const f = fixture();
  const entry = f.open();
  entry.publish(f.output);
  expect(f.open().restore(f.destination)).toBe(false);
  vi.mocked(spawnSync).mockReturnValue({
    pid: 1,
    status: 0,
    signal: null,
    output: [],
    stdout: "",
    stderr: "",
  });
  expect(entry.trace([], f.stage)).toBe(false);
  entry.publish(f.output);
  expect(f.open().restore(f.destination)).toBe(false);
  vi.mocked(spawnSync).mockReturnValue({
    pid: 1,
    status: 1,
    signal: null,
    output: [],
    stdout: "",
    stderr: "failed",
  });
  expect(entry.trace([], f.stage)).toBe(false);
});