test(web): work toward 100% mutation coverage

packages/web/eslint.config.ts

@@ -68,10 +68,38 @@ export default tseslint.config(
       "@typescript-eslint/only-throw-error": "off",
     },
   },
+  {
+    // doubleStrokeKeys is a pure helper exported alongside the SlidesPreview component purely so a test can pin its return value directly: the React `key` strings it computes never reach rendered DOM output at all (React keys are consumed internally, not written to markup), so a rendering-only test has no way to observe them -- the one case in this file where allowConstantExport's "still a component-shaped module" carve-out doesn't apply, since the export is a function, not a constant.
+    files: ["src/ui/SlidesPreview.tsx"],
+    rules: {
+      "react-refresh/only-export-components": [
+        "warn",
+        { allowConstantExport: true, allowExportNames: ["doubleStrokeKeys"] },
+      ],
+    },
+  },
+  {
+    // formatBytes and reopenTooltipLabel are pure helpers exported alongside RecentFilesPanel for the identical reason __root.tsx's own colorSchemeTooltipLabel/navbarConfig are: Mantine's Tooltip only mounts its floating label content once genuinely open, which a render-only test cannot drive, so the label logic needs to be callable directly.
+    files: ["src/ui/RecentFilesPanel.tsx"],
+    rules: {
+      "react-refresh/only-export-components": [
+        "warn",
+        {
+          allowConstantExport: true,
+          allowExportNames: ["formatBytes", "reopenTooltipLabel"],
+        },
+      ],
+    },
+  },
   {
     files: ["src/workers/**/*.ts"],
     languageOptions: { globals: { ...globals.worker } },
   },
+  {
+    // setup.ts's own window.matchMedia stub implements MediaQueryList's legacy addListener/removeListener members because the real interface still declares them as required -- deprecated does not mean absent, and a stub that only satisfies the non-deprecated half of the type would be an incomplete implementation of what it stands in for. Testing that those two members are genuinely present and callable (setup.test.ts) means calling them by name, which is exactly what this rule exists to flag in ordinary application code; scoped to the one test file that has a legitimate reason to.
+    files: ["src/test/setup.test.ts"],
+    rules: { "@typescript-eslint/no-deprecated": "off" },
+  },
   {
     files: [
       "vite.config.ts",

packages/web/package.json

@@ -80,10 +80,12 @@
     "eslint-plugin-jsx-a11y": "6.10.2",
     "eslint-plugin-react-hooks": "7.1.1",
     "eslint-plugin-react-refresh": "0.5.3",
+    "fake-indexeddb": "6.2.5",
     "globals": "17.9.0",
     "husky": "9.1.7",
     "jiti": "2.7.0",
     "jsdom": "30.0.1",
+    "ooxml.js": "8.14.7",
     "semantic-release": "25.0.9",
     "typescript": "6.0.3",
     "typescript-eslint": "8.66.0",

packages/web/src/adapters/documentConverter/workerDocumentConverter.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createMockRpcClient } from "../../test/mockRpcClient";
+
+vi.mock("../../rpc/client", () => ({ getRpcClient: vi.fn() }));
+
+import { getRpcClient } from "../../rpc/client";
+import { convertViaWorker } from "./workerDocumentConverter";
+
+describe("convertViaWorker", () => {
+  it("calls the RPC client's convert with only the source, targetFormat, and bytes fields", async () => {
+    const client = createMockRpcClient();
+    const output = {
+      document: { format: "pdf" as const, bytes: new Uint8Array([9]) },
+      diagnostics: [],
+      content: undefined,
+    };
+    vi.mocked(client.convert).mockResolvedValue(output);
+    vi.mocked(getRpcClient).mockReturnValue(client);
+
+    const controller = new AbortController();
+    const result = await convertViaWorker({
+      source: "docx",
+      targetFormat: "pdf",
+      bytes: new Uint8Array([1, 2]),
+      signal: controller.signal,
+    });
+
+    expect(client.convert).toHaveBeenCalledWith(
+      { source: "docx", targetFormat: "pdf", bytes: new Uint8Array([1, 2]) },
+      { signal: controller.signal },
+    );
+    expect(result).toEqual(output);
+  });
+
+  it("passes an undefined signal through unchanged when the caller supplies none", async () => {
+    const client = createMockRpcClient();
+    vi.mocked(client.convert).mockResolvedValue({
+      document: { format: "pdf" as const, bytes: new Uint8Array() },
+      diagnostics: [],
+      content: undefined,
+    });
+    vi.mocked(getRpcClient).mockReturnValue(client);
+
+    await convertViaWorker({
+      source: "docx",
+      targetFormat: "pdf",
+      bytes: new Uint8Array([1]),
+    });
+
+    expect(client.convert).toHaveBeenCalledWith(expect.anything(), {
+      signal: undefined,
+    });
+  });
+});

packages/web/src/adapters/fileAccess/createFileAccess.test.ts

@@ -0,0 +1,24 @@
+/// <reference lib="dom" />
+/// <reference types="wicg-file-system-access" />
+import { afterEach, describe, expect, it } from "vitest";
+
+import { createFileAccess } from "./createFileAccess";
+
+afterEach(() => {
+  Reflect.deleteProperty(window, "showOpenFilePicker");
+});
+
+describe("createFileAccess", () => {
+  it("returns the native adapter when the browser exposes showOpenFilePicker", () => {
+    window.showOpenFilePicker = (): Promise<[FileSystemFileHandle]> =>
+      Promise.reject(new Error("not used by this test"));
+    const access = createFileAccess();
+    expect(access.supportsNativePicker()).toBe(true);
+  });
+
+  it("returns the fallback adapter when the browser has no showOpenFilePicker", () => {
+    Reflect.deleteProperty(window, "showOpenFilePicker");
+    const access = createFileAccess();
+    expect(access.supportsNativePicker()).toBe(false);
+  });
+});

packages/web/src/adapters/fileAccess/fallbackFileAccess.test.ts

@@ -0,0 +1,154 @@
+/// <reference lib="dom" />
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { createFallbackFileAccess } from "./fallbackFileAccess";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// The adapter only ever reads input.files?.[0] -- a numeric-indexed, length-and-item object is all FileList's real interface requires for that, so this builds one directly rather than via object-spreading a File[] (which TypeScript flags as overwriting length/index properties it considers already declared by the array's own structural type).
+function fileList(files: File[]): FileList {
+  const list: FileList = {
+    length: files.length,
+    item: (index: number) => files[index] ?? null,
+    [Symbol.iterator]: () => files[Symbol.iterator](),
+  };
+  files.forEach((file, index) => {
+    list[index] = file;
+  });
+  return list;
+}
+
+// The adapter drives the picker via input.click(), which a real browser resolves only after the user interacts -- here we intercept the click itself to synthesize the OS picker's outcome (a chosen file, or none) before dispatching the 'change' listener the code awaits.
+function stubPickedFiles(files: File[]): void {
+  vi.spyOn(HTMLInputElement.prototype, "click").mockImplementation(function (
+    this: HTMLInputElement,
+  ) {
+    Object.defineProperty(this, "files", {
+      value: fileList(files),
+      configurable: true,
+    });
+    this.dispatchEvent(new Event("change"));
+  });
+}
+
+describe("createFallbackFileAccess", () => {
+  it("reports no native picker support", () => {
+    expect(createFallbackFileAccess().supportsNativePicker()).toBe(false);
+  });
+
+  it("resolves the opened file's bytes and name when a file is chosen", async () => {
+    const file = new File([new Uint8Array([1, 2, 3])], "report.pdf", {
+      type: "application/pdf",
+    });
+    stubPickedFiles([file]);
+    const opened = await createFallbackFileAccess().openFile({});
+    expect(opened?.name).toBe("report.pdf");
+    expect(Array.from(opened?.bytes ?? [])).toEqual([1, 2, 3]);
+    expect(opened?.handle).toBeUndefined();
+  });
+
+  it("creates a genuine file-type input element", async () => {
+    let capturedType = "";
+    vi.spyOn(HTMLInputElement.prototype, "click").mockImplementation(function (
+      this: HTMLInputElement,
+    ) {
+      capturedType = this.type;
+      Object.defineProperty(this, "files", {
+        value: fileList([]),
+        configurable: true,
+      });
+      this.dispatchEvent(new Event("change"));
+    });
+    await createFallbackFileAccess().openFile({});
+    expect(capturedType).toBe("file");
+  });
+
+  it("registers the change listener with once: true, so it never re-fires on a later change event", async () => {
+    const addEventListenerSpy = vi.spyOn(
+      HTMLInputElement.prototype,
+      "addEventListener",
+    );
+    stubPickedFiles([]);
+    await createFallbackFileAccess().openFile({});
+    const [, , options] = addEventListenerSpy.mock.calls.find(
+      ([type]) => type === "change",
+    )!;
+    expect(options).toEqual({ once: true });
+  });
+
+  it("resolves undefined when the picker is dismissed with no file chosen", async () => {
+    stubPickedFiles([]);
+    const opened = await createFallbackFileAccess().openFile({});
+    expect(opened).toBeUndefined();
+  });
+
+  it("flattens and joins an accept map's extension groups into the input's accept attribute", async () => {
+    let capturedAccept = "";
+    vi.spyOn(HTMLInputElement.prototype, "click").mockImplementation(function (
+      this: HTMLInputElement,
+    ) {
+      capturedAccept = this.accept;
+      Object.defineProperty(this, "files", {
+        value: fileList([]),
+        configurable: true,
+      });
+      this.dispatchEvent(new Event("change"));
+    });
+    await createFallbackFileAccess().openFile({
+      accept: {
+        "application/pdf": [".pdf"],
+        "text/markdown": [".md", ".markdown"],
+      },
+    });
+    expect(capturedAccept).toBe(".pdf,.md,.markdown");
+  });
+
+  it("leaves the input's accept attribute empty when no accept option is given", async () => {
+    let capturedAccept = "not set";
+    vi.spyOn(HTMLInputElement.prototype, "click").mockImplementation(function (
+      this: HTMLInputElement,
+    ) {
+      capturedAccept = this.accept;
+      Object.defineProperty(this, "files", {
+        value: fileList([]),
+        configurable: true,
+      });
+      this.dispatchEvent(new Event("change"));
+    });
+    await createFallbackFileAccess().openFile({});
+    expect(capturedAccept).toBe("");
+  });
+
+  it("saves via a Blob-URL download anchor and revokes the object URL afterwards", async () => {
+    const createObjectURLSpy = vi
+      .spyOn(URL, "createObjectURL")
+      .mockReturnValue("blob:mock-url");
+    const revokeObjectURLSpy = vi
+      .spyOn(URL, "revokeObjectURL")
+      .mockImplementation(() => {});
+    let clickedHref = "";
+    let clickedDownload = "";
+    vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(function (
+      this: HTMLAnchorElement,
+    ) {
+      clickedHref = this.href;
+      clickedDownload = this.download;
+    });
+
+    const result = await createFallbackFileAccess().saveFile(
+      new Uint8Array([1, 2, 3]),
+      { suggestedName: "out.pdf", mimeType: "application/pdf" },
+    );
+
+    expect(createObjectURLSpy).toHaveBeenCalledTimes(1);
+    const [blob] = createObjectURLSpy.mock.calls[0] as [Blob];
+    expect(blob.size).toBe(3);
+    expect(blob.type).toBe("application/pdf");
+    expect(clickedHref).toBe("blob:mock-url");
+    expect(clickedDownload).toBe("out.pdf");
+    expect(revokeObjectURLSpy).toHaveBeenCalledWith("blob:mock-url");
+    expect(result).toEqual({});
+  });
+});