Files
reverse-engineering-anything/src/process/LocalSocketConnection.test.ts
T
morluto 819a72678f 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
2026-11-20 16:55:34 +00:00

97 lines
3.2 KiB
TypeScript

import { once } from "node:events";
import { createServer, type AddressInfo } from "node:net";
import { join } from "node:path";
import { expect, it } from "vitest";
import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
import { connectLocalSocketOnce } from "./LocalSocketConnection.js";
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 path =
transport === "unix"
? join(await createTestTempDirectory("rea-local-socket-"), "socket")
: undefined;
const server = createServer();
try {
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 =
path !== undefined
? { path }
: {
host: "127.0.0.1",
port: (server.address() as AddressInfo).port,
};
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;
try {
controller.abort();
expect(result.value.destroyed).toBe(false);
} finally {
result.value.destroy();
peer.destroy();
}
} finally {
await new Promise<void>((resolve, reject) =>
server.close((error) => (error ? reject(error) : resolve())),
);
}
},
);
it("retains an already-aborted caller's reason", async () => {
const controller = new AbortController();
const reason = { caller: "cancelled" };
controller.abort(reason);
const result = await connectLocalSocketOnce(
{ host: "127.0.0.1", port: -1 },
controller.signal,
);
expect(result).toEqual({ ok: false, error: { kind: "cancelled", reason } });
});
it("cancels an outstanding connection attempt with the caller's reason", async () => {
const server = createServer((peer) => peer.destroy());
server.listen(0, "127.0.0.1");
await once(server, "listening");
try {
const controller = new AbortController();
const reason = { caller: "stop connecting" };
const pending = connectLocalSocketOnce(
{ host: "127.0.0.1", port: (server.address() as AddressInfo).port },
controller.signal,
);
controller.abort(reason);
expect(await pending).toEqual({
ok: false,
error: { kind: "cancelled", reason },
});
} finally {
await new Promise<void>((resolve, reject) =>
server.close((error) => (error ? reject(error) : resolve())),
);
}
});
it.skipIf(process.platform === "win32")(
"reports a local socket connection failure",
async () => {
const directory = await createTestTempDirectory("rea-missing-socket-");
const result = await connectLocalSocketOnce(
{ path: join(directory, "missing") },
new AbortController().signal,
);
expect(result).toMatchObject({
ok: false,
error: { kind: "error", cause: { code: "ENOENT" } },
});
},
);