@shaykec/bridge 0.1.0

package/src/router.test.js

@@ -0,0 +1,329 @@
+/**
+ * Tests for ClaudeTeach bridge EventRouter.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { EventRouter } from './router.js';
+import {
+  createEnvelope,
+  MSG_SYS_HEARTBEAT,
+  MSG_SYS_CONNECT,
+  MSG_SYS_DISCONNECT,
+  MSG_EVENT_QUIZ_ANSWER,
+  MSG_EVENT_CLICK,
+  MSG_CAPTURE_TEXT,
+  MSG_CONTEXT_TOPIC,
+  MSG_CANVAS_DIAGRAM,
+} from '@shaykec/shared';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createMockTierManager() {
+  return {
+    broadcastWs: vi.fn(),
+    broadcastSse: vi.fn(),
+  };
+}
+
+/** Build a valid envelope string */
+function makeEnvelope(type, payload = {}, source = 'canvas') {
+  return JSON.stringify(createEnvelope(type, payload, source));
+}
+
+/** Build a valid envelope object */
+function makeEnvelopeObj(type, payload = {}, source = 'canvas') {
+  return createEnvelope(type, payload, source);
+}
+
+// ---------------------------------------------------------------------------
+// routeVisualCommand
+// ---------------------------------------------------------------------------
+
+describe('EventRouter — routeVisualCommand', () => {
+  let tm;
+  let router;
+
+  beforeEach(() => {
+    tm = createMockTierManager();
+    router = new EventRouter(tm);
+  });
+
+  it('broadcasts to WS and SSE clients', () => {
+    const envelope = makeEnvelopeObj(MSG_CANVAS_DIAGRAM, { format: 'mermaid' }, 'plugin');
+    router.routeVisualCommand(envelope);
+
+    expect(tm.broadcastWs).toHaveBeenCalledTimes(1);
+    expect(tm.broadcastSse).toHaveBeenCalledTimes(1);
+
+    const sentData = tm.broadcastWs.mock.calls[0][0];
+    expect(JSON.parse(sentData)).toMatchObject({ type: MSG_CANVAS_DIAGRAM });
+  });
+
+  it('serialises the envelope to JSON for both channels', () => {
+    const envelope = makeEnvelopeObj(MSG_CANVAS_DIAGRAM, { x: 1 });
+    router.routeVisualCommand(envelope);
+
+    const wsData = tm.broadcastWs.mock.calls[0][0];
+    const sseData = tm.broadcastSse.mock.calls[0][0];
+    expect(wsData).toBe(sseData); // same serialised string
+    expect(typeof wsData).toBe('string');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// handleWsMessage
+// ---------------------------------------------------------------------------
+
+describe('EventRouter — handleWsMessage', () => {
+  let tm;
+  let router;
+
+  beforeEach(() => {
+    tm = createMockTierManager();
+    router = new EventRouter(tm);
+  });
+
+  // --- User events get enqueued ---
+
+  it('enqueues a valid user event (event:*)', () => {
+    const raw = makeEnvelope(MSG_EVENT_QUIZ_ANSWER, { answer: 42 });
+    const result = router.handleWsMessage(raw, 'c1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(router.getQueueSize()).toBe(1);
+    expect(router.peekEvents()[0].type).toBe(MSG_EVENT_QUIZ_ANSWER);
+  });
+
+  it('enqueues capture events (capture:*)', () => {
+    const raw = makeEnvelope(MSG_CAPTURE_TEXT, { text: 'hello' });
+    const result = router.handleWsMessage(raw, 'c1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(router.getQueueSize()).toBe(1);
+  });
+
+  it('enqueues context events (context:*)', () => {
+    const raw = makeEnvelope(MSG_CONTEXT_TOPIC, { topic: 'math' });
+    const result = router.handleWsMessage(raw, 'c1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(router.getQueueSize()).toBe(1);
+  });
+
+  // --- System messages are not enqueued ---
+
+  it('does not enqueue heartbeat messages', () => {
+    const raw = makeEnvelope(MSG_SYS_HEARTBEAT);
+    const result = router.handleWsMessage(raw, 'c1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(router.getQueueSize()).toBe(0);
+  });
+
+  it('does not enqueue sys:connect messages', () => {
+    const raw = makeEnvelope(MSG_SYS_CONNECT, { clientType: 'canvas', protocolVersion: 1 });
+    const result = router.handleWsMessage(raw, 'c1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(router.getQueueSize()).toBe(0);
+  });
+
+  it('does not enqueue sys:disconnect messages', () => {
+    const raw = makeEnvelope(MSG_SYS_DISCONNECT);
+    const result = router.handleWsMessage(raw, 'c1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(router.getQueueSize()).toBe(0);
+  });
+
+  // --- Invalid JSON ---
+
+  it('rejects invalid JSON', () => {
+    const result = router.handleWsMessage('not json at all', 'c1');
+
+    expect(result.handled).toBe(false);
+    expect(result.error).toBeDefined();
+    expect(router.getQueueSize()).toBe(0);
+  });
+
+  it('rejects an envelope missing required fields', () => {
+    const result = router.handleWsMessage(JSON.stringify({ foo: 'bar' }), 'c1');
+
+    expect(result.handled).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  // --- Canvas commands fan out ---
+
+  it('broadcasts canvas commands to connected clients', () => {
+    const raw = makeEnvelope(MSG_CANVAS_DIAGRAM, { format: 'mermaid' }, 'extension');
+    const result = router.handleWsMessage(raw, 'e1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(tm.broadcastWs).toHaveBeenCalledTimes(1);
+    expect(tm.broadcastSse).toHaveBeenCalledTimes(1);
+    // Canvas commands are not enqueued
+    expect(router.getQueueSize()).toBe(0);
+  });
+
+  // --- Unknown types ---
+
+  it('handles unknown types silently (accepted, not routed)', () => {
+    const raw = JSON.stringify({ v: 1, type: 'custom:unknown', payload: {}, source: 'x' });
+    const result = router.handleWsMessage(raw, 'c1');
+
+    expect(result).toEqual({ handled: true, error: null });
+    expect(router.getQueueSize()).toBe(0);
+    expect(tm.broadcastWs).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// handleRestEvent
+// ---------------------------------------------------------------------------
+
+describe('EventRouter — handleRestEvent', () => {
+  let tm;
+  let router;
+
+  beforeEach(() => {
+    tm = createMockTierManager();
+    router = new EventRouter(tm);
+  });
+
+  it('accepts and enqueues a valid envelope object', () => {
+    const body = makeEnvelopeObj(MSG_EVENT_CLICK, { x: 10, y: 20 });
+    const result = router.handleRestEvent(body);
+
+    expect(result).toEqual({ ok: true, error: null });
+    expect(router.getQueueSize()).toBe(1);
+  });
+
+  it('rejects invalid body (missing required fields)', () => {
+    const result = router.handleRestEvent({ random: 'stuff' });
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBeDefined();
+    expect(router.getQueueSize()).toBe(0);
+  });
+
+  it('rejects null body', () => {
+    const result = router.handleRestEvent(null);
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('accepts a JSON string body', () => {
+    const body = makeEnvelope(MSG_EVENT_CLICK, { x: 5 });
+    const result = router.handleRestEvent(body);
+
+    expect(result).toEqual({ ok: true, error: null });
+    expect(router.getQueueSize()).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// pollEvents / peekEvents / getQueueSize
+// ---------------------------------------------------------------------------
+
+describe('EventRouter — queue operations', () => {
+  let tm;
+  let router;
+
+  beforeEach(() => {
+    tm = createMockTierManager();
+    router = new EventRouter(tm);
+  });
+
+  it('pollEvents returns events and clears the queue', () => {
+    router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { a: 1 }));
+    router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { a: 2 }));
+
+    expect(router.getQueueSize()).toBe(2);
+
+    const events = router.pollEvents();
+    expect(events).toHaveLength(2);
+    expect(events[0].type).toBe(MSG_EVENT_CLICK);
+    expect(router.getQueueSize()).toBe(0);
+  });
+
+  it('peekEvents returns events without clearing the queue', () => {
+    router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { a: 1 }));
+
+    const peeked = router.peekEvents();
+    expect(peeked).toHaveLength(1);
+    expect(router.getQueueSize()).toBe(1); // still there
+  });
+
+  it('peekEvents returns a copy (modifying it does not affect internal queue)', () => {
+    router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { a: 1 }));
+
+    const peeked = router.peekEvents();
+    peeked.push({ fake: true });
+
+    expect(router.getQueueSize()).toBe(1); // unaffected
+  });
+
+  it('pollEvents returns a copy (modifying it does not affect future polls)', () => {
+    router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { a: 1 }));
+
+    const polled = router.pollEvents();
+    polled.push({ fake: true });
+
+    // Next poll should be empty (not affected by the push above)
+    expect(router.pollEvents()).toHaveLength(0);
+  });
+
+  it('getQueueSize returns 0 when empty', () => {
+    expect(router.getQueueSize()).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Queue overflow
+// ---------------------------------------------------------------------------
+
+describe('EventRouter — queue overflow', () => {
+  let tm;
+  let router;
+
+  beforeEach(() => {
+    tm = createMockTierManager();
+    router = new EventRouter(tm);
+  });
+
+  it('drops oldest 10% when queue reaches max capacity (1000)', () => {
+    // Fill to exactly maxQueueSize
+    for (let i = 0; i < 1000; i++) {
+      router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { i }));
+    }
+    expect(router.getQueueSize()).toBe(1000);
+
+    // Adding one more triggers the trim
+    router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { i: 1000 }));
+
+    // 1000 - 100 (drop 10%) + 1 (newly added) = 901
+    expect(router.getQueueSize()).toBe(901);
+
+    // The oldest events (indices 0..99) should be gone
+    const events = router.peekEvents();
+    // The first event in the queue should have i === 100 (after dropping 0-99)
+    expect(events[0].payload.i).toBe(100);
+    // The last event should be the newly added one
+    expect(events[events.length - 1].payload.i).toBe(1000);
+  });
+
+  it('handles multiple overflows correctly', () => {
+    // Fill past capacity twice
+    for (let i = 0; i < 1100; i++) {
+      router.handleRestEvent(makeEnvelopeObj(MSG_EVENT_CLICK, { i }));
+    }
+
+    // Should have trimmed and still be under control
+    expect(router.getQueueSize()).toBeLessThanOrEqual(1000);
+    expect(router.getQueueSize()).toBeGreaterThan(0);
+  });
+});