scriptc/tests/harness/ts7-client-harness.ts

import { spawn, type ChildProcess } from "node:child_process";
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { expect } from "vitest";
import { ts7Executable } from "../../packages/compiler/src/frontend/ts7/rpc-api.js";
import { TS7_FILE_SYSTEM_CALLBACKS } from "../../packages/compiler/src/frontend/ts7/rpc-filesystem.js";

const root = fileURLToPath(new URL("../..", import.meta.url));

function result(
  child: ChildProcess,
): Promise<{ status: number | null; signal: string | null; stdout: string; stderr: string }> {
  return new Promise((resolve, reject) => {
    let stdout = "";
    let stderr = "";
    const timeout = setTimeout(() => {
      child.kill("SIGKILL");
      reject(new Error(`TypeScript client timed out: ${stderr}`));
    }, 45_000);
    child.stdout?.setEncoding("utf8").on("data", (chunk: string) => {
      stdout += chunk;
    });
    child.stderr?.setEncoding("utf8").on("data", (chunk: string) => {
      stderr += chunk;
    });
    child.once("error", (error) => {
      clearTimeout(timeout);
      reject(error);
    });
    child.once("close", (status, signal) => {
      clearTimeout(timeout);
      resolve({ status, signal, stdout, stderr });
    });
  });
}

export async function runClient(
  command: string,
  args: string[],
  directory: string,
  report: string,
): Promise<string> {
  const server = spawn(
    ts7Executable(),
    ["--api", "--timing", "--cwd", directory, `--callbacks=${TS7_FILE_SYSTEM_CALLBACKS}`],
    {
      stdio: ["pipe", "pipe", "pipe"],
    },
  );
  let serverStderr = "";
  server.stderr.setEncoding("utf8").on("data", (chunk: string) => {
    serverStderr += chunk;
  });
  const serverDone = new Promise<void>((resolve) => {
    server.once("close", () => resolve());
  });
  let serverError: Error | undefined;
  server.on("error", (error) => {
    serverError = error;
  });
  try {
    // Node creates POSIX pipes nonblocking. Both consumers below use sync
    // reads; change that property before inheriting the underlying handles.
    if (process.platform !== "win32") {
      for (const stream of [server.stdin, server.stdout]) {
        (
          stream as unknown as { _handle: { setBlocking: (value: boolean) => void } }
        )._handle.setBlocking(true);
      }
    }
    const child = spawn(command, [...args, directory, report], {
      cwd: root,
      stdio: ["ignore", "pipe", "pipe", server.stdout, server.stdin],
    });
    const actual = await result(child);
    expect(serverError).toBeUndefined();
    expect(actual.signal, actual.stderr + serverStderr).toBeNull();
    expect(actual.status, actual.stderr + serverStderr).toBe(0);
    expect(actual.stdout).toBe("");
    expect(actual.stderr).toBe("");
    expect(serverStderr).toBe("");
    return readFileSync(report, "utf8");
  } finally {
    server.stdin.destroy();
    server.stdout.destroy();
    server.kill();
    await serverDone;
  }
}