Initial Commit

packages/networking/events/events-transport/tests/dep-graph.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Dependency graph smoke test — verifies the package entry point exports
+ * all expected symbols and that no unexpected runtime imports are present.
+ */
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import * as Transport from "../src/index.js";
+
+describe("@suaveplan/events-transport — public API surface", () => {
+    it("exports createMessageChannelTransport", { timeout: 5000 }, () => {
+        expect(typeof Transport.createMessageChannelTransport).toBe("function");
+    });
+
+    it("exports createBroadcastChannelTransport", { timeout: 5000 }, () => {
+        expect(typeof Transport.createBroadcastChannelTransport).toBe(
+            "function"
+        );
+    });
+
+    it("exports buildEnvelope and parseEnvelope", { timeout: 5000 }, () => {
+        expect(typeof Transport.buildEnvelope).toBe("function");
+        expect(typeof Transport.parseEnvelope).toBe("function");
+    });
+
+    it("exports NonceWindow", { timeout: 5000 }, () => {
+        expect(typeof Transport.NonceWindow).toBe("function");
+    });
+
+    it("exports isStructuredCloneable and assertStructuredCloneable", {
+        timeout: 5000,
+    }, () => {
+        expect(typeof Transport.isStructuredCloneable).toBe("function");
+        expect(typeof Transport.assertStructuredCloneable).toBe("function");
+    });
+
+    it("exports EventsTransportError", { timeout: 5000 }, () => {
+        expect(typeof Transport.EventsTransportError).toBe("function");
+    });
+
+    it("exports EVENTS_TRANSPORT_CODES", { timeout: 5000 }, () => {
+        expect(typeof Transport.EVENTS_TRANSPORT_CODES).toBe("object");
+    });
+
+    it("registerEventsTransportErrorCodes is a no-op function", {
+        timeout: 5000,
+    }, () => {
+        expect(() =>
+            Transport.registerEventsTransportErrorCodes()
+        ).not.toThrow();
+    });
+
+    it("exports constants", { timeout: 5000 }, () => {
+        expect(typeof Transport.DEFAULT_ACK_TIMEOUT_MS).toBe("number");
+        expect(typeof Transport.DEFAULT_MAX_RETRIES).toBe("number");
+        expect(typeof Transport.DEFAULT_NONCE_WINDOW_SIZE).toBe("number");
+        expect(typeof Transport.ENVELOPE_VERSION).toBe("number");
+    });
+
+    it("createMessageChannelTransport returns correct transport shape", {
+        timeout: 5000,
+    }, () => {
+        const channel = new MessageChannel();
+        const transport = Transport.createMessageChannelTransport({ channel });
+        expect(transport.name).toBe("message-channel");
+        expect(transport.deliveryGuarantee).toBe("at-least-once");
+        expect(typeof transport.connect).toBe("function");
+        channel.port1.close();
+        channel.port2.close();
+    });
+
+    it("createBroadcastChannelTransport with mock channel shape", {
+        timeout: 5000,
+    }, () => {
+        // Minimal mock since BroadcastChannel is not available in Node test env
+        const mockChannel = {
+            name: "test",
+            addEventListener: () => {},
+            removeEventListener: () => {},
+            postMessage: () => {},
+            close: () => {},
+        } as unknown as BroadcastChannel;
+
+        const transport = Transport.createBroadcastChannelTransport({
+            channel: mockChannel,
+        });
+        expect(transport.name).toBe("broadcast-channel");
+        expect(transport.deliveryGuarantee).toBe("at-most-once");
+    });
+
+    it("NonceWindow tracks and deduplicates nonces", { timeout: 5000 }, () => {
+        const nw = new Transport.NonceWindow(10);
+        expect(nw.check("a")).toBe(false); // new
+        expect(nw.check("a")).toBe(true); // duplicate
+        expect(nw.check("b")).toBe(false); // new
+    });
+
+    it("buildEnvelope and parseEnvelope round-trips correctly", {
+        timeout: 5000,
+    }, () => {
+        const env = Transport.buildEnvelope(
+            "test.event",
+            { id: "1" },
+            {
+                nonce: "n1",
+                origin: "local",
+                ts: 1000,
+            }
+        );
+        const parsed = Transport.parseEnvelope(env);
+        expect(parsed.event).toBe("test.event");
+        expect(parsed.payload).toEqual({ id: "1" });
+        expect(parsed.nonce).toBe("n1");
+    });
+
+    it("isStructuredCloneable returns correct results", {
+        timeout: 5000,
+    }, () => {
+        expect(Transport.isStructuredCloneable({ a: 1 })).toBe(true);
+        expect(Transport.isStructuredCloneable(() => {})).toBe(false);
+    });
+});