markupr 2.1.8

package/tests/unit/permissionManagerExpanded.test.ts

@@ -0,0 +1,296 @@
+/**
+ * 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

@@ -0,0 +1,368 @@
+/**
+ * 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));
+    });
+  });
+});