markupr 2.1.8

package/tests/unit/appViewState.test.ts

@@ -0,0 +1,281 @@
+/**
+ * App.tsx View State & Integration Logic Tests
+ *
+ * Tests the view-state pattern and component wiring logic added to App.tsx.
+ * Since we're in a Node environment (no DOM), we test the logic layer:
+ * - View state transitions
+ * - mapPopoverState mapping
+ * - formatDuration helper
+ * - formatRelativeTime helper
+ * - State machine integration behavior
+ */
+
+import { describe, it, expect } from 'vitest';
+import type { SessionState } from '../../src/shared/types';
+
+// ============================================================================
+// Extract and test pure functions from App.tsx
+// (These are module-scoped functions we can test without rendering)
+// ============================================================================
+
+// Replicate the pure functions from App.tsx for testing
+function formatDuration(durationMs: number): string {
+  const seconds = Math.floor(durationMs / 1000);
+  const mins = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+}
+
+function formatRelativeTime(timestamp: number): string {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const minute = 60_000;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+
+  if (diff < minute) return 'just now';
+  if (diff < hour) return `${Math.floor(diff / minute)}m ago`;
+  if (diff < day) return `${Math.floor(diff / hour)}h ago`;
+  return `${Math.floor(diff / day)}d ago`;
+}
+
+function formatCaptureTrigger(trigger?: 'pause' | 'manual' | 'voice-command'): string {
+  switch (trigger) {
+    case 'manual':
+      return 'Manual Capture';
+    case 'voice-command':
+      return 'Voice Cue Capture';
+    default:
+      return 'Auto Pause Capture';
+  }
+}
+
+function mapPopoverState(state: SessionState): 'idle' | 'recording' | 'processing' | 'complete' | 'error' {
+  if (state === 'recording' || state === 'starting') return 'recording';
+  if (state === 'stopping' || state === 'processing') return 'processing';
+  if (state === 'complete') return 'complete';
+  if (state === 'error') return 'error';
+  return 'idle';
+}
+
+// ============================================================================
+// AppView type definition (mirrors App.tsx)
+// ============================================================================
+
+type AppView = 'main' | 'settings' | 'history' | 'shortcuts';
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('formatDuration', () => {
+  it('formats zero duration', () => {
+    expect(formatDuration(0)).toBe('00:00');
+  });
+
+  it('formats seconds only', () => {
+    expect(formatDuration(45000)).toBe('00:45');
+  });
+
+  it('formats minutes and seconds', () => {
+    expect(formatDuration(125000)).toBe('02:05');
+  });
+
+  it('formats large durations', () => {
+    expect(formatDuration(3600000)).toBe('60:00');
+  });
+
+  it('truncates partial seconds', () => {
+    expect(formatDuration(1500)).toBe('00:01');
+  });
+});
+
+describe('formatRelativeTime', () => {
+  it('formats recent timestamps as "just now"', () => {
+    const recent = Date.now() - 30000; // 30 seconds ago
+    expect(formatRelativeTime(recent)).toBe('just now');
+  });
+
+  it('formats minutes ago', () => {
+    const fiveMinAgo = Date.now() - 300000;
+    expect(formatRelativeTime(fiveMinAgo)).toBe('5m ago');
+  });
+
+  it('formats hours ago', () => {
+    const twoHoursAgo = Date.now() - 7200000;
+    expect(formatRelativeTime(twoHoursAgo)).toBe('2h ago');
+  });
+
+  it('formats days ago', () => {
+    const threeDaysAgo = Date.now() - 259200000;
+    expect(formatRelativeTime(threeDaysAgo)).toBe('3d ago');
+  });
+});
+
+describe('formatCaptureTrigger', () => {
+  it('formats manual trigger', () => {
+    expect(formatCaptureTrigger('manual')).toBe('Manual Capture');
+  });
+
+  it('formats voice-command trigger', () => {
+    expect(formatCaptureTrigger('voice-command')).toBe('Voice Cue Capture');
+  });
+
+  it('formats undefined trigger as pause', () => {
+    expect(formatCaptureTrigger(undefined)).toBe('Auto Pause Capture');
+  });
+
+  it('formats pause trigger as auto', () => {
+    expect(formatCaptureTrigger('pause')).toBe('Auto Pause Capture');
+  });
+});
+
+describe('mapPopoverState', () => {
+  it('maps idle to idle', () => {
+    expect(mapPopoverState('idle')).toBe('idle');
+  });
+
+  it('maps starting to recording', () => {
+    expect(mapPopoverState('starting')).toBe('recording');
+  });
+
+  it('maps recording to recording', () => {
+    expect(mapPopoverState('recording')).toBe('recording');
+  });
+
+  it('maps stopping to processing', () => {
+    expect(mapPopoverState('stopping')).toBe('processing');
+  });
+
+  it('maps processing to processing', () => {
+    expect(mapPopoverState('processing')).toBe('processing');
+  });
+
+  it('maps complete to complete', () => {
+    expect(mapPopoverState('complete')).toBe('complete');
+  });
+
+  it('maps error to error', () => {
+    expect(mapPopoverState('error')).toBe('error');
+  });
+});
+
+describe('AppView type system', () => {
+  it('has valid view states', () => {
+    const views: AppView[] = ['main', 'settings', 'history', 'shortcuts'];
+    expect(views).toHaveLength(4);
+  });
+
+  it('view transitions are valid', () => {
+    // Simulate navigation flow
+    let currentView: AppView = 'main';
+
+    // Navigate to settings
+    currentView = 'settings';
+    expect(currentView).toBe('settings');
+
+    // Navigate back
+    currentView = 'main';
+    expect(currentView).toBe('main');
+
+    // Navigate to history
+    currentView = 'history';
+    expect(currentView).toBe('history');
+
+    // Navigate to shortcuts
+    currentView = 'shortcuts';
+    expect(currentView).toBe('shortcuts');
+  });
+
+  it('recording forces view back to main', () => {
+    // Simulate the behavior: when recording starts, currentView resets to main
+    let currentView: AppView = 'settings';
+    const sessionState: SessionState = 'recording';
+
+    // This mirrors the logic in App.tsx onStateChange handler
+    if (sessionState === 'recording') {
+      currentView = 'main';
+    }
+
+    expect(currentView).toBe('main');
+  });
+});
+
+describe('Component rendering conditions', () => {
+  it('CountdownTimer shows only when idle and countdown > 0', () => {
+    const state: SessionState = 'idle';
+    const countdownDuration = 3;
+    const showCountdown = true;
+
+    const shouldRender = showCountdown && countdownDuration > 0 && state === 'idle';
+    expect(shouldRender).toBe(true);
+  });
+
+  it('CountdownTimer hidden when countdown is 0', () => {
+    const countdownDuration = 0;
+    const showCountdown = true;
+
+    const shouldRender = showCountdown && countdownDuration > 0;
+    expect(shouldRender).toBe(false);
+  });
+
+  it('CompactAudioIndicator shows during recording when setting enabled', () => {
+    const state: SessionState = 'recording';
+    const showAudioWaveform = true;
+
+    const shouldRender = state === 'recording' && showAudioWaveform;
+    expect(shouldRender).toBe(true);
+  });
+
+  it('CompactAudioIndicator hidden when setting disabled', () => {
+    const state: SessionState = 'recording';
+    const showAudioWaveform = false;
+
+    const shouldRender = state === 'recording' && showAudioWaveform;
+    expect(shouldRender).toBe(false);
+  });
+
+  it('RecordingOverlay shows only during recording', () => {
+    const states: SessionState[] = ['idle', 'starting', 'recording', 'stopping', 'processing', 'complete', 'error'];
+    const results = states.map((s) => ({ state: s, shows: s === 'recording' }));
+
+    expect(results.find((r) => r.state === 'recording')?.shows).toBe(true);
+    expect(results.find((r) => r.state === 'idle')?.shows).toBe(false);
+    expect(results.find((r) => r.state === 'complete')?.shows).toBe(false);
+  });
+
+  it('SettingsPanel visibility tied to currentView', () => {
+    const views: AppView[] = ['main', 'settings', 'history', 'shortcuts'];
+    const settingsVisible = views.map((v) => v === 'settings');
+
+    expect(settingsVisible).toEqual([false, true, false, false]);
+  });
+
+  it('SessionHistory visibility tied to currentView', () => {
+    const views: AppView[] = ['main', 'settings', 'history', 'shortcuts'];
+    const historyVisible = views.map((v) => v === 'history');
+
+    expect(historyVisible).toEqual([false, false, true, false]);
+  });
+
+  it('KeyboardShortcuts visibility tied to currentView', () => {
+    const views: AppView[] = ['main', 'settings', 'history', 'shortcuts'];
+    const shortcutsVisible = views.map((v) => v === 'shortcuts');
+
+    expect(shortcutsVisible).toEqual([false, false, false, true]);
+  });
+
+  it('primary button disabled during transient states', () => {
+    const states: SessionState[] = ['idle', 'starting', 'recording', 'stopping', 'processing', 'complete', 'error'];
+    const disabled = states.map((s) => s === 'starting' || s === 'stopping' || s === 'processing');
+
+    expect(disabled).toEqual([false, true, false, true, true, false, false]);
+  });
+
+  it('manual capture only available during recording', () => {
+    const states: SessionState[] = ['idle', 'starting', 'recording', 'stopping', 'processing', 'complete', 'error'];
+    const available = states.map((s) => s === 'recording');
+
+    expect(available).toEqual([false, false, true, false, false, false, false]);
+  });
+});

package/tests/unit/audioIpcChannels.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { AUDIO_IPC_CHANNELS } from '../../src/main/audio/AudioCapture';
+import { IPC_CHANNELS } from '../../src/shared/types';
+
+describe('Audio IPC Channel Mapping', () => {
+  it('uses the shared IPC channel names expected by preload', () => {
+    expect(AUDIO_IPC_CHANNELS.REQUEST_DEVICES).toBe(IPC_CHANNELS.AUDIO_REQUEST_DEVICES);
+    expect(AUDIO_IPC_CHANNELS.START_CAPTURE).toBe(IPC_CHANNELS.AUDIO_START_CAPTURE);
+    expect(AUDIO_IPC_CHANNELS.STOP_CAPTURE).toBe(IPC_CHANNELS.AUDIO_STOP_CAPTURE);
+    expect(AUDIO_IPC_CHANNELS.SET_DEVICE).toBe(IPC_CHANNELS.AUDIO_SET_DEVICE);
+    expect(AUDIO_IPC_CHANNELS.AUDIO_CHUNK).toBe(IPC_CHANNELS.AUDIO_CHUNK);
+    expect(AUDIO_IPC_CHANNELS.DEVICES_RESPONSE).toBe(IPC_CHANNELS.AUDIO_DEVICES_RESPONSE);
+    expect(AUDIO_IPC_CHANNELS.CAPTURE_ERROR).toBe(IPC_CHANNELS.AUDIO_CAPTURE_ERROR);
+    expect(AUDIO_IPC_CHANNELS.CAPTURE_STARTED).toBe(IPC_CHANNELS.AUDIO_CAPTURE_STARTED);
+    expect(AUDIO_IPC_CHANNELS.CAPTURE_STOPPED).toBe(IPC_CHANNELS.AUDIO_CAPTURE_STOPPED);
+  });
+});