test: add WebSocket server tests — connect, broadcast, events, cleanup (7 tests)

Cover WS connection, path rejection, event broadcast (note, task,
skill, relation events), and listener cleanup verification.
Coverage: 32% → 57% lines.

Author: prih

src/tests/websocket.test.ts

@@ -0,0 +1,144 @@
+import http from 'http';
+import { WebSocket } from 'ws';
+import { EventEmitter } from 'events';
+import { attachWebSocket, type WebSocketHandle } from '@/api/rest/websocket';
+import type { ProjectManager } from '@/lib/project-manager';
+
+function createMockProjectManager(): ProjectManager & EventEmitter {
+  const em = new EventEmitter();
+  // Minimal mock — only event emitter behavior needed
+  (em as any).getProject = (id: string) => {
+    if (id === 'test') return {
+      config: {
+        graphConfigs: {
+          docs: { enabled: true }, code: { enabled: true },
+          knowledge: { enabled: true }, files: { enabled: true },
+          tasks: { enabled: true }, skills: { enabled: true },
+        },
+      },
+      workspaceId: undefined,
+    };
+    return undefined;
+  };
+  (em as any).getWorkspace = () => undefined;
+  return em as any;
+}
+
+function waitForOpen(ws: WebSocket): Promise<void> {
+  return new Promise((resolve, reject) => {
+    ws.on('open', resolve);
+    ws.on('error', reject);
+    setTimeout(() => reject(new Error('WS open timeout')), 3000);
+  });
+}
+
+function waitForMessage(ws: WebSocket): Promise<any> {
+  return new Promise((resolve, reject) => {
+    ws.on('message', (data) => resolve(JSON.parse(data.toString())));
+    setTimeout(() => reject(new Error('WS message timeout')), 3000);
+  });
+}
+
+describe('WebSocket server', () => {
+  let server: http.Server;
+  let wsHandle: WebSocketHandle;
+  let pm: ProjectManager & EventEmitter;
+  let port: number;
+
+  beforeAll(async () => {
+    pm = createMockProjectManager();
+    server = http.createServer();
+    wsHandle = attachWebSocket(server, pm);
+
+    await new Promise<void>((resolve) => {
+      server.listen(0, '127.0.0.1', () => {
+        port = (server.address() as any).port;
+        resolve();
+      });
+    });
+  });
+
+  afterAll(async () => {
+    // Close all connected clients and WSS
+    for (const client of wsHandle.wss.clients) {
+      client.terminate();
+    }
+    wsHandle.cleanup();
+    await new Promise<void>((resolve) => wsHandle.wss.close(() => resolve()));
+    server.closeAllConnections();
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  });
+
+  it('connects to /api/ws without auth', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/api/ws`);
+    await waitForOpen(ws);
+    expect(ws.readyState).toBe(WebSocket.OPEN);
+    ws.close();
+  });
+
+  it('rejects non /api/ws paths', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/other`);
+    await expect(waitForOpen(ws)).rejects.toThrow();
+  });
+
+  it('broadcasts note:created event', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/api/ws`);
+    await waitForOpen(ws);
+
+    const msgPromise = waitForMessage(ws);
+    pm.emit('note:created', { projectId: 'test', noteId: 'n1' });
+    const msg = await msgPromise;
+
+    expect(msg.type).toBe('note:created');
+    expect(msg.projectId).toBe('test');
+    expect(msg.data.noteId).toBe('n1');
+    ws.close();
+  });
+
+  it('broadcasts task:moved event', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/api/ws`);
+    await waitForOpen(ws);
+
+    const msgPromise = waitForMessage(ws);
+    pm.emit('task:moved', { projectId: 'test', taskId: 't1', status: 'done' });
+    const msg = await msgPromise;
+
+    expect(msg.type).toBe('task:moved');
+    expect(msg.data.taskId).toBe('t1');
+    ws.close();
+  });
+
+  it('broadcasts relation events', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/api/ws`);
+    await waitForOpen(ws);
+
+    const msgPromise = waitForMessage(ws);
+    pm.emit('note:relation:added', { projectId: 'test', noteId: 'n1', toId: 'n2', kind: 'refs' });
+    const msg = await msgPromise;
+
+    expect(msg.type).toBe('note:relation:added');
+    ws.close();
+  });
+
+  it('broadcasts skill events', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/api/ws`);
+    await waitForOpen(ws);
+
+    const msgPromise = waitForMessage(ws);
+    pm.emit('skill:created', { projectId: 'test', skillId: 's1' });
+    const msg = await msgPromise;
+
+    expect(msg.type).toBe('skill:created');
+    ws.close();
+  });
+
+  it('cleanup removes listeners', () => {
+    const pm2 = createMockProjectManager();
+    const server2 = http.createServer();
+    const handle = attachWebSocket(server2, pm2);
+    expect(pm2.listenerCount('note:created')).toBeGreaterThan(0);
+    handle.cleanup();
+    expect(pm2.listenerCount('note:created')).toBe(0);
+    server2.close();
+  });
+});