Build your personal knowledge base with Trilium Notes
TypeScript electronelectron-appknowledge-baseknowledge-graphknowledge-managementknowledge-management-graphlocal-firstnote-managmentnote-takernote-takingnotebooknotesnotes-apppersonal-knowledge-basepersonal-wikiscriptableself-hostedself-hostingwiki
import { beforeEach, describe, expect, it, vi } from "vitest";
let exposedApi: Record<string, Record<string, unknown>> = {};
let mockZoomFactor = 1.0;
const ipcRendererListeners = new Map<string, Function[]>();
const ipcRendererSent: Array<{ channel: string; args: unknown[] }> = [];
const ipcRendererInvoked: Array<{ channel: string; args: unknown[] }> = [];
const ipcRendererSyncResults = new Map<string, unknown>();
vi.mock("electron", () => ({
contextBridge: {
exposeInMainWorld(apiKey: string, api: Record<string, unknown>) {
exposedApi[apiKey] = api;
}
},
webFrame: {
setZoomFactor(factor: number) {
mockZoomFactor = factor;
},
getZoomFactor() {
return mockZoomFactor;
}
},
ipcRenderer: {
on(channel: string, listener: Function) {
const listeners = ipcRendererListeners.get(channel) ?? [];
listeners.push(listener);
ipcRendererListeners.set(channel, listeners);
},
send(channel: string, ...args: unknown[]) {
ipcRendererSent.push({ channel, args });
},
invoke(channel: string, ...args: unknown[]) {
ipcRendererInvoked.push({ channel, args });
return Promise.resolve("");
},
sendSync(channel: string, ...args: unknown[]) {
return ipcRendererSyncResults.get(`${channel}:${args[0]}`);
},
removeAllListeners(channel: string) {
ipcRendererListeners.delete(channel);
},
removeListener(channel: string, listener: Function) {
const listeners = ipcRendererListeners.get(channel);
if (!listeners) return;
const filtered = listeners.filter(l => l !== listener);
if (filtered.length === 0) {
ipcRendererListeners.delete(channel);
} else {
ipcRendererListeners.set(channel, filtered);
}
}
},
// Maps a dropped File to its on-disk path; here we read a test-only `path` field off the fake File.
webUtils: {
getPathForFile(file: { path?: string }) {
return file.path ?? "";
}
}
}));
function getGroup(name: string) {
return (exposedApi.electronApi as Record<string, Record<string, Function>>)[name];
}
describe("preload script", () => {
beforeEach(async () => {
exposedApi = {};
mockZoomFactor = 1.0;
ipcRendererListeners.clear();
ipcRendererSent.length = 0;
ipcRendererInvoked.length = 0;
ipcRendererSyncResults.clear();
vi.resetModules();
await import("./preload.js");
});
it("exposes electronApi on the window", () => {
expect(exposedApi).toHaveProperty("electronApi");
});
describe("window", () => {
const win = () => getGroup("window");
it("setZoomFactor delegates to webFrame", () => {
win().setZoomFactor(1.5);
expect(mockZoomFactor).toBe(1.5);
});
it("getZoomFactor delegates to webFrame", () => {
mockZoomFactor = 0.8;
expect(win().getZoomFactor()).toBe(0.8);
});
it("setNativeThemeSource sends correct IPC message", () => {
win().setNativeThemeSource("dark");
expect(ipcRendererSent).toContainEqual({
channel: "set-native-theme-source",
args: ["dark"]
});
});
it("setTitleBarOverlay sends correct IPC message", () => {
win().setTitleBarOverlay({ color: "#fff", symbolColor: "#000" });
expect(ipcRendererSent).toContainEqual({
channel: "set-title-bar-overlay",
args: [{ color: "#fff", symbolColor: "#000" }]
});
});
it("setWindowButtonPosition sends correct IPC message", () => {
win().setWindowButtonPosition({ x: 10, y: 20 });
expect(ipcRendererSent).toContainEqual({
channel: "set-window-button-position",
args: [{ x: 10, y: 20 }]
});
});
it("onEnterFullScreen registers and forwards enter-full-screen channel", () => {
const callback = vi.fn();
win().onEnterFullScreen(callback);
const listeners = ipcRendererListeners.get("enter-full-screen")!;
expect(listeners).toHaveLength(1);
listeners[0]();
expect(callback).toHaveBeenCalled();
});
it("onLeaveFullScreen registers and forwards leave-full-screen channel", () => {
const callback = vi.fn();
win().onLeaveFullScreen(callback);
const listeners = ipcRendererListeners.get("leave-full-screen")!;
expect(listeners).toHaveLength(1);
listeners[0]();
expect(callback).toHaveBeenCalled();
});
it("isFullScreen uses sendSync", () => {
ipcRendererSyncResults.set("is-full-screen:undefined", true);
expect(win().isFullScreen()).toBe(true);
});
it("setFullScreen sends correct IPC message", () => {
win().setFullScreen(true);
expect(ipcRendererSent).toContainEqual({
channel: "set-full-screen",
args: [true]
});
});
it("minimizeWindow sends correct IPC message", () => {
win().minimizeWindow();
expect(ipcRendererSent).toContainEqual({ channel: "minimize-window", args: [] });
});
it("maximizeWindow sends correct IPC message", () => {
win().maximizeWindow();
expect(ipcRendererSent).toContainEqual({ channel: "maximize-window", args: [] });
});
it("unmaximizeWindow sends correct IPC message", () => {
win().unmaximizeWindow();
expect(ipcRendererSent).toContainEqual({ channel: "unmaximize-window", args: [] });
});
it("isMaximized uses sendSync", () => {
ipcRendererSyncResults.set("is-maximized:undefined", true);
expect(win().isMaximized()).toBe(true);
});
it("closeWindow sends correct IPC message", () => {
win().closeWindow();
expect(ipcRendererSent).toContainEqual({ channel: "close-window", args: [] });
});
it("isAlwaysOnTop uses sendSync", () => {
ipcRendererSyncResults.set("is-always-on-top:undefined", true);
expect(win().isAlwaysOnTop()).toBe(true);
});
it("setAlwaysOnTop sends correct IPC message", () => {
win().setAlwaysOnTop(true);
expect(ipcRendererSent).toContainEqual({ channel: "set-always-on-top", args: [true] });
});
it("toggleDevTools sends correct IPC message", () => {
win().toggleDevTools();
expect(ipcRendererSent).toContainEqual({ channel: "toggle-dev-tools", args: [] });
});
it("isDevToolsDocked uses sendSync", () => {
ipcRendererSyncResults.set("is-dev-tools-docked:undefined", true);
expect(win().isDevToolsDocked()).toBe(true);
});
it("onDevToolsDockChanged registers and forwards the dock state", () => {
const callback = vi.fn();
win().onDevToolsDockChanged(callback);
const listeners = ipcRendererListeners.get("dev-tools-dock-changed") ?? [];
expect(listeners).toHaveLength(1);
listeners[0]({}, true);
expect(callback).toHaveBeenCalledWith(true);
});
it("reloadAllWindows sends correct IPC message", () => {
win().reloadAllWindows();
expect(ipcRendererSent).toContainEqual({ channel: "reload-all-windows", args: [] });
});
it("restartApp sends correct IPC message", () => {
win().restartApp();
expect(ipcRendererSent).toContainEqual({ channel: "restart-app", args: [] });
});
it("toggleAllWindows sends correct IPC message", () => {
win().toggleAllWindows();
expect(ipcRendererSent).toContainEqual({ channel: "toggle-all-windows", args: [] });
});
it("showWindow sends correct IPC message", () => {
win().showWindow();
expect(ipcRendererSent).toContainEqual({ channel: "show-window", args: [] });
});
it("reportStartupMetric sends correct IPC message", () => {
win().reportStartupMetric("client-full-render");
expect(ipcRendererSent).toContainEqual({
channel: "report-startup-metric",
args: ["client-full-render"]
});
});
it("clearCache invokes correct IPC channel", async () => {
await win().clearCache();
expect(ipcRendererInvoked).toContainEqual({ channel: "clear-cache", args: [] });
});
it("setBackgroundMaterial sends correct IPC message", () => {
win().setBackgroundMaterial("mica");
expect(ipcRendererSent).toContainEqual({ channel: "set-background-material", args: ["mica"] });
});
it("setVibrancy sends correct IPC message", () => {
win().setVibrancy("under-window");
expect(ipcRendererSent).toContainEqual({ channel: "set-vibrancy", args: ["under-window"] });
});
it("onGlobalShortcut registers and forwards globalShortcut channel", () => {
const callback = vi.fn();
win().onGlobalShortcut(callback);
const listeners = ipcRendererListeners.get("globalShortcut")!;
expect(listeners).toHaveLength(1);
listeners[0]({}, "toggleNoteHoisting");
expect(callback).toHaveBeenCalledWith("toggleNoteHoisting");
});
it("onOpenInSameTab registers and forwards openInSameTab channel", () => {
const callback = vi.fn();
win().onOpenInSameTab(callback);
const listeners = ipcRendererListeners.get("openInSameTab")!;
expect(listeners).toHaveLength(1);
listeners[0]({}, "abc123");
expect(callback).toHaveBeenCalledWith("abc123");
});
});
describe("clipboard", () => {
const clip = () => getGroup("clipboard");
it("copyImageToClipboard sends correct IPC message", () => {
const buffer = new Uint8Array([1, 2, 3]);
clip().copyImageToClipboard(buffer);
expect(ipcRendererSent).toContainEqual({
channel: "copy-image-to-clipboard",
args: [buffer]
});
});
it("readText invokes correct IPC channel", async () => {
await clip().readText();
expect(ipcRendererInvoked).toContainEqual({ channel: "read-clipboard-text", args: [] });
});
it("readHTML invokes correct IPC channel", async () => {
await clip().readHTML();
expect(ipcRendererInvoked).toContainEqual({ channel: "read-clipboard-html", args: [] });
});
});
describe("shell", () => {
const shell = () => getGroup("shell");
it("openExternal sends correct IPC message", () => {
shell().openExternal("https://example.com");
expect(ipcRendererSent).toContainEqual({
channel: "open-external",
args: ["https://example.com"]
});
});
it("openPath invokes correct IPC channel", async () => {
await shell().openPath("/tmp/test.txt");
expect(ipcRendererInvoked).toContainEqual({
channel: "open-path",
args: ["/tmp/test.txt"]
});
});
it("showItemInFolder sends correct IPC message", () => {
shell().showItemInFolder("/tmp/test.txt");
expect(ipcRendererSent).toContainEqual({
channel: "show-item-in-folder",
args: ["/tmp/test.txt"]
});
});
it("openFileUrl invokes correct IPC channel", async () => {
await shell().openFileUrl("file:///tmp/test.txt");
expect(ipcRendererInvoked).toContainEqual({
channel: "open-file-url",
args: ["file:///tmp/test.txt"]
});
});
it("downloadURL sends correct IPC message", () => {
shell().downloadURL("https://example.com/file.zip");
expect(ipcRendererSent).toContainEqual({
channel: "download-url",
args: ["https://example.com/file.zip"]
});
});
it("openCustom invokes correct IPC channel", async () => {
await shell().openCustom("/tmp/test.txt");
expect(ipcRendererInvoked).toContainEqual({
channel: "open-custom",
args: ["/tmp/test.txt"]
});
});
});
describe("contextMenu", () => {
const ctx = () => getGroup("contextMenu");
it("onContextMenu registers and forwards context-menu channel", () => {
const callback = vi.fn();
ctx().onContextMenu(callback);
const listeners = ipcRendererListeners.get("context-menu")!;
expect(listeners).toHaveLength(1);
const params = { x: 100, y: 200, selectionText: "test" };
listeners[0]({}, params);
expect(callback).toHaveBeenCalledWith(params);
});
it("webContentsAction sends action and optional text", () => {
ctx().webContentsAction("cut");
expect(ipcRendererSent).toContainEqual({
channel: "web-contents-action",
args: ["cut", undefined]
});
ctx().webContentsAction("insertText", "hello");
expect(ipcRendererSent).toContainEqual({
channel: "web-contents-action",
args: ["insertText", "hello"]
});
});
});
describe("spellcheck", () => {
const spell = () => getGroup("spellcheck");
it("addWordToDictionary sends correct IPC message", () => {
spell().addWordToDictionary("trilium");
expect(ipcRendererSent).toContainEqual({
channel: "add-word-to-dictionary",
args: ["trilium"]
});
});
it("getAvailableSpellCheckerLanguages uses sendSync", () => {
ipcRendererSyncResults.set("get-available-spellchecker-languages:undefined", ["en-US", "de-DE"]);
expect(spell().getAvailableSpellCheckerLanguages()).toEqual(["en-US", "de-DE"]);
});
it("setSpellCheckerLanguages sends correct IPC message", () => {
spell().setSpellCheckerLanguages(["en-US", "fr"]);
expect(ipcRendererSent).toContainEqual({
channel: "set-spellchecker-languages",
args: [["en-US", "fr"]]
});
});
it("setSpellCheckerEnabled sends correct IPC message", () => {
spell().setSpellCheckerEnabled(false);
expect(ipcRendererSent).toContainEqual({
channel: "set-spellchecker-enabled",
args: [false]
});
});
});
describe("systemIntegration", () => {
const systemIntegration = () => getGroup("systemIntegration");
it("reloadTray sends correct IPC message", () => {
systemIntegration().reloadTray();
expect(ipcRendererSent).toContainEqual({ channel: "reload-tray", args: [] });
});
it("reapplyLaunchOnStartup sends correct IPC message", () => {
systemIntegration().reapplyLaunchOnStartup();
expect(ipcRendererSent).toContainEqual({ channel: "reapply-launch-on-startup", args: [] });
});
});
describe("printing", () => {
const printing = () => getGroup("printing");
it("sendPrintProgress sends correct IPC message", () => {
printing().sendPrintProgress(50);
expect(ipcRendererSent).toContainEqual({ channel: "print-progress", args: [50] });
});
it("onPrintProgress registers and forwards print-progress channel", () => {
const callback = vi.fn();
printing().onPrintProgress(callback);
const listeners = ipcRendererListeners.get("print-progress")!;
expect(listeners).toHaveLength(1);
listeners[0]({}, { progress: 50, action: "printing" });
expect(callback).toHaveBeenCalledWith({ progress: 50, action: "printing" });
});
it("onPrintDone registers and forwards print-done channel", () => {
const callback = vi.fn();
printing().onPrintDone(callback);
const listeners = ipcRendererListeners.get("print-done")!;
expect(listeners).toHaveLength(1);
listeners[0]({}, { success: true });
expect(callback).toHaveBeenCalledWith({ success: true }, undefined);
listeners[0]({}, { type: "single-note" }, 3);
expect(callback).toHaveBeenLastCalledWith({ type: "single-note" }, 3);
});
it("removePrintListeners clears both print listeners", () => {
printing().onPrintProgress(vi.fn());
printing().onPrintDone(vi.fn());
expect(ipcRendererListeners.has("print-progress")).toBe(true);
expect(ipcRendererListeners.has("print-done")).toBe(true);
printing().removePrintListeners();
expect(ipcRendererListeners.has("print-progress")).toBe(false);
expect(ipcRendererListeners.has("print-done")).toBe(false);
});
it("getPrinters invokes correct IPC channel", async () => {
await printing().getPrinters();
expect(ipcRendererInvoked).toContainEqual({ channel: "get-printers", args: [] });
});
it("exportAsPdfPreview sends correct IPC message", () => {
const opts = { notePath: "root/abc", pageSize: "A4" };
printing().exportAsPdfPreview(opts);
expect(ipcRendererSent).toContainEqual({ channel: "export-as-pdf-preview", args: [opts] });
});
it("onExportAsPdfPreviewResult registers and forwards channel", () => {
const callback = vi.fn();
printing().onExportAsPdfPreviewResult(callback);
const listeners = ipcRendererListeners.get("export-as-pdf-preview-result")!;
expect(listeners).toHaveLength(1);
const result = { buffer: new Uint8Array([1, 2, 3]) };
listeners[0]({}, result);
expect(callback).toHaveBeenCalledWith(result);
});
it("removeExportAsPdfPreviewResultListener clears listener", () => {
printing().onExportAsPdfPreviewResult(vi.fn());
expect(ipcRendererListeners.has("export-as-pdf-preview-result")).toBe(true);
printing().removeExportAsPdfPreviewResultListener();
expect(ipcRendererListeners.has("export-as-pdf-preview-result")).toBe(false);
});
it("savePdf sends correct IPC message", () => {
const data = { title: "Test", buffer: new Uint8Array([1]) };
printing().savePdf(data);
expect(ipcRendererSent).toContainEqual({ channel: "save-pdf", args: [data] });
});
it("printFromPreview sends correct IPC message", () => {
const opts = { notePath: "root/abc", silent: true };
printing().printFromPreview(opts);
expect(ipcRendererSent).toContainEqual({ channel: "print-from-preview", args: [opts] });
});
});
describe("navigation", () => {
const nav = () => getGroup("navigation");
it("clearNavigationHistory sends correct IPC message", () => {
nav().clearNavigationHistory();
expect(ipcRendererSent).toContainEqual({ channel: "clear-navigation-history", args: [] });
});
it("navigationCanGoBack uses sendSync", () => {
ipcRendererSyncResults.set("navigation-history:canGoBack", true);
expect(nav().navigationCanGoBack()).toBe(true);
});
it("navigationCanGoForward uses sendSync", () => {
ipcRendererSyncResults.set("navigation-history:canGoForward", false);
expect(nav().navigationCanGoForward()).toBe(false);
});
it("navigationGetAllEntries uses sendSync", () => {
const entries = [{ url: "trilium-app://app/?#abc", title: "Note" }];
ipcRendererSyncResults.set("navigation-history:getAllEntries", entries);
expect(nav().navigationGetAllEntries()).toEqual(entries);
});
it("navigationGetActiveIndex uses sendSync", () => {
ipcRendererSyncResults.set("navigation-history:getActiveIndex", 3);
expect(nav().navigationGetActiveIndex()).toBe(3);
});
it("navigationLength uses sendSync", () => {
ipcRendererSyncResults.set("navigation-history:length", 5);
expect(nav().navigationLength()).toBe(5);
});
it("navigationGoToIndex sends correct IPC message", () => {
nav().navigationGoToIndex(2);
expect(ipcRendererSent).toContainEqual({
channel: "navigation-history-go-to-index",
args: [2]
});
});
it("onDidNavigate registers and forwards did-navigate channel", () => {
const callback = vi.fn();
nav().onDidNavigate(callback);
const listeners = ipcRendererListeners.get("did-navigate")!;
expect(listeners).toHaveLength(1);
listeners[0]();
expect(callback).toHaveBeenCalled();
});
it("onDidNavigateInPage registers and forwards did-navigate-in-page channel", () => {
const callback = vi.fn();
nav().onDidNavigateInPage(callback);
const listeners = ipcRendererListeners.get("did-navigate-in-page")!;
expect(listeners).toHaveLength(1);
listeners[0]();
expect(callback).toHaveBeenCalled();
});
it("removeDidNavigateListeners clears both navigation listeners", () => {
nav().onDidNavigate(vi.fn());
nav().onDidNavigateInPage(vi.fn());
expect(ipcRendererListeners.has("did-navigate")).toBe(true);
expect(ipcRendererListeners.has("did-navigate-in-page")).toBe(true);
nav().removeDidNavigateListeners();
expect(ipcRendererListeners.has("did-navigate")).toBe(false);
expect(ipcRendererListeners.has("did-navigate-in-page")).toBe(false);
});
});
describe("ws", () => {
const ws = () => getGroup("ws");
it("send forwards the message on the trilium-ws-from-renderer channel", () => {
ws().send({ type: "ping", lastEntityChangeId: 42 });
expect(ipcRendererSent).toContainEqual({
channel: "trilium-ws-from-renderer",
args: [{ type: "ping", lastEntityChangeId: 42 }]
});
});
it("onMessage subscribes to trilium-ws-message and forwards payloads", () => {
const callback = vi.fn();
ws().onMessage(callback);
const listeners = ipcRendererListeners.get("trilium-ws-message")!;
expect(listeners).toHaveLength(1);
listeners[0]({}, { type: "frontend-update", data: { entityChanges: [] } });
expect(callback).toHaveBeenCalledWith({ type: "frontend-update", data: { entityChanges: [] } });
});
it("onMessage returns an unsubscribe that detaches only its own listener", () => {
const first = vi.fn();
const second = vi.fn();
const unsubFirst = ws().onMessage(first);
ws().onMessage(second);
expect(ipcRendererListeners.get("trilium-ws-message")).toHaveLength(2);
unsubFirst();
const remaining = ipcRendererListeners.get("trilium-ws-message")!;
expect(remaining).toHaveLength(1);
remaining[0]({}, { type: "toast", message: "hi" });
expect(first).not.toHaveBeenCalled();
expect(second).toHaveBeenCalledWith({ type: "toast", message: "hi" });
});
});
describe("security", () => {
const security = () => getGroup("security");
it("setBackendScriptingEnabled invokes the corresponding IPC channel", async () => {
await security().setBackendScriptingEnabled(true);
expect(ipcRendererInvoked).toContainEqual({ channel: "security-set-backend-scripting", args: [true] });
});
it("setSqlConsoleEnabled invokes the corresponding IPC channel", async () => {
await security().setSqlConsoleEnabled(false);
expect(ipcRendererInvoked).toContainEqual({ channel: "security-set-sql-console", args: [false] });
});
it("setLanAccessEnabled invokes the corresponding IPC channel", async () => {
await security().setLanAccessEnabled(true);
expect(ipcRendererInvoked).toContainEqual({ channel: "security-set-lan-access", args: [true] });
});
});
describe("backupPassphrase", () => {
const backupPassphrase = () => getGroup("backupPassphrase");
it("getStatus invokes the corresponding IPC channel", async () => {
await backupPassphrase().getStatus();
expect(ipcRendererInvoked).toContainEqual({
channel: "backup-passphrase-status",
args: []
});
});
it("set invokes the corresponding IPC channel", async () => {
await backupPassphrase().set("hunter2");
expect(ipcRendererInvoked).toContainEqual({
channel: "backup-passphrase-set",
args: [ "hunter2" ]
});
});
it("clear invokes the corresponding IPC channel", async () => {
await backupPassphrase().clear();
expect(ipcRendererInvoked).toContainEqual({
channel: "backup-passphrase-clear",
args: []
});
});
it("exposes no way to read the passphrase back", () => {
const exposed = Object.keys(backupPassphrase()).sort();
expect(exposed).toEqual([ "clear", "getStatus", "set" ]);
});
});
describe("onenote", () => {
const onenote = () => getGroup("onenote");
it("login invokes the corresponding IPC channel", async () => {
await onenote().login();
expect(ipcRendererInvoked).toContainEqual({ channel: "onenote-login", args: [] });
});
});
describe("nativeExport", () => {
const nativeExport = () => getGroup("nativeExport");
it("exportSubtreeToFile invokes the corresponding IPC channel with the options", async () => {
const opts = { branchId: "branch123", format: "html", title: "My Note", taskId: "task1" };
await nativeExport().exportSubtreeToFile(opts);
expect(ipcRendererInvoked).toContainEqual({ channel: "export-subtree-to-file", args: [opts] });
});
});
describe("nativeImport", () => {
const nativeImport = () => getGroup("nativeImport");
it("pickFiles invokes the open-dialog IPC channel with no path argument", async () => {
await nativeImport().pickFiles();
expect(ipcRendererInvoked).toContainEqual({ channel: "import-pick-files", args: [] });
});
it("importFromToken forwards the token + options (never a path) to its IPC channel", async () => {
const opts = { token: "tok-1", parentNoteId: "p1", taskId: "task1", options: { explodeArchives: true }, last: true };
await nativeImport().importFromToken(opts);
expect(ipcRendererInvoked).toContainEqual({ channel: "import-from-token", args: [opts] });
});
it("grantDroppedFiles resolves File objects to paths and forwards only those (dropping unresolved)", async () => {
const grantDroppedFiles = nativeImport().grantDroppedFiles as (files: unknown[]) => Promise<unknown>;
// The second file has no backing path (a script-built blob / browser drag) → getPathForFile yields "".
await grantDroppedFiles([{ path: "/data/a.zip" }, { /* no path */ }]);
expect(ipcRendererInvoked).toContainEqual({ channel: "import-grant-dropped", args: [["/data/a.zip"]] });
});
});
describe("dialog", () => {
const dialog = () => getGroup("dialog");
it("pickDirectory forwards the starting location to its IPC channel", async () => {
await dialog().pickDirectory({ defaultPath: "/data/backup" });
expect(ipcRendererInvoked).toContainEqual({ channel: "dialog-pick-directory", args: [{ defaultPath: "/data/backup" }] });
});
it("pickDirectory may be called without a starting location", async () => {
await dialog().pickDirectory();
expect(ipcRendererInvoked).toContainEqual({ channel: "dialog-pick-directory", args: [undefined] });
});
it("confirmStartOver invokes its IPC channel, passing nothing it could steer", async () => {
await dialog().confirmStartOver();
expect(ipcRendererInvoked).toContainEqual({ channel: "dialog-confirm-start-over", args: [] });
});
});
describe("restore", () => {
const restore = () => getGroup("restore");
it("pickBackup invokes the open-dialog IPC channel, passing nothing it could steer", async () => {
await restore().pickBackup();
expect(ipcRendererInvoked).toContainEqual({ channel: "restore-pick-backup", args: [] });
});
});
describe("transcription", () => {
const transcription = () => getGroup("transcription");
it("isSupported, start, stop, getState, renameSpeaker and getRecordingsDirectory invoke their IPC channels", async () => {
await transcription().isSupported();
await transcription().start("meeting");
await transcription().stop();
await transcription().getState();
await transcription().renameSpeaker("transcript1", "system:1", "Alexandra");
await transcription().getRecordingsDirectory();
expect(ipcRendererInvoked).toEqual([
{ channel: "transcription-is-supported", args: [] },
{ channel: "transcription-start", args: [ "meeting" ] },
{ channel: "transcription-stop", args: [] },
{ channel: "transcription-get-state", args: [] },
{
channel: "transcription-rename-speaker",
args: [ "transcript1", "system:1", "Alexandra" ]
},
{ channel: "transcription-get-recordings-directory", args: [] }
]);
});
it("onStateChanged relays each state until unsubscribed", () => {
const callback = vi.fn();
const unsubscribe = transcription().onStateChanged(callback);
const listeners = ipcRendererListeners.get("transcription-state") ?? [];
expect(listeners).toHaveLength(1);
listeners[0]({}, { status: "recording", noteId: "meeting" });
expect(callback).toHaveBeenCalledExactlyOnceWith({ status: "recording", noteId: "meeting" });
unsubscribe();
expect(ipcRendererListeners.has("transcription-state")).toBe(false);
});
it("onLevel relays each source's level until unsubscribed", () => {
const callback = vi.fn();
const unsubscribe = transcription().onLevel(callback);
const listeners = ipcRendererListeners.get("transcription-level") ?? [];
expect(listeners).toHaveLength(1);
listeners[0]({}, "microphone", 0.25);
expect(callback).toHaveBeenCalledExactlyOnceWith("microphone", 0.25);
unsubscribe();
expect(ipcRendererListeners.has("transcription-level")).toBe(false);
});
});
});