test(process): consolidate Darwin helper request and cleanup proof (#12897)

* test(process): consolidate Darwin helper request and cleanup proof

* test(process): preserve native helper argument boundaries in fixture
This commit is contained in:
morluto authored and GitHub committed 2026-11-20 17:47:03 +00:00
1 parent 56682a75c1
commit 193bc533be
1 file changed
+176 -280
@@ -2,75 +2,61 @@ import { basename, join } from "node:path";
import { tmpdir } from "node:os";
import { access } from "node:fs/promises";
import { expect, it, onTestFinished, vi } from "vitest";
import { expect, it, vi } from "vitest";
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
import { awaitAcknowledgement } from "../../tests/fixtures/lifecycleAcknowledgement.js";
interface HelperRequest {
readonly arguments: readonly string[];
readonly rows?: readonly unknown[];
readonly failure?: Error;
}
const command = vi.hoisted(() => {
let helperMode: "read" | "identities" = "read";
let identityAbsent = false;
let helperSessions: Array<{
readonly pid: number;
readonly failed: boolean;
readonly gate: Promise<void>;
readonly release: () => void;
}> = [];
let expectedHelpers = 1;
let startedHelpers = 0;
let failRootRemovals = 0;
let startedResolve: (() => void) | undefined;
let started: Promise<void> = Promise.resolve();
const events: string[] = [];
const makeGate = () => {
let release = (): void => {};
const gate = new Promise<void>((resolve) => {
release = resolve;
});
return { gate, release };
};
let helpers = new Map<
string,
HelperRequest & { gate: Promise<void>; release: () => void }
>();
let started: Promise<void>;
let acknowledge: () => void;
const startedRequests = new Set<string>();
let failRootRemovals = 0;
return {
configure(mode: "read" | "identities", absent = false) {
helperMode = mode;
identityAbsent = absent;
configure(requests: readonly HelperRequest[], failedRemovals = 0) {
events.length = 0;
expectedHelpers = 1;
startedHelpers = 0;
failRootRemovals = 0;
const session = makeGate();
helperSessions = [{ pid: 123, failed: false, ...session }];
started = new Promise<void>((resolve) => {
startedResolve = resolve;
startedRequests.clear();
failRootRemovals = failedRemovals;
started = new Promise((resolve) => {
acknowledge = resolve;
});
helpers = new Map(
requests.map((request) => {
let release!: () => void;
const gate = new Promise<void>((resolve) => {
release = resolve;
});
return [
JSON.stringify(request.arguments),
{ ...request, gate, release },
];
}),
);
},
configureMixed() {
helperMode = "read";
events.length = 0;
expectedHelpers = 2;
startedHelpers = 0;
failRootRemovals = 1;
helperSessions = [
{ pid: 123, failed: false, ...makeGate() },
{ pid: 124, failed: true, ...makeGate() },
];
started = new Promise<void>((resolve) => {
startedResolve = resolve;
});
},
waitUntilStarted() {
return started;
},
waitUntilStarted: () => started,
release() {
for (const session of helperSessions) session.release();
for (const helper of helpers.values()) helper.release();
},
releaseHelper(pid: number) {
helperSessions.find((session) => session.pid === pid)?.release();
const helper = helpers.get(JSON.stringify([String(pid)]));
if (helper === undefined) throw new Error(`Unexpected helper PID ${pid}`);
helper.release();
},
async remove(path: string) {
const ownedPath = String(path);
if (ownedPath.includes("rea-process-token-")) {
events.push(`root-remove:${ownedPath}`);
remove(path: string) {
if (path.includes("rea-process-token-")) {
events.push(`remove:${path}`);
if (failRootRemovals > 0) {
failRootRemovals -= 1;
throw new Error("fixture root removal failure");
@@ -80,48 +66,26 @@ const command = vi.hoisted(() => {
get events() {
return [...events];
},
async run(commandPath: string, arguments_: readonly string[]) {
async run(commandPath: string, args: readonly string[]) {
if (basename(commandPath) === "fixture-swiftc") {
const outputIndex = arguments_.indexOf("-o");
const output = arguments_[outputIndex + 1];
const output = args[args.indexOf("-o") + 1];
if (output === undefined) throw new Error("Missing helper output path");
const fs = await import("node:fs/promises");
await fs.writeFile(output, "fixture helper");
return { stdout: "", stderr: "", stdoutBytes: 0, stderrBytes: 0 };
}
const session = helperSessions[startedHelpers];
if (session === undefined)
throw new Error("Unexpected helper invocation");
startedHelpers += 1;
events.push(`helper-start:${session.pid}`);
if (startedHelpers === expectedHelpers) startedResolve?.();
const key = JSON.stringify(args);
const helper = helpers.get(key);
if (helper === undefined || startedRequests.has(key))
throw new Error(`Unexpected helper request ${key}`);
startedRequests.add(key);
const request = args.join(" ");
events.push(`start:${request}`);
if (startedRequests.size === helpers.size) acknowledge();
try {
await session.gate;
if (session.failed) throw new Error("fixture helper failure");
const stdout = JSON.stringify({
results: [
helperMode === "read"
? { pid: session.pid, state: "readable", run_id: "run" }
: identityAbsent
? {
pid: session.pid,
state: "absent",
identity: null,
reason: "not-in-snapshot",
}
: {
pid: session.pid,
state: "readable",
identity: "start:456",
lifecycle: "non-zombie",
relation: {
state: "observed",
parent_pid: 1,
process_group_id: 123,
},
},
],
});
await helper.gate;
if (helper.failure !== undefined) throw helper.failure;
const stdout = JSON.stringify({ results: helper.rows });
return {
stdout,
stderr: "",
@@ -129,7 +93,7 @@ const command = vi.hoisted(() => {
stderrBytes: 0,
};
} finally {
events.push(`helper-finalized:${session.pid}`);
events.push(`finalized:${request}`);
}
},
};
@@ -139,31 +103,22 @@ vi.mock("node:fs/promises", async (importOriginal) => {
const original = await importOriginal<typeof import("node:fs/promises")>();
return {
...original,
rm: async (
path: Parameters<typeof original.rm>[0],
options?: Parameters<typeof original.rm>[1],
) => {
const ownedPath = String(path);
await command.remove(ownedPath);
return original.rm(path, options);
rm: async (...args: Parameters<typeof original.rm>) => {
command.remove(String(args[0]));
return original.rm(...args);
},
};
});
vi.mock("./ExecFileOutput.js", async (importOriginal) => {
const original = await importOriginal<typeof import("./ExecFileOutput.js")>();
return {
...original,
execFileOutput: (commandPath: string, arguments_: readonly string[]) =>
command.run(commandPath, arguments_),
};
});
vi.mock("./ExecFileOutput.js", async (importOriginal) => ({
...(await importOriginal<typeof import("./ExecFileOutput.js")>()),
execFileOutput: command.run,
}));
import { createDarwinProcessRunTokenReader } from "./DarwinProcessRunTokenReader.js";
it("decodes a successful native snapshot absence as a distinct identity fact", async () => {
command.configure("identities", true);
const reader = createDarwinProcessRunTokenReader({
const createReader = () =>
createDarwinProcessRunTokenReader({
compiler: {
kind: "swiftc",
executable: join(tmpdir(), "fixture-swiftc"),
@@ -171,187 +126,128 @@ it("decodes a successful native snapshot absence as a distinct identity fact", a
},
environment: {},
});
it("joins native identity observation before close and distinguishes absence from a live generation", async () => {
command.configure([
{
arguments: ["--identities", "123", "124"],
rows: [
{
pid: 123,
state: "readable",
identity: "start:456",
lifecycle: "non-zombie",
relation: { state: "observed", parent_pid: 1, process_group_id: 123 },
},
{
pid: 124,
state: "absent",
identity: null,
reason: "not-in-snapshot",
},
],
},
]);
const reader = createReader();
const processes = [{ pid: 123 }, { pid: 124 }];
const observing = reader.identities(processes);
let closing: Promise<void> | undefined;
try {
const processes = [
{
pid: 123,
parentPid: 1,
processGroupId: 123,
state: "S",
command: "fixture",
},
];
const operation = reader.identities(processes);
await command.waitUntilStarted();
command.release();
await expect(operation).resolves.toEqual(
new Map([[123, { state: "absent", reason: "not-in-snapshot" }]]),
await awaitAcknowledgement(
command.waitUntilStarted(),
observing,
"identity helper",
);
const closed = vi.fn<() => void>();
closing = reader.close().then(closed);
void closing.catch(() => undefined);
await new Promise<void>((resolve) => setImmediate(resolve));
expect(closed).not.toHaveBeenCalled();
command.release();
await expect(observing).resolves.toEqual(
new Map<number, unknown>([
[
123,
{
state: "readable",
identity: "start:456",
lifecycle: { state: "observed", lifecycle: "non-zombie" },
relation: { state: "observed", parentPid: 1, processGroupId: 123 },
},
],
[124, { state: "absent", reason: "not-in-snapshot" }],
]),
);
await closing;
expect(command.events).toEqual([
"start:--identities 123 124",
"finalized:--identities 123 124",
expect.stringMatching(/^remove:/u),
]);
await expect(reader.identities(processes)).rejects.toThrow("closed");
} finally {
command.release();
await reader.close();
await Promise.allSettled([observing, closing, reader.close()]);
}
});
it.each(["read", "identities"] as const)(
"waits for an active helper %s before removing its executable root",
async (mode) => {
command.configure(mode);
const reader = createDarwinProcessRunTokenReader({
compiler: {
kind: "swiftc",
executable: join(tmpdir(), "fixture-swiftc"),
sdkRoot: tmpdir(),
},
environment: {},
});
let operation: Promise<unknown> | undefined;
let closing: Promise<void> | undefined;
onTestFinished(async () => {
command.release();
await Promise.allSettled([operation, closing, reader.close()]);
});
const processes = [
it("drains mixed token read outcomes and retries only the failed root removal", async () => {
const helperFailure = new Error("fixture helper failure");
command.configure(
[
{
pid: 123,
parentPid: 1,
processGroupId: 123,
state: "S",
command: "fixture",
arguments: ["123"],
rows: [{ pid: 123, state: "readable", run_id: "run" }],
},
];
operation =
mode === "read" ? reader.read(processes) : reader.identities(processes);
await command.waitUntilStarted();
let closeSettled = false;
closing = reader.close().then(() => {
closeSettled = true;
});
await new Promise<void>((resolve) => setImmediate(resolve));
const closeWaitedForHelper = !closeSettled;
command.release();
const result = await operation;
await closing;
expect(closeWaitedForHelper).toBe(true);
const events = command.events;
const helperFinalizedAt = events.findIndex((event) =>
event.startsWith("helper-finalized:"),
);
const rootRemovedAt = events.findIndex((event) =>
event.startsWith("root-remove:"),
);
expect(helperFinalizedAt).toBeGreaterThanOrEqual(0);
expect(rootRemovedAt).toBeGreaterThan(helperFinalizedAt);
expect(result).toEqual(
new Map([
[
123,
mode === "read"
? { state: "readable", runId: "run" }
: {
state: "readable",
identity: "start:456",
lifecycle: { state: "observed", lifecycle: "non-zombie" },
relation: {
state: "observed",
parentPid: 1,
processGroupId: 123,
},
},
],
]),
);
await expect(
mode === "read" ? reader.read(processes) : reader.identities(processes),
).rejects.toThrow("closed");
},
);
it("drains mixed helper outcomes before cleanup and retries failed root removal", async () => {
command.configureMixed();
const reader = createDarwinProcessRunTokenReader({
compiler: {
kind: "swiftc",
executable: join(tmpdir(), "fixture-swiftc"),
sdkRoot: tmpdir(),
},
environment: {},
});
const entry = (pid: number) => ({
pid,
parentPid: 1,
processGroupId: pid,
state: "S",
command: "fixture",
});
let successfulRead: Promise<unknown> | undefined;
let failedRead: Promise<unknown> | undefined;
{ arguments: ["124"], failure: helperFailure },
],
1,
);
const reader = createReader();
const failed = reader.read([{ pid: 124 }]);
const successful = reader.read([{ pid: 123 }]);
let closing: Promise<void> | undefined;
onTestFinished(async () => {
command.release();
await Promise.allSettled([
successfulRead,
failedRead,
closing,
reader.close(),
try {
await awaitAcknowledgement(
command.waitUntilStarted(),
Promise.race([failed, successful]),
"both token helpers",
);
closing = reader.close();
void closing.catch(() => undefined);
command.releaseHelper(124);
await expect(failed).rejects.toBe(helperFailure);
expect(command.events).not.toContainEqual(
expect.stringMatching(/^remove:/u),
);
command.releaseHelper(123);
await expect(successful).resolves.toEqual(
new Map([[123, { state: "readable", runId: "run" }]]),
);
const closeFailure = await closing.catch((cause: unknown) => cause);
if (!(closeFailure instanceof ProviderCleanupError))
throw new Error("Expected retained helper-root cleanup failure");
expect(closeFailure.cleanupIncomplete).toBe(true);
expect(closeFailure.cleanupResources).toHaveLength(1);
const [root] = closeFailure.cleanupResources;
if (root === undefined) throw new Error("Expected retained helper root");
await access(root);
expect(command.events.slice(-3)).toEqual([
"finalized:124",
"finalized:123",
`remove:${root}`,
]);
});
successfulRead = reader.read([entry(123)]);
failedRead = reader.read([entry(124)]);
await command.waitUntilStarted();
closing = reader.close();
command.releaseHelper(124);
const failedOutcome = await failedRead.then(
() => undefined,
(cause: unknown) => cause,
);
expect(failedOutcome).toBeInstanceOf(Error);
expect(command.events.some((event) => event.startsWith("root-remove:"))).toBe(
false,
);
command.releaseHelper(123);
await expect(successfulRead).resolves.toEqual(
new Map([[123, { state: "readable", runId: "run" }]]),
);
const closeFailure = await closing.then(
() => undefined,
(cause: unknown) => cause,
);
if (!(closeFailure instanceof ProviderCleanupError))
throw new Error("Expected retained helper-root cleanup failure");
expect(closeFailure.cleanupIncomplete).toBe(true);
expect(closeFailure.cleanupResources).toHaveLength(1);
const [retainedRoot] = closeFailure.cleanupResources;
if (retainedRoot === undefined)
throw new Error("Expected retained helper root");
await expect(access(retainedRoot)).resolves.toBeUndefined();
const events = command.events;
const finalHelperAt = Math.max(
events.indexOf("helper-finalized:123"),
events.indexOf("helper-finalized:124"),
);
const removalEvents = events.filter((event) =>
event.startsWith("root-remove:"),
);
expect(finalHelperAt).toBeGreaterThanOrEqual(0);
expect(removalEvents).toHaveLength(1);
expect(events.indexOf(removalEvents[0]!)).toBeGreaterThan(finalHelperAt);
await reader.close();
await expect(access(retainedRoot)).rejects.toMatchObject({ code: "ENOENT" });
expect(closeFailure.cleanupIncomplete).toBe(false);
expect(
command.events.filter((event) => event.startsWith("helper-start:")),
).toHaveLength(2);
expect(
command.events.filter((event) => event.startsWith("root-remove:")),
).toHaveLength(2);
await expect(reader.read([entry(123)])).rejects.toThrow("closed");
const before = command.events;
await reader.close();
await expect(access(root)).rejects.toMatchObject({ code: "ENOENT" });
expect(closeFailure.cleanupIncomplete).toBe(false);
expect(command.events).toEqual([...before, `remove:${root}`]);
await expect(reader.read([{ pid: 123 }])).rejects.toThrow("closed");
} finally {
command.release();
await Promise.allSettled([failed, successful, closing, reader.close()]);
}
});