beads-ui 0.1.0

package/server/watcher.test.js

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { watchDb } from './watcher.js';
+
+/** @type {{ dir: string, cb: (event: string, filename?: string) => void, w: { close: () => void } }[]} */
+const watchers = [];
+
+vi.mock('node:fs', () => {
+  const watch = vi.fn((dir, _opts, cb) => {
+    // Minimal event emitter interface for FSWatcher
+    const handlers = /** @type {{ close: Array<() => void> }} */ ({
+      close: []
+    });
+    const w = {
+      close: () => handlers.close.forEach((fn) => fn())
+    };
+    watchers.push({ dir, cb, w });
+    return /** @type {any} */ (w);
+  });
+  return { default: { watch }, watch };
+});
+
+beforeEach(() => {
+  watchers.length = 0;
+  vi.useFakeTimers();
+  vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+
+describe('watchDb', () => {
+  test('debounces rapid change events', () => {
+    const calls = [];
+    const handle = watchDb('/repo', (p) => calls.push(p), {
+      debounce_ms: 100,
+      explicit_db: '/repo/.beads/ui.db'
+    });
+    expect(watchers.length).toBe(1);
+    const { cb } = watchers[0];
+
+    // Fire multiple changes in quick succession
+    cb('change', 'ui.db');
+    cb('change', 'ui.db');
+    cb('rename', 'ui.db');
+
+    // Nothing yet until debounce passes
+    expect(calls.length).toBe(0);
+    vi.advanceTimersByTime(99);
+    expect(calls.length).toBe(0);
+    vi.advanceTimersByTime(1);
+    expect(calls.length).toBe(1);
+
+    // Cleanup
+    handle.close();
+  });
+
+  test('ignores other filenames', () => {
+    const calls = [];
+    const handle = watchDb('/repo', (p) => calls.push(p), {
+      debounce_ms: 50,
+      explicit_db: '/repo/.beads/ui.db'
+    });
+    const { cb } = watchers[0];
+    cb('change', 'something-else.db');
+    vi.advanceTimersByTime(60);
+    expect(calls.length).toBe(0);
+    handle.close();
+  });
+
+  test('rebind attaches to new db path', () => {
+    const calls = [];
+    const handle = watchDb('/repo', (p) => calls.push(p), {
+      debounce_ms: 50,
+      explicit_db: '/repo/.beads/ui.db'
+    });
+    expect(watchers.length).toBe(1);
+    const first = watchers[0];
+
+    // Rebind to a different DB path
+    handle.rebind({ explicit_db: '/other/.beads/alt.db' });
+
+    // A new watcher is created
+    expect(watchers.length).toBe(2);
+    const second = watchers[1];
+
+    // Old watcher should ignore new file name
+    first.cb('change', 'ui.db');
+    vi.advanceTimersByTime(60);
+    expect(calls.length).toBe(0);
+
+    // New watcher reacts
+    second.cb('change', 'alt.db');
+    vi.advanceTimersByTime(60);
+    expect(calls.length).toBe(1);
+
+    handle.close();
+  });
+});

package/server/ws.handlers.test.js

@@ -0,0 +1,174 @@
+import { describe, expect, test, vi } from 'vitest';
+import { runBdJson } from './bd.js';
+import { handleMessage } from './ws.js';
+
+vi.mock('./bd.js', () => ({ runBdJson: vi.fn() }));
+
+function makeStubSocket() {
+  return {
+    sent: /** @type {string[]} */ ([]),
+    readyState: 1,
+    OPEN: 1,
+    /** @param {string} msg */
+    send(msg) {
+      this.sent.push(String(msg));
+    }
+  };
+}
+
+describe('ws handlers: list/show', () => {
+  test('list-issues forwards payload from bd', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [{ id: 'UI-1' }] });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r1',
+      type: 'list-issues',
+      payload: { filters: { status: 'open' } }
+    };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(Array.isArray(obj.payload)).toBe(true);
+  });
+
+  test('list-issues with filters.ready uses bd "ready"', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [{ id: 'UI-2' }] });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r1a',
+      type: 'list-issues',
+      payload: { filters: { ready: true } }
+    };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    // Ensure we called the ready command
+    const call = mocked.mock.calls[mocked.mock.calls.length - 1];
+    expect(Array.isArray(call[0])).toBe(true);
+    expect(call[0][0]).toBe('ready');
+
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(Array.isArray(obj.payload)).toBe(true);
+  });
+
+  test('show-issue returns error on missing id', async () => {
+    const ws = makeStubSocket();
+    const req = { id: 'r2', type: 'show-issue', payload: {} };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(false);
+    expect(obj.error.code).toBe('bad_request');
+  });
+
+  test('show-issue forwards bd JSON on success', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-9', title: 'X' }
+    });
+    const ws = makeStubSocket();
+    const req = { id: 'r3', type: 'show-issue', payload: { id: 'UI-9' } };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(obj.payload.id).toBe('UI-9');
+  });
+
+  test('show-issue unwraps single-element arrays from bd', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: [{ id: 'UI-9', title: 'X' }]
+    });
+    const ws = makeStubSocket();
+    const req = { id: 'r3a', type: 'show-issue', payload: { id: 'UI-9' } };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(obj.payload && obj.payload.id).toBe('UI-9');
+  });
+
+  test('show-issue returns not_found when bd returns empty array', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [] });
+    const ws = makeStubSocket();
+    const req = { id: 'r3b', type: 'show-issue', payload: { id: 'X' } };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(false);
+    expect(obj.error && obj.error.code).toBe('not_found');
+  });
+
+  test('epic-status forwards bd epic status', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [] });
+    const ws = makeStubSocket();
+    const req = { id: 're', type: /** @type {any} */ ('epic-status') };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const call = mocked.mock.calls[mocked.mock.calls.length - 1];
+    expect(Array.isArray(call[0])).toBe(true);
+    expect(call[0][0]).toBe('epic');
+    expect(call[0][1]).toBe('status');
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(Array.isArray(obj.payload)).toBe(true);
+  });
+
+  test('list-issues supports limit passthrough', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [] });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'rlim',
+      type: 'list-issues',
+      payload: { filters: { status: 'closed', limit: 10 } }
+    };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const call = mocked.mock.calls[mocked.mock.calls.length - 1];
+    const args = /** @type {string[]} */ (call[0]);
+    expect(args.includes('--limit')).toBe(true);
+    expect(args.includes('10')).toBe(true);
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(Array.isArray(obj.payload)).toBe(true);
+  });
+
+  test('bd error propagates as bd_error reply', async () => {
+    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
+    mocked.mockResolvedValueOnce({ code: 1, stderr: 'boom' });
+    const ws = makeStubSocket();
+    const req = { id: 'r4', type: 'list-issues', payload: {} };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(false);
+    expect(obj.error.code).toBe('bd_error');
+  });
+});