@joe-broadhead/messaging 0.7.1 → 0.9.0

package/dist/lib/modules/ipc/testing.js

@@ -1,10 +1,10 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { IPC_METHODS, MessagingError } from "../core/index.js";
+import { CONVERSATION_METHODS, IPC_METHODS, MessagingError } from "../core/index.js";
 import { MessagingClient } from "./client.js";
 import { IS_WINDOWS, MAX_SOCKET_PATH_BYTES, socketPath as socketOf } from "./paths.js";
-import { createIpcServer } from "./server.js";
+import { createConversationIpcServerForTesting, createIpcServer } from "./server.js";
 import { newPipeName, readPointer, writePointer } from "./pipes.js";
 import { securePrivate } from "./windows-acl.js";
 /**
@@ -55,36 +55,30 @@ export function rawEndpoint(socketPath) {
 export function ulid(n) {
     return `01JC${String(n).padStart(22, "0")}`;
 }
-/** Polls `predicate` every 10 ms until it holds; throws after `timeoutMs`. */
-export async function until(predicate, timeoutMs = 3_000, what = "condition") {
-    const deadline = Date.now() + timeoutMs;
+/** Polls state with no notification; the enclosing test's timeout is the single bound. Legacy timeout and label are ignored. */
+export async function until(predicate, _timeoutMs, _what = "condition") {
     while (!predicate()) {
-        if (Date.now() > deadline)
-            throw new Error(`timed out waiting for ${what}`);
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        await new Promise((resolve) => setTimeout(resolve, 10).unref());
     }
 }
 export async function recordingDaemon(options = {}) {
+    const conversationMode = "methods" in options && options.methods !== undefined;
+    if (conversationMode && options.methods !== CONVERSATION_METHODS)
+        throw new TypeError("recordingDaemon: unsupported method table");
     const owned = options.at === undefined;
     const dir = options.at?.dir ?? tempSocketPath(options.prefix).dir;
     const socketPath = socketOf(dir, "agent");
     const adminSocketPath = socketOf(dir, "admin");
     const handlers = { ...options.handlers };
     const calls = [];
-    const convSubscribers = new Set();
     const dispatch = {};
-    for (const method of Object.keys(IPC_METHODS)) {
+    for (const method of Object.keys(conversationMode ? CONVERSATION_METHODS : IPC_METHODS)) {
         dispatch[method] = async (params, ctx) => {
             calls.push({ method, params: structuredClone(params) });
             const handler = handlers[method];
             if (!handler)
                 throw new MessagingError("forbidden", `fake daemon: no handler for ${method}`);
-            const result = await handler(params, ctx);
-            if (method === "conv.subscribe") {
-                convSubscribers.add(ctx);
-                ctx.signal.addEventListener("abort", () => convSubscribers.delete(ctx));
-            }
-            return result;
+            return handler(params, ctx);
         };
     }
     let servers;
@@ -92,8 +86,9 @@ export async function recordingDaemon(options = {}) {
         if (servers)
             return;
         const version = options.version === undefined ? {} : { version: options.version };
-        const agent = await createIpcServer({ socketPath, tier: "agent", handlers: dispatch, ...version });
-        const admin = await createIpcServer({ socketPath: adminSocketPath, tier: "admin", handlers: dispatch, ...version }).catch(async (error) => {
+        const serve = conversationMode ? createConversationIpcServerForTesting : createIpcServer;
+        const agent = await serve({ socketPath, tier: "agent", handlers: dispatch, ...version });
+        const admin = await serve({ socketPath: adminSocketPath, tier: "admin", handlers: dispatch, ...version }).catch(async (error) => {
             await agent.close();
             throw error;
         });
@@ -116,17 +111,12 @@ export async function recordingDaemon(options = {}) {
         callsTo,
         last: (method) => callsTo(method).at(-1),
         handle: (method, handler) => {
-            ;
             handlers[method] = handler;
         },
         publish: (event) => {
             for (const server of servers ?? [])
                 server.publish(event);
         },
-        conv: (event) => {
-            for (const ctx of convSubscribers)
-                ctx.notify(event);
-        },
         connect: (tier = "agent") => MessagingClient.connect({ socketPath: tier === "agent" ? socketPath : adminSocketPath, connectTimeoutMs: 500 }),
         connections: () => (servers ?? []).reduce((sum, server) => sum + server.connections(), 0),
         start,