@zhin.js/testing 1.0.6 → 1.0.8

package/src/index.ts

@@ -1,6 +1,6 @@
 import { realpath } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { defineAdapter, type AdapterDefinition, type AdapterSegmentPolicy,
+import { Adapter, createEndpointSpecification, endpointSpec, defineAdapter, type Endpoint, type AdapterDefinition, type AdapterSegmentPolicy,
   type EndpointIdentity, type EndpointEventSink, type EndpointIncomingMessage, type EndpointSendRequest } from 'zhin.js/adapter';
 import { ImRuntime, type ConversationAddress, type MessageDispatchResult,
   type RuntimeMessageDiagnosticsReader, type SendContent } from 'zhin.js/core/runtime';
@@ -16,9 +16,10 @@ export { FakeDatabaseRootHost, FakeOutboundRootHost, type FakeOutboundCall } fro
 export { FakePlugin, createFakePlugin, runPluginSetup, resolvePluginConfig, PluginConfigValidationError, fakeResource,
   type FakePluginOptions, type RunPluginSetupOptions, type FakeResource, type FakeRegisteredFeature } from './fake-plugin.js';
 export { fakeOf } from './partial.js';
-export { createFakeMessage, createCommandContext, runCommand, runMiddleware, runHandler,
+export { createFakeMessage, createFakeInteraction, createCommandContext, runCommand, runMiddleware, runHandler,
   createToolContext, runTool, toolOriginFromMessage,
-  type FakeMessage, type RunToolOptions, type FakeMessageInit, type RunCommandOptions, type RunMiddlewareResult } from './fake-runners.js';
+  type FakeMessage, type FakeSentDelivery, type FakeInteraction, type FakeInteractionOptions,
+  type RunToolOptions, type FakeMessageInit, type RunCommandOptions, type RunMiddlewareResult } from './fake-runners.js';
 
 export interface PluginTestKitOptions {
   /** A real, disposable test app with its own package.json, plugin entry, dependencies and mounts. */
@@ -80,27 +81,55 @@ export class PluginTestKit {
       || names.some(name => !/^[a-z][a-z0-9-]*$/.test(name))) {
       throw new TypeError('Test endpoints must have unique lowercase names');
     }
-    this.#defaultEndpoint = names[0]!;
-    const definitions = new Map<string, AdapterDefinition>(names.map(name => [name, defineAdapter({
-      capabilities: ['inbound', 'outbound'],
-      segments: options.segments ?? { html: 'text', interactive: 'text', markdown: 'text' },
-      create: () => ({
-        client: Object.freeze({ synthetic: true }),
-        connect: ({ events, identity }) => {
-          this.#identities.set(name, identity);
-          this.#sinks.set(name, events);
-          return () => { if (this.#sinks.get(name) === events) { this.#sinks.delete(name); this.#identities.delete(name); } };
-        },
-        send: (request: EndpointSendRequest) => {
-          const id = `test-${this.#nextDelivery++}`;
-          this.#attempts.push(Object.freeze({ endpoint: name, id,
-            conversation: captureDeliveryValue(request.conversation),
-            payload: captureDeliveryValue(request.payload),
-          }));
-          return id;
-        },
-      }),
-    })]));
+    const [firstEndpoint = 'test'] = names;
+    this.#defaultEndpoint = firstEndpoint;
+    const recordAttempt = (endpoint: string, request: EndpointSendRequest): string => {
+      const id = `test-${this.#nextDelivery++}`;
+      this.#attempts.push(Object.freeze({
+        endpoint,
+        id,
+        conversation: captureDeliveryValue(request.conversation),
+        payload: captureDeliveryValue(request.payload),
+      }));
+      return id;
+    };
+    const registerOpen = (endpoint: string, spec: Endpoint[typeof endpointSpec]): void => {
+      this.#identities.set(endpoint, spec.identity);
+      this.#sinks.set(endpoint, spec.events);
+    };
+    const releaseEndpoint = (endpoint: string, spec: Endpoint[typeof endpointSpec]): void => {
+      if (this.#sinks.get(endpoint) !== spec.events) return;
+      this.#sinks.delete(endpoint);
+      this.#identities.delete(endpoint);
+    };
+    const definitions = new Map<string, AdapterDefinition>(names.map(name => {
+      class SyntheticClient {
+        readonly synthetic = true;
+        send(request: EndpointSendRequest): string {
+          return recordAttempt(name, request);
+        }
+      }
+      class SyntheticEndpoint extends SyntheticClient implements Endpoint {
+        readonly [endpointSpec] = createEndpointSpecification(this, {
+          start: signal => signal.throwIfAborted(),
+          open: () => {
+            registerOpen(name, this[endpointSpec]);
+          },
+          close: () => this.#release(), stop: () => this.#release(),
+          send: request => this.send(request),
+        });
+        #release(): void {
+          releaseEndpoint(name, this[endpointSpec]);
+        }
+      }
+      class SyntheticAdapter extends Adapter<SyntheticEndpoint> {
+        protected createEndpoint(): SyntheticEndpoint { return new SyntheticEndpoint(); }
+      }
+      return [name, defineAdapter({ capabilities: ['inbound', 'outbound'],
+        segments: options.segments ?? { html: 'text', interactive: 'text', markdown: 'text' },
+        createAdapter: () => new SyntheticAdapter(),
+      })];
+    }));
     const modules = options.modules ?? new NativeDevelopmentModuleRuntime({ projectRoot, watch: false });
     this.#root = new RootRuntime({ projectRoot,
       modules: withTestEndpoints(modules, rootEntry, definitions),

package/src/test-module-runtime.ts

@@ -24,7 +24,22 @@ export function withTestEndpoints(
       });
       return { ...loaded, default: definition } as T;
     },
-    ...(delegate.loadClientModule ? { loadClientModule: delegate.loadClientModule.bind(delegate) } : {}),
+    loadClientModule: delegate.loadClientModule
+      ? delegate.loadClientModule.bind(delegate)
+      : async <T = unknown>(source: string): Promise<T> => {
+          let metadata: unknown;
+          try {
+            const loaded = await delegate.load<{ meta?: unknown }>(source);
+            metadata = loaded?.meta;
+          } catch {
+            // Browser-only client modules may not load in headless Node test mode; fall back to default metadata.
+          }
+          return Object.freeze({
+            module: source,
+            hash: 'test',
+            ...(metadata !== undefined ? { metadata } : {}),
+          }) as T;
+        },
     ...(delegate.invalidate ? { invalidate: delegate.invalidate.bind(delegate) } : {}),
     ...(delegate.affectedSources ? { affectedSources: delegate.affectedSources.bind(delegate) } : {}),
     ...(delegate.requiresProcessRestart ? { requiresProcessRestart: delegate.requiresProcessRestart.bind(delegate) } : {}),