@hasna/recordings 0.1.11 → 0.1.13

package/src/__tests__/config.test.ts

@@ -1,252 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { tmpdir } from "os";
-import { join } from "path";
-import { mkdirSync, rmSync, existsSync, writeFileSync } from "fs";
-import { loadConfig, getDataDir, ensureDataDir, DEFAULT_CONFIG } from "../lib/config.js";
-
-let tempDir: string;
-
-// Save and restore env vars
-const savedEnv: Record<string, string | undefined> = {};
-const envKeys = [
-  "OPENAI_API_KEY",
-  "RECORDINGS_API_KEY",
-  "RECORDINGS_ENHANCEMENT_KEY",
-  "RECORDINGS_MODEL",
-  "RECORDINGS_ENHANCEMENT_MODEL",
-  "RECORDINGS_LANGUAGE",
-  "RECORDINGS_DB_PATH",
-  "RECORDINGS_AUDIO_DIR",
-  "RECORDINGS_MAX_SECONDS",
-];
-
-beforeEach(() => {
-  tempDir = join(tmpdir(), `open-recordings-test-config-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(tempDir, { recursive: true });
-
-  // Save env vars
-  for (const key of envKeys) {
-    savedEnv[key] = process.env[key];
-    delete process.env[key];
-  }
-});
-
-afterEach(() => {
-  // Restore env vars
-  for (const key of envKeys) {
-    if (savedEnv[key] !== undefined) {
-      process.env[key] = savedEnv[key];
-    } else {
-      delete process.env[key];
-    }
-  }
-
-  if (existsSync(tempDir)) {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-});
-
-describe("DEFAULT_CONFIG", () => {
-  test("has expected default values", () => {
-    expect(DEFAULT_CONFIG.transcription_model).toBe("gpt-4o-mini-transcribe");
-    expect(DEFAULT_CONFIG.enhancement_model).toBe("gpt-4o");
-    expect(DEFAULT_CONFIG.language).toBe("en");
-    expect(DEFAULT_CONFIG.audio_format).toBe("wav");
-    expect(DEFAULT_CONFIG.sample_rate).toBe(16000);
-    expect(DEFAULT_CONFIG.record_command).toBe("sox");
-    expect(DEFAULT_CONFIG.hotkey).toBe("space");
-    expect(DEFAULT_CONFIG.auto_enhance).toBe(true);
-    expect(DEFAULT_CONFIG.max_recording_seconds).toBe(300);
-    expect(DEFAULT_CONFIG.enhance_triggers).toContain("say it better");
-    expect(DEFAULT_CONFIG.enhance_triggers).toContain("rewrite this");
-  });
-});
-
-describe("loadConfig", () => {
-  test("returns defaults when no config file or env vars", () => {
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.transcription_model).toBe("gpt-4o-mini-transcribe");
-    expect(config.enhancement_model).toBe("gpt-4o");
-    expect(config.language).toBe("en");
-    expect(config.audio_format).toBe("wav");
-    expect(config.auto_enhance).toBe(true);
-  });
-
-  test("loads config from file", () => {
-    const configPath = join(tempDir, "config.json");
-    writeFileSync(
-      configPath,
-      JSON.stringify({
-        transcription_model: "whisper-1",
-        language: "fr",
-        auto_enhance: false,
-      })
-    );
-
-    const config = loadConfig(configPath);
-    expect(config.transcription_model).toBe("whisper-1");
-    expect(config.language).toBe("fr");
-    expect(config.auto_enhance).toBe(false);
-    // Other defaults still present
-    expect(config.audio_format).toBe("wav");
-  });
-
-  test("ignores invalid JSON config file", () => {
-    const configPath = join(tempDir, "bad-config.json");
-    writeFileSync(configPath, "this is not json {{{");
-
-    const config = loadConfig(configPath);
-    // Should fall back to defaults
-    expect(config.transcription_model).toBe("gpt-4o-mini-transcribe");
-  });
-
-  test("env var OPENAI_API_KEY overrides config", () => {
-    process.env.OPENAI_API_KEY = "sk-env-key";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.openai_api_key).toBe("sk-env-key");
-  });
-
-  test("env var RECORDINGS_API_KEY overrides OPENAI_API_KEY", () => {
-    process.env.OPENAI_API_KEY = "sk-openai";
-    process.env.RECORDINGS_API_KEY = "sk-recordings";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.openai_api_key).toBe("sk-recordings");
-  });
-
-  test("env var RECORDINGS_ENHANCEMENT_KEY sets enhancement_api_key", () => {
-    process.env.RECORDINGS_ENHANCEMENT_KEY = "sk-enhance";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.enhancement_api_key).toBe("sk-enhance");
-  });
-
-  test("env var RECORDINGS_MODEL overrides transcription_model", () => {
-    process.env.RECORDINGS_MODEL = "whisper-1";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.transcription_model).toBe("whisper-1");
-  });
-
-  test("env var RECORDINGS_ENHANCEMENT_MODEL overrides enhancement_model", () => {
-    process.env.RECORDINGS_ENHANCEMENT_MODEL = "gpt-3.5-turbo";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.enhancement_model).toBe("gpt-3.5-turbo");
-  });
-
-  test("env var RECORDINGS_LANGUAGE overrides language", () => {
-    process.env.RECORDINGS_LANGUAGE = "de";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.language).toBe("de");
-  });
-
-  test("env var RECORDINGS_DB_PATH overrides db_path", () => {
-    process.env.RECORDINGS_DB_PATH = "/custom/db.sqlite";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.db_path).toBe("/custom/db.sqlite");
-  });
-
-  test("env var RECORDINGS_AUDIO_DIR overrides audio_dir", () => {
-    process.env.RECORDINGS_AUDIO_DIR = "/custom/audio";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.audio_dir).toBe("/custom/audio");
-  });
-
-  test("env var RECORDINGS_MAX_SECONDS overrides max_recording_seconds", () => {
-    process.env.RECORDINGS_MAX_SECONDS = "60";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.max_recording_seconds).toBe(60);
-  });
-
-  test("sets default db_path when not configured", () => {
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.db_path).toBeTruthy();
-    expect(config.db_path).toContain("recordings.db");
-  });
-
-  test("sets default audio_dir when not configured", () => {
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.audio_dir).toBeTruthy();
-    expect(config.audio_dir).toContain("audio");
-  });
-
-  test("enhancement_api_key falls back to openai_api_key", () => {
-    process.env.OPENAI_API_KEY = "sk-shared";
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    expect(config.enhancement_api_key).toBe("sk-shared");
-  });
-
-  test("file config values are overridden by env vars", () => {
-    const configPath = join(tempDir, "config.json");
-    writeFileSync(
-      configPath,
-      JSON.stringify({ language: "fr", transcription_model: "file-model" })
-    );
-    process.env.RECORDINGS_LANGUAGE = "ja";
-
-    const config = loadConfig(configPath);
-    expect(config.language).toBe("ja"); // env wins
-    expect(config.transcription_model).toBe("file-model"); // no env override for this
-  });
-});
-
-describe("ensureDataDir", () => {
-  test("creates audio_dir and db directory", () => {
-    const audioDir = join(tempDir, "audio-out");
-    const dbPath = join(tempDir, "db-dir/recordings.db");
-    const config = {
-      ...DEFAULT_CONFIG,
-      audio_dir: audioDir,
-      db_path: dbPath,
-    };
-
-    ensureDataDir(config);
-    expect(existsSync(audioDir)).toBe(true);
-    expect(existsSync(join(tempDir, "db-dir"))).toBe(true);
-  });
-});
-
-describe("getDataDir", () => {
-  test("returns a string", () => {
-    const dir = getDataDir();
-    expect(typeof dir).toBe("string");
-    expect(dir).toContain("recordings");
-  });
-});
-
-describe("loadSecretKey (via loadConfig)", () => {
-  test("loads API key from ~/.secrets with double quotes", () => {
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    // The key is either loaded from ~/.secrets or empty
-    expect(typeof config.openai_api_key).toBe("string");
-  });
-
-  test("loads secret key with single quotes format", () => {
-    // We can't easily mock ~/.secrets, but we test the regex patterns directly
-    // by testing the config loading with different env overrides
-    // The loadSecretKey function is internal, so we test its effect indirectly
-    // When no env var is set and no ~/.secrets has the key, it returns ""
-    const config = loadConfig(join(tempDir, "nonexistent.json"));
-    // At minimum, the function doesn't crash
-    expect(config).toBeDefined();
-  });
-});
-
-describe("findConfigFile (via loadConfig without explicit path)", () => {
-  test("loads config without explicit path (uses findConfigFile)", () => {
-    // When no configPath is given, findConfigFile walks up from cwd
-    const config = loadConfig();
-    expect(config).toBeDefined();
-    expect(config.transcription_model).toBeTruthy();
-  });
-});
-
-describe("ensureDataDir edge cases", () => {
-  test("handles db_path without directory separator", () => {
-    const config = {
-      ...DEFAULT_CONFIG,
-      audio_dir: join(tempDir, "audio"),
-      db_path: "recordings.db", // no directory part
-    };
-    // Should not throw - dbDir will be empty string
-    ensureDataDir(config);
-    expect(existsSync(join(tempDir, "audio"))).toBe(true);
-  });
-});

package/src/__tests__/database.test.ts

@@ -1,167 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { tmpdir } from "os";
-import { join } from "path";
-import { mkdirSync, rmSync, existsSync } from "fs";
-import {
-  getDatabase,
-  closeDatabase,
-  resetDatabase,
-  shortUuid,
-} from "../db/database.js";
-
-let tempDir: string;
-
-beforeEach(() => {
-  resetDatabase();
-  tempDir = join(tmpdir(), `open-recordings-test-db-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(tempDir, { recursive: true });
-});
-
-afterEach(() => {
-  closeDatabase();
-  resetDatabase();
-  if (existsSync(tempDir)) {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-});
-
-describe("getDatabase", () => {
-  test("creates database file and returns a database instance", () => {
-    const dbPath = join(tempDir, "test.db");
-    const db = getDatabase(dbPath);
-    expect(db).toBeDefined();
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  test("creates parent directories if they don't exist", () => {
-    const dbPath = join(tempDir, "nested", "deep", "test.db");
-    const db = getDatabase(dbPath);
-    expect(db).toBeDefined();
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  test("returns the same instance on subsequent calls (singleton)", () => {
-    const dbPath = join(tempDir, "test.db");
-    const db1 = getDatabase(dbPath);
-    const db2 = getDatabase(dbPath);
-    expect(db1).toBe(db2);
-  });
-
-  test("runs migrations on creation", () => {
-    const dbPath = join(tempDir, "test.db");
-    const db = getDatabase(dbPath);
-
-    // Check that the tables exist
-    const tables = db
-      .query("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
-      .all() as { name: string }[];
-    const tableNames = tables.map((t) => t.name);
-
-    expect(tableNames).toContain("recordings");
-    expect(tableNames).toContain("agents");
-    expect(tableNames).toContain("projects");
-    expect(tableNames).toContain("recording_tags");
-    expect(tableNames).toContain("_migrations");
-  });
-
-  test("sets WAL journal mode", () => {
-    const dbPath = join(tempDir, "test.db");
-    const db = getDatabase(dbPath);
-    const result = db.query("PRAGMA journal_mode").get() as { journal_mode: string } | null;
-    expect(result?.journal_mode).toBe("wal");
-  });
-
-  test("enables foreign keys", () => {
-    const dbPath = join(tempDir, "test.db");
-    const db = getDatabase(dbPath);
-    const result = db.query("PRAGMA foreign_keys").get() as { foreign_keys: number } | null;
-    expect(result?.foreign_keys).toBe(1);
-  });
-
-  test("records migration level", () => {
-    const dbPath = join(tempDir, "test.db");
-    const db = getDatabase(dbPath);
-    const result = db
-      .query("SELECT MAX(id) as max_id FROM _migrations")
-      .get() as { max_id: number };
-    expect(result.max_id).toBe(0);
-  });
-
-  test("does not re-run migrations on second open", () => {
-    const dbPath = join(tempDir, "test.db");
-    const db1 = getDatabase(dbPath);
-    // Insert a test row
-    db1.query("INSERT INTO agents (id, name, created_at, last_seen_at) VALUES (?, ?, ?, ?)").run(
-      "test-id",
-      "test-agent",
-      new Date().toISOString(),
-      new Date().toISOString()
-    );
-    closeDatabase();
-    resetDatabase();
-
-    // Re-open
-    const db2 = getDatabase(dbPath);
-    const agent = db2.query("SELECT * FROM agents WHERE id = ?").get("test-id") as Record<string, unknown> | undefined;
-    expect(agent).toBeDefined();
-    expect(agent!["name"]).toBe("test-agent");
-  });
-});
-
-describe("closeDatabase", () => {
-  test("closes the database and allows reset", () => {
-    const dbPath = join(tempDir, "test.db");
-    getDatabase(dbPath);
-    closeDatabase();
-    resetDatabase();
-
-    // Should be able to open a new database
-    const dbPath2 = join(tempDir, "test2.db");
-    const db2 = getDatabase(dbPath2);
-    expect(db2).toBeDefined();
-  });
-
-  test("is a no-op when no database is open", () => {
-    // Should not throw
-    closeDatabase();
-  });
-});
-
-describe("resetDatabase", () => {
-  test("clears the singleton so next getDatabase creates new instance", () => {
-    const dbPath1 = join(tempDir, "test1.db");
-    const db1 = getDatabase(dbPath1);
-    closeDatabase();
-    resetDatabase();
-
-    const dbPath2 = join(tempDir, "test2.db");
-    const db2 = getDatabase(dbPath2);
-    expect(db2).not.toBe(db1);
-  });
-});
-
-describe("getDbPath", () => {
-  test("returns the db_path from config", async () => {
-    const { getDbPath } = await import("../db/database.js");
-    const path = getDbPath();
-    expect(typeof path).toBe("string");
-    expect(path).toContain("recordings.db");
-  });
-});
-
-describe("shortUuid", () => {
-  test("returns an 8-character string", () => {
-    const id = shortUuid();
-    expect(id).toHaveLength(8);
-  });
-
-  test("returns different values on each call", () => {
-    const ids = new Set(Array.from({ length: 100 }, () => shortUuid()));
-    expect(ids.size).toBe(100);
-  });
-
-  test("only contains valid UUID characters", () => {
-    const id = shortUuid();
-    expect(id).toMatch(/^[0-9a-f]{8}$/);
-  });
-});