mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 14:05:49 +00:00
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:
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()]);
|
||||
}
|
||||
});
|
||||
Reference in new issue
Block a user