markupr 2.1.8 → 2.5.0

package/tests/unit/permissionManagerExpanded.test.ts

@@ -1,296 +0,0 @@
-/**
- * PermissionManager Expanded Tests
- *
- * Extends the existing permissionManager.test.ts with:
- * - requestPermission flow
- * - showStartupPermissionDialog behavior
- * - openSystemPreferences URL construction
- * - getPermissionStateDescription output
- * - Non-macOS fallback behavior
- * - Edge cases: restricted status, dialog interactions
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { systemPreferences, dialog, shell, app } from 'electron';
-
-// Mock ErrorHandler (must be before import)
-vi.mock('../../src/main/ErrorHandler', () => ({
-  errorHandler: {
-    log: vi.fn(),
-  },
-}));
-
-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 (expanded)', () => {
-  let manager: PermissionManager;
-
-  beforeEach(() => {
-    manager = new PermissionManager();
-    vi.clearAllMocks();
-  });
-
-  // ========================================================================
-  // getPermissionStateDescription
-  // ========================================================================
-
-  describe('getPermissionStateDescription', () => {
-    it('returns "Enabled" for granted', () => {
-      expect(manager.getPermissionStateDescription('microphone', 'granted')).toBe('Enabled');
-    });
-
-    it('returns denied message for denied', () => {
-      const desc = manager.getPermissionStateDescription('microphone', 'denied');
-      expect(desc).toContain('Denied');
-      expect(desc).toContain('System Settings');
-    });
-
-    it('returns not-set message for not-determined', () => {
-      const desc = manager.getPermissionStateDescription('screen', 'not-determined');
-      expect(desc).toContain('Not set');
-    });
-
-    it('returns restricted message for restricted', () => {
-      const desc = manager.getPermissionStateDescription('screen', 'restricted');
-      expect(desc).toContain('Restricted');
-    });
-
-    it('returns Unknown for unknown states', () => {
-      expect(manager.getPermissionStateDescription('microphone', 'something-else')).toBe('Unknown');
-    });
-  });
-
-  // ========================================================================
-  // requestPermission - microphone
-  // ========================================================================
-
-  describe('requestPermission - microphone', () => {
-    it('returns true if already granted', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-
-      const result = await manager.requestPermission('microphone');
-
-      expect(result).toBe(true);
-    });
-
-    it('triggers system prompt for not-determined and returns true if granted', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
-      vi.mocked(systemPreferences.askForMediaAccess).mockResolvedValue(true);
-
-      const result = await manager.requestPermission('microphone');
-
-      expect(systemPreferences.askForMediaAccess).toHaveBeenCalledWith('microphone');
-      expect(result).toBe(true);
-    });
-
-    it('shows dialog when not-determined and user denies system prompt', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('not-determined');
-      vi.mocked(systemPreferences.askForMediaAccess).mockResolvedValue(false);
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1, checkboxChecked: false });
-
-      const result = await manager.requestPermission('microphone');
-
-      expect(result).toBe(false);
-    });
-
-    it('shows dialog for denied status', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('denied');
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1, checkboxChecked: false });
-
-      const result = await manager.requestPermission('microphone');
-
-      expect(dialog.showMessageBox).toHaveBeenCalled();
-      expect(result).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // requestPermission - screen
-  // ========================================================================
-
-  describe('requestPermission - screen', () => {
-    it('returns true if already granted', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-
-      const result = await manager.requestPermission('screen');
-
-      expect(result).toBe(true);
-    });
-
-    it('shows dialog for denied status', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('denied');
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1, checkboxChecked: false });
-
-      const result = await manager.requestPermission('screen');
-
-      expect(result).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // requestPermission - accessibility
-  // ========================================================================
-
-  describe('requestPermission - accessibility', () => {
-    it('returns true if already trusted', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(true);
-
-      const result = await manager.requestPermission('accessibility');
-
-      expect(result).toBe(true);
-    });
-
-    it('shows dialog when not trusted', async () => {
-      // First call: getPermissionStatus check returns 'denied'
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockReturnValue(false);
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('granted');
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1, checkboxChecked: false });
-
-      const result = await manager.requestPermission('accessibility');
-
-      expect(result).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // showStartupPermissionDialog
-  // ========================================================================
-
-  describe('showStartupPermissionDialog', () => {
-    it('does nothing when no permissions missing', async () => {
-      await manager.showStartupPermissionDialog([]);
-
-      expect(dialog.showMessageBox).not.toHaveBeenCalled();
-    });
-
-    it('shows dialog listing missing permissions', async () => {
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1, checkboxChecked: false });
-
-      await manager.showStartupPermissionDialog(['microphone', 'screen']);
-
-      expect(dialog.showMessageBox).toHaveBeenCalled();
-      const options = vi.mocked(dialog.showMessageBox).mock.calls[0][0] as Electron.MessageBoxOptions;
-      expect(options.detail).toContain('Microphone Access');
-      expect(options.detail).toContain('Screen Recording');
-    });
-
-    it('opens system preferences when user clicks "Set Up Permissions"', async () => {
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 0, checkboxChecked: false });
-
-      await manager.showStartupPermissionDialog(['microphone']);
-
-      expect(shell.openExternal).toHaveBeenCalledWith(
-        expect.stringContaining('Privacy_Microphone')
-      );
-    });
-
-    it('quits app when user clicks "Quit"', async () => {
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 2, checkboxChecked: false });
-
-      await manager.showStartupPermissionDialog(['microphone']);
-
-      expect(app.quit).toHaveBeenCalled();
-    });
-
-    it('does nothing when user clicks "Continue Anyway"', async () => {
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1, checkboxChecked: false });
-
-      await manager.showStartupPermissionDialog(['microphone']);
-
-      expect(shell.openExternal).not.toHaveBeenCalled();
-      expect(app.quit).not.toHaveBeenCalled();
-    });
-  });
-
-  // ========================================================================
-  // openSystemPreferences
-  // ========================================================================
-
-  describe('openSystemPreferences', () => {
-    it('opens microphone privacy pane on macOS', async () => {
-      await manager.openSystemPreferences('microphone');
-
-      expect(shell.openExternal).toHaveBeenCalledWith(
-        'x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone'
-      );
-    });
-
-    it('opens screen capture privacy pane on macOS', async () => {
-      await manager.openSystemPreferences('screen');
-
-      expect(shell.openExternal).toHaveBeenCalledWith(
-        'x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture'
-      );
-    });
-
-    it('opens accessibility privacy pane on macOS', async () => {
-      await manager.openSystemPreferences('accessibility');
-
-      expect(shell.openExternal).toHaveBeenCalledWith(
-        'x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility'
-      );
-    });
-  });
-
-  // ========================================================================
-  // Error handling
-  // ========================================================================
-
-  describe('error handling', () => {
-    it('returns unknown when getMediaAccessStatus throws', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockImplementation(() => {
-        throw new Error('System API unavailable');
-      });
-
-      const status = await manager.getPermissionStatus('microphone');
-
-      expect(status).toBe('unknown');
-    });
-
-    it('returns unknown when isTrustedAccessibilityClient throws', async () => {
-      vi.mocked(systemPreferences.isTrustedAccessibilityClient).mockImplementation(() => {
-        throw new Error('System API unavailable');
-      });
-
-      const status = await manager.getPermissionStatus('accessibility');
-
-      expect(status).toBe('unknown');
-    });
-
-    it('isGranted returns false for unknown status', async () => {
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockImplementation(() => {
-        throw new Error('System error');
-      });
-
-      const granted = await manager.isGranted('microphone');
-
-      expect(granted).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // setMainWindow
-  // ========================================================================
-
-  describe('setMainWindow', () => {
-    it('uses main window for dialog when set', async () => {
-      const mockWindow = { webContents: { send: vi.fn() } };
-      manager.setMainWindow(mockWindow as never);
-
-      vi.mocked(systemPreferences.getMediaAccessStatus).mockReturnValue('denied');
-      vi.mocked(dialog.showMessageBox).mockResolvedValue({ response: 1, checkboxChecked: false });
-
-      await manager.requestPermission('microphone');
-
-      // When mainWindow is set, dialog.showMessageBox is called with window as first arg
-      expect(dialog.showMessageBox).toHaveBeenCalledWith(
-        mockWindow,
-        expect.objectContaining({ type: 'warning' })
-      );
-    });
-  });
-});

package/tests/unit/screenRecordingRenderer.test.ts

@@ -1,368 +0,0 @@
-/**
- * ScreenRecordingRenderer Unit Tests
- *
- * Tests the renderer-side screen recording lifecycle:
- * - Start/stop recording
- * - Chunk streaming to main process via IPC
- * - Error handling and cleanup
- * - Guard against double-start, double-stop
- * - In-flight write draining on stop
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// ---------------------------------------------------------------------------
-// Mock MediaRecorder + MediaStream + navigator.mediaDevices
-// ---------------------------------------------------------------------------
-
-class MockMediaStream {
-  private tracks: Array<{ stop: ReturnType<typeof vi.fn>; kind: string }> = [];
-
-  constructor() {
-    this.tracks = [{ stop: vi.fn(), kind: 'video' }];
-  }
-
-  getTracks() {
-    return this.tracks;
-  }
-}
-
-let mockRecorderInstance: {
-  state: string;
-  start: ReturnType<typeof vi.fn>;
-  stop: ReturnType<typeof vi.fn>;
-  requestData: ReturnType<typeof vi.fn>;
-  ondataavailable: ((event: { data: Blob }) => void) | null;
-  onstop: (() => void) | null;
-};
-
-class MockMediaRecorder {
-  static isTypeSupported = vi.fn(() => true);
-  state = 'inactive';
-  ondataavailable: ((event: { data: Blob }) => void) | null = null;
-  onstop: (() => void) | null = null;
-  requestData = vi.fn();
-  start = vi.fn(() => {
-    this.state = 'recording';
-  });
-  stop = vi.fn(() => {
-    this.state = 'inactive';
-    // Fire onstop async
-    setTimeout(() => this.onstop?.(), 0);
-  });
-
-  constructor() {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    mockRecorderInstance = this;
-  }
-}
-
-vi.stubGlobal('MediaRecorder', MockMediaRecorder);
-
-vi.stubGlobal('navigator', {
-  mediaDevices: {
-    getUserMedia: vi.fn(() => Promise.resolve(new MockMediaStream())),
-  },
-});
-
-// ---------------------------------------------------------------------------
-// Mock window.markupr.screenRecording IPC
-// ---------------------------------------------------------------------------
-
-const mockScreenRecordingIPC = {
-  start: vi.fn(() => Promise.resolve({ success: true, path: '/tmp/rec.webm' })),
-  appendChunk: vi.fn(() => Promise.resolve({ success: true })),
-  stop: vi.fn(() =>
-    Promise.resolve({ success: true, path: '/tmp/rec.webm', bytes: 1024, mimeType: 'video/webm' })
-  ),
-};
-
-vi.stubGlobal('window', {
-  markupr: {
-    screenRecording: mockScreenRecordingIPC,
-  },
-});
-
-// ---------------------------------------------------------------------------
-// Import AFTER mocks are in place
-// ---------------------------------------------------------------------------
-
-import { ScreenRecordingRenderer } from '../../src/renderer/capture/ScreenRecordingRenderer';
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('ScreenRecordingRenderer', () => {
-  let renderer: ScreenRecordingRenderer;
-
-  beforeEach(() => {
-    renderer = new ScreenRecordingRenderer();
-    vi.clearAllMocks();
-  });
-
-  afterEach(async () => {
-    // Ensure cleanup
-    if (renderer.isRecording()) {
-      await renderer.stop();
-    }
-  });
-
-  // ========================================================================
-  // Initial state
-  // ========================================================================
-
-  describe('initial state', () => {
-    it('should not be recording initially', () => {
-      expect(renderer.isRecording()).toBe(false);
-    });
-
-    it('should have null sessionId initially', () => {
-      expect(renderer.getSessionId()).toBeNull();
-    });
-  });
-
-  // ========================================================================
-  // Start recording
-  // ========================================================================
-
-  describe('start', () => {
-    it('should request getUserMedia with desktop source constraints', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledWith(
-        expect.objectContaining({
-          audio: false,
-          video: expect.objectContaining({
-            mandatory: expect.objectContaining({
-              chromeMediaSource: 'desktop',
-              chromeMediaSourceId: 'screen:0:0',
-            }),
-          }),
-        })
-      );
-    });
-
-    it('should call IPC start with sessionId and mimeType', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(mockScreenRecordingIPC.start).toHaveBeenCalledWith('sess-1', expect.any(String), expect.any(Number));
-    });
-
-    it('should set isRecording to true after start', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(renderer.isRecording()).toBe(true);
-    });
-
-    it('should set sessionId after start', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(renderer.getSessionId()).toBe('sess-1');
-    });
-
-    it('should set recordingStartTime after start', async () => {
-      const before = Date.now();
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      const after = Date.now();
-
-      const startTime = renderer.getRecordingStartTime();
-      expect(startTime).toBeTypeOf('number');
-      expect(startTime).toBeGreaterThanOrEqual(before);
-      expect(startTime).toBeLessThanOrEqual(after);
-    });
-
-    it('should start MediaRecorder with 1000ms timeslice', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(mockRecorderInstance.start).toHaveBeenCalledWith(1000);
-    });
-
-    it('should no-op if already recording', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      vi.clearAllMocks();
-
-      await renderer.start({ sessionId: 'sess-2', sourceId: 'screen:0:0' });
-
-      // Should NOT have called getUserMedia again
-      expect(navigator.mediaDevices.getUserMedia).not.toHaveBeenCalled();
-      // Session ID should still be the first one
-      expect(renderer.getSessionId()).toBe('sess-1');
-    });
-
-    it('should throw if IPC start fails', async () => {
-      mockScreenRecordingIPC.start.mockResolvedValueOnce({ success: false, error: 'disk full' });
-
-      await expect(
-        renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' })
-      ).rejects.toThrow('disk full');
-    });
-
-    it('should stop tracks if IPC start fails', async () => {
-      const mockStream = new MockMediaStream();
-      vi.mocked(navigator.mediaDevices.getUserMedia).mockResolvedValueOnce(
-        mockStream as unknown as MediaStream
-      );
-      mockScreenRecordingIPC.start.mockResolvedValueOnce({ success: false, error: 'fail' });
-
-      await expect(renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' })).rejects.toThrow();
-
-      expect(mockStream.getTracks()[0].stop).toHaveBeenCalled();
-    });
-
-    it('should fall back to basic constraints if high-quality fails', async () => {
-      let callCount = 0;
-      vi.mocked(navigator.mediaDevices.getUserMedia).mockImplementation(() => {
-        callCount++;
-        if (callCount === 1) {
-          return Promise.reject(new Error('OverconstrainedError'));
-        }
-        return Promise.resolve(new MockMediaStream() as unknown as MediaStream);
-      });
-
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledTimes(2);
-      expect(renderer.isRecording()).toBe(true);
-    });
-  });
-
-  // ========================================================================
-  // Chunk streaming
-  // ========================================================================
-
-  describe('chunk streaming', () => {
-    it('should send chunks to IPC when data is available', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      // Simulate a data chunk from MediaRecorder
-      const blob = new Blob(['test-data'], { type: 'video/webm' });
-      mockRecorderInstance.ondataavailable?.({ data: blob });
-
-      // Wait for async processing
-      await new Promise((r) => setTimeout(r, 10));
-
-      expect(mockScreenRecordingIPC.appendChunk).toHaveBeenCalledWith(
-        'sess-1',
-        expect.any(Uint8Array)
-      );
-    });
-
-    it('should ignore empty chunks', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      const emptyBlob = new Blob([], { type: 'video/webm' });
-      mockRecorderInstance.ondataavailable?.({ data: emptyBlob });
-
-      await new Promise((r) => setTimeout(r, 10));
-
-      expect(mockScreenRecordingIPC.appendChunk).not.toHaveBeenCalled();
-    });
-  });
-
-  // ========================================================================
-  // Stop recording
-  // ========================================================================
-
-  describe('stop', () => {
-    it('should return success immediately if not recording', async () => {
-      const result = await renderer.stop();
-
-      expect(result).toEqual({ success: true });
-    });
-
-    it('should call IPC stop with sessionId', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      await renderer.stop();
-
-      expect(mockScreenRecordingIPC.stop).toHaveBeenCalledWith('sess-1');
-    });
-
-    it('should reset state after stop', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      await renderer.stop();
-
-      expect(renderer.isRecording()).toBe(false);
-      expect(renderer.getSessionId()).toBeNull();
-    });
-
-    it('should stop media stream tracks on stop', async () => {
-      const mockStream = new MockMediaStream();
-      vi.mocked(navigator.mediaDevices.getUserMedia).mockResolvedValueOnce(
-        mockStream as unknown as MediaStream
-      );
-
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      await renderer.stop();
-
-      expect(mockStream.getTracks()[0].stop).toHaveBeenCalled();
-    });
-
-    it('should return IPC stop result', async () => {
-      const expected = { success: true, path: '/tmp/rec.webm', bytes: 2048, mimeType: 'video/webm' };
-      mockScreenRecordingIPC.stop.mockResolvedValueOnce(expected);
-
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      const result = await renderer.stop();
-
-      expect(result).toEqual(expected);
-    });
-
-    it('should request a final recorder data flush before stop', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      await renderer.stop();
-
-      expect(mockRecorderInstance.requestData).toHaveBeenCalled();
-    });
-
-    it('should still stop tracks if IPC finalize fails', async () => {
-      const mockStream = new MockMediaStream();
-      vi.mocked(navigator.mediaDevices.getUserMedia).mockResolvedValueOnce(
-        mockStream as unknown as MediaStream
-      );
-      mockScreenRecordingIPC.stop.mockRejectedValueOnce(new Error('ipc stop failed'));
-
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      const result = await renderer.stop();
-
-      expect(result.success).toBe(false);
-      expect(mockStream.getTracks()[0].stop).toHaveBeenCalled();
-    });
-
-    it('should no-op on double stop', async () => {
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-      await renderer.stop();
-
-      vi.clearAllMocks();
-
-      const result = await renderer.stop();
-
-      expect(result).toEqual({ success: true });
-      expect(mockScreenRecordingIPC.stop).not.toHaveBeenCalled();
-    });
-  });
-
-  // ========================================================================
-  // MIME type selection
-  // ========================================================================
-
-  describe('MIME type selection', () => {
-    it('should use first supported MIME type', async () => {
-      MockMediaRecorder.isTypeSupported.mockImplementation(
-        (type: string) => type === 'video/webm;codecs=vp9'
-      );
-
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(mockScreenRecordingIPC.start).toHaveBeenCalledWith('sess-1', 'video/webm;codecs=vp9', expect.any(Number));
-    });
-
-    it('should fall back to video/webm when no codecs supported', async () => {
-      MockMediaRecorder.isTypeSupported.mockReturnValue(false);
-
-      await renderer.start({ sessionId: 'sess-1', sourceId: 'screen:0:0' });
-
-      expect(mockScreenRecordingIPC.start).toHaveBeenCalledWith('sess-1', 'video/webm', expect.any(Number));
-    });
-  });
-});