amical/apps/desktop/tests/helpers/fixtures.ts

import type { TestDatabase } from "./test-db";
import * as schema from "@db/schema";
import type {
  NewTranscription,
  NewVocabulary,
  NewModel,
  NewAppSettings,
  NewNote,
  AppSettingsData,
} from "@db/schema";

/**
 * Default app settings for testing
 */
export const defaultAppSettings: AppSettingsData = {
  formatterConfig: {
    model: "gpt-4o-mini",
    enabled: false,
  },
  ui: {
    theme: "system",
  },
  transcription: {
    language: "en",
    autoTranscribe: true,
    confidenceThreshold: 0.7,
    enablePunctuation: true,
    enableTimestamps: false,
    preloadWhisperModel: false,
  },
  recording: {
    defaultFormat: "wav",
    sampleRate: 16000,
    autoStopSilence: true,
    silenceThreshold: -45,
    maxRecordingDuration: 600,
  },
  shortcuts: {
    pushToTalk: "CommandOrControl+Shift+Space",
    toggleRecording: "CommandOrControl+Shift+R",
    toggleWindow: "CommandOrControl+Shift+W",
  },
  modelProvidersConfig: {
    defaultSpeechModel: "local-whisper:ggml-base.en",
  },
  dictation: {
    autoDetectEnabled: true,
    selectedLanguage: "en",
  },
  preferences: {
    launchAtLogin: false,
    minimizeToTray: true,
    showWidgetWhileInactive: true,
  },
  telemetry: {
    enabled: false,
  },
  auth: {
    isAuthenticated: false,
    idToken: null,
    refreshToken: null,
    expiresAt: null,
  },
};

/**
 * Sample transcriptions for testing
 */
export const sampleTranscriptions: NewTranscription[] = [
  {
    text: "This is a test transcription",
    language: "en",
    confidence: 0.95,
    duration: 5,
    speechModel: "whisper-base",
    formattingModel: null,
  },
  {
    text: "Another test transcription with more content",
    language: "en",
    confidence: 0.88,
    duration: 8,
    speechModel: "whisper-base",
    formattingModel: "gpt-4o-mini",
  },
  {
    text: "A third transcription for comprehensive testing",
    language: "en",
    confidence: 0.92,
    duration: 6,
    speechModel: "whisper-large",
    formattingModel: null,
  },
];

/**
 * Sample vocabulary items for testing
 */
export const sampleVocabulary: NewVocabulary[] = [
  {
    word: "Amical",
    replacementWord: null,
    isReplacement: false,
    usageCount: 5,
  },
  {
    word: "API",
    replacementWord: null,
    isReplacement: false,
    usageCount: 3,
  },
  {
    word: "teh",
    replacementWord: "the",
    isReplacement: true,
    usageCount: 2,
  },
];

/**
 * Sample models for testing
 */
export const sampleModels: NewModel[] = [
  {
    id: "ggml-base.en",
    provider: "local-whisper",
    name: "Whisper Base English",
    type: "speech",
    size: "~147 MB",
    description: "Optimized for English transcription",
    localPath: "/test/models/ggml-base.en.bin",
    sizeBytes: 147964211,
    checksum: "test-checksum-base",
    downloadedAt: new Date(),
    speed: 4,
    accuracy: 3,
  },
  {
    id: "gpt-4o-mini",
    provider: "openrouter",
    name: "GPT-4o Mini",
    type: "language",
    context: "128k",
    description: "Fast and efficient language model",
    speed: 5,
    accuracy: 4,
  },
];

/**
 * Sample notes for testing
 */
export const sampleNotes: NewNote[] = [
  {
    title: "Test Note 1",
    content: "This is the first test note",
    icon: "📝",
  },
  {
    title: "Test Note 2",
    content: "This is the second test note with more content",
    icon: "📄",
  },
];

/**
 * Fixture presets
 */
export const fixtures = {
  /**
   * Empty database with only default settings
   */
  empty: async (testDb: TestDatabase) => {
    // Clear existing settings first
    await testDb.db.delete(schema.appSettings);
    // Insert default settings
    await testDb.db.insert(schema.appSettings).values({
      id: 1,
      data: defaultAppSettings,
      version: 1,
    });
  },

  /**
   * Database with existing transcriptions
   */
  withTranscriptions: async (testDb: TestDatabase) => {
    await fixtures.empty(testDb);
    await testDb.db.insert(schema.transcriptions).values(sampleTranscriptions);
  },

  /**
   * Database with vocabulary items
   */
  withVocabulary: async (testDb: TestDatabase) => {
    await fixtures.empty(testDb);
    await testDb.db.insert(schema.vocabulary).values(sampleVocabulary);
  },

  /**
   * Database with downloaded models
   */
  withModels: async (testDb: TestDatabase) => {
    await fixtures.empty(testDb);
    await testDb.db.insert(schema.models).values(sampleModels);
  },

  /**
   * Database with notes
   */
  withNotes: async (testDb: TestDatabase) => {
    await fixtures.empty(testDb);
    await testDb.db.insert(schema.notes).values(sampleNotes);
  },

  /**
   * Full database with all types of data
   */
  full: async (testDb: TestDatabase) => {
    await fixtures.empty(testDb);
    await testDb.db.insert(schema.transcriptions).values(sampleTranscriptions);
    await testDb.db.insert(schema.vocabulary).values(sampleVocabulary);
    await testDb.db.insert(schema.models).values(sampleModels);
    await testDb.db.insert(schema.notes).values(sampleNotes);
  },

  /**
   * Database with custom settings
   */
  withCustomSettings: async (
    testDb: TestDatabase,
    settings: Partial<AppSettingsData>,
  ) => {
    // Clear existing settings first
    await testDb.db.delete(schema.appSettings);
    // Insert custom settings
    await testDb.db.insert(schema.appSettings).values({
      id: 1,
      data: { ...defaultAppSettings, ...settings },
      version: 1,
    });
  },

  /**
   * Database with authenticated user
   */
  withAuth: async (testDb: TestDatabase) => {
    await fixtures.withCustomSettings(testDb, {
      auth: {
        isAuthenticated: true,
        idToken: "test-id-token",
        refreshToken: "test-refresh-token",
        expiresAt: Date.now() + 3600000, // 1 hour from now
        userInfo: {
          sub: "test-user-123",
          email: "test@example.com",
          name: "Test User",
        },
      },
    });
  },
};

/**
 * Helper to seed specific data
 */
export async function seedDatabase(
  testDb: TestDatabase,
  fixture: keyof typeof fixtures | ((testDb: TestDatabase) => Promise<void>),
): Promise<void> {
  if (typeof fixture === "function") {
    await fixture(testDb);
  } else {
    await fixtures[fixture](testDb);
  }
}