Merge branch 'master' into phase2/e2e-suite

Author: krassowski

test/setup/electron-mock.ts

@@ -1,48 +1,27 @@
 import { vi } from 'vitest';
 import { tmpdir } from 'os';
 import { join } from 'path';
+import * as electronStub from './electron-stub';
 
-const userDataPath = join(tmpdir(), 'jlab-test-userdata');
 const logFilePath = join(tmpdir(), 'jlab-test.log');
 
-vi.mock('electron', () => ({
-  app: {
-    getPath: vi.fn((name: string) => join(userDataPath, name)),
-    getVersion: vi.fn(() => '4.4.7'),
-    getName: vi.fn(() => 'JupyterLab'),
-    isPackaged: false,
-    whenReady: vi.fn(() => Promise.resolve())
-  },
-  ipcMain: {
-    on: vi.fn(),
-    handle: vi.fn(),
-    removeHandler: vi.fn(),
-    removeListener: vi.fn(),
-    removeAllListeners: vi.fn(),
-    emit: vi.fn()
-  },
-  dialog: {
-    showOpenDialog: vi.fn(),
-    showMessageBox: vi.fn(),
-    showMessageBoxSync: vi.fn(() => 0)
-  },
-  BrowserWindow: vi.fn().mockImplementation(() => ({
-    loadURL: vi.fn(),
-    webContents: { send: vi.fn(), on: vi.fn() },
-    on: vi.fn(),
-    once: vi.fn(),
-    show: vi.fn(),
-    close: vi.fn(),
-    isDestroyed: vi.fn(() => false)
-  })),
-  shell: { openExternal: vi.fn(), openPath: vi.fn() },
-  nativeTheme: { shouldUseDarkColors: false },
-  screen: {
-    getPrimaryDisplay: vi.fn(() => ({
-      workAreaSize: { width: 1920, height: 1080 }
-    }))
-  }
-}));
+// `electron` is mocked two ways pointing at the same ./electron-stub instances:
+//   - vitest.config `resolve.alias` redirects ESM `import ... from 'electron'`.
+//   - vitest leaves CJS `require('electron')` (used by the preload scripts)
+//     externalized, so it hits Node's require and would return the binary path
+//     string. Pre-seeding require.cache for electron's resolved id makes that
+//     require return the stub instead. Both paths share electronStub's vi.fns.
+try {
+  const electronId = require.resolve('electron');
+  (require.cache as Record<string, unknown>)[electronId] = {
+    id: electronId,
+    filename: electronId,
+    loaded: true,
+    exports: electronStub
+  };
+} catch {
+  // electron not resolvable in this environment; ESM alias still applies.
+}
 
 vi.mock('electron-log', () => ({
   default: {

test/setup/electron-stub.ts

@@ -0,0 +1,64 @@
+// Single source of truth for the mocked `electron` module.
+// Aliased in vitest.config so BOTH `import ... from 'electron'` (ESM) and
+// `require('electron')` (used by the preload scripts) resolve here to the same
+// vi.fn instances. Native require would otherwise return the electron binary
+// path string and bypass vi.mock, leaving preload code untestable.
+import { vi } from 'vitest';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+const userDataPath = join(tmpdir(), 'jlab-test-userdata');
+
+export const app = {
+  getPath: vi.fn((name: string) => join(userDataPath, name)),
+  getVersion: vi.fn(() => '4.4.7'),
+  getName: vi.fn(() => 'JupyterLab'),
+  isPackaged: false,
+  whenReady: vi.fn(() => Promise.resolve())
+};
+
+export const ipcMain = {
+  on: vi.fn(),
+  handle: vi.fn(),
+  removeHandler: vi.fn(),
+  removeListener: vi.fn(),
+  removeAllListeners: vi.fn(),
+  emit: vi.fn()
+};
+
+export const ipcRenderer = {
+  invoke: vi.fn(),
+  send: vi.fn(),
+  on: vi.fn(),
+  removeListener: vi.fn()
+};
+
+export const contextBridge = {
+  exposeInMainWorld: vi.fn()
+};
+
+export const dialog = {
+  showOpenDialog: vi.fn(),
+  showMessageBox: vi.fn(),
+  showMessageBoxSync: vi.fn(() => 0)
+};
+
+export const BrowserWindow = vi.fn().mockImplementation(() => ({
+  loadURL: vi.fn(),
+  webContents: { send: vi.fn(), on: vi.fn() },
+  on: vi.fn(),
+  once: vi.fn(),
+  show: vi.fn(),
+  close: vi.fn(),
+  isDestroyed: vi.fn(() => false)
+}));
+
+export const shell = { openExternal: vi.fn(), openPath: vi.fn() };
+
+export const nativeTheme = { shouldUseDarkColors: false };
+
+export const screen = {
+  getPrimaryDisplay: vi.fn(() => ({
+    workAreaSize: { width: 1920, height: 1080 }
+  }))
+};

test/unit/preload/aboutdialog.test.ts

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventTypeMain } from '../../../src/main/eventtypes';
+import { exposedAPI, ipcRenderer } from './helpers';
+
+async function load(): Promise<Record<string, any>> {
+  await import('../../../src/main/aboutdialog/preload');
+  return exposedAPI();
+}
+
+describe('aboutdialog preload', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  it('exposes exactly the documented electronAPI keys', async () => {
+    const api = await load();
+    expect(Object.keys(api).sort()).toEqual(
+      ['getAppConfig', 'isDarkTheme', 'launchAboutJupyterPage'].sort()
+    );
+  });
+
+  it('getAppConfig returns the platform without touching IPC', async () => {
+    const api = await load();
+    expect(api.getAppConfig()).toEqual({ platform: process.platform });
+    expect(ipcRenderer.invoke).not.toHaveBeenCalled();
+    expect(ipcRenderer.send).not.toHaveBeenCalled();
+  });
+
+  it('isDarkTheme forwards to invoke on the IsDarkTheme channel', async () => {
+    const api = await load();
+    api.isDarkTheme();
+    expect(ipcRenderer.invoke).toHaveBeenCalledWith(EventTypeMain.IsDarkTheme);
+  });
+
+  it('launchAboutJupyterPage forwards to send on the LaunchAboutJupyterPage channel', async () => {
+    const api = await load();
+    api.launchAboutJupyterPage();
+    expect(ipcRenderer.send).toHaveBeenCalledWith(
+      EventTypeMain.LaunchAboutJupyterPage
+    );
+  });
+
+  it('does not expose the raw ipcRenderer object', async () => {
+    const api = await load();
+    expect(Object.values(api)).not.toContain(ipcRenderer);
+  });
+});

test/unit/preload/authdialog.test.ts

@@ -0,0 +1,50 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventTypeMain } from '../../../src/main/eventtypes';
+import { exposedAPI, ipcRenderer } from './helpers';
+
+async function load(): Promise<Record<string, any>> {
+  await import('../../../src/main/authdialog/preload');
+  return exposedAPI();
+}
+
+describe('authdialog preload', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  it('exposes exactly the documented electronAPI keys', async () => {
+    const api = await load();
+    expect(Object.keys(api).sort()).toEqual(
+      ['getAppConfig', 'isDarkTheme', 'setAuthDialogResponse'].sort()
+    );
+  });
+
+  it('getAppConfig returns the platform without touching IPC', async () => {
+    const api = await load();
+    expect(api.getAppConfig()).toEqual({ platform: process.platform });
+    expect(ipcRenderer.invoke).not.toHaveBeenCalled();
+    expect(ipcRenderer.send).not.toHaveBeenCalled();
+  });
+
+  it('isDarkTheme forwards to invoke on the IsDarkTheme channel', async () => {
+    const api = await load();
+    api.isDarkTheme();
+    expect(ipcRenderer.invoke).toHaveBeenCalledWith(EventTypeMain.IsDarkTheme);
+  });
+
+  it('setAuthDialogResponse forwards username and password on SetAuthDialogResponse', async () => {
+    const api = await load();
+    api.setAuthDialogResponse('user', 'pass');
+    expect(ipcRenderer.send).toHaveBeenCalledWith(
+      EventTypeMain.SetAuthDialogResponse,
+      'user',
+      'pass'
+    );
+  });
+
+  it('does not expose the raw ipcRenderer object', async () => {
+    const api = await load();
+    expect(Object.values(api)).not.toContain(ipcRenderer);
+  });
+});

test/unit/preload/dialog.test.ts

@@ -0,0 +1,40 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventTypeMain } from '../../../src/main/eventtypes';
+import { exposedAPI, ipcRenderer } from './helpers';
+
+async function load(): Promise<Record<string, any>> {
+  await import('../../../src/main/dialog/preload');
+  return exposedAPI();
+}
+
+describe('dialog preload', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  it('exposes exactly the documented electronAPI keys', async () => {
+    const api = await load();
+    expect(Object.keys(api).sort()).toEqual(
+      ['getAppConfig', 'isDarkTheme'].sort()
+    );
+  });
+
+  it('getAppConfig returns the platform without touching IPC', async () => {
+    const api = await load();
+    expect(api.getAppConfig()).toEqual({ platform: process.platform });
+    expect(ipcRenderer.invoke).not.toHaveBeenCalled();
+    expect(ipcRenderer.send).not.toHaveBeenCalled();
+  });
+
+  it('isDarkTheme forwards to invoke on the IsDarkTheme channel', async () => {
+    const api = await load();
+    api.isDarkTheme();
+    expect(ipcRenderer.invoke).toHaveBeenCalledWith(EventTypeMain.IsDarkTheme);
+  });
+
+  it('does not expose the raw ipcRenderer object', async () => {
+    const api = await load();
+    expect(Object.values(api)).not.toContain(ipcRenderer);
+  });
+});

test/unit/preload/helpers.ts

@@ -0,0 +1,25 @@
+import { contextBridge, ipcRenderer } from 'electron';
+import { vi } from 'vitest';
+
+export { ipcRenderer };
+
+// The API object the preload handed to contextBridge.exposeInMainWorld('electronAPI', ...).
+export function exposedAPI(): Record<string, any> {
+  const call = vi
+    .mocked(contextBridge.exposeInMainWorld)
+    .mock.calls.find(c => c[0] === 'electronAPI');
+  if (!call) {
+    throw new Error('preload did not expose an "electronAPI" namespace');
+  }
+  return call[1] as Record<string, any>;
+}
+
+// The handler the preload registered for a given EventTypeRenderer channel via
+// ipcRenderer.on at module load. Invoke it to simulate a message from main.
+export function rendererHandler(channel: string): (...args: any[]) => void {
+  const call = vi.mocked(ipcRenderer.on).mock.calls.find(c => c[0] === channel);
+  if (!call) {
+    throw new Error(`no ipcRenderer.on listener registered for "${channel}"`);
+  }
+  return call[1] as (...args: any[]) => void;
+}

test/unit/preload/labview.test.ts

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventTypeMain } from '../../../src/main/eventtypes';
+import { exposedAPI, ipcRenderer } from './helpers';
+
+async function load(): Promise<Record<string, any>> {
+  await import('../../../src/main/labview/preload');
+  return exposedAPI();
+}
+
+describe('labview preload', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  it('exposes exactly the documented electronAPI keys', async () => {
+    const api = await load();
+    expect(Object.keys(api).sort()).toEqual(
+      ['getServerInfo', 'broadcastLabUIReady'].sort()
+    );
+  });
+
+  it('getServerInfo forwards to invoke on the GetServerInfo channel', async () => {
+    const api = await load();
+    api.getServerInfo();
+    expect(ipcRenderer.invoke).toHaveBeenCalledWith(
+      EventTypeMain.GetServerInfo
+    );
+  });
+
+  it('broadcastLabUIReady forwards to send on the LabUIReady channel', async () => {
+    const api = await load();
+    api.broadcastLabUIReady();
+    expect(ipcRenderer.send).toHaveBeenCalledWith(EventTypeMain.LabUIReady);
+  });
+
+  it('does not expose the raw ipcRenderer object', async () => {
+    const api = await load();
+    expect(Object.values(api)).not.toContain(ipcRenderer);
+  });
+});