Usability and test infrastructure updates.

2026-07-29 09:20:43 +02:00
parent 99b1732003
commit 7040f031a6
12 changed files with 549 additions and 127 deletions
@@ -0,0 +1,185 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createLiveWebSocket, type LiveSessionData, type LiveSocket } from "../src/server/live";
+import type { Sidecar, SidecarSegment, SidecarTranscribeRequest } from "../src/server/transcribe";
+import type { SessionUser } from "../src/server/auth";
+
+// D-019: the server-live WebSocket bridge, tested against a fake Sidecar
+// (createLiveWebSocket takes it as an injected dependency, mirroring
+// createTranscribeHandlers in tests/transcribe.test.ts) — no Python sidecar,
+// no real model, but real LiveTranscriber/segmenter logic and real temp files.
+
+const USER: SessionUser = { id: 1, username: "tester" };
+const RATE = 16_000;
+
+function speech(seconds: number): Float32Array {
+  const out = new Float32Array(Math.round(seconds * RATE));
+  for (let i = 0; i < out.length; i++) out[i] = i % 2 === 0 ? 0.1 : -0.1;
+  return out;
+}
+
+function silence(seconds: number): Float32Array {
+  return new Float32Array(Math.round(seconds * RATE));
+}
+
+function toBuffer(audio: Float32Array): Buffer {
+  return Buffer.from(audio.buffer, audio.byteOffset, audio.byteLength);
+}
+
+async function waitFor(
+  predicate: () => boolean | Promise<boolean>,
+  timeoutMs = 3000,
+): Promise<void> {
+  const start = performance.now();
+  while (!(await predicate())) {
+    if (performance.now() - start > timeoutMs) {
+      throw new Error("timed out waiting for condition");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+const tempDirs: string[] = [];
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "live-ws-test-"));
+  tempDirs.push(dir);
+  return dir;
+}
+afterAll(async () => {
+  await Promise.all(tempDirs.map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+interface FakeSidecar extends Sidecar {
+  requests: SidecarTranscribeRequest[];
+  audioPayloads: Float32Array[];
+}
+
+function fakeSidecar(
+  behavior: { segments?: SidecarSegment[]; error?: string } = {},
+): FakeSidecar {
+  const segments = behavior.segments ?? [{ start: 0, end: 1, text: " hello world" }];
+  const sidecar: FakeSidecar = {
+    requests: [],
+    audioPayloads: [],
+    async status() {
+      return { available: true };
+    },
+    async transcribe(request, onSegment) {
+      sidecar.requests.push(request);
+      sidecar.audioPayloads.push(
+        new Float32Array(await Bun.file(request.audioPath).arrayBuffer()),
+      );
+      if (behavior.error) throw new Error(behavior.error);
+      for (const segment of segments) onSegment(segment);
+      return { cancelled: false };
+    },
+  };
+  return sidecar;
+}
+
+type FakeSocket = LiveSocket & {
+  sent: { type: string; [key: string]: unknown }[];
+  closed: boolean;
+};
+
+function fakeSocket(data: LiveSessionData): FakeSocket {
+  const sent: { type: string; [key: string]: unknown }[] = [];
+  const ws = {
+    data,
+    sent,
+    closed: false,
+    send(message: string) {
+      sent.push(JSON.parse(message));
+    },
+    close() {
+      ws.closed = true;
+    },
+  };
+  return ws as unknown as FakeSocket;
+}
+
+function sessionData(overrides: Partial<LiveSessionData> = {}): LiveSessionData {
+  return {
+    user: USER,
+    model: "tiny",
+    task: "transcribe",
+    tempDir: "/tmp",
+    ...overrides,
+  };
+}
+
+describe("createLiveWebSocket", () => {
+  test("a committed segment writes the exact PCM bytes and passes model/language/task through", async () => {
+    const tempDir = await makeTempDir();
+    const sidecar = fakeSidecar();
+    const handler = createLiveWebSocket({ sidecar });
+    const ws = fakeSocket(sessionData({ model: "base", language: "da", task: "translate", tempDir }));
+
+    handler.open(ws);
+    handler.message(ws, toBuffer(speech(1)));
+    handler.message(ws, toBuffer(silence(1.5))); // trailing silence commits the segment
+
+    await waitFor(() => sidecar.requests.length > 0);
+    expect(sidecar.requests[0]).toEqual(
+      expect.objectContaining({ model: "base", language: "da", task: "translate" }),
+    );
+    // The bytes written to the temp file are exactly the committed segment's
+    // samples — not, e.g., a whole shared buffer (see the byteOffset/byteLength fix).
+    const payload = sidecar.audioPayloads[0]!;
+    expect(payload.length).toBeGreaterThan(0);
+    for (const sample of payload) expect(Math.abs(sample)).toBeLessThanOrEqual(0.1 + 1e-6);
+
+    await waitFor(() =>
+      ws.sent.some((m) => m.type === "update" && (m.update as any).committedText === "hello world"),
+    );
+
+    // The temp file is cleaned up once the pass finishes.
+    await waitFor(async () => (await readdir(tempDir)).length === 0);
+  });
+
+  test("a sidecar error surfaces on the update stream instead of crashing the session", async () => {
+    const sidecar = fakeSidecar({ error: "model load failed" });
+    const handler = createLiveWebSocket({ sidecar });
+    const ws = fakeSocket(sessionData({ tempDir: await makeTempDir() }));
+
+    handler.open(ws);
+    handler.message(ws, toBuffer(speech(1)));
+    handler.message(ws, toBuffer(silence(1.5)));
+
+    await waitFor(() =>
+      ws.sent.some((m) => m.type === "update" && (m.update as any).error === "model load failed"),
+    );
+  });
+
+  test('a "stop" text frame drains, sends the result, and closes the socket', async () => {
+    const sidecar = fakeSidecar({ segments: [{ start: 0, end: 1, text: " done" }] });
+    const handler = createLiveWebSocket({ sidecar });
+    const ws = fakeSocket(sessionData({ tempDir: await makeTempDir() }));
+
+    handler.open(ws);
+    handler.message(ws, toBuffer(speech(1)));
+    handler.message(ws, JSON.stringify({ type: "stop" }));
+
+    await waitFor(() => ws.closed);
+    const result = ws.sent.find((m) => m.type === "result");
+    expect(result?.result).toEqual({ text: "done", chunks: [{ text: " done", timestamp: [0, 1] }] });
+  });
+
+  test("a malformed text frame is ignored rather than throwing", () => {
+    const handler = createLiveWebSocket({ sidecar: fakeSidecar() });
+    const ws = fakeSocket(sessionData({ tempDir: "/tmp" }));
+    handler.open(ws);
+    expect(() => handler.message(ws, "not json")).not.toThrow();
+    expect(ws.closed).toBe(false);
+  });
+
+  test("close() drains the session without throwing even if never stopped", async () => {
+    const handler = createLiveWebSocket({ sidecar: fakeSidecar() });
+    const ws = fakeSocket(sessionData({ tempDir: await makeTempDir() }));
+    handler.open(ws);
+    handler.message(ws, toBuffer(speech(0.5)));
+    expect(() => handler.close(ws)).not.toThrow();
+  });
+});
@@ -5,6 +5,7 @@ import { join } from "node:path";
 import {
  createSidecar,
  createTranscribeHandlers,
+  parseLanguageAndTask,
  type Sidecar,
  type SidecarSegment,
  type SidecarTranscribeRequest,
@@ -124,6 +125,46 @@ async function readStreamLines(response: Response): Promise<TranscribeStreamLine
 // HTTP handlers (fake sidecar)
 // ---------------------------------------------------------------------------

+// ---------------------------------------------------------------------------
+// parseLanguageAndTask — shared with the WS live route (src/server/live.ts,
+// src/index.ts) so it can't skip the validation the HTTP route enforces.
+// ---------------------------------------------------------------------------
+
+describe("parseLanguageAndTask", () => {
+  test("defaults to transcribe with no language", () => {
+    expect(parseLanguageAndTask(new URL("http://localhost/x"))).toEqual({
+      language: undefined,
+      task: "transcribe",
+    });
+  });
+
+  test("accepts a valid language and task", () => {
+    expect(parseLanguageAndTask(new URL("http://localhost/x?language=da&task=translate"))).toEqual(
+      { language: "da", task: "translate" },
+    );
+  });
+
+  test('"auto"/empty language means no language override', () => {
+    expect(parseLanguageAndTask(new URL("http://localhost/x?language=auto"))).toEqual({
+      language: undefined,
+      task: "transcribe",
+    });
+    expect(parseLanguageAndTask(new URL("http://localhost/x?language="))).toEqual({
+      language: undefined,
+      task: "transcribe",
+    });
+  });
+
+  test("rejects an invalid language or task", () => {
+    expect(parseLanguageAndTask(new URL("http://localhost/x?language=Danish!"))).toBe(
+      "invalid language: Danish!",
+    );
+    expect(parseLanguageAndTask(new URL("http://localhost/x?task=summarize"))).toBe(
+      "invalid task: summarize",
+    );
+  });
+});
+
 describe("GET /api/transcribe/status", () => {
  test("401 without a session", async () => {
    const handlers = createTranscribeHandlers({