Initial Commit

packages/api-stack/api/api-ws-broker-in-memory/tests/conformance/api-ws-broker.conformance.test.ts

@@ -0,0 +1,68 @@
+/**
+ * §16 conformance proof — the in-memory broker MUST satisfy every
+ * documented invariant of the `@suaveplan/api-ws` `WsBroker` contract.
+ *
+ * The api-ws package's `runWsEngineConformance` harness needs a full
+ * `(bus, registry, broker, makeConnection)` tuple — broker-only
+ * packages cannot drive it. Instead, this conformance suite mirrors
+ * the broker-shaped assertions from `api-ws/broker/broker.spec-conformance.test.ts`
+ * against the concrete `createInMemoryWsBroker` factory.
+ */
+import type { TenantId } from "@suaveplan/api-types/tenant";
+import type {
+    BrokerEnvelope,
+    BrokerHandler,
+    BrokerSubscription,
+    WsBroker,
+} from "@suaveplan/api-ws/broker";
+import { describe, expect, expectTypeOf, it } from "@suaveplan/testing/runner";
+import { createInMemoryWsBroker } from "../../src/broker/broker.js";
+
+describe("WsBroker conformance: in-memory-direct", () => {
+    it("type-shape matches WsBroker", { timeout: 5000 }, () => {
+        const broker = createInMemoryWsBroker<number>();
+        expectTypeOf(broker).toMatchTypeOf<WsBroker<number>>();
+        expectTypeOf(broker.publish).parameters.toEqualTypeOf<
+            [topic: string, envelope: BrokerEnvelope<number>]
+        >();
+        expectTypeOf(broker.subscribe).parameters.toEqualTypeOf<
+            [topic: string, handler: BrokerHandler<number>]
+        >();
+        broker.dispose();
+    });
+
+    it("subscribe returns a BrokerSubscription", { timeout: 5000 }, () => {
+        const broker = createInMemoryWsBroker();
+        const sub: BrokerSubscription = broker.subscribe("x", () => undefined);
+        expect(sub.topic).toBe("x");
+        expect(typeof sub.unsubscribe).toBe("function");
+        sub.unsubscribe();
+        broker.dispose();
+    });
+
+    it("publish + subscribe round-trip delivers an envelope", {
+        timeout: 5000,
+    }, async () => {
+        const broker = createInMemoryWsBroker<{ ok: true }>({
+            deliveryMode: "await-all",
+        });
+        let delivered: BrokerEnvelope<{ ok: true }> | null = null;
+        broker.subscribe("orders", (e) => {
+            delivered = e;
+        });
+        await broker.publish("orders", {
+            topic: "orders",
+            tenant: "t" as unknown as TenantId,
+            payload: { ok: true },
+        });
+        expect(delivered).not.toBeNull();
+        expect(delivered?.payload.ok).toBe(true);
+        broker.dispose();
+    });
+
+    it("dispose is mandatory and idempotent", { timeout: 5000 }, () => {
+        const broker = createInMemoryWsBroker();
+        broker.dispose();
+        broker.dispose();
+    });
+});