@myerscarpenter/quest-dev 1.4.0 → 2.0.0

package/tests/daemon/cast-manager.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ServerResponse } from "node:http";
+
+/**
+ * Minimal extraction of CastManager.broadcast() logic for unit testing
+ * without needing to instantiate the full CastManager (which requires ADB).
+ */
+function broadcast(
+  sseClients: Set<ServerResponse>,
+  event: string,
+  data: unknown,
+): void {
+  const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const res of sseClients) {
+    try {
+      res.write(msg);
+    } catch {
+      sseClients.delete(res);
+    }
+  }
+}
+
+function makeFakeRes(opts?: { throwOnWrite?: boolean }): ServerResponse {
+  return {
+    write: opts?.throwOnWrite
+      ? () => { throw new Error("socket destroyed"); }
+      : vi.fn(),
+  } as unknown as ServerResponse;
+}
+
+describe("SSE broadcast", () => {
+  it("writes to all live clients", () => {
+    const clients = new Set<ServerResponse>();
+    const a = makeFakeRes();
+    const b = makeFakeRes();
+    clients.add(a);
+    clients.add(b);
+
+    broadcast(clients, "status", { ok: true });
+
+    expect(a.write).toHaveBeenCalledOnce();
+    expect(b.write).toHaveBeenCalledOnce();
+    expect(clients.size).toBe(2);
+  });
+
+  it("removes dead clients on write error", () => {
+    const clients = new Set<ServerResponse>();
+    const alive = makeFakeRes();
+    const dead = makeFakeRes({ throwOnWrite: true });
+    clients.add(alive);
+    clients.add(dead);
+
+    broadcast(clients, "status", { ok: true });
+
+    expect(alive.write).toHaveBeenCalledOnce();
+    expect(clients.size).toBe(1);
+    expect(clients.has(alive)).toBe(true);
+    expect(clients.has(dead)).toBe(false);
+  });
+
+  it("handles all clients dead", () => {
+    const clients = new Set<ServerResponse>();
+    clients.add(makeFakeRes({ throwOnWrite: true }));
+    clients.add(makeFakeRes({ throwOnWrite: true }));
+
+    expect(() => broadcast(clients, "status", {})).not.toThrow();
+    expect(clients.size).toBe(0);
+  });
+});

package/tests/daemon/mjpeg-stream.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+/**
+ * MJPEG stream cleanup logic.
+ * Bug: interval can fire after reply.raw.end() if session stops
+ * and client hasn't disconnected yet.
+ */
+
+interface FakeResponse {
+  writeHead: ReturnType<typeof vi.fn>;
+  write: ReturnType<typeof vi.fn>;
+  end: ReturnType<typeof vi.fn>;
+  ended: boolean;
+}
+
+function createFakeResponse(): FakeResponse {
+  const res: FakeResponse = {
+    writeHead: vi.fn(),
+    write: vi.fn(),
+    end: vi.fn(() => { res.ended = true; }),
+    ended: false,
+  };
+  return res;
+}
+
+/**
+ * Fixed MJPEG stream loop: checks `ended` before writing,
+ * and wraps writes in try-catch.
+ */
+function startMjpegStream(
+  res: FakeResponse,
+  getSession: () => { running: boolean; getScreenshot: () => Buffer | null } | null,
+  onCleanup: () => void,
+): { interval: ReturnType<typeof setInterval>; cleanup: () => void } {
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    clearInterval(interval);
+    try { res.end(); } catch { /* ignore */ }
+    onCleanup();
+  };
+
+  const interval = setInterval(() => {
+    const s = getSession();
+    if (!s?.running) {
+      cleanup();
+      return;
+    }
+    if (res.ended) {
+      cleanup();
+      return;
+    }
+    const jpeg = s.getScreenshot();
+    if (jpeg) {
+      try {
+        res.write(`--frame\r\nContent-Type: image/jpeg\r\nContent-Length: ${jpeg.length}\r\n\r\n`);
+        res.write(jpeg);
+        res.write("\r\n");
+      } catch {
+        cleanup();
+      }
+    }
+  }, 50);
+
+  return { interval, cleanup };
+}
+
+describe("MJPEG stream cleanup", () => {
+  beforeEach(() => { vi.useFakeTimers(); });
+  afterEach(() => { vi.useRealTimers(); });
+
+  it("writes frames while session is running", () => {
+    const res = createFakeResponse();
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xd9]);
+    const session = { running: true, getScreenshot: () => jpeg };
+    const cleanupFn = vi.fn();
+
+    startMjpegStream(res, () => session, cleanupFn);
+    vi.advanceTimersByTime(100);
+
+    expect(res.write).toHaveBeenCalled();
+    expect(cleanupFn).not.toHaveBeenCalled();
+  });
+
+  it("cleans up when session stops", () => {
+    const res = createFakeResponse();
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    startMjpegStream(res, () => session, cleanupFn);
+    vi.advanceTimersByTime(50);
+
+    session.running = false;
+    vi.advanceTimersByTime(100);
+
+    expect(res.end).toHaveBeenCalled();
+    expect(cleanupFn).toHaveBeenCalledOnce();
+  });
+
+  it("does not write after cleanup", () => {
+    const res = createFakeResponse();
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    const { cleanup } = startMjpegStream(res, () => session, cleanupFn);
+
+    // Simulate client disconnect
+    cleanup();
+    res.write.mockClear();
+
+    vi.advanceTimersByTime(200);
+
+    // No more writes after cleanup
+    expect(res.write).not.toHaveBeenCalled();
+  });
+
+  it("cleanup is idempotent", () => {
+    const res = createFakeResponse();
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    const { cleanup } = startMjpegStream(res, () => session, cleanupFn);
+
+    cleanup();
+    cleanup();
+    cleanup();
+
+    expect(res.end).toHaveBeenCalledOnce();
+    expect(cleanupFn).toHaveBeenCalledOnce();
+  });
+
+  it("handles write errors gracefully", () => {
+    const res = createFakeResponse();
+    res.write.mockImplementation(() => { throw new Error("broken pipe"); });
+    const session = { running: true, getScreenshot: () => Buffer.from([1]) };
+    const cleanupFn = vi.fn();
+
+    startMjpegStream(res, () => session, cleanupFn);
+    vi.advanceTimersByTime(100);
+
+    expect(cleanupFn).toHaveBeenCalledOnce();
+  });
+});

package/tests/daemon/pose-endpoint.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { createPoseState, updatePose, setPoseOffset, type PoseState } from "@myerscarpenter/cast2-protocol";
+
+/**
+ * Simulates the /cast/pose endpoint logic:
+ * offset and delta should be mutually exclusive.
+ */
+function applyPoseRequest(
+  state: PoseState,
+  data: Record<string, number>,
+): PoseState {
+  // Direct offset — takes priority
+  if ("x" in data || "y" in data || "z" in data || "yaw" in data || "pitch" in data) {
+    return setPoseOffset(state, {
+      x: data.x,
+      y: data.y,
+      z: data.z,
+      yaw: data.yaw,
+      pitch: data.pitch,
+    });
+  }
+  // Incremental deltas — only if no offset fields present
+  if ("dx" in data || "dy" in data || "dz" in data || "d_yaw" in data || "d_pitch" in data) {
+    return updatePose(state, {
+      dForward: data.dz ?? 0,
+      dStrafe: data.dx ?? 0,
+      dUp: data.dy ?? 0,
+      dYaw: data.d_yaw ?? 0,
+      dPitch: data.d_pitch ?? 0,
+    });
+  }
+  return state;
+}
+
+describe("/cast/pose endpoint logic", () => {
+  it("applies offset when offset fields provided", () => {
+    const state = createPoseState();
+    const result = applyPoseRequest(state, { x: 1.0, y: 2.0 });
+    expect(result.x).toBeCloseTo(1.0);
+    expect(result.y).toBeCloseTo(2.0);
+  });
+
+  it("applies delta when delta fields provided", () => {
+    const state = createPoseState();
+    const result = applyPoseRequest(state, { dz: 0.3 }); // forward
+    expect(result.z).toBeCloseTo(-0.3); // OpenXR: forward = -Z
+  });
+
+  it("does not double-apply when both offset and delta provided", () => {
+    const state = createPoseState();
+    // If both are present, offset wins — delta is NOT also applied
+    const result = applyPoseRequest(state, { x: 1.0, dz: 0.3 });
+    expect(result.x).toBeCloseTo(1.0);
+    // z should be 0 (offset only set x, delta was ignored)
+    expect(result.z).toBeCloseTo(0);
+  });
+
+  it("returns unchanged state when no recognized fields", () => {
+    const state = createPoseState();
+    const result = applyPoseRequest(state, { foo: 42 } as any);
+    expect(result).toBe(state);
+  });
+});

package/tests/daemon/start-guard.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+/**
+ * Bug 1: Stats interval leaked on start failure.
+ * If session.bind() throws after statsInterval is created,
+ * the interval is never cleared.
+ *
+ * Bug 2: Concurrent /cast/start calls can both pass the
+ * isActive check and create two sessions.
+ */
+
+describe("stats interval cleanup on start failure", () => {
+  it("interval is cleared if setup fails after creation", async () => {
+    let intervalId: ReturnType<typeof setInterval> | null = null;
+    let intervalCleared = false;
+
+    // Simulate the fixed pattern: create interval only AFTER all async ops succeed
+    async function startFixed(shouldFail: boolean) {
+      // Do all async work first
+      if (shouldFail) throw new Error("bind failed");
+
+      // Only create interval after success
+      intervalId = setInterval(() => {}, 500);
+    }
+
+    // Start should fail
+    await expect(startFixed(true)).rejects.toThrow("bind failed");
+
+    // Interval was never created
+    expect(intervalId).toBeNull();
+  });
+
+  it("buggy pattern: interval created before async work leaks", async () => {
+    let intervalId: ReturnType<typeof setInterval> | null = null;
+
+    async function startBuggy(shouldFail: boolean) {
+      // Bug: interval created BEFORE async work
+      intervalId = setInterval(() => {}, 500);
+
+      // Async work that might fail
+      if (shouldFail) throw new Error("bind failed");
+    }
+
+    await expect(startBuggy(true)).rejects.toThrow("bind failed");
+
+    // Interval was created and is now leaked!
+    expect(intervalId).not.toBeNull();
+    clearInterval(intervalId!); // clean up for test
+  });
+});
+
+describe("concurrent start guard", () => {
+  it("second concurrent start is rejected while first is in progress", async () => {
+    let starting = false;
+    let startCount = 0;
+
+    async function startGuarded() {
+      if (starting) throw new Error("start already in progress");
+      starting = true;
+      try {
+        startCount++;
+        await new Promise((r) => setTimeout(r, 50));
+      } finally {
+        starting = false;
+      }
+    }
+
+    const p1 = startGuarded();
+    const p2 = startGuarded().catch((e) => e);
+
+    await p1;
+    const err = await p2;
+    expect(err).toBeInstanceOf(Error);
+    expect(err.message).toBe("start already in progress");
+    expect(startCount).toBe(1);
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@myerscarpenter/cast2-protocol': resolve(__dirname, 'packages/cast2-protocol/src/index.ts'),
+    },
+  },
+});