@madeinoz67/voice-server 0.1.3

package/tests/mocks/index.ts

@@ -0,0 +1,152 @@
+/**
+ * Mock utilities for testing
+ */
+
+import { mockDeep } from "bun:test";
+
+/**
+ * Mock MLX-audio TTS process
+ */
+export interface MockMLXProcess {
+  stdout: { readonly: () => ReadableStream<Uint8Array> };
+  stderr: { readonly: () => ReadableStream<Uint8Array> };
+  killed: boolean;
+  kill(): void;
+}
+
+/**
+ * Create a mock MLX TTS process
+ */
+export function createMockMLXProcess(options: {
+  stdout?: string;
+  stderr?: string;
+  exitCode?: number;
+}): MockMLXProcess {
+  const stdoutStream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      if (options.stdout) {
+        controller.enqueue(new TextEncoder().encode(options.stdout));
+      }
+      controller.close();
+    },
+  });
+
+  const stderrStream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      if (options.stderr) {
+        controller.enqueue(new TextEncoder().encode(options.stderr));
+      }
+      controller.close();
+    },
+  });
+
+  return {
+    stdout: { readonly: () => stdoutStream },
+    stderr: { readonly: () => stderrStream },
+    killed: false,
+    kill() {
+      this.killed = true;
+    },
+  };
+}
+
+/**
+ * Mock file system operations
+ */
+export const mockFS = {
+  existsSync: (path: string): boolean => {
+    // Build paths outside object literal for CodeQL compatibility
+    const homeVoicePath = process.env.HOME + "/.claude/VoiceServer/voices/pronunciations.json";
+    const mockExists: Record<string, boolean> = {
+      "/tmp/test.wav": true,
+      "/tmp/test.mp3": true,
+      [homeVoicePath]: false,
+    };
+    return mockExists[path] || false;
+  },
+  readFileSync: (path: string, encoding: string): string => {
+    const mockFiles: Record<string, string> = {
+      "/tmp/pronunciations.json": JSON.stringify({
+        pronunciations: [
+          { term: "TEST", pronunciation: "test pronunciation" },
+        ],
+      }),
+    };
+    return mockFiles[path] || "";
+  },
+  writeFileSync: (): void => {},
+  unlinkSync: (): void => {},
+  mkdirSync: (): void => {},
+};
+
+/**
+ * Mock subprocess for Bun.spawn
+ */
+export function mockSpawn(cmd: string, args: string[]): MockMLXProcess {
+  if (cmd.endsWith("mlx_tts") || cmd.includes("python")) {
+    return createMockMLXProcess({
+      stdout: "",
+      stderr: "",
+    });
+  }
+  throw new Error(`Unknown mock command: ${cmd}`);
+}
+
+/**
+ * Test fixtures
+ */
+export const fixtures = {
+  validWAVFile: Buffer.from([
+    // RIFF header
+    0x52, 0x49, 0x46, 0x46, // "RIFF"
+    0x24, 0x08, 0x00, 0x00, // file size
+    0x57, 0x41, 0x56, 0x45, // "WAVE"
+    // fmt chunk
+    0x66, 0x6D, 0x74, 0x20, // "fmt "
+    0x10, 0x00, 0x00, 0x00, // chunk size
+    0x01, 0x00, 0x01, 0x00, // audio format, channels
+    0x40, 0x1F, 0x00, 0x00, // sample rate (8000)
+    0x40, 0x1F, 0x00, 0x00, // byte rate
+    0x01, 0x00, 0x08, 0x00, // block align, bits per sample
+    // data chunk
+    0x64, 0x61, 0x74, 0x61, // "data"
+    0x00, 0x08, 0x00, 0x00, // data size
+    // 1 second of silence at 8000Hz
+    ...Array(2048).fill(0x00),
+  ]),
+
+  validTTSRequest: {
+    text: "Hello world",
+    voice_id: "marrvin",
+  },
+
+  validNotificationRequest: {
+    message: "Test notification",
+    voice_id: "marrvin",
+  },
+
+  validProsodySettings: {
+    stability: 0.5,
+    style: 0.0,
+    speed: 1.0,
+    similarity_boost: 0.75,
+    use_speaker_boost: true,
+  },
+
+  validVoiceConfig: {
+    voice_id: "marrvin",
+    name: "Marvin",
+    language: "en",
+    gender: "male",
+  },
+};
+
+/**
+ * Mock logger that doesn't output to console
+ */
+export const mockLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};

package/tests/ts/server.test.ts

@@ -0,0 +1,11 @@
+/**
+ * Basic server tests
+ */
+
+import { describe, test, expect } from "bun:test";
+
+describe("voice server", () => {
+  test("placeholder test", () => {
+    expect(true).toBe(true);
+  });
+});

package/tests/unit/middleware/cors.test.ts

@@ -0,0 +1,146 @@
+/**
+ * CORS middleware tests
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import {
+  CORSMiddleware,
+  getCORSMiddleware,
+  resetCORSMiddleware,
+} from "@/middleware/cors.js";
+import type { CORSConfig } from "@/middleware/cors.js";
+
+describe("CORSMiddleware", () => {
+  let middleware: CORSMiddleware;
+
+  beforeEach(() => {
+    resetCORSMiddleware();
+    middleware = new CORSMiddleware();
+  });
+
+  describe("isOriginAllowed", () => {
+    test("should allow localhost:8888", () => {
+      expect(middleware.isOriginAllowed("http://localhost:8888")).toBe(true);
+    });
+
+    test("should allow 127.0.0.1:8888", () => {
+      expect(middleware.isOriginAllowed("http://127.0.0.1:8888")).toBe(true);
+    });
+
+    test("should allow localhost:3000", () => {
+      expect(middleware.isOriginAllowed("http://localhost:3000")).toBe(true);
+    });
+
+    test("should reject unknown origins", () => {
+      expect(middleware.isOriginAllowed("http://evil.com")).toBe(false);
+      expect(middleware.isOriginAllowed("https://example.com")).toBe(false);
+    });
+
+    test("should allow null origin (same-origin)", () => {
+      expect(middleware.isOriginAllowed(null)).toBe(true);
+    });
+  });
+
+  describe("getCORSHeaders", () => {
+    test("should include standard CORS headers", () => {
+      const headers = middleware.getCORSHeaders("http://localhost:8888");
+      expect(headers["Access-Control-Allow-Methods"]).toBeDefined();
+      expect(headers["Access-Control-Allow-Headers"]).toBeDefined();
+      expect(headers["Access-Control-Max-Age"]).toBeDefined();
+    });
+
+    test("should include origin for allowed origins", () => {
+      const headers = middleware.getCORSHeaders("http://localhost:8888");
+      expect(headers["Access-Control-Allow-Origin"]).toBe("http://localhost:8888");
+    });
+
+    test("should not include origin for disallowed origins", () => {
+      const headers = middleware.getCORSHeaders("http://evil.com");
+      expect(headers["Access-Control-Allow-Origin"]).toBeUndefined();
+    });
+
+    test("should use wildcard for null origin", () => {
+      const headers = middleware.getCORSHeaders(null);
+      expect(headers["Access-Control-Allow-Origin"]).toBe("*");
+    });
+
+    test("should include credentials header when enabled", () => {
+      const authMiddleware = new CORSMiddleware({ allowCredentials: true });
+      const headers = authMiddleware.getCORSHeaders("http://localhost:8888");
+      expect(headers["Access-Control-Allow-Credentials"]).toBe("true");
+    });
+  });
+
+  describe("handlePreflight", () => {
+    test("should return 204 status for OPTIONS request", () => {
+      const response = middleware.handlePreflight("http://localhost:8888");
+      expect(response.status).toBe(204);
+    });
+
+    test("should include CORS headers in preflight response", () => {
+      const response = middleware.handlePreflight("http://localhost:8888");
+      expect(response.headers.get("Access-Control-Allow-Methods")).toBeDefined();
+      expect(response.headers.get("Access-Control-Allow-Origin")).toBe("http://localhost:8888");
+    });
+  });
+
+  describe("addCorsHeaders", () => {
+    test("should add CORS headers to existing response", () => {
+      const response = new Response("OK", { status: 200 });
+      const corsResponse = middleware.addCorsHeaders(response, "http://localhost:8888");
+      expect(corsResponse.headers.get("Access-Control-Allow-Origin")).toBe("http://localhost:8888");
+    });
+  });
+
+  describe("createResponse", () => {
+    test("should create new response with CORS headers", () => {
+      const response = middleware.createResponse("Hello", {
+        status: 200,
+        origin: "http://localhost:8888",
+      });
+      expect(response.status).toBe(200);
+      expect(response.headers.get("Access-Control-Allow-Origin")).toBe("http://localhost:8888");
+    });
+  });
+
+  describe("setConfig", () => {
+    test("should update configuration", () => {
+      middleware.setConfig({ allowCredentials: true });
+      const config = middleware.getConfig();
+      expect(config.allowCredentials).toBe(true);
+    });
+
+    test("should merge with existing config", () => {
+      middleware.setConfig({ allowCredentials: true });
+      const config = middleware.getConfig();
+      expect(config.allowedOrigins.length).toBeGreaterThan(0); // Defaults preserved
+    });
+  });
+
+  describe("getConfig", () => {
+    test("should return copy of config", () => {
+      const config1 = middleware.getConfig();
+      const config2 = middleware.getConfig();
+      expect(config1).toEqual(config2);
+      expect(config1).not.toBe(config2); // Different references
+    });
+  });
+});
+
+describe("getCORSMiddleware", () => {
+  afterEach(() => {
+    resetCORSMiddleware();
+  });
+
+  test("should return singleton instance", () => {
+    const middleware1 = getCORSMiddleware();
+    const middleware2 = getCORSMiddleware();
+    expect(middleware1).toBe(middleware2);
+  });
+
+  test("should create with custom config", () => {
+    const middleware = getCORSMiddleware({ allowCredentials: true });
+    const config = middleware.getConfig();
+    expect(config.allowCredentials).toBe(true);
+  });
+});

package/tests/unit/models/validation.test.ts

@@ -0,0 +1,332 @@
+/**
+ * Model validation tests
+ */
+
+import { describe, test, expect } from "bun:test";
+import { isValidNotificationRequest } from "@/models/notification.js";
+import { isValidTTSRequest } from "@/models/tts.js";
+import {
+  isValidVoiceConfig,
+  isValidProsody,
+} from "@/models/voice-config.js";
+import { isValidPronunciationRule } from "@/models/pronunciation.js";
+import type { NotificationRequest } from "@/models/notification.js";
+import type { TTSRequest } from "@/models/tts.js";
+import type { VoiceConfig, ProsodySettings } from "@/models/voice-config.js";
+import type { PronunciationRule } from "@/models/pronunciation.js";
+
+describe("NotificationRequest validation", () => {
+  describe("isValidNotificationRequest", () => {
+    test("should validate correct request", () => {
+      const request: NotificationRequest = {
+        message: "Test notification",
+        voice_id: "marrvin",
+      };
+      expect(isValidNotificationRequest(request)).toBe(true);
+    });
+
+    test("should validate request with just message (minimal)", () => {
+      const request: NotificationRequest = {
+        message: "Test notification",
+      };
+      expect(isValidNotificationRequest(request)).toBe(true);
+    });
+
+    test("should require message", () => {
+      const request = { voice_id: "marrvin" } as Partial<NotificationRequest>;
+      expect(isValidNotificationRequest(request as NotificationRequest)).toBe(false);
+    });
+
+    test("should allow optional title", () => {
+      const request: NotificationRequest = {
+        message: "Test",
+        title: "Test Title",
+      };
+      expect(isValidNotificationRequest(request)).toBe(true);
+    });
+
+    test("should reject title over 100 chars", () => {
+      const request: NotificationRequest = {
+        message: "Test",
+        title: "a".repeat(101),
+      };
+      expect(isValidNotificationRequest(request)).toBe(false);
+    });
+
+    test("should reject message over 500 chars", () => {
+      const request: NotificationRequest = {
+        message: "a".repeat(501),
+      };
+      expect(isValidNotificationRequest(request)).toBe(false);
+    });
+
+    test("should reject both voice_id and voice_name specified", () => {
+      const request: NotificationRequest = {
+        message: "Test",
+        voice_id: "marrvin",
+        voice_name: "marvin",
+      };
+      expect(isValidNotificationRequest(request)).toBe(false);
+    });
+
+    test("should allow voice_id alone", () => {
+      const request: NotificationRequest = {
+        message: "Test",
+        voice_id: "marrvin",
+      };
+      expect(isValidNotificationRequest(request)).toBe(true);
+    });
+
+    test("should allow voice_name alone", () => {
+      const request: NotificationRequest = {
+        message: "Test",
+        voice_name: "marvin",
+      };
+      expect(isValidNotificationRequest(request)).toBe(true);
+    });
+  });
+});
+
+describe("TTSRequest validation", () => {
+  describe("isValidTTSRequest", () => {
+    test("should validate correct request", () => {
+      const request: TTSRequest = {
+        text: "Hello world",
+        voice: "marrvin",
+        prosody_instruction: "speak normally",
+        speed: 1.0,
+      };
+      expect(isValidTTSRequest(request)).toBe(true);
+    });
+
+    test("should require text", () => {
+      const request = {
+        voice: "marrvin",
+        prosody_instruction: "speak normally",
+      } as Partial<TTSRequest>;
+      expect(isValidTTSRequest(request as TTSRequest)).toBe(false);
+    });
+
+    test("should require voice", () => {
+      const request = {
+        text: "Hello",
+        prosody_instruction: "speak normally",
+      } as Partial<TTSRequest>;
+      expect(isValidTTSRequest(request as TTSRequest)).toBe(false);
+    });
+
+    test("should require prosody_instruction", () => {
+      const request = {
+        text: "Hello",
+        voice: "marrvin",
+      } as Partial<TTSRequest>;
+      expect(isValidTTSRequest(request as TTSRequest)).toBe(false);
+    });
+
+    test("should reject empty text", () => {
+      const request: TTSRequest = {
+        text: "",
+        voice: "marrvin",
+        prosody_instruction: "speak normally",
+      };
+      expect(isValidTTSRequest(request)).toBe(false);
+    });
+
+    test("should reject whitespace-only text", () => {
+      const request: TTSRequest = {
+        text: "   ",
+        voice: "marrvin",
+        prosody_instruction: "speak normally",
+      };
+      expect(isValidTTSRequest(request)).toBe(false);
+    });
+
+    test("should allow optional output_format", () => {
+      const request: TTSRequest = {
+        text: "Hello",
+        voice: "marrvin",
+        prosody_instruction: "speak normally",
+        output_format: "wav",
+      };
+      expect(isValidTTSRequest(request)).toBe(true);
+    });
+
+    test("should reject speed below 0.5", () => {
+      const request: TTSRequest = {
+        text: "Hello",
+        voice: "marrvin",
+        prosody_instruction: "speak normally",
+        speed: 0.4,
+      };
+      expect(isValidTTSRequest(request)).toBe(false);
+    });
+
+    test("should reject speed above 2.0", () => {
+      const request: TTSRequest = {
+        text: "Hello",
+        voice: "marrvin",
+        prosody_instruction: "speak normally",
+        speed: 2.1,
+      };
+      expect(isValidTTSRequest(request)).toBe(false);
+    });
+  });
+});
+
+describe("ProsodySettings validation", () => {
+  describe("isValidProsody", () => {
+    test("should validate correct settings", () => {
+      const settings: ProsodySettings = {
+        stability: 0.5,
+        style: 0.3,
+        speed: 1.0,
+        similarity_boost: 0.75,
+        use_speaker_boost: true,
+      };
+      expect(isValidProsody(settings)).toBe(true);
+    });
+
+    test("should allow partial settings", () => {
+      const settings = { stability: 0.5 };
+      expect(isValidProsody(settings as ProsodySettings)).toBe(true);
+    });
+
+    test("should allow empty settings", () => {
+      const settings = {};
+      expect(isValidProsody(settings as ProsodySettings)).toBe(true);
+    });
+
+    test("should reject stability out of range", () => {
+      const settings = { stability: -0.1 };
+      expect(isValidProsody(settings as ProsodySettings)).toBe(false);
+
+      const settings2 = { stability: 1.1 };
+      expect(isValidProsody(settings2 as ProsodySettings)).toBe(false);
+    });
+
+    test("should reject speed out of range", () => {
+      const settings = { speed: 0.05 };
+      expect(isValidProsody(settings as ProsodySettings)).toBe(false);
+
+      const settings2 = { speed: 2.5 };
+      expect(isValidProsody(settings2 as ProsodySettings)).toBe(false);
+    });
+
+    test("should reject volume out of range", () => {
+      const settings = { volume: -0.1 };
+      expect(isValidProsody(settings as ProsodySettings)).toBe(false);
+
+      const settings2 = { volume: 1.5 };
+      expect(isValidProsody(settings2 as ProsodySettings)).toBe(false);
+    });
+  });
+});
+
+describe("VoiceConfig validation", () => {
+  describe("isValidVoiceConfig", () => {
+    test("should validate correct config", () => {
+      const config: VoiceConfig = {
+        voice_id: "marrvin",
+        voice_name: "Marvin",
+        description: "A test voice",
+        type: "built-in",
+        stability: 0.5,
+        similarity_boost: 0.75,
+        style: 0.0,
+        speed: 1.0,
+        use_speaker_boost: true,
+      };
+      expect(isValidVoiceConfig(config)).toBe(true);
+    });
+
+    test("should require voice_id", () => {
+      const config = { voice_name: "Test" } as Partial<VoiceConfig>;
+      expect(isValidVoiceConfig(config as VoiceConfig)).toBe(false);
+    });
+
+    test("should require voice_name", () => {
+      const config = { voice_id: "test" } as Partial<VoiceConfig>;
+      expect(isValidVoiceConfig(config as VoiceConfig)).toBe(false);
+    });
+
+    test("should reject invalid voice_id format", () => {
+      const config: Partial<VoiceConfig> = {
+        voice_id: "invalid id!",
+        voice_name: "Test",
+      };
+      expect(isValidVoiceConfig(config)).toBe(false);
+    });
+
+    test("should reject stability out of range", () => {
+      const config: Partial<VoiceConfig> = {
+        voice_id: "test",
+        voice_name: "Test",
+        stability: 1.5,
+      };
+      expect(isValidVoiceConfig(config)).toBe(false);
+    });
+
+    test("should reject speed out of range", () => {
+      const config: Partial<VoiceConfig> = {
+        voice_id: "test",
+        voice_name: "Test",
+        speed: 3.0,
+      };
+      expect(isValidVoiceConfig(config)).toBe(false);
+    });
+  });
+});
+
+describe("PronunciationRule validation", () => {
+  describe("isValidPronunciationRule", () => {
+    test("should validate correct rule", () => {
+      const rule: PronunciationRule = {
+        term: "API",
+        pronunciation: "A P I",
+      };
+      expect(isValidPronunciationRule(rule)).toBe(true);
+    });
+
+    test("should require term", () => {
+      const rule = { pronunciation: "test" } as Partial<PronunciationRule>;
+      expect(isValidPronunciationRule(rule as PronunciationRule)).toBe(false);
+    });
+
+    test("should require pronunciation", () => {
+      const rule = { term: "test" } as Partial<PronunciationRule>;
+      expect(isValidPronunciationRule(rule as PronunciationRule)).toBe(false);
+    });
+
+    test("should reject empty term", () => {
+      const rule: PronunciationRule = {
+        term: "",
+        pronunciation: "test",
+      };
+      expect(isValidPronunciationRule(rule)).toBe(false);
+    });
+
+    test("should reject whitespace-only term", () => {
+      const rule: PronunciationRule = {
+        term: "   ",
+        pronunciation: "test",
+      };
+      expect(isValidPronunciationRule(rule)).toBe(false);
+    });
+
+    test("should reject empty pronunciation", () => {
+      const rule: PronunciationRule = {
+        term: "test",
+        pronunciation: "",
+      };
+      expect(isValidPronunciationRule(rule)).toBe(false);
+    });
+
+    test("should reject whitespace-only pronunciation", () => {
+      const rule: PronunciationRule = {
+        term: "test",
+        pronunciation: "   ",
+      };
+      expect(isValidPronunciationRule(rule)).toBe(false);
+    });
+  });
+});