From 819a72678f8a05b5f892f65ae3b8b7b23656cc70 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Fri, 20 Nov 2026 11:55:34 -0500 Subject: [PATCH] test(process): consolidate worker and transport ownership checks (#12887) * test(process): consolidate worker admission and cleanup ownership checks * test(process): prove local transport ownership after setup * test(process): keep cleanup coverage after a skipped owner --- src/process/LocalSocketConnection.test.ts | 25 ++++--- src/process/OwnedMcpStdioTransport.test.ts | 33 +++++---- src/process/OwnedWorkerRuntime.test.ts | 42 +++++------- src/process/WorkerCleanupRegistry.test.ts | 79 ++++++++++------------ 4 files changed, 83 insertions(+), 96 deletions(-) diff --git a/src/process/LocalSocketConnection.test.ts b/src/process/LocalSocketConnection.test.ts index 8ffbbbf8b6..3cdd6d03f0 100644 --- a/src/process/LocalSocketConnection.test.ts +++ b/src/process/LocalSocketConnection.test.ts @@ -9,30 +9,35 @@ for (const transport of ["tcp", "unix"] as const) it.skipIf(transport === "unix" && process.platform === "win32")( `connects a real local ${transport} socket and transfers ownership`, async () => { - const directory = await createTestTempDirectory("rea-local-socket-"); + const path = + transport === "unix" + ? join(await createTestTempDirectory("rea-local-socket-"), "socket") + : undefined; const server = createServer(); - const path = join(directory, "socket"); try { - if (transport === "unix") server.listen(path); + if (path !== undefined) server.listen(path); else server.listen(0, "127.0.0.1"); await once(server, "listening"); const incoming = once(server, "connection"); const target = - transport === "unix" + path !== undefined ? { path } : { host: "127.0.0.1", port: (server.address() as AddressInfo).port, }; - const result = await connectLocalSocketOnce( - target, - new AbortController().signal, - ); + const controller = new AbortController(); + const result = await connectLocalSocketOnce(target, controller.signal); if (!result.ok) throw new Error(`Connection failed: ${result.error.kind}`); const [peer] = await incoming; - result.value.destroy(); - peer.destroy(); + try { + controller.abort(); + expect(result.value.destroyed).toBe(false); + } finally { + result.value.destroy(); + peer.destroy(); + } } finally { await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())), diff --git a/src/process/OwnedMcpStdioTransport.test.ts b/src/process/OwnedMcpStdioTransport.test.ts index 65f15fbabf..807a265836 100644 --- a/src/process/OwnedMcpStdioTransport.test.ts +++ b/src/process/OwnedMcpStdioTransport.test.ts @@ -54,25 +54,24 @@ it("keeps a failed launch's transferred preparation cleanup until a close releas }); it("reports a failed launch's preparation cleanup failure that names no owner", async () => { + const preparation = new DarwinProcessOwnershipInspectionError( + "ownership-helper preparation failed", + { + cleanupFailure: new ProviderCleanupError("fixture", ["helper root"], { + reason: "unremovable", + }), + }, + ); const owned = transport(async () => { - throw new DarwinProcessOwnershipInspectionError( - "ownership-helper preparation failed", - { - cleanupFailure: new ProviderCleanupError("fixture", ["helper root"], { - reason: "unremovable", - }), - }, - ); + throw preparation; + }); + await expect(owned.start()).rejects.toBe(preparation); + await expect(owned.close()).rejects.toBeInstanceOf(ProviderCleanupError); + await expect(owned.close()).rejects.toMatchObject({ + cause: preparation, + cleanupIncomplete: true, + cleanupResources: ["process ownership inspection"], }); - await expect(owned.start()).rejects.toBeInstanceOf( - DarwinProcessOwnershipInspectionError, - ); - const failure = await owned.close().then( - () => undefined, - (cause: unknown) => cause, - ); - expect(failure).toBeInstanceOf(ProviderCleanupError); - expect((failure as ProviderCleanupError).cleanupIncomplete).toBe(true); }); it("closes cleanly after a launch failure that transferred no cleanup", async () => { diff --git a/src/process/OwnedWorkerRuntime.test.ts b/src/process/OwnedWorkerRuntime.test.ts index ae82b16961..76ac613b41 100644 --- a/src/process/OwnedWorkerRuntime.test.ts +++ b/src/process/OwnedWorkerRuntime.test.ts @@ -1,6 +1,6 @@ import { access } from "node:fs/promises"; import { randomUUID } from "node:crypto"; -import { expect, it } from "vitest"; +import { expect, it, vi } from "vitest"; import { withVerifierCleanup } from "../../scripts/lib/verifier-cleanup.mjs"; import { phaseGate } from "../../tests/support/lifecycleHarness.js"; @@ -11,7 +11,10 @@ import { OwnedWorkerRuntimeCleanupError, type OwnedWorkerRuntimeOptions, } from "./OwnedWorkerRuntime.js"; -import { spawnOwnedProviderProcess } from "./ProviderProcess.js"; +import { + spawnOwnedProviderProcess, + type ProviderProcessSupervisor, +} from "./ProviderProcess.js"; const runtimeOptions = ( overrides: Partial = {}, @@ -27,39 +30,30 @@ const startOptions = () => ({ stdin: "pipe" as const, }); -const waitFor = async (predicate: () => boolean): Promise => { - for (let attempt = 0; attempt < 100; attempt++) { - if (predicate()) return; - await new Promise((resolve) => setTimeout(resolve, 5)); - } - throw new Error("Timed out waiting for owned worker startup"); -}; - it("waits for an admitted late handshake before closing its process and root", async () => { const runtime = new OwnedWorkerRuntime(runtimeOptions()); - const initialization = phaseGate(); - let closeSettled = false; - const starting = runtime.start(startOptions(), async () => { - await initialization.hold(); - }); + const initialization = phaseGate(); + const starting = runtime.start(startOptions(), initialization.hold); let closing: Promise | undefined; await withVerifierCleanup(async () => { - await initialization.reached(starting, "worker initialization"); - await waitFor(() => runtime.supervisor !== undefined); + const supervisor = await initialization.reached( + starting, + "worker initialization", + ); const rootPath = runtime.rootPath; - expect(rootPath).toBeDefined(); - closing = runtime.close().then(() => { - closeSettled = true; - }); + if (rootPath === undefined) throw new Error("Worker root was not admitted"); + const stop = vi.spyOn(supervisor, "stop"); + closing = runtime.close(); await new Promise((resolve) => setImmediate(resolve)); - expect(closeSettled).toBe(false); - expect(runtime.supervisor).toBeDefined(); + expect(stop).not.toHaveBeenCalled(); + await access(rootPath); initialization.release(); await expect(starting).rejects.toThrow("closing"); await closing; + expect(stop).toHaveBeenCalledTimes(1); expect(runtime.supervisor).toBeUndefined(); expect(runtime.rootPath).toBeUndefined(); - await expect(access(rootPath as string)).rejects.toThrow(); + await expect(access(rootPath)).rejects.toThrow(); }, [ initialization.release, async () => { diff --git a/src/process/WorkerCleanupRegistry.test.ts b/src/process/WorkerCleanupRegistry.test.ts index 292e36bae3..0b43dc5029 100644 --- a/src/process/WorkerCleanupRegistry.test.ts +++ b/src/process/WorkerCleanupRegistry.test.ts @@ -1,4 +1,4 @@ -import { expect, it } from "vitest"; +import { expect, it, vi } from "vitest"; import { OwnedWorkerRuntime, @@ -26,57 +26,46 @@ it("retries one host's retained runtime without failing another host", async () } }); -it("retries every independent retained owner and keeps only exact failures pending", async () => { +it("retries all retained owners, preserves exact causes, and skips only the selected owner", async () => { const registry = new WorkerCleanupRegistry(); - const physical = new Error("first owner still owns its worker"); - let failing = true; - const calls: string[] = []; + const firstCause = new Error("first owner still owns its worker"); + const secondCause = new Error("second owner still owns its worker"); const first = { - retryRetainedCleanup: async () => { - calls.push("first"); - if (failing) throw physical; - registry.delete(first); - }, + retryRetainedCleanup: vi + .fn<() => Promise>() + .mockRejectedValue(firstCause), }; const second = { - retryRetainedCleanup: async () => { - calls.push("second"); - registry.delete(second); - }, + retryRetainedCleanup: vi + .fn<() => Promise>() + .mockRejectedValue(secondCause), }; - registry.add(first); - registry.add(second); - await expect(registry.retry()).rejects.toBe(physical); - expect(calls).toEqual(["first", "second"]); + const skipped = { retryRetainedCleanup: vi.fn(async () => {}) }; + for (const owner of [first, skipped, second]) registry.add(owner); + + const failure: unknown = await registry + .retry(skipped) + .catch((cause: unknown) => cause); + if (!(failure instanceof AggregateError)) + throw new Error("Expected both failed cleanup causes"); + expect(failure.errors).toHaveLength(2); + expect(failure.errors[0]).toBe(firstCause); + expect(failure.errors[1]).toBe(secondCause); + + second.retryRetainedCleanup.mockImplementation(async () => { + registry.delete(second); + }); + await expect(registry.retry(skipped)).rejects.toBe(firstCause); expect(registry.has(first)).toBe(true); expect(registry.has(second)).toBe(false); - failing = false; - await registry.retry(); - expect(calls).toEqual(["first", "second", "first"]); - expect(registry.has(first)).toBe(false); -}); -it("retains every failed cleanup cause and skips only the caller-selected owner", async () => { - const registry = new WorkerCleanupRegistry(); - const causes = [ - new Error("first exact cleanup"), - new Error("second exact cleanup"), - ]; - const skipped = { - retryRetainedCleanup: async () => { - throw new Error("must not retry selected owner"); - }, - }; - const owners = causes.map((cause) => ({ - retryRetainedCleanup: async () => { - throw cause; - }, - })); - registry.add(skipped); - for (const owner of owners) registry.add(owner); - const failure = await registry.retry(skipped).catch((cause) => cause); - expect(failure).toBeInstanceOf(AggregateError); - expect(failure.errors).toEqual(causes); + first.retryRetainedCleanup.mockImplementation(async () => { + registry.delete(first); + }); + await registry.retry(skipped); + expect(first.retryRetainedCleanup).toHaveBeenCalledTimes(3); + expect(second.retryRetainedCleanup).toHaveBeenCalledTimes(2); + expect(skipped.retryRetainedCleanup).not.toHaveBeenCalled(); + expect(registry.has(first)).toBe(false); expect(registry.has(skipped)).toBe(true); - for (const owner of owners) expect(registry.has(owner)).toBe(true); });