markupr 2.1.8 → 2.5.0

package/tests/unit/onboardingFlow.test.ts

@@ -1,345 +0,0 @@
-/**
- * Onboarding Flow Logic Tests
- *
- * Tests the onboarding wizard logic layer:
- * - Step transitions and ordering
- * - API key step can be skipped
- * - Permissions flow (microphone, screen)
- * - Navigation (forward, back)
- * - Progress dots track current step
- */
-
-import { describe, it, expect } from 'vitest';
-
-// ============================================================================
-// Replicate onboarding flow logic for testability
-// (These mirror the pure logic from Onboarding.tsx)
-// ============================================================================
-
-type OnboardingStep = 'welcome' | 'microphone' | 'screen' | 'apikey' | 'success';
-
-const STEPS: OnboardingStep[] = ['welcome', 'microphone', 'screen', 'apikey', 'success'];
-
-interface PermissionStatus {
-  microphone: 'unknown' | 'pending' | 'granted' | 'denied';
-  screen: 'unknown' | 'pending' | 'granted' | 'denied';
-}
-
-interface ApiKeyStatus {
-  value: string;
-  testing: boolean;
-  valid: boolean | null;
-  error: string | null;
-}
-
-function getStepIndex(step: OnboardingStep): number {
-  return STEPS.indexOf(step);
-}
-
-function isLastStep(step: OnboardingStep): boolean {
-  return step === 'success';
-}
-
-function isFirstStep(step: OnboardingStep): boolean {
-  return step === 'welcome';
-}
-
-function canProceedFromMicrophone(permissions: PermissionStatus): boolean {
-  return permissions.microphone === 'granted';
-}
-
-function canProceedFromScreen(permissions: PermissionStatus): boolean {
-  return permissions.screen === 'granted';
-}
-
-function canProceedFromApiKey(apiKey: ApiKeyStatus): boolean {
-  return apiKey.valid === true;
-}
-
-function canSkipApiKey(): boolean {
-  // API key step is always skippable (uses local Whisper instead)
-  return true;
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('Onboarding Flow', () => {
-  // ========================================================================
-  // Step ordering
-  // ========================================================================
-
-  describe('step ordering', () => {
-    it('should have 5 steps in correct order', () => {
-      expect(STEPS).toEqual(['welcome', 'microphone', 'screen', 'apikey', 'success']);
-    });
-
-    it('should start at welcome step', () => {
-      const initialStep: OnboardingStep = 'welcome';
-      expect(getStepIndex(initialStep)).toBe(0);
-    });
-
-    it('should end at success step', () => {
-      expect(isLastStep('success')).toBe(true);
-      expect(isLastStep('welcome')).toBe(false);
-    });
-
-    it('welcome is the first step', () => {
-      expect(isFirstStep('welcome')).toBe(true);
-      expect(isFirstStep('microphone')).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // Forward navigation
-  // ========================================================================
-
-  describe('forward navigation', () => {
-    it('welcome -> microphone', () => {
-      const nextStep: OnboardingStep = 'microphone';
-      expect(getStepIndex(nextStep)).toBe(1);
-    });
-
-    it('microphone -> screen (when granted)', () => {
-      const permissions: PermissionStatus = { microphone: 'granted', screen: 'unknown' };
-      expect(canProceedFromMicrophone(permissions)).toBe(true);
-    });
-
-    it('microphone blocked when denied', () => {
-      const permissions: PermissionStatus = { microphone: 'denied', screen: 'unknown' };
-      expect(canProceedFromMicrophone(permissions)).toBe(false);
-    });
-
-    it('microphone blocked when pending', () => {
-      const permissions: PermissionStatus = { microphone: 'pending', screen: 'unknown' };
-      expect(canProceedFromMicrophone(permissions)).toBe(false);
-    });
-
-    it('screen -> apikey (when granted)', () => {
-      const permissions: PermissionStatus = { microphone: 'granted', screen: 'granted' };
-      expect(canProceedFromScreen(permissions)).toBe(true);
-    });
-
-    it('screen blocked when denied', () => {
-      const permissions: PermissionStatus = { microphone: 'granted', screen: 'denied' };
-      expect(canProceedFromScreen(permissions)).toBe(false);
-    });
-
-    it('apikey -> success (when valid)', () => {
-      const apiKey: ApiKeyStatus = { value: 'dg-test-key', testing: false, valid: true, error: null };
-      expect(canProceedFromApiKey(apiKey)).toBe(true);
-    });
-
-    it('apikey blocked when invalid', () => {
-      const apiKey: ApiKeyStatus = { value: 'bad-key', testing: false, valid: false, error: 'Invalid API key' };
-      expect(canProceedFromApiKey(apiKey)).toBe(false);
-    });
-
-    it('apikey blocked when untested', () => {
-      const apiKey: ApiKeyStatus = { value: 'some-key', testing: false, valid: null, error: null };
-      expect(canProceedFromApiKey(apiKey)).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // Backward navigation
-  // ========================================================================
-
-  describe('backward navigation', () => {
-    it('microphone -> welcome', () => {
-      const prevIndex = getStepIndex('microphone') - 1;
-      expect(STEPS[prevIndex]).toBe('welcome');
-    });
-
-    it('screen -> microphone', () => {
-      const prevIndex = getStepIndex('screen') - 1;
-      expect(STEPS[prevIndex]).toBe('microphone');
-    });
-
-    it('apikey -> screen', () => {
-      const prevIndex = getStepIndex('apikey') - 1;
-      expect(STEPS[prevIndex]).toBe('screen');
-    });
-
-    it('cannot go back from welcome', () => {
-      expect(isFirstStep('welcome')).toBe(true);
-      expect(getStepIndex('welcome')).toBe(0);
-    });
-  });
-
-  // ========================================================================
-  // API key skip
-  // ========================================================================
-
-  describe('API key skip', () => {
-    it('API key step is always skippable', () => {
-      expect(canSkipApiKey()).toBe(true);
-    });
-
-    it('skip goes directly to success step', () => {
-      // Mirrors: onSkip={() => goToStep('success')}
-      const targetStep: OnboardingStep = 'success';
-      expect(targetStep).toBe('success');
-      expect(isLastStep(targetStep)).toBe(true);
-    });
-
-    it('skip does not require valid API key', () => {
-      const apiKey: ApiKeyStatus = { value: '', testing: false, valid: null, error: null };
-      // Even with empty key, skip is allowed
-      expect(canSkipApiKey()).toBe(true);
-      expect(canProceedFromApiKey(apiKey)).toBe(false); // Can't proceed, but can skip
-    });
-  });
-
-  // ========================================================================
-  // Progress dots
-  // ========================================================================
-
-  describe('progress dots', () => {
-    it('progress dots hidden on welcome step', () => {
-      const step: OnboardingStep = 'welcome';
-      const showDots = step !== 'welcome' && step !== 'success';
-      expect(showDots).toBe(false);
-    });
-
-    it('progress dots hidden on success step', () => {
-      const step: OnboardingStep = 'success';
-      const showDots = step !== 'welcome' && step !== 'success';
-      expect(showDots).toBe(false);
-    });
-
-    it('progress dots shown for middle steps', () => {
-      const middleSteps: OnboardingStep[] = ['microphone', 'screen', 'apikey'];
-      middleSteps.forEach((step) => {
-        const showDots = step !== 'welcome' && step !== 'success';
-        expect(showDots).toBe(true);
-      });
-    });
-
-    it('current step index tracks correctly', () => {
-      expect(getStepIndex('welcome')).toBe(0);
-      expect(getStepIndex('microphone')).toBe(1);
-      expect(getStepIndex('screen')).toBe(2);
-      expect(getStepIndex('apikey')).toBe(3);
-      expect(getStepIndex('success')).toBe(4);
-    });
-  });
-
-  // ========================================================================
-  // Permission status transitions
-  // ========================================================================
-
-  describe('permission status transitions', () => {
-    it('initial permission state is all unknown', () => {
-      const initial: PermissionStatus = { microphone: 'unknown', screen: 'unknown' };
-      expect(initial.microphone).toBe('unknown');
-      expect(initial.screen).toBe('unknown');
-    });
-
-    it('transitions from unknown to pending to granted', () => {
-      const statuses: PermissionStatus['microphone'][] = ['unknown', 'pending', 'granted'];
-      expect(statuses[0]).toBe('unknown');
-      expect(statuses[1]).toBe('pending');
-      expect(statuses[2]).toBe('granted');
-    });
-
-    it('can transition from unknown directly to denied', () => {
-      const status: PermissionStatus = { microphone: 'denied', screen: 'unknown' };
-      expect(canProceedFromMicrophone(status)).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // Full flow simulation
-  // ========================================================================
-
-  describe('full flow simulation', () => {
-    it('happy path: welcome -> mic -> screen -> apikey -> success', () => {
-      const visited: OnboardingStep[] = [];
-      let current: OnboardingStep = 'welcome';
-
-      // Step 1: Welcome -> Next
-      visited.push(current);
-      current = 'microphone';
-
-      // Step 2: Mic granted -> Next
-      visited.push(current);
-      const perms: PermissionStatus = { microphone: 'granted', screen: 'unknown' };
-      expect(canProceedFromMicrophone(perms)).toBe(true);
-      current = 'screen';
-
-      // Step 3: Screen granted -> Next
-      visited.push(current);
-      perms.screen = 'granted';
-      expect(canProceedFromScreen(perms)).toBe(true);
-      current = 'apikey';
-
-      // Step 4: API key valid -> Next
-      visited.push(current);
-      const apiKey: ApiKeyStatus = { value: 'dg-key', testing: false, valid: true, error: null };
-      expect(canProceedFromApiKey(apiKey)).toBe(true);
-      current = 'success';
-
-      visited.push(current);
-      expect(visited).toEqual(STEPS);
-    });
-
-    it('skip path: welcome -> mic -> screen -> skip apikey -> success', () => {
-      const visited: OnboardingStep[] = [];
-      let current: OnboardingStep = 'welcome';
-
-      visited.push(current);
-      current = 'microphone';
-      visited.push(current);
-      current = 'screen';
-      visited.push(current);
-      current = 'apikey';
-      visited.push(current);
-
-      // Skip API key
-      expect(canSkipApiKey()).toBe(true);
-      current = 'success';
-      visited.push(current);
-
-      expect(visited).toEqual(STEPS);
-      expect(current).toBe('success');
-    });
-
-    it('back-and-forth navigation preserves step order', () => {
-      let current: OnboardingStep = 'welcome';
-
-      // Forward to screen
-      current = 'microphone';
-      current = 'screen';
-      expect(current).toBe('screen');
-
-      // Back to microphone
-      current = STEPS[getStepIndex(current) - 1];
-      expect(current).toBe('microphone');
-
-      // Forward again
-      current = 'screen';
-      current = 'apikey';
-      expect(current).toBe('apikey');
-    });
-  });
-
-  // ========================================================================
-  // Reduced motion
-  // ========================================================================
-
-  describe('reduced motion behavior', () => {
-    it('confetti is disabled when prefers-reduced-motion matches', () => {
-      const prefersReducedMotion = true; // Simulates matchMedia result
-      const showConfetti = !prefersReducedMotion;
-      expect(showConfetti).toBe(false);
-    });
-
-    it('confetti is enabled when prefers-reduced-motion does not match', () => {
-      const prefersReducedMotion = false;
-      const showConfetti = !prefersReducedMotion;
-      expect(showConfetti).toBe(true);
-    });
-  });
-});

package/tests/unit/permissionManager.test.ts

@@ -1,175 +0,0 @@
-/**
- * PermissionManager Unit Tests
- *
- * NOTE: These tests require Electron's systemPreferences API which is only
- * available on macOS. They are skipped in CI (headless Linux) environments.
- *
- * Tests the centralized macOS permission handling:
- * - Permission status checking for microphone, screen, accessibility
- * - checkAllPermissions aggregation
- * - isGranted convenience method
- * - Non-macOS fallback behavior
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { systemPreferences } from 'electron';
-
-// Mock the ErrorHandler used by PermissionManager (must be before import)
-vi.mock('../../src/main/ErrorHandler', () => ({
-  errorHandler: {
-    log: vi.fn(),
-  },
-}));
-
-// Must import after electron mock is set up by tests/setup.ts
-import PermissionManager from '../../src/main/PermissionManager';
-
-// Skip in CI — these tests require Electron's systemPreferences (macOS only)
-const describeOrSkip = process.env.CI ? describe.skip : describe;
-
-describeOrSkip('PermissionManager', () => {
-  let manager: PermissionManager;
-
-  beforeEach(() => {
-    manager = new PermissionManager();
-    vi.clearAllMocks();
-  });
-
-  describe('getPermissionStatus', () => {
-    it('should return microphone status from systemPreferences', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-
-      const status = await manager.getPermissionStatus('microphone');
-
-      expect(status).toBe('granted');
-      expect(systemPreferences.getMediaAccessStatus).toHaveBeenCalledWith('microphone');
-    });
-
-    it('should return screen status from systemPreferences', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('denied');
-
-      const status = await manager.getPermissionStatus('screen');
-
-      expect(status).toBe('denied');
-      expect(systemPreferences.getMediaAccessStatus).toHaveBeenCalledWith('screen');
-    });
-
-    it('should return accessibility status using isTrustedAccessibilityClient', async () => {
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(true);
-
-      const status = await manager.getPermissionStatus('accessibility');
-
-      expect(status).toBe('granted');
-    });
-
-    it('should return denied for accessibility when not trusted', async () => {
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(false);
-
-      const status = await manager.getPermissionStatus('accessibility');
-
-      expect(status).toBe('denied');
-    });
-
-    it('should return unknown for errors', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockImplementation(() => {
-        throw new Error('System error');
-      });
-
-      const status = await manager.getPermissionStatus('microphone');
-
-      expect(status).toBe('unknown');
-    });
-  });
-
-  describe('isGranted', () => {
-    it('should return true when permission is granted', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-
-      const granted = await manager.isGranted('microphone');
-
-      expect(granted).toBe(true);
-    });
-
-    it('should return false when permission is denied', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('denied');
-
-      const granted = await manager.isGranted('microphone');
-
-      expect(granted).toBe(false);
-    });
-
-    it('should return false when permission is not-determined', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
-
-      const granted = await manager.isGranted('screen');
-
-      expect(granted).toBe(false);
-    });
-  });
-
-  describe('checkAllPermissions', () => {
-    it('should return allGranted=true when all required permissions granted', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(true);
-
-      const result = await manager.checkAllPermissions();
-
-      expect(result.allGranted).toBe(true);
-      expect(result.missing).toHaveLength(0);
-      expect(result.state.microphone).toBe('granted');
-      expect(result.state.screen).toBe('granted');
-      expect(result.state.accessibility).toBe('granted');
-    });
-
-    it('should report missing microphone permission', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockImplementation((type: string) => {
-        if (type === 'microphone') return 'denied';
-        return 'granted';
-      });
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(true);
-
-      const result = await manager.checkAllPermissions();
-
-      expect(result.allGranted).toBe(false);
-      expect(result.missing).toContain('microphone');
-      expect(result.missing).not.toContain('screen');
-    });
-
-    it('should report missing screen permission', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockImplementation((type: string) => {
-        if (type === 'screen') return 'not-determined';
-        return 'granted';
-      });
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(true);
-
-      const result = await manager.checkAllPermissions();
-
-      expect(result.allGranted).toBe(false);
-      expect(result.missing).toContain('screen');
-    });
-
-    it('should not report accessibility as missing (it is optional)', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(false);
-
-      const result = await manager.checkAllPermissions();
-
-      // Accessibility is optional so missing array should be empty
-      expect(result.allGranted).toBe(true);
-      expect(result.missing).not.toContain('accessibility');
-      expect(result.state.accessibility).toBe('denied');
-    });
-
-    it('should report multiple missing permissions', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('denied');
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(false);
-
-      const result = await manager.checkAllPermissions();
-
-      expect(result.allGranted).toBe(false);
-      expect(result.missing).toContain('microphone');
-      expect(result.missing).toContain('screen');
-      expect(result.missing).toHaveLength(2);
-    });
-  });
-});