@kuralle-syrinx/server-websocket 4.4.1 → 4.5.0

package/src/websocket-close.test.ts

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, it } from "vitest";
+import { WebSocket } from "ws";
+import { sendJsonCapped } from "./websocket-close.js";
+
+interface FakeSocket {
+  readyState: number;
+  bufferedAmount: number;
+  sent: string[];
+  closed: { code: number; reason: string } | null;
+}
+
+function makeSocket(overrides: Partial<FakeSocket> = {}): WebSocket {
+  const socket: FakeSocket & { send(d: string): void; close(c: number, r: string): void; once(): void } = {
+    readyState: WebSocket.OPEN,
+    bufferedAmount: 0,
+    sent: [],
+    closed: null,
+    ...overrides,
+    send(data: string) { this.sent.push(data); },
+    close(code: number, reason: string) { this.closed = { code, reason }; this.readyState = WebSocket.CLOSING; },
+    once() { /* close-cleanup listener — unused in these paths */ },
+  };
+  return socket as unknown as WebSocket;
+}
+
+describe("sendJsonCapped", () => {
+  it("serializes and sends when OPEN and under the buffer cap", () => {
+    const socket = makeSocket();
+    const ok = sendJsonCapped(socket, { event: "media", n: 1 }, 1_000);
+    expect(ok).toBe(true);
+    expect((socket as unknown as FakeSocket).sent).toEqual([JSON.stringify({ event: "media", n: 1 })]);
+  });
+
+  it("sends nothing and returns false when the socket is not OPEN", () => {
+    const socket = makeSocket({ readyState: WebSocket.CONNECTING });
+    const ok = sendJsonCapped(socket, { event: "media" }, 1_000);
+    expect(ok).toBe(false);
+    expect((socket as unknown as FakeSocket).sent).toHaveLength(0);
+  });
+
+  it("closes 1013 and drops the message when the send would exceed the buffer cap", () => {
+    const payload = { event: "media", blob: "x".repeat(100) };
+    const cap = 50; // far below the serialized size
+    const socket = makeSocket({ bufferedAmount: 0 });
+    const ok = sendJsonCapped(socket, payload, cap);
+    expect(ok).toBe(false);
+    const fake = socket as unknown as FakeSocket;
+    expect(fake.sent).toHaveLength(0);
+    expect(fake.closed?.code).toBe(1013);
+  });
+
+  it("accounts for already-buffered bytes against the cap", () => {
+    const data = JSON.stringify({ event: "media" });
+    const cap = Buffer.byteLength(data, "utf8") + 5;
+    // Already near the cap: adding this message tips it over.
+    const socket = makeSocket({ bufferedAmount: 10 });
+    const ok = sendJsonCapped(socket, { event: "media" }, cap);
+    expect(ok).toBe(false);
+    expect((socket as unknown as FakeSocket).closed?.code).toBe(1013);
+  });
+});

package/src/websocket-lifecycle.test.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { installGracefulShutdown, type GracefulClosable } from "./websocket-lifecycle.js";
+
+describe("installGracefulShutdown", () => {
+  afterEach(() => {
+    process.removeAllListeners("SIGTERM");
+    process.removeAllListeners("SIGINT");
+  });
+
+  it("drains the server gracefully on a termination signal", async () => {
+    const closeCalls: Array<{ graceful?: boolean; drainDeadlineMs?: number }> = [];
+    const server: GracefulClosable = {
+      close: async (opts) => {
+        closeCalls.push(opts ?? {});
+      },
+    };
+    const onClosed = vi.fn();
+    installGracefulShutdown(server, { drainDeadlineMs: 7000, onClosed });
+
+    process.emit("SIGTERM");
+    await vi.waitFor(() => expect(onClosed).toHaveBeenCalledTimes(1));
+
+    expect(closeCalls).toEqual([{ graceful: true, drainDeadlineMs: 7000 }]);
+  });
+
+  it("is idempotent — a second signal during shutdown does not double-close", async () => {
+    let closeCount = 0;
+    const server: GracefulClosable = { close: async () => { closeCount += 1; } };
+    installGracefulShutdown(server, { signals: ["SIGTERM"] });
+
+    process.emit("SIGTERM");
+    process.emit("SIGTERM");
+    await vi.waitFor(() => expect(closeCount).toBe(1));
+    expect(closeCount).toBe(1);
+  });
+
+  it("the disposer removes the signal handler", async () => {
+    let closeCount = 0;
+    const server: GracefulClosable = { close: async () => { closeCount += 1; } };
+    const dispose = installGracefulShutdown(server, { signals: ["SIGINT"] });
+    dispose();
+
+    process.emit("SIGINT");
+    await new Promise((r) => setTimeout(r, 10));
+    expect(closeCount).toBe(0);
+  });
+});