test(superdoc): push test coverage (#2840)

* test(superdoc): quick wins + WhiteboardPage deep coverage

- read-file, use-selected-text, use-high-contrast, comment-focus (new)
- WhiteboardPage image onload/onerror/transform paths + editTextNode
- create-app.js devtools edge cases

Lifts coverage 90.07% → 91.33%.

* test(collab): cover setupAwarenessHandler branches

Author: caio-pizzol

packages/superdoc/src/composables/use-high-contrast-mode.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { useHighContrastMode } from './use-high-contrast-mode.js';
+
+describe('useHighContrastMode', () => {
+  it('exposes a shared reactive isHighContrastMode flag defaulting to false', () => {
+    const { isHighContrastMode, setHighContrastMode } = useHighContrastMode();
+    setHighContrastMode(false);
+    expect(isHighContrastMode.value).toBe(false);
+  });
+
+  it('setHighContrastMode updates the flag', () => {
+    const { isHighContrastMode, setHighContrastMode } = useHighContrastMode();
+    setHighContrastMode(true);
+    expect(isHighContrastMode.value).toBe(true);
+    setHighContrastMode(false);
+    expect(isHighContrastMode.value).toBe(false);
+  });
+
+  it('state is shared across invocations (module-scoped ref)', () => {
+    const a = useHighContrastMode();
+    const b = useHighContrastMode();
+    a.setHighContrastMode(true);
+    expect(b.isHighContrastMode.value).toBe(true);
+    a.setHighContrastMode(false);
+  });
+});

packages/superdoc/src/composables/use-selected-text.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { ref } from 'vue';
+import { useSelectedText } from './use-selected-text.js';
+
+const makeEditor = (textBetween) => ({
+  state: {
+    doc: { textBetween: (from, to, sep) => textBetween(from, to, sep) },
+    selection: { from: 3, to: 7 },
+  },
+});
+
+describe('useSelectedText', () => {
+  it('returns empty string when ref is null', () => {
+    const { selectedText } = useSelectedText(ref(null));
+    expect(selectedText.value).toBe('');
+  });
+
+  it('returns empty string when editor has no state', () => {
+    const { selectedText } = useSelectedText(ref({}));
+    expect(selectedText.value).toBe('');
+  });
+
+  it('returns textBetween over the current selection range, space-joined', () => {
+    const fn = (from, to, sep) => `text[${from}..${to}|${sep}]`;
+    const { selectedText } = useSelectedText(ref(makeEditor(fn)));
+    expect(selectedText.value).toBe('text[3..7| ]');
+  });
+
+  it('recomputes when the editor ref changes', () => {
+    const r = ref(makeEditor(() => 'first'));
+    const { selectedText } = useSelectedText(r);
+    expect(selectedText.value).toBe('first');
+    r.value = makeEditor(() => 'second');
+    expect(selectedText.value).toBe('second');
+  });
+});

packages/superdoc/src/core/collaboration/setup-awareness-handler.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('y-websocket', () => ({ WebsocketProvider: class {} }));
+vi.mock('@hocuspocus/provider', () => ({ HocuspocusProvider: class {} }));
+vi.mock('yjs', () => ({ Doc: class {} }));
+vi.mock('@superdoc/common/collaboration/awareness', () => ({
+  awarenessStatesToArray: vi.fn(() => [{ name: 'X' }]),
+}));
+
+import { setupAwarenessHandler } from './collaboration.js';
+
+const makeAwareness = (overrides = {}) => {
+  const listeners = new Map();
+  return {
+    setLocalStateField: vi.fn(),
+    on: vi.fn((event, fn) => listeners.set(event, fn)),
+    off: vi.fn(),
+    getStates: vi.fn(() => new Map([[1, { user: { name: 'Alice' } }]])),
+    _listeners: listeners,
+    ...overrides,
+  };
+};
+
+describe('setupAwarenessHandler', () => {
+  it('warns and returns a no-op cleanup when provider has no awareness', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const cleanup = setupAwarenessHandler({}, { emit: vi.fn() }, { name: 'A' });
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('missing awareness'));
+    expect(typeof cleanup).toBe('function');
+    expect(() => cleanup()).not.toThrow();
+    warn.mockRestore();
+  });
+
+  it('sets the local user state when setLocalStateField is available', () => {
+    const awareness = makeAwareness();
+    const user = { name: 'Alice', email: 'a@x.com' };
+    setupAwarenessHandler({ awareness }, { emit: vi.fn() }, user);
+    expect(awareness.setLocalStateField).toHaveBeenCalledWith('user', user);
+  });
+
+  it('skips setLocalStateField when user is falsy', () => {
+    const awareness = makeAwareness();
+    setupAwarenessHandler({ awareness }, { emit: vi.fn() }, null);
+    expect(awareness.setLocalStateField).not.toHaveBeenCalled();
+  });
+
+  it('skips setLocalStateField when awareness has no such method', () => {
+    const awareness = makeAwareness({ setLocalStateField: undefined });
+    setupAwarenessHandler({ awareness }, { emit: vi.fn() }, { name: 'A' });
+    // no throw
+  });
+
+  it('listens on change and invokes awarenessHandler on emission', () => {
+    const awareness = makeAwareness();
+    const emit = vi.fn();
+    setupAwarenessHandler({ awareness }, { emit }, { name: 'A' });
+    expect(awareness.on).toHaveBeenCalledWith('change', expect.any(Function));
+    const handler = awareness._listeners.get('change');
+    handler({ added: [1], removed: [] });
+    expect(emit).toHaveBeenCalledWith('awareness-update', expect.objectContaining({ added: [1], removed: [] }));
+  });
+
+  it('cleanup removes the change listener when awareness.off is available', () => {
+    const awareness = makeAwareness();
+    const cleanup = setupAwarenessHandler({ awareness }, { emit: vi.fn() }, { name: 'A' });
+    cleanup();
+    expect(awareness.off).toHaveBeenCalledWith('change', expect.any(Function));
+  });
+
+  it('cleanup is a no-op when awareness.off is not a function', () => {
+    const awareness = makeAwareness({ off: 'not-a-function' });
+    const cleanup = setupAwarenessHandler({ awareness }, { emit: vi.fn() }, { name: 'A' });
+    expect(() => cleanup()).not.toThrow();
+  });
+});

packages/superdoc/src/core/create-app-edges.test.js

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const createAppMock = vi.fn();
+const createPiniaMock = vi.fn();
+const useSuperdocStoreMock = vi.fn();
+const useCommentsStoreMock = vi.fn();
+const useHighContrastModeMock = vi.fn();
+const clickOutsideDirectiveMock = vi.fn();
+
+vi.mock('vue', () => ({ createApp: createAppMock }));
+vi.mock('pinia', () => ({ createPinia: createPiniaMock }));
+vi.mock('@superdoc/common', () => ({ vClickOutside: clickOutsideDirectiveMock }));
+vi.mock('../stores/superdoc-store', () => ({ useSuperdocStore: useSuperdocStoreMock }));
+vi.mock('../stores/comments-store', () => ({ useCommentsStore: useCommentsStoreMock }));
+vi.mock('../composables/use-high-contrast-mode', () => ({
+  useHighContrastMode: useHighContrastModeMock,
+}));
+vi.mock('../SuperDoc.vue', () => ({ default: { name: 'SuperDocMock' } }));
+
+const setupAppMocks = () => {
+  const originalUnmount = vi.fn();
+  const app = {
+    use: vi.fn(),
+    directive: vi.fn(),
+    unmount: originalUnmount,
+  };
+  createAppMock.mockReturnValue(app);
+  createPiniaMock.mockReturnValue({});
+  useSuperdocStoreMock.mockReturnValue({});
+  useCommentsStoreMock.mockReturnValue({});
+  useHighContrastModeMock.mockReturnValue({});
+  return { app, originalUnmount };
+};
+
+const safeDelete = (key) => {
+  const desc = Object.getOwnPropertyDescriptor(globalThis, key);
+  if (!desc || desc.configurable !== false) {
+    delete globalThis[key];
+  }
+};
+
+describe('createSuperdocVueApp edge cases', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    safeDelete('__VUE_DEVTOOLS_GLOBAL_HOOK__');
+    safeDelete('__VUE_DEVTOOLS_PLUGINS__');
+  });
+
+  afterEach(() => {
+    safeDelete('__VUE_DEVTOOLS_GLOBAL_HOOK__');
+    safeDelete('__VUE_DEVTOOLS_PLUGINS__');
+  });
+
+  it('handles queue replacement via property setter', async () => {
+    const { app } = setupAppMocks();
+    const { createSuperdocVueApp } = await import('./create-app.js');
+    createSuperdocVueApp({ disablePiniaDevtools: true });
+
+    const newQueue = [];
+    globalThis.__VUE_DEVTOOLS_PLUGINS__ = newQueue;
+    newQueue.push([{ id: 'dev.esm.pinia', app }, vi.fn()]);
+    expect(newQueue).toHaveLength(0);
+
+    const otherApp = {};
+    newQueue.push([{ id: 'dev.esm.pinia', app: otherApp }, vi.fn()]);
+    expect(newQueue).toHaveLength(1);
+  });
+
+  it('handles multiple unmount calls safely', async () => {
+    const { app } = setupAppMocks();
+    const { createSuperdocVueApp } = await import('./create-app.js');
+    createSuperdocVueApp({ disablePiniaDevtools: true });
+    app.unmount();
+    app.unmount(); // second call — no-op via ref count guard
+    expect(true).toBe(true);
+  });
+
+  it('handles non-array pre-existing queue', async () => {
+    globalThis.__VUE_DEVTOOLS_PLUGINS__ = { notAnArray: true };
+    const { app } = setupAppMocks();
+    const { createSuperdocVueApp } = await import('./create-app.js');
+    expect(() => createSuperdocVueApp({ disablePiniaDevtools: true })).not.toThrow();
+  });
+
+  it('emits unrelated events without suppression', async () => {
+    const emitSpy = vi.fn(() => 'emitted');
+    globalThis.__VUE_DEVTOOLS_GLOBAL_HOOK__ = { emit: emitSpy };
+    const { app } = setupAppMocks();
+    const { createSuperdocVueApp } = await import('./create-app.js');
+    createSuperdocVueApp({ disablePiniaDevtools: true });
+    const hook = globalThis.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+    expect(hook.emit('other-event', { id: 'other', app: {} })).toBe('emitted');
+    expect(emitSpy).toHaveBeenCalled();
+  });
+
+  it('returns app + stores from factory', async () => {
+    const { app } = setupAppMocks();
+    const { createSuperdocVueApp } = await import('./create-app.js');
+    const result = createSuperdocVueApp({ disablePiniaDevtools: false });
+    expect(result.app).toBe(app);
+    expect(result.pinia).toBeDefined();
+    expect(result.superdocStore).toBeDefined();
+    expect(result.commentsStore).toBeDefined();
+    expect(result.highContrastModeStore).toBeDefined();
+  });
+
+  it('replacing hook at runtime picks up new hook instance', async () => {
+    const { app } = setupAppMocks();
+    const { createSuperdocVueApp } = await import('./create-app.js');
+    createSuperdocVueApp({ disablePiniaDevtools: true });
+
+    const firstEmit = vi.fn(() => 'a');
+    globalThis.__VUE_DEVTOOLS_GLOBAL_HOOK__ = { emit: firstEmit };
+    let hook = globalThis.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+    expect(hook.emit('devtools-plugin:setup', { id: 'dev.esm.pinia', app }, vi.fn())).toBeUndefined();
+
+    const secondEmit = vi.fn(() => 'b');
+    globalThis.__VUE_DEVTOOLS_GLOBAL_HOOK__ = { emit: secondEmit };
+    hook = globalThis.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+    expect(hook.emit('devtools-plugin:setup', { id: 'dev.esm.pinia', app }, vi.fn())).toBeUndefined();
+  });
+
+  it('replacement queue also intercepts pinia setup for suppressed app', async () => {
+    const { app } = setupAppMocks();
+    const { createSuperdocVueApp } = await import('./create-app.js');
+    createSuperdocVueApp({ disablePiniaDevtools: true });
+
+    const replacement1 = [];
+    globalThis.__VUE_DEVTOOLS_PLUGINS__ = replacement1;
+    replacement1.push([{ id: 'dev.esm.pinia', app }, vi.fn()]);
+    expect(replacement1).toHaveLength(0);
+
+    // Replace again — new queue should also get patched
+    const replacement2 = [];
+    globalThis.__VUE_DEVTOOLS_PLUGINS__ = replacement2;
+    replacement2.push([{ id: 'dev.esm.pinia', app }, vi.fn()]);
+    expect(replacement2).toHaveLength(0);
+  });
+});

packages/superdoc/src/core/pdf/helpers/read-file.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileAsArrayBuffer } from './read-file.js';
+
+describe('readFileAsArrayBuffer', () => {
+  class FakeReader {
+    constructor() {
+      this.onload = null;
+      this.onerror = null;
+    }
+    readAsDataURL() {
+      this._invoke();
+    }
+  }
+
+  const originalFileReader = globalThis.FileReader;
+
+  beforeEach(() => {
+    globalThis.FileReader = FakeReader;
+  });
+
+  afterEach(() => {
+    globalThis.FileReader = originalFileReader;
+  });
+
+  it('resolves with the reader result on load', async () => {
+    FakeReader.prototype._invoke = function () {
+      queueMicrotask(() => this.onload({ target: { result: 'data:url' } }));
+    };
+    const blob = new Blob(['abc']);
+    await expect(readFileAsArrayBuffer(blob)).resolves.toBe('data:url');
+  });
+
+  it('rejects when the reader emits an error', async () => {
+    FakeReader.prototype._invoke = function () {
+      queueMicrotask(() => this.onerror(new Error('bad read')));
+    };
+    const blob = new Blob(['abc']);
+    await expect(readFileAsArrayBuffer(blob)).rejects.toThrow('bad read');
+  });
+});