@gencow/core 0.1.23 → 0.1.25

package/src/__tests__/ws-integration.test.ts

@@ -18,12 +18,12 @@
 
 import { describe, it, expect, afterAll } from "bun:test";
 import {
-    buildRealtimeCtx,
-    handleWsMessage,
-    registerClient,
-    deregisterClient,
-    subscribe,
-} from "../reactive";
+  buildRealtimeCtx,
+  handleWsMessage,
+  registerClient,
+  deregisterClient,
+  subscribe,
+} from "../reactive.js";
 
 // ─── 최소 WebSocket 서버 (Bun native) ────────────────────────────────────────
 //
@@ -31,71 +31,80 @@ import {
 // 실제 subscribe / handleWsMessage / buildRealtimeCtx를 그대로 사용한다.
 
 function startServer(port: number) {
-    const server = Bun.serve({
-        port,
-        fetch(req: Request, server: any) {
-            if (req.headers.get("upgrade") === "websocket") {
-                const upgraded = server.upgrade(req);
-                if (!upgraded) return new Response("WS upgrade failed", { status: 500 });
-                return undefined;
-            }
-            return new Response("OK");
-        },
-        websocket: {
-            open(ws: any) {
-                registerClient(ws);
-            },
-            message(ws: any, data: string | Buffer) {
-                handleWsMessage(ws, typeof data === "string" ? data : data.toString());
-            },
-            close(ws: any) {
-                deregisterClient(ws);
-            },
-        },
-    });
-    return server;
+  const server = Bun.serve({
+    port,
+    fetch(req: Request, server: any) {
+      if (req.headers.get("upgrade") === "websocket") {
+        const upgraded = server.upgrade(req);
+        if (!upgraded) return new Response("WS upgrade failed", { status: 500 });
+        return undefined;
+      }
+      return new Response("OK");
+    },
+    websocket: {
+      open(ws: any) {
+        registerClient(ws);
+      },
+      message(ws: any, data: string | Buffer) {
+        handleWsMessage(ws, typeof data === "string" ? data : data.toString());
+      },
+      close(ws: any) {
+        deregisterClient(ws);
+      },
+    },
+  });
+  return server;
 }
 
 // ─── Helper: 클라이언트 연결 + 메시지 수집 ───────────────────────────────────
 
 function connectClient(port: number): Promise<{
-    ws: WebSocket;
-    messages: any[];
-    waitForMessage: (filter?: (msg: any) => boolean, timeoutMs?: number) => Promise<any>;
-    close: () => void;
+  ws: WebSocket;
+  messages: any[];
+  waitForMessage: (filter?: (msg: any) => boolean, timeoutMs?: number) => Promise<any>;
+  close: () => void;
 }> {
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(`ws://localhost:${port}`);
-        const messages: any[] = [];
-        const listeners: Array<{ filter: (msg: any) => boolean; resolve: (msg: any) => void; reject: (e: any) => void; timer: any }> = [];
-
-        ws.onmessage = (e: MessageEvent) => {
-            const msg = JSON.parse(e.data);
-            messages.push(msg);
-            for (const l of listeners) {
-                if (l.filter(msg)) {
-                    clearTimeout(l.timer);
-                    l.resolve(msg);
-                }
-            }
-        };
-
-        ws.onopen = () => resolve({
-            ws,
-            messages,
-            waitForMessage: (filter = () => true, timeoutMs = 2000) =>
-                new Promise((res, rej) => {
-                    // 이미 수신된 메시지 중 일치하는 것이 있으면 즉시 반환
-                    const found = messages.find(filter);
-                    if (found) return res(found);
-                    const timer = setTimeout(() => rej(new Error(`waitForMessage timeout (${timeoutMs}ms)`)), timeoutMs);
-                    listeners.push({ filter, resolve: res, reject: rej, timer });
-                }),
-            close: () => ws.close(),
-        });
-
-        ws.onerror = reject;
-    });
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    const messages: any[] = [];
+    const listeners: Array<{
+      filter: (msg: any) => boolean;
+      resolve: (msg: any) => void;
+      reject: (e: any) => void;
+      timer: any;
+    }> = [];
+
+    ws.onmessage = (e: MessageEvent) => {
+      const msg = JSON.parse(e.data);
+      messages.push(msg);
+      for (const l of listeners) {
+        if (l.filter(msg)) {
+          clearTimeout(l.timer);
+          l.resolve(msg);
+        }
+      }
+    };
+
+    ws.onopen = () =>
+      resolve({
+        ws,
+        messages,
+        waitForMessage: (filter = () => true, timeoutMs = 2000) =>
+          new Promise((res, rej) => {
+            // 이미 수신된 메시지 중 일치하는 것이 있으면 즉시 반환
+            const found = messages.find(filter);
+            if (found) return res(found);
+            const timer = setTimeout(
+              () => rej(new Error(`waitForMessage timeout (${timeoutMs}ms)`)),
+              timeoutMs,
+            );
+            listeners.push({ filter, resolve: res, reject: rej, timer });
+          }),
+        close: () => ws.close(),
+      });
+
+    ws.onerror = reject;
+  });
 }
 
 // ─── 서버 인스턴스 (테스트 파일 당 하나) ─────────────────────────────────────
@@ -104,201 +113,197 @@ const PORT = 57890; // 충돌 방지용 높은 포트
 const server = startServer(PORT);
 
 afterAll(() => {
-    // force=true: 열려 있는 WebSocket 연결을 즉시 닫고 서버를 종료한다.
-    server.stop(true);
+  // force=true: 열려 있는 WebSocket 연결을 즉시 닫고 서버를 종료한다.
+  server.stop(true);
 });
 
 // ─── 1. 단일 구독자 실시간 수신 ──────────────────────────────────────────────
 
 describe("[WS Integration] 단일 구독자 emit 수신", () => {
-    it("subscribe 후 emit하면 query:updated 메시지를 실시간으로 수신한다", async () => {
-        const client = await connectClient(PORT);
+  it("subscribe 후 emit하면 query:updated 메시지를 실시간으로 수신한다", async () => {
+    const client = await connectClient(PORT);
 
-        // subscribe 메시지 전송
-        client.ws.send(JSON.stringify({ type: "subscribe", query: "ws.tasks.list" }));
-        await client.waitForMessage(m => m.type === "subscribed");
+    // subscribe 메시지 전송
+    client.ws.send(JSON.stringify({ type: "subscribe", query: "ws.tasks.list" }));
+    await client.waitForMessage((m) => m.type === "subscribed");
 
-        // 서버 사이드에서 emit
-        const freshData = [{ id: 1, title: "Real WebSocket Task" }];
-        buildRealtimeCtx().emit("ws.tasks.list", freshData);
+    // 서버 사이드에서 emit
+    const freshData = [{ id: 1, title: "Real WebSocket Task" }];
+    buildRealtimeCtx().emit("ws.tasks.list", freshData);
 
-        // query:updated 수신 대기
-        const msg = await client.waitForMessage(m => m.type === "query:updated", 500);
+    // query:updated 수신 대기
+    const msg = await client.waitForMessage((m) => m.type === "query:updated", 500);
 
-        expect(msg.query).toBe("ws.tasks.list");
-        expect(msg.data).toEqual(freshData);
+    expect(msg.query).toBe("ws.tasks.list");
+    expect(msg.data).toEqual(freshData);
 
-        client.close();
-    });
+    client.close();
+  });
 
-    it("subscribe 전에는 query:updated를 수신하지 않는다", async () => {
-        const client = await connectClient(PORT);
+  it("subscribe 전에는 query:updated를 수신하지 않는다", async () => {
+    const client = await connectClient(PORT);
 
-        // subscribe 없이 emit
-        buildRealtimeCtx().emit("ws.unsubscribed", [{ id: 99 }]);
-        await new Promise(r => setTimeout(r, 200));
+    // subscribe 없이 emit
+    buildRealtimeCtx().emit("ws.unsubscribed", [{ id: 99 }]);
+    await new Promise((r) => setTimeout(r, 200));
 
-        const unrelated = client.messages.filter(m => m.query === "ws.unsubscribed");
-        expect(unrelated).toHaveLength(0);
+    const unrelated = client.messages.filter((m) => m.query === "ws.unsubscribed");
+    expect(unrelated).toHaveLength(0);
 
-        client.close();
-    });
+    client.close();
+  });
 });
 
 // ─── 2. 다수 구독자 동시 수신 ────────────────────────────────────────────────
 
 describe("[WS Integration] 다수 구독자 동시 수신", () => {
-    it("10명 구독자 모두 동일 query:updated를 수신한다", async () => {
-        const N = 10;
-        const queryKey = "ws.multi.tasks";
-        const clients = await Promise.all(
-            Array.from({ length: N }, () => connectClient(PORT))
-        );
-
-        // 모두 같은 query 구독
-        for (const c of clients) {
-            c.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
-        }
-        await Promise.all(clients.map(c => c.waitForMessage(m => m.type === "subscribed")));
-
-        // emit
-        const payload = [{ id: 1 }, { id: 2 }, { id: 3 }];
-        buildRealtimeCtx().emit(queryKey, payload);
-
-        // 모두 수신 대기
-        const results = await Promise.all(
-            clients.map(c => c.waitForMessage(m => m.type === "query:updated", 500))
-        );
-
-        expect(results).toHaveLength(N);
-        for (const msg of results) {
-            expect(msg.query).toBe(queryKey);
-            expect(msg.data).toEqual(payload);
-        }
-
-        clients.forEach(c => c.close());
+  it("10명 구독자 모두 동일 query:updated를 수신한다", async () => {
+    const N = 10;
+    const queryKey = "ws.multi.tasks";
+    const clients = await Promise.all(Array.from({ length: N }, () => connectClient(PORT)));
+
+    // 모두 같은 query 구독
+    for (const c of clients) {
+      c.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
+    }
+    await Promise.all(clients.map((c) => c.waitForMessage((m) => m.type === "subscribed")));
+
+    // emit
+    const payload = [{ id: 1 }, { id: 2 }, { id: 3 }];
+    buildRealtimeCtx().emit(queryKey, payload);
+
+    // 모두 수신 대기
+    const results = await Promise.all(
+      clients.map((c) => c.waitForMessage((m) => m.type === "query:updated", 500)),
+    );
+
+    expect(results).toHaveLength(N);
+    for (const msg of results) {
+      expect(msg.query).toBe(queryKey);
+      expect(msg.data).toEqual(payload);
+    }
+
+    clients.forEach((c) => c.close());
+  });
+
+  it("50명 구독자 부하 테스트 — 모두 수신, P99 latency 측정", async () => {
+    const N = 50;
+    const queryKey = "ws.load.tasks";
+
+    const clients = await Promise.all(Array.from({ length: N }, () => connectClient(PORT)));
+    for (const c of clients) {
+      c.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
+    }
+    await Promise.all(clients.map((c) => c.waitForMessage((m) => m.type === "subscribed")));
+
+    const emitTime = performance.now();
+    buildRealtimeCtx().emit(queryKey, [{ id: 1, title: "load test" }]);
+
+    const receivePromises = clients.map(async (c) => {
+      const msg = await c.waitForMessage((m) => m.type === "query:updated", 1000);
+      return performance.now() - emitTime;
     });
 
-    it("50명 구독자 부하 테스트 — 모두 수신, P99 latency 측정", async () => {
-        const N = 50;
-        const queryKey = "ws.load.tasks";
-
-        const clients = await Promise.all(
-            Array.from({ length: N }, () => connectClient(PORT))
-        );
-        for (const c of clients) {
-            c.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
-        }
-        await Promise.all(clients.map(c => c.waitForMessage(m => m.type === "subscribed")));
-
-        const emitTime = performance.now();
-        buildRealtimeCtx().emit(queryKey, [{ id: 1, title: "load test" }]);
-
-        const receivePromises = clients.map(async c => {
-            const msg = await c.waitForMessage(m => m.type === "query:updated", 1000);
-            return performance.now() - emitTime;
-        });
-
-        const latencies = await Promise.all(receivePromises);
-        latencies.sort((a, b) => a - b);
+    const latencies = await Promise.all(receivePromises);
+    latencies.sort((a, b) => a - b);
 
-        const p50 = latencies[Math.floor(N * 0.5)];
-        const p99 = latencies[Math.floor(N * 0.99)];
+    const p50 = latencies[Math.floor(N * 0.5)];
+    const p99 = latencies[Math.floor(N * 0.99)];
 
-        console.log(`[WS/50 clients] P50=${p50.toFixed(1)}ms P99=${p99.toFixed(1)}ms (debounce=50ms incl.)`);
+    console.log(`[WS/50 clients] P50=${p50.toFixed(1)}ms P99=${p99.toFixed(1)}ms (debounce=50ms incl.)`);
 
-        expect(latencies).toHaveLength(N); // 50/50 수신
-        expect(p99).toBeLessThan(500);     // 디바운스 포함 P99 < 500ms
+    expect(latencies).toHaveLength(N); // 50/50 수신
+    expect(p99).toBeLessThan(500); // 디바운스 포함 P99 < 500ms
 
-        clients.forEach(c => c.close());
-    });
+    clients.forEach((c) => c.close());
+  });
 });
 
 // ─── 3. 실제 debounce 동작 검증 ──────────────────────────────────────────────
 
 describe("[WS Integration] debounce 동작 (실제 타이머)", () => {
-    it("40ms 내 5번 rapid emit → 단 1회 query:updated 수신", async () => {
-        const client = await connectClient(PORT);
-        client.ws.send(JSON.stringify({ type: "subscribe", query: "ws.debounce" }));
-        await client.waitForMessage(m => m.type === "subscribed");
-
-        const rt = buildRealtimeCtx();
-        for (let i = 0; i < 5; i++) {
-            rt.emit("ws.debounce", [{ id: i }]);
-            await new Promise(r => setTimeout(r, 8)); // 8ms 간격 → 40ms < 50ms
-        }
+  it("40ms 내 5번 rapid emit → 단 1회 query:updated 수신", async () => {
+    const client = await connectClient(PORT);
+    client.ws.send(JSON.stringify({ type: "subscribe", query: "ws.debounce" }));
+    await client.waitForMessage((m) => m.type === "subscribed");
 
-        // debounce(50ms) + 마진
-        await new Promise(r => setTimeout(r, 150));
+    const rt = buildRealtimeCtx();
+    for (let i = 0; i < 5; i++) {
+      rt.emit("ws.debounce", [{ id: i }]);
+      await new Promise((r) => setTimeout(r, 8)); // 8ms 간격 → 40ms < 50ms
+    }
 
-        const updates = client.messages.filter(m => m.type === "query:updated" && m.query === "ws.debounce");
-        console.log(`[WS/debounce] 5 emits → ${updates.length} messages received`);
+    // debounce(50ms) + 마진
+    await new Promise((r) => setTimeout(r, 150));
 
-        expect(updates).toHaveLength(1);                        // 1번만 전달
-        expect(updates[0].data).toEqual([{ id: 4 }]);          // 마지막 데이터
+    const updates = client.messages.filter((m) => m.type === "query:updated" && m.query === "ws.debounce");
+    console.log(`[WS/debounce] 5 emits → ${updates.length} messages received`);
 
-        client.close();
-    });
+    expect(updates).toHaveLength(1); // 1번만 전달
+    expect(updates[0].data).toEqual([{ id: 4 }]); // 마지막 데이터
+
+    client.close();
+  });
 });
 
 // ─── 4. 클라이언트 연결 해제 후 자동 정리 ────────────────────────────────────
 
 describe("[WS Integration] disconnect 후 정리", () => {
-    it("disconnected 클라이언트는 다음 emit에서 에러 없이 제거된다", async () => {
-        const stableClient = await connectClient(PORT);
-        const disconnectClient = await connectClient(PORT);
-
-        const queryKey = "ws.cleanup.test";
-        stableClient.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
-        disconnectClient.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
-
-        await Promise.all([
-            stableClient.waitForMessage(m => m.type === "subscribed"),
-            disconnectClient.waitForMessage(m => m.type === "subscribed"),
-        ]);
-
-        // 한 클라이언트 강제 종료
-        disconnectClient.close();
-        await new Promise(r => setTimeout(r, 100)); // 서버가 close 처리할 시간
-
-        // emit 후 stable client는 정상 수신
-        buildRealtimeCtx().emit(queryKey, [{ id: 1 }]);
-        const msg = await stableClient.waitForMessage(m => m.type === "query:updated", 500);
-
-        expect(msg.query).toBe(queryKey);
-        stableClient.close();
-    });
+  it("disconnected 클라이언트는 다음 emit에서 에러 없이 제거된다", async () => {
+    const stableClient = await connectClient(PORT);
+    const disconnectClient = await connectClient(PORT);
+
+    const queryKey = "ws.cleanup.test";
+    stableClient.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
+    disconnectClient.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
+
+    await Promise.all([
+      stableClient.waitForMessage((m) => m.type === "subscribed"),
+      disconnectClient.waitForMessage((m) => m.type === "subscribed"),
+    ]);
+
+    // 한 클라이언트 강제 종료
+    disconnectClient.close();
+    await new Promise((r) => setTimeout(r, 100)); // 서버가 close 처리할 시간
+
+    // emit 후 stable client는 정상 수신
+    buildRealtimeCtx().emit(queryKey, [{ id: 1 }]);
+    const msg = await stableClient.waitForMessage((m) => m.type === "query:updated", 500);
+
+    expect(msg.query).toBe(queryKey);
+    stableClient.close();
+  });
 });
 
 // ─── 5. 부하: 다수 mutation 연속 실행 ────────────────────────────────────────
 
 describe("[WS Integration] 연속 mutations 부하", () => {
-    it("20 mutations × 각각 query:updated → 구독자가 모두 수신한다", async () => {
-        const N_MUTATIONS = 20;
-        const queryKey = "ws.mutations.load";
-        const client = await connectClient(PORT);
-
-        client.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
-        await client.waitForMessage(m => m.type === "subscribed");
-
-        // 20번 mutation 실행 (각자 별도 buildRealtimeCtx — 서로 독립적 debounce)
-        const promises: Promise<any>[] = [];
-        for (let i = 0; i < N_MUTATIONS; i++) {
-            const rt = buildRealtimeCtx();
-            rt.emit(queryKey, [{ id: i, title: `Mutation ${i}` }]);
-            // 각 emit을 60ms 간격으로 — 각자 debounce가 완료된 후 다음 emit
-            if (i < N_MUTATIONS - 1) await new Promise(r => setTimeout(r, 60));
-        }
-
-        // 마지막 debounce 완료 대기
-        await new Promise(r => setTimeout(r, 200));
-
-        const updates = client.messages.filter(m => m.type === "query:updated" && m.query === queryKey);
-        console.log(`[WS/mutations] ${N_MUTATIONS} mutations → ${updates.length} updates received`);
-
-        // 각 mutation이 별도 buildRealtimeCtx → 각자 debounce → N번 전달
-        expect(updates.length).toBe(N_MUTATIONS);
-
-        client.close();
-    }, 30000); // 20 × 60ms = 1200ms + margin
+  it("20 mutations × 각각 query:updated → 구독자가 모두 수신한다", async () => {
+    const N_MUTATIONS = 20;
+    const queryKey = "ws.mutations.load";
+    const client = await connectClient(PORT);
+
+    client.ws.send(JSON.stringify({ type: "subscribe", query: queryKey }));
+    await client.waitForMessage((m) => m.type === "subscribed");
+
+    // 20번 mutation 실행 (각자 별도 buildRealtimeCtx — 서로 독립적 debounce)
+    const promises: Promise<any>[] = [];
+    for (let i = 0; i < N_MUTATIONS; i++) {
+      const rt = buildRealtimeCtx();
+      rt.emit(queryKey, [{ id: i, title: `Mutation ${i}` }]);
+      // 각 emit을 60ms 간격으로 — 각자 debounce가 완료된 후 다음 emit
+      if (i < N_MUTATIONS - 1) await new Promise((r) => setTimeout(r, 60));
+    }
+
+    // 마지막 debounce 완료 대기
+    await new Promise((r) => setTimeout(r, 200));
+
+    const updates = client.messages.filter((m) => m.type === "query:updated" && m.query === queryKey);
+    console.log(`[WS/mutations] ${N_MUTATIONS} mutations → ${updates.length} updates received`);
+
+    // 각 mutation이 별도 buildRealtimeCtx → 각자 debounce → N번 전달
+    expect(updates.length).toBe(N_MUTATIONS);
+
+    client.close();
+  }, 30000); // 20 × 60ms = 1200ms + margin
 });