markupr 2.1.8 → 2.5.0

package/tests/unit/sessionController.test.ts

@@ -1,515 +0,0 @@
-/**
- * SessionController Unit Tests
- *
- * Tests the core session orchestration logic:
- * - State machine transitions
- * - Session lifecycle (start, stop, cancel)
- * - Status tracking
- * - Error handling
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { EventEmitter } from 'events';
-
-// =============================================================================
-// Mocks
-// =============================================================================
-
-// Mock audio capture service
-const createMockAudioCapture = () => ({
-  _events: new EventEmitter(),
-  start: vi.fn(() => Promise.resolve()),
-  stop: vi.fn(),
-  setMainWindow: vi.fn(),
-  onAudioChunk: vi.fn((callback) => {
-    createMockAudioCapture._events.on('audioChunk', callback);
-    return () => createMockAudioCapture._events.off('audioChunk', callback);
-  }),
-  onVoiceActivity: vi.fn((callback) => {
-    createMockAudioCapture._events.on('voiceActivity', callback);
-    return () => createMockAudioCapture._events.off('voiceActivity', callback);
-  }),
-  onError: vi.fn((callback) => {
-    createMockAudioCapture._events.on('error', callback);
-    return () => createMockAudioCapture._events.off('error', callback);
-  }),
-});
-
-// Shared event emitter for mocks
-createMockAudioCapture._events = new EventEmitter();
-
-// Mock screen capture service
-const createMockScreenCapture = () => ({
-  capture: vi.fn(() =>
-    Promise.resolve({
-      id: `screenshot-${Date.now()}`,
-      buffer: Buffer.from('mock-image'),
-      width: 1920,
-      height: 1080,
-      timestamp: Date.now(),
-    })
-  ),
-});
-
-// Mock transcription service
-const createMockTranscriptionService = () => {
-  const events = new EventEmitter();
-  return {
-    _events: events,
-    configure: vi.fn(),
-    start: vi.fn(() => Promise.resolve()),
-    stop: vi.fn(),
-    sendAudio: vi.fn(),
-    onTranscript: vi.fn((callback) => {
-      events.on('transcript', callback);
-      return () => events.off('transcript', callback);
-    }),
-    onUtteranceEnd: vi.fn((callback) => {
-      events.on('utteranceEnd', callback);
-      return () => events.off('utteranceEnd', callback);
-    }),
-    onError: vi.fn((callback) => {
-      events.on('error', callback);
-      return () => events.off('error', callback);
-    }),
-    emitTranscript: (result: { text: string; isFinal: boolean; confidence: number; timestamp: number }) => {
-      events.emit('transcript', result);
-    },
-    emitUtteranceEnd: (timestamp: number) => {
-      events.emit('utteranceEnd', timestamp);
-    },
-  };
-};
-
-// Mock electron-store
-vi.mock('electron-store', () => ({
-  default: vi.fn().mockImplementation(() => ({
-    get: vi.fn((key: string, defaultValue?: unknown) => defaultValue),
-    set: vi.fn(),
-    delete: vi.fn(),
-    clear: vi.fn(),
-  })),
-}));
-
-// Mock electron
-vi.mock('electron', () => ({
-  BrowserWindow: vi.fn(),
-  app: {
-    getPath: vi.fn(() => '/tmp'),
-    getName: vi.fn(() => 'markupr'),
-    getVersion: vi.fn(() => '0.4.0'),
-  },
-}));
-
-// =============================================================================
-// Mock Session Controller (Isolated for Testing)
-// =============================================================================
-
-/**
- * Simplified SessionController for testing state machine logic
- * without Electron dependencies
- */
-class TestableSessionController {
-  private state: 'idle' | 'recording' | 'processing' | 'complete' = 'idle';
-  private session: {
-    id: string;
-    startTime: number;
-    endTime?: number;
-    state: string;
-    sourceId: string;
-    feedbackItems: Array<{ id: string; timestamp: number; text: string; confidence: number }>;
-    transcriptBuffer: Array<{ text: string; isFinal: boolean; confidence: number; timestamp: number }>;
-    screenshotBuffer: Array<{ id: string; timestamp: number; buffer: Buffer; width: number; height: number }>;
-    metadata: { sourceId: string; sourceName?: string };
-  } | null = null;
-
-  private audioCapture = createMockAudioCapture();
-  private screenCapture = createMockScreenCapture();
-  private transcriptionService = createMockTranscriptionService();
-
-  // Valid state transitions
-  private readonly STATE_TRANSITIONS: Record<string, string[]> = {
-    idle: ['recording'],
-    recording: ['processing', 'idle'],
-    processing: ['complete', 'idle'],
-    complete: ['idle'],
-  };
-
-  getState() {
-    return this.state;
-  }
-
-  getSession() {
-    return this.session;
-  }
-
-  getStatus() {
-    return {
-      state: this.state,
-      duration: this.session ? Date.now() - this.session.startTime : 0,
-      feedbackCount: this.session?.feedbackItems.length ?? 0,
-      screenshotCount: this.session?.screenshotBuffer.length ?? 0,
-    };
-  }
-
-  private transition(newState: 'idle' | 'recording' | 'processing' | 'complete'): boolean {
-    const validTransitions = this.STATE_TRANSITIONS[this.state];
-    if (!validTransitions.includes(newState)) {
-      return false;
-    }
-    this.state = newState;
-    return true;
-  }
-
-  async start(sourceId: string, sourceName?: string): Promise<void> {
-    if (this.state !== 'idle') {
-      throw new Error(`Cannot start session from state: ${this.state}`);
-    }
-
-    this.session = {
-      id: `session-${Date.now()}`,
-      startTime: Date.now(),
-      state: 'recording',
-      sourceId,
-      feedbackItems: [],
-      transcriptBuffer: [],
-      screenshotBuffer: [],
-      metadata: { sourceId, sourceName },
-    };
-
-    if (!this.transition('recording')) {
-      this.session = null;
-      throw new Error('Failed to transition to recording state');
-    }
-
-    // Start mock services
-    await this.audioCapture.start();
-    await this.transcriptionService.start();
-  }
-
-  async stop(): Promise<typeof this.session> {
-    if (this.state !== 'recording') {
-      return null;
-    }
-
-    if (!this.session) {
-      return null;
-    }
-
-    this.transition('processing');
-    this.session.state = 'processing';
-
-    // Stop services
-    this.audioCapture.stop();
-    this.transcriptionService.stop();
-
-    // Set end time
-    this.session.endTime = Date.now();
-
-    // Transition to complete
-    this.transition('complete');
-    this.session.state = 'complete';
-
-    return { ...this.session };
-  }
-
-  cancel(): void {
-    if (this.state !== 'recording' && this.state !== 'processing') {
-      return;
-    }
-
-    this.audioCapture.stop();
-    this.transcriptionService.stop();
-    this.session = null;
-    this.state = 'idle';
-  }
-
-  reset(): void {
-    this.audioCapture.stop();
-    this.transcriptionService.stop();
-    this.session = null;
-    this.state = 'idle';
-  }
-
-  addFeedbackItem(item: { text: string; confidence?: number }): { id: string; timestamp: number; text: string; confidence: number } {
-    if (!this.session) {
-      throw new Error('No active session');
-    }
-
-    const feedbackItem = {
-      id: `fb-${Date.now()}`,
-      timestamp: Date.now(),
-      text: item.text,
-      confidence: item.confidence ?? 1.0,
-    };
-
-    this.session.feedbackItems.push(feedbackItem);
-    return feedbackItem;
-  }
-
-  deleteFeedbackItem(id: string): boolean {
-    if (!this.session) {
-      return false;
-    }
-
-    const index = this.session.feedbackItems.findIndex((item) => item.id === id);
-    if (index === -1) {
-      return false;
-    }
-
-    this.session.feedbackItems.splice(index, 1);
-    return true;
-  }
-
-  // Expose mocks for testing
-  getMocks() {
-    return {
-      audioCapture: this.audioCapture,
-      screenCapture: this.screenCapture,
-      transcriptionService: this.transcriptionService,
-    };
-  }
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe('SessionController', () => {
-  let controller: TestableSessionController;
-
-  beforeEach(() => {
-    controller = new TestableSessionController();
-  });
-
-  afterEach(() => {
-    controller.reset();
-  });
-
-  describe('State Machine', () => {
-    it('should start in idle state', () => {
-      expect(controller.getState()).toBe('idle');
-    });
-
-    it('should transition idle -> recording on start', async () => {
-      await controller.start('screen:0:0', 'Test Screen');
-
-      expect(controller.getState()).toBe('recording');
-    });
-
-    it('should transition recording -> processing -> complete on stop', async () => {
-      await controller.start('screen:0:0', 'Test Screen');
-
-      const session = await controller.stop();
-
-      expect(controller.getState()).toBe('complete');
-      expect(session).not.toBeNull();
-      expect(session?.state).toBe('complete');
-    });
-
-    it('should transition back to idle on cancel', async () => {
-      await controller.start('screen:0:0', 'Test Screen');
-
-      controller.cancel();
-
-      expect(controller.getState()).toBe('idle');
-      expect(controller.getSession()).toBeNull();
-    });
-
-    it('should not allow invalid state transitions', async () => {
-      // Cannot start from recording state
-      await controller.start('screen:0:0');
-
-      await expect(controller.start('screen:0:0')).rejects.toThrow();
-    });
-
-    it('should not allow stopping from idle state', async () => {
-      const result = await controller.stop();
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('Session Lifecycle', () => {
-    it('should create a session on start', async () => {
-      await controller.start('screen:0:0', 'Primary Display');
-
-      const session = controller.getSession();
-
-      expect(session).not.toBeNull();
-      expect(session?.sourceId).toBe('screen:0:0');
-      expect(session?.metadata.sourceName).toBe('Primary Display');
-      expect(session?.startTime).toBeDefined();
-      expect(session?.feedbackItems).toHaveLength(0);
-    });
-
-    it('should set end time on stop', async () => {
-      await controller.start('screen:0:0');
-
-      const session = await controller.stop();
-
-      expect(session?.endTime).toBeDefined();
-      expect(session!.endTime!).toBeGreaterThanOrEqual(session!.startTime);
-    });
-
-    it('should track duration during recording', async () => {
-      await controller.start('screen:0:0');
-
-      // Wait a bit
-      await new Promise((r) => setTimeout(r, 50));
-
-      const status = controller.getStatus();
-
-      expect(status.duration).toBeGreaterThan(0);
-    });
-
-    it('should preserve session data through state transitions', async () => {
-      await controller.start('screen:0:0', 'Test');
-
-      // Add feedback
-      controller.addFeedbackItem({ text: 'Test feedback 1' });
-      controller.addFeedbackItem({ text: 'Test feedback 2' });
-
-      const session = await controller.stop();
-
-      expect(session?.feedbackItems).toHaveLength(2);
-      expect(session?.feedbackItems[0].text).toBe('Test feedback 1');
-    });
-  });
-
-  describe('Status Tracking', () => {
-    it('should return correct status when idle', () => {
-      const status = controller.getStatus();
-
-      expect(status.state).toBe('idle');
-      expect(status.duration).toBe(0);
-      expect(status.feedbackCount).toBe(0);
-      expect(status.screenshotCount).toBe(0);
-    });
-
-    it('should track feedback count', async () => {
-      await controller.start('screen:0:0');
-
-      controller.addFeedbackItem({ text: 'Feedback 1' });
-      controller.addFeedbackItem({ text: 'Feedback 2' });
-      controller.addFeedbackItem({ text: 'Feedback 3' });
-
-      const status = controller.getStatus();
-
-      expect(status.feedbackCount).toBe(3);
-    });
-
-    it('should update state in status', async () => {
-      expect(controller.getStatus().state).toBe('idle');
-
-      await controller.start('screen:0:0');
-      expect(controller.getStatus().state).toBe('recording');
-
-      await controller.stop();
-      expect(controller.getStatus().state).toBe('complete');
-    });
-  });
-
-  describe('Feedback Item Management', () => {
-    beforeEach(async () => {
-      await controller.start('screen:0:0');
-    });
-
-    it('should add feedback items', () => {
-      const item = controller.addFeedbackItem({ text: 'Test feedback', confidence: 0.95 });
-
-      expect(item.id).toBeDefined();
-      expect(item.text).toBe('Test feedback');
-      expect(item.confidence).toBe(0.95);
-      expect(item.timestamp).toBeDefined();
-    });
-
-    it('should default confidence to 1.0', () => {
-      const item = controller.addFeedbackItem({ text: 'Test' });
-
-      expect(item.confidence).toBe(1.0);
-    });
-
-    it('should delete feedback items', () => {
-      const item = controller.addFeedbackItem({ text: 'To delete' });
-
-      const deleted = controller.deleteFeedbackItem(item.id);
-
-      expect(deleted).toBe(true);
-      expect(controller.getStatus().feedbackCount).toBe(0);
-    });
-
-    it('should return false when deleting non-existent item', () => {
-      const deleted = controller.deleteFeedbackItem('non-existent-id');
-
-      expect(deleted).toBe(false);
-    });
-
-    it('should throw when adding items without active session', async () => {
-      await controller.stop();
-      controller.reset();
-
-      expect(() => controller.addFeedbackItem({ text: 'Test' })).toThrow('No active session');
-    });
-  });
-
-  describe('Service Integration', () => {
-    it('should start audio capture on session start', async () => {
-      const { audioCapture } = controller.getMocks();
-
-      await controller.start('screen:0:0');
-
-      expect(audioCapture.start).toHaveBeenCalled();
-    });
-
-    it('should start transcription service on session start', async () => {
-      const { transcriptionService } = controller.getMocks();
-
-      await controller.start('screen:0:0');
-
-      expect(transcriptionService.start).toHaveBeenCalled();
-    });
-
-    it('should stop services on session stop', async () => {
-      const { audioCapture, transcriptionService } = controller.getMocks();
-
-      await controller.start('screen:0:0');
-      await controller.stop();
-
-      expect(audioCapture.stop).toHaveBeenCalled();
-      expect(transcriptionService.stop).toHaveBeenCalled();
-    });
-
-    it('should stop services on cancel', async () => {
-      const { audioCapture, transcriptionService } = controller.getMocks();
-
-      await controller.start('screen:0:0');
-      controller.cancel();
-
-      expect(audioCapture.stop).toHaveBeenCalled();
-      expect(transcriptionService.stop).toHaveBeenCalled();
-    });
-  });
-
-  describe('Reset', () => {
-    it('should reset to idle state', async () => {
-      await controller.start('screen:0:0');
-      controller.addFeedbackItem({ text: 'Test' });
-
-      controller.reset();
-
-      expect(controller.getState()).toBe('idle');
-      expect(controller.getSession()).toBeNull();
-    });
-
-    it('should stop all services on reset', async () => {
-      const { audioCapture, transcriptionService } = controller.getMocks();
-
-      await controller.start('screen:0:0');
-      controller.reset();
-
-      expect(audioCapture.stop).toHaveBeenCalled();
-      expect(transcriptionService.stop).toHaveBeenCalled();
-    });
-  });
-});

package/tests/unit/tierManager.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { TierManager } from '../../src/main/transcription/TierManager';
-import type { TierStatus } from '../../src/main/transcription/types';
-
-function makeStatuses(
-  overrides: Partial<Record<TierStatus['tier'], TierStatus>>
-): TierStatus[] {
-  const defaults: TierStatus[] = [
-    { tier: 'whisper', available: false, reason: 'Model not downloaded' },
-    { tier: 'timer-only', available: true },
-  ];
-
-  return defaults.map((status) => overrides[status.tier] ?? status);
-}
-
-describe('TierManager preference selection', () => {
-  it('prefers Whisper by default when auto mode and Whisper is available', async () => {
-    const manager = new TierManager();
-    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
-      makeStatuses({
-        whisper: { tier: 'whisper', available: true },
-      })
-    );
-
-    const selected = await manager.selectBestTier();
-    expect(selected).toBe('whisper');
-  });
-
-  it('uses preferred Whisper when available', async () => {
-    const manager = new TierManager();
-    manager.setPreferredTier('whisper');
-    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
-      makeStatuses({
-        whisper: { tier: 'whisper', available: true },
-      })
-    );
-
-    const selected = await manager.selectBestTier();
-    expect(selected).toBe('whisper');
-  });
-
-  it('falls back to timer-only when preferred tier is unavailable', async () => {
-    const manager = new TierManager();
-    manager.setPreferredTier('whisper');
-    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
-      makeStatuses({
-        whisper: { tier: 'whisper', available: false, reason: 'No model' },
-      })
-    );
-
-    const selected = await manager.selectBestTier();
-    expect(selected).toBe('timer-only');
-  });
-
-  it('rejects non-transcribing preferred tiers in strict feedback mode', () => {
-    const manager = new TierManager();
-    expect(() => manager.setPreferredTier('timer-only')).toThrow(
-      'does not provide transcription'
-    );
-  });
-});