Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

20.9 KB
Raw Blame
const assert = require("node:assert/strict");
const test = require("node:test");
const React = require("react");
const { createRoot } = require("react-dom/client");
const {
  createRendererServer,
  installBrowserGlobals,
  installHookDom,
} = require("../lib/rendererTestHarness");

const FIRST_LLM = "qwen3.5-4b-q4_k_m";
const SECOND_LLM = "qwen3.5-2b-q4_k_m";
const PARAKEET = "parakeet-tdt-0.6b-v3";

function findElement(node, predicate) {
  if (Array.isArray(node)) {
    for (const child of node) {
      const match = findElement(child, predicate);
      if (match) return match;
    }
    return null;
  }
  if (!node || typeof node !== "object") return null;
  return predicate(node) ? node : findElement(node.props?.children, predicate);
}

function textContent(node) {
  if (Array.isArray(node)) return node.map(textContent).join("");
  if (node && typeof node === "object") return textContent(node.props?.children);
  return node == null || typeof node === "boolean" ? "" : String(node);
}

async function createSetupHarness(
  t,
  {
    assistant = false,
    provider = assistant ? "qwen" : "whisper",
    installed = {},
    selectedModel = "",
    resumeState,
    capability = { supported: true },
    freshInstall = false,
  } = {}
) {
  let unmount = async () => {};
  t.after(() => unmount());
  const listeners = { whisper: new Set(), parakeet: new Set(), llm: new Set() };
  const inventory = {
    whisper: new Set(installed.whisper),
    parakeet: new Set(installed.parakeet),
    llm: new Set(installed.llm),
  };
  const requests = new Map();
  const events = new EventTarget();
  const subscribe = (family) => (listener) => {
    listeners[family].add(listener);
    return () => listeners[family].delete(listener);
  };
  const startDownload = (family) => (modelId) =>
    new Promise((resolve) => requests.set(modelId, { family, resolve }));
  installBrowserGlobals(t, {
    window: {
      addEventListener: events.addEventListener.bind(events),
      removeEventListener: events.removeEventListener.bind(events),
      dispatchEvent: events.dispatchEvent.bind(events),
      electronAPI: {
        getPlatform: () => "linux",
        checkParakeetInstallation: async () => capability,
        listWhisperModels: async () => ({
          success: true,
          models: [...inventory.whisper].map((model) => ({ model, downloaded: true })),
        }),
        listParakeetModels: async () => ({
          success: true,
          models: [...inventory.parakeet].map((model) => ({ model, downloaded: true })),
        }),
        modelGetAll: async () =>
          [...inventory.llm].map((id) => ({ id, isDownloaded: true, isDownloading: false })),
        modelGetActiveDownloads: async () => [],
        downloadWhisperModel: startDownload("whisper"),
        downloadParakeetModel: startDownload("parakeet"),
        modelDownload: startDownload("llm"),
        modelCancelDownload: async (modelId) => {
          const response = {
            success: false,
            code: "DOWNLOAD_CANCELLED",
            error: "Download cancelled by user",
          };
          for (const listener of listeners.llm) {
            listener({}, { type: "error", modelId, code: response.code, error: response.error });
          }
          requests.get(modelId).resolve(response);
          return { success: true };
        },
        onWhisperDownloadProgress: subscribe("whisper"),
        onParakeetDownloadProgress: subscribe("parakeet"),
        onModelDownloadProgress: subscribe("llm"),
      },
    },
  });
  const container = installHookDom(t);
  const vite = await createRendererServer(t, {
    cachePrefix: "openwhispr-local-setup-test-",
    noExternal: ["react-i18next"],
    mockModules: {
      "react-i18next": `
        const t = (key) => key;
        export function useTranslation() { return { t }; }
        export const initReactI18next = { type: "3rdParty", init() {} };
      `,
      "/OnboardingShell": `export function BrandMark() { return null; }`,
      "/ui/ProviderIcon": `export function ProviderIcon() { return null; }`,
    },
  });
  const { useSettingsStore } = await vite.ssrLoadModule("/stores/settingsStore.ts");
  useSettingsStore.setState({
    localTranscriptionProvider: provider === "nvidia" ? "nvidia" : "whisper",
    whisperModel: !assistant && provider === "whisper" ? selectedModel : "",
    parakeetModel: !assistant && provider === "nvidia" ? selectedModel : "",
    chatAgentProvider: assistant ? provider : "qwen",
    chatAgentModel: assistant ? selectedModel : "",
    chatAgentMode: "local",
  });
  // The store setter also persists the choice; only a fresh install has no key.
  if (!assistant && !freshInstall) {
    localStorage.setItem(
      "localTranscriptionProvider",
      provider === "nvidia" ? "nvidia" : "whisper"
    );
  }
  const { LocalModelSetupStep } = await vite.ssrLoadModule(
    "/components/onboarding/ProviderSetupStep.tsx"
  );
  const { ToastContext } = await vite.ssrLoadModule("/components/ui/useToast.ts");
  const pending = await vite.ssrLoadModule("/components/onboarding/pendingLocalModels.ts");
  const { default: BackgroundModelDownloadTray } = await vite.ssrLoadModule(
    "/components/onboarding/BackgroundModelDownloadTray.tsx"
  );
  let tree;
  let trayTree;
  let ready = false;
  let proceeded = false;
  let skipped = false;
  const resumeDrafts = [];
  const props = {
    stepId: assistant ? "local-assistant" : "local-dictation",
    onReadinessChange: (value) => {
      ready = value;
    },
    onProceed() {
      proceeded = true;
    },
    onSkip() {
      skipped = true;
    },
    resumeState,
    onResumeStateChange: (draft) => resumeDrafts.push(draft),
  };
  function Harness() {
    // Execute the real component and hooks with React lifecycle, while leaving
    // native controls unmounted: their returned handlers are the test boundary.
    tree = LocalModelSetupStep(props);
    trayTree = BackgroundModelDownloadTray({ placement: "onboarding" });
    return null;
  }
  const root = createRoot(container);
  const toast = { toast: () => "test-toast" };
  await React.act(async () => {
    root.render(
      React.createElement(ToastContext.Provider, { value: toast }, React.createElement(Harness))
    );
  });
  unmount = async () => {
    await React.act(async () => root.unmount());
  };

  const row = (modelId) => {
    const element = findElement(tree, (node) => node.type === "div" && node.key === modelId);
    assert.ok(element, `model row ${modelId} is visible`);
    return element;
  };
  const click = async (modelId, action) => {
    const button = findElement(
      row(modelId),
      (node) => typeof node.props?.onClick === "function" && textContent(node) === action
    );
    assert.ok(button, `${action} is available for ${modelId}: ${textContent(row(modelId))}`);
    await React.act(async () => button.props.onClick());
  };
  const emit = async (family, event) => {
    await React.act(async () => {
      for (const listener of listeners[family]) listener({}, event);
    });
  };
  const progress = async (modelId, percentage, phase = "progress") => {
    const family = requests.get(modelId).family;
    const event =
      family === "llm"
        ? { modelId, type: phase, progress: percentage, downloadedSize: percentage, totalSize: 100 }
        : {
            model: modelId,
            type: phase,
            percentage,
            downloaded_bytes: percentage,
            total_bytes: 100,
          };
    await emit(family, event);
  };
  const complete = async (modelId) => {
    const request = requests.get(modelId);
    assert.ok(request, `download ${modelId} started`);
    inventory[request.family].add(modelId);
    await React.act(async () => {
      for (const listener of listeners[request.family]) {
        listener(
          {},
          request.family === "llm"
            ? { type: "complete", modelId, progress: 100 }
            : { type: "complete", model: modelId, percentage: 100 }
        );
      }
      request.resolve({ success: true });
    });
  };
  const trayRow = (key) => {
    const element = findElement(trayTree, (node) => node.type === "div" && node.key === key);
    assert.ok(element, `tray row ${key} is visible`);
    return element;
  };
  const actionButton = (label) =>
    findElement(
      tree,
      (node) => typeof node.props?.onClick === "function" && textContent(node) === label
    );
  return {
    store: useSettingsStore,
    pending,
    row,
    click,
    progress,
    complete,
    emit,
    trayRow,
    cancel: async (modelId) => {
      const button = findElement(trayRow(`llm:${modelId}`), (node) => node.type === "button");
      await React.act(async () => button.props.onClick());
    },
    trayHeader: () => {
      const header = findElement(
        trayTree,
        (node) => node.type === "div" && String(node.props?.className).includes("gap-[5px]")
      );
      assert.ok(header, "tray header is visible");
      return textContent(header);
    },
    chooseProvider: async (providerId) => {
      const select = findElement(tree, (node) => typeof node.props?.onValueChange === "function");
      await React.act(async () => select.props.onValueChange(providerId));
    },
    proceed: async () => {
      const button = actionButton("onboarding.rehaul.provider.proceed");
      assert.equal(button.props.disabled, false, "Proceed is enabled");
      await React.act(async () => button.props.onClick());
    },
    skip: async () => {
      const button = actionButton("common.skip");
      assert.ok(button && !button.props.disabled, "Skip is enabled");
      await React.act(async () => button.props.onClick());
    },
    proceeded: () => proceeded,
    skipped: () => skipped,
    ready: () => ready,
    resumeDrafts: () => resumeDrafts,
    canProceed: () => !actionButton("onboarding.rehaul.provider.proceed").props.disabled,
    canSkip: () => {
      const button = actionButton("common.skip");
      return Boolean(button && !button.props.disabled);
    },
  };
}

for (const fixture of [
  { family: "whisper", provider: "whisper", modelId: "base", setting: "whisperModel" },
  {
    family: "parakeet",
    provider: "nvidia",
    modelId: "parakeet-tdt-0.6b-v3",
    setting: "parakeetModel",
  },
  { family: "llm", provider: "qwen", modelId: FIRST_LLM, setting: "chatAgentModel" },
]) {
  test(`Use selects an installed ${fixture.family} model without a pending download`, async (t) => {
    const setup = await createSetupHarness(t, {
      assistant: fixture.family === "llm",
      provider: fixture.provider,
      installed: { [fixture.family]: [fixture.modelId] },
    });
    assert.equal(setup.canProceed(), false);
    await setup.click(fixture.modelId, "onboarding.rehaul.local.use");
    assert.equal(setup.store.getState()[fixture.setting], fixture.modelId);
    assert.equal(setup.ready(), true);
    assert.equal(setup.canProceed(), true);
  });
}

test("a fresh install opens the local dictation step on Oruk with Orukeet offered", async (t) => {
  const setup = await createSetupHarness(t, { freshInstall: true });
  assert.ok(setup.row("orukeet-v0.1.0"));
  assert.throws(() => setup.row("base"));
});

test("an explicit installed-model choice supersedes an earlier pending download", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true, installed: { llm: [SECOND_LLM] } });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  await setup.click(SECOND_LLM, "onboarding.rehaul.local.use");
  assert.equal(setup.pending.hasPendingLocalModels(), false);
  assert.equal(setup.canProceed(), true);
  assert.equal(setup.canSkip(), true);
  await setup.complete(FIRST_LLM);
  assert.equal(setup.store.getState().chatAgentModel, SECOND_LLM);
  assert.equal(setup.ready(), true);
});

test("completion enables Proceed after the background tray consumes the pending selection", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  localStorage.setItem("localSetupPending", "true");
  await setup.complete(FIRST_LLM);
  assert.equal(setup.pending.hasPendingLocalModels(), false);
  assert.equal(setup.store.getState().chatAgentModel, FIRST_LLM);
  assert.equal(setup.ready(), true);
  assert.equal(setup.canProceed(), true);
});

test("simultaneous assistant downloads display their own progress", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
  await setup.progress(FIRST_LLM, 10);
  await setup.progress(SECOND_LLM, 80);
  assert.match(textContent(setup.row(FIRST_LLM)), /10%/);
  assert.match(textContent(setup.row(SECOND_LLM)), /80%/);
});

test("the most recently started assistant download owns pending selection", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
  assert.equal(setup.pending.readPendingLocalModels().assistant.modelId, SECOND_LLM);
  await setup.complete(FIRST_LLM);
  assert.equal(setup.store.getState().chatAgentModel, "");
  await setup.complete(SECOND_LLM);
  assert.equal(setup.store.getState().chatAgentModel, SECOND_LLM);
  assert.equal(setup.ready(), true);
});

test("a refused concurrent Whisper download preserves the original pending selection", async (t) => {
  const setup = await createSetupHarness(t);
  await setup.click("base", "onboarding.rehaul.local.download");
  await setup.click("small", "onboarding.rehaul.local.download");
  assert.equal(setup.pending.readPendingLocalModels().dictation.modelId, "base");
  await setup.complete("base");
  assert.equal(setup.store.getState().whisperModel, "base");
  assert.equal(setup.ready(), true);
});

test("cancelling the newest assistant download permits Skip without activating an older model", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
  await setup.progress(FIRST_LLM, 10);
  await setup.progress(SECOND_LLM, 20);
  await setup.cancel(SECOND_LLM);

  assert.equal(setup.pending.hasPendingLocalModels(), false);
  assert.deepEqual(
    { proceed: setup.canProceed(), skip: setup.canSkip() },
    { proceed: false, skip: true }
  );
  await setup.skip();
  assert.equal(setup.skipped(), true);
  await setup.complete(FIRST_LLM);
  assert.equal(setup.store.getState().chatAgentModel, "");
  assert.equal(setup.canProceed(), false);
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.use");
  assert.equal(setup.store.getState().chatAgentModel, FIRST_LLM);
  assert.equal(setup.canProceed(), true);
});

test("cancelling an older assistant download preserves the pending background selection", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
  await setup.progress(FIRST_LLM, 10);
  await setup.progress(SECOND_LLM, 20);
  await setup.cancel(FIRST_LLM);

  assert.equal(setup.pending.readPendingLocalModels().assistant.modelId, SECOND_LLM);
  assert.equal(setup.canProceed(), true);
  assert.equal(setup.canSkip(), true);
  await setup.proceed();
  assert.equal(setup.proceeded(), true);
  assert.equal(localStorage.getItem("localSetupPending"), "true");
  await setup.complete(SECOND_LLM);
  assert.equal(setup.store.getState().chatAgentModel, SECOND_LLM);
  assert.equal(setup.ready(), true);
});

test("browsing another dictation provider preserves the active pending background selection", async (t) => {
  const setup = await createSetupHarness(t);
  await setup.click("base", "onboarding.rehaul.local.download");
  await setup.chooseProvider("nvidia");
  assert.equal(setup.canProceed(), true);
  assert.equal(setup.canSkip(), true);
  await setup.proceed();
  assert.equal(localStorage.getItem("localSetupPending"), "true");
  await setup.complete("base");
  assert.equal(setup.store.getState().localTranscriptionProvider, "whisper");
  assert.equal(setup.store.getState().whisperModel, "base");
});

test("a resumed local-model draft overrides the previously saved model", async (t) => {
  const setup = await createSetupHarness(t, {
    assistant: true,
    installed: { llm: [FIRST_LLM, SECOND_LLM] },
    selectedModel: FIRST_LLM,
    resumeState: { provider: "qwen", modelId: SECOND_LLM },
  });

  assert.match(textContent(setup.row(SECOND_LLM)), /onboarding\.rehaul\.local\.selected/);
  assert.match(textContent(setup.row(FIRST_LLM)), /onboarding\.rehaul\.local\.use/);
  assert.equal(setup.ready(), true);
  assert.equal(setup.canProceed(), true);
});

test("Skip marks a pending model for background activation", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  assert.equal(setup.canSkip(), true);
  await setup.skip();
  assert.equal(localStorage.getItem("localSetupPending"), "true");
});

test("the assistant step can be skipped with no model selected or downloading", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  assert.equal(setup.canProceed(), false);
  await setup.skip();
  assert.equal(setup.skipped(), true);
});

test("choosing a local model records it in the resume draft", async (t) => {
  const setup = await createSetupHarness(t, {
    assistant: true,
    installed: { llm: [FIRST_LLM, SECOND_LLM] },
    selectedModel: FIRST_LLM,
  });

  await setup.click(SECOND_LLM, "onboarding.rehaul.local.use");

  // Without this the pick is only in component state, so relaunching mid-setup
  // silently reverts to whatever was saved before onboarding started.
  assert.deepEqual(setup.resumeDrafts().at(-1), { provider: "qwen", modelId: SECOND_LLM });
});

test("Oruk installs and activates Orukeet through the existing parakeet download flow", async (t) => {
  const modelId = "orukeet-v0.1.0";
  const setup = await createSetupHarness(t);
  await setup.chooseProvider("oruk");
  assert.match(textContent(setup.row(modelId)), /common\.recommended/);
  assert.equal(setup.store.getState().localTranscriptionProvider, "whisper");
  await setup.click(modelId, "onboarding.rehaul.local.download");
  assert.deepEqual(setup.pending.readPendingLocalModels().dictation, {
    provider: "nvidia",
    modelId,
  });
  await setup.complete(modelId);
  assert.equal(setup.store.getState().localTranscriptionProvider, "nvidia");
  assert.equal(setup.store.getState().parakeetModel, modelId);
  assert.equal(setup.ready(), true);
  assert.equal(setup.canProceed(), true);
});

test("browsing Oruk preserves an installed stock Parakeet selection", async (t) => {
  const modelId = "parakeet-tdt-0.6b-v3";
  const setup = await createSetupHarness(t, {
    provider: "nvidia",
    installed: { parakeet: [modelId] },
  });
  await setup.click(modelId, "onboarding.rehaul.local.use");
  await setup.chooseProvider("oruk");
  assert.equal(setup.store.getState().parakeetModel, modelId);
  assert.equal(setup.store.getState().localTranscriptionProvider, "nvidia");
  assert.equal(setup.ready(), false);
});

test("unsupported Macs cannot choose Oruk or NVIDIA during local onboarding", async (t) => {
  const setup = await createSetupHarness(t, {
    provider: "nvidia",
    capability: { supported: false, minimumMacOSVersion: "15.5" },
  });
  assert.ok(setup.row("base"));
  for (const provider of ["oruk", "nvidia"]) {
    await setup.chooseProvider(provider);
    assert.ok(setup.row("base"));
    assert.equal(setup.ready(), false);
  }
});

test("the tray header follows the transfer into its installing phase", async (t) => {
  const modelId = "parakeet-tdt-0.6b-v3";
  const setup = await createSetupHarness(t, { provider: "nvidia" });

  await setup.click(modelId, "onboarding.rehaul.local.download");
  await setup.progress(modelId, 100);
  assert.equal(setup.trayHeader(), "onboarding.rehaul.local.downloadInProgress");

  // Extraction reports no further bytes, so the header is the only thing left
  // that can tell a full bar apart from a stalled one.
  await setup.progress(modelId, 100, "installing");
  assert.equal(setup.trayHeader(), "onboarding.rehaul.local.installing");
});

test("an extracting row says so while another model is still downloading", async (t) => {
  const setup = await createSetupHarness(t, { assistant: true });
  await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
  await setup.progress(FIRST_LLM, 40);

  // The tray outlives the step that started a transfer, so a dictation model
  // picked earlier keeps extracting behind the assistant step.
  await setup.emit("parakeet", { model: PARAKEET, type: "installing", percentage: 100 });

  assert.match(
    textContent(setup.trayRow(`parakeet:${PARAKEET}`)),
    /onboarding\.rehaul\.local\.installing/
  );
  assert.match(textContent(setup.trayRow(`llm:${FIRST_LLM}`)), /40%/);
  // Not every row has reached extraction, so the strip stays on downloading.
  assert.equal(setup.trayHeader(), "onboarding.rehaul.local.downloadInProgress");
});