121 lines
4.3 KiB
TypeScript
121 lines
4.3 KiB
TypeScript
/**
|
|
* 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);
|
|
});
|
|
});
|