Skip to content

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

14.4 KB
Raw Blame
const assert = require("node:assert/strict");
const test = require("node:test");
const { mountSettingsPanel } = require("../lib/settingsPanelHarness");

const SELECTOR = "/components/ReasoningModelSelector.tsx";
const KEY = "common.apiKey";
const REJECTED = { success: false, errorCode: "credentialsRejected", status: 401 };
const props = (overrides = {}) => ({
  reasoningModel: "gpt-test",
  setReasoningModel() {},
  localReasoningProvider: "openai",
  setLocalReasoningProvider() {},
  cloudReasoningBaseUrl: "",
  setCloudReasoningBaseUrl() {},
  mode: "cloud",
  ...overrides,
});
const mount = (t, { overrides, ...options } = {}) =>
  mountSettingsPanel(t, { module: SELECTOR, props: props(overrides), ...options });

test("a saved key is checked once the panel is shown, with the panel's model", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  assert.equal(panel.phase(), "waiting");
  await panel.wait(0);
  assert.deepEqual(panel.requests(), [
    { scope: "reasoning", provider: "openai", apiKey: "sk-saved", model: "gpt-test" },
  ]);
  await panel.answer({ success: true });
  assert.equal(panel.phase(), "connected");
  assert.equal(panel.announcement(), "connected");
});

test("a provider tab that is only browsed checks its key alone", async (t) => {
  const panel = await mount(t, {
    secrets: { openaiApiKey: "sk-saved", anthropicApiKey: "sk-ant-saved" },
  });
  await panel.selectTab("anthropic");
  await panel.wait(0);
  assert.deepEqual(panel.requests(), [
    { scope: "reasoning", provider: "anthropic", apiKey: "sk-ant-saved", model: "" },
  ]);
});

test("a hidden panel waits until it is shown, and asks again each time it is shown", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" }, visible: false });
  await panel.wait(5000);
  assert.equal(panel.requests().length, 0);
  assert.equal(panel.phase(), "idle");
  await panel.setVisible(true);
  assert.equal(panel.phase(), "waiting");
  await panel.wait(0);
  assert.equal(panel.requests().length, 1);
  await panel.answer({ success: true });
  assert.equal(panel.phase(), "connected");
  await panel.setVisible(false);
  assert.equal(panel.phase(), "idle", "nothing is shown while hidden");
  await panel.setVisible(true);
  assert.equal(panel.phase(), "waiting");
  await panel.wait(0);
  // The main process answers a check it remembers at once, without asking the provider.
  assert.equal(panel.requests().length, 2, "a shown panel asks again");
  await panel.answer({ success: true });
  assert.equal(panel.phase(), "connected");
});

test("a shown panel with a remembered answer shows it at once, with no pause", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" }, visible: false });
  await panel.setVisible(true);
  await panel.wait(0); // no time passes
  assert.equal(panel.requests().length, 1, "asked as soon as it is shown");
  // The main process answers a check it remembers at once, without asking the provider.
  await panel.answer({ success: true });
  assert.equal(panel.phase(), "connected");
  assert.equal(panel.announcement(), "connected");
});

test("a key saves trimmed once its check passes or its field is left, never half typed", async (t) => {
  const panel = await mount(t);
  assert.equal(panel.phase(), "idle", "no key, no status");
  await panel.type(KEY, "  sk-pas");
  await panel.type(KEY, "  sk-pasted  ");
  await panel.wait(500);
  assert.equal(panel.requests().at(-1).apiKey, "sk-pasted");
  assert.equal(panel.state().openaiApiKey, "", "nothing is saved while the key is typed");
  await panel.answer({ success: true });
  assert.equal(panel.state().openaiApiKey, "sk-pasted", "a passing key saves at once");
  await panel.type(KEY, "sk-other");
  await panel.blur(KEY, { windowSwitch: true });
  await panel.wait(500); // the field keeps its pause while another window has focus
  assert.equal(panel.state().openaiApiKey, "sk-pasted", "nothing is saved before its answer");
  await panel.answer({ success: false, errorCode: "network", unverified: true });
  assert.equal(panel.state().openaiApiKey, "sk-other", "leaving the window saves it");
});

test("a typed key is kept when another provider takes its field, and saves on unmount", async (t) => {
  const panel = await mount(t);
  await panel.type(KEY, "sk-typed");
  // The scope's provider changes elsewhere, so the focused field shows Anthropic's key.
  await panel.setProps({ localReasoningProvider: "anthropic" });
  await panel.type(KEY, "sk-ant-typed");
  await panel.wait(500);
  await panel.answer({ success: true });
  assert.equal(panel.state().anthropicApiKey, "sk-ant-typed");
  assert.equal(panel.state().openaiApiKey, "", "another provider's answer settles nothing here");
  await panel.setProps({ localReasoningProvider: "openai" });
  assert.equal(panel.field(KEY).props.value, "sk-typed", "and is still there to come back to");
  await panel.unmount(); // Escape closing Settings fires no blur
  assert.equal(panel.state().openaiApiKey, "sk-typed");
  assert.equal(panel.state().anthropicApiKey, "sk-ant-typed");
});

test("typing keeps the 0.5 s pause, and leaving the field sends at once", async (t) => {
  const panel = await mount(t);
  await panel.type(KEY, "sk-first");
  assert.equal(panel.phase(), "waiting");
  await panel.wait(499);
  assert.equal(panel.requests().length, 0, "nothing while the pause runs");
  await panel.wait(1);
  assert.deepEqual(
    panel.requests().map((config) => config.apiKey),
    ["sk-first"]
  );
  await panel.type(KEY, "sk-second");
  await panel.wait(200);
  await panel.blur(KEY); // mid-pause
  await panel.wait(0);
  assert.deepEqual(
    panel.requests().map((config) => config.apiKey),
    ["sk-first", "sk-second"]
  );
});

test("a key typed in another shown panel still waits for the pause", async (t) => {
  const panel = await mount(t, { secrets: { anthropicApiKey: "sk-ant-saved" } });
  // The hosted key is shared: another shown panel types it, so no field here has focus.
  await panel.setStore({ openaiApiKey: "s" });
  assert.equal(panel.phase(), "waiting");
  await panel.wait(499);
  assert.equal(panel.requests().length, 0, "a half-typed key is not sent");
  await panel.setStore({ openaiApiKey: "sk" });
  await panel.wait(499);
  assert.equal(panel.requests().length, 0, "each change starts the pause over");
  await panel.wait(1);
  assert.deepEqual(
    panel.requests().map((config) => config.apiKey),
    ["sk"]
  );
  await panel.selectTab("anthropic");
  await panel.wait(0); // a tab switch checks at once, though it shows another key
  assert.deepEqual(
    panel.requests().map((config) => config.apiKey),
    ["sk", "sk-ant-saved"]
  );
});

test("a rejected key keeps its reason and Retry, and stays saved", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  await panel.wait(0);
  await panel.answer(REJECTED);
  assert.equal(panel.checkField().props.check.failure.errorCode, "credentialsRejected");
  assert.equal(panel.checkField().props.invalidOn, "credentialsRejected", "the key is at fault");
  assert.equal(panel.state().openaiApiKey, "sk-saved");
  await panel.retry();
  assert.equal(panel.requests().length, 2, "Retry does not wait for the pause");
});

test("each hosted provider shows one shared key field under Settings' heading", async (t) => {
  for (const [provider, url] of [
    ["openai", "https://platform.openai.com/api-keys"],
    ["anthropic", "https://console.anthropic.com/settings/keys"],
    ["gemini", "https://aistudio.google.com/app/api-keys"],
    ["groq", "https://console.groq.com/keys"],
    ["corti", "https://www.corti.ai/?utm_source=referral&utm_campaign=openwhispr"],
  ]) {
    await t.test(provider, async (t) => {
      const panel = await mount(t, { overrides: { localReasoningProvider: provider } });
      assert.equal(panel.field(KEY).props.type, "password");
      assert.ok(panel.field(KEY).props.check, "the key carries the status");
      assert.equal(panel.find((node) => node.props?.url === url).length, 1);
      const euOnly = panel.find((node) => node.props?.children === "reasoning.corti.euOnly");
      assert.equal(euOnly.length, provider === "corti" ? 1 : 0);
    });
  }
});

test("local mode, OpenRouter and Custom send nothing from this panel", async (t) => {
  for (const [name, overrides] of [
    ["local", { mode: "local", localReasoningProvider: "qwen" }],
    ["openrouter", { localReasoningProvider: "openrouter" }],
    ["custom", { localReasoningProvider: "custom" }],
  ]) {
    await t.test(name, async (t) => {
      const panel = await mount(t, {
        overrides,
        secrets: { openaiApiKey: "sk-saved", openrouterApiKey: "sk-or-saved" },
      });
      await panel.wait(1000);
      assert.equal(panel.requests().length, 0);
      assert.equal(panel.field(KEY), undefined);
      if (name === "openrouter") {
        assert.equal(panel.find((node) => node.props?.provider === "openrouter").length, 1);
      }
    });
  }
});

test("a key the provider refuses is never saved, and the saved key stays in use", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  await panel.wait(0);
  await panel.answer({ success: true });
  await panel.type(KEY, "sk-wrong");
  await panel.wait(500);
  await panel.answer(REJECTED);
  await panel.blur(KEY);
  assert.equal(panel.state().openaiApiKey, "sk-saved", "leaving the field keeps the saved key");
  assert.equal(panel.field(KEY).props.value, "sk-wrong", "the refused key stays to be fixed");
  // Another provider takes the field, then Settings closes: neither saves the refused key.
  await panel.setProps({ localReasoningProvider: "anthropic" });
  await panel.type(KEY, "sk-ant-typed");
  await panel.unmount();
  assert.equal(panel.state().openaiApiKey, "sk-saved");
  assert.equal(panel.state().anthropicApiKey, "sk-ant-typed");
});

for (const [answered, answer, saved] of [
  ["a refusal", REJECTED, "sk-saved"],
  ["no verdict", { success: false, errorCode: "network", unverified: true }, "sk-typed"],
  [
    "a failure about the account",
    { success: false, errorCode: "providerStatus", status: 402 },
    "sk-typed",
  ],
]) {
  test(`a key left while its check runs waits for the answer: ${answered}`, async (t) => {
    const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
    await panel.wait(0);
    await panel.answer({ success: true });
    await panel.type(KEY, "sk-typed");
    await panel.blur(KEY);
    await panel.wait(0); // leaving the field checks at once
    assert.equal(panel.state().openaiApiKey, "sk-saved", "nothing is saved before the answer");
    await panel.answer(answer);
    assert.equal(panel.state().openaiApiKey, saved);
  });
}

test("a refused key saves once a later check of it passes", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  await panel.wait(0);
  await panel.answer({ success: true });
  await panel.type(KEY, "sk-new");
  await panel.wait(500);
  await panel.answer(REJECTED);
  await panel.blur(KEY);
  await panel.retry(); // the key was only just activated
  await panel.answer({ success: true });
  assert.equal(panel.state().openaiApiKey, "sk-new");
});

test("a refused key stays unsaved when a later check gives no verdict", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  await panel.wait(0);
  await panel.answer({ success: true });
  await panel.type(KEY, "sk-wrong");
  await panel.wait(500);
  await panel.answer(REJECTED);
  await panel.blur(KEY);
  await panel.retry();
  await panel.answer({
    success: false,
    errorCode: "providerStatus",
    status: 503,
    unverified: true,
  });
  await panel.unmount();
  assert.equal(panel.state().openaiApiKey, "sk-saved");
});

test("a key left before its answer is saved as it stands when its panel is hidden", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-old" } });
  await panel.wait(0);
  await panel.answer({ success: true });
  await panel.type(KEY, "sk-new");
  await panel.blur(KEY);
  await panel.wait(0); // leaving the field checks at once
  assert.equal(panel.state().openaiApiKey, "sk-old");
  await panel.setVisible(false); // another Settings tab: no answer is coming for it
  assert.equal(panel.state().openaiApiKey, "sk-new");
});

test("a refused key stays in its field across a hidden panel and is never saved", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  await panel.wait(0);
  await panel.answer({ success: true });
  await panel.type(KEY, "sk-wrong");
  await panel.wait(500);
  await panel.answer(REJECTED);
  await panel.blur(KEY);
  await panel.setVisible(false);
  await panel.setStore({ openaiApiKey: "sk-fixed" }); // another panel saves a working key
  await panel.setVisible(true);
  await panel.wait(0);
  assert.equal(panel.field(KEY).props.value, "sk-wrong", "the refused key waits to be fixed");
  await panel.answer(REJECTED);
  await panel.unmount();
  assert.equal(panel.state().openaiApiKey, "sk-fixed");
});

test("every refused key stays refused, not only the last one", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  await panel.wait(0);
  await panel.answer({ success: true });
  for (const key of ["sk-bad1", "sk-bad2"]) {
    await panel.type(KEY, key);
    await panel.wait(500);
    await panel.answer(REJECTED);
  }
  await panel.type(KEY, "sk-bad1");
  await panel.blur(KEY);
  await panel.wait(0);
  await panel.answer({ success: false, errorCode: "network", unverified: true });
  await panel.unmount();
  assert.equal(panel.state().openaiApiKey, "sk-saved");
});

test("closing Settings saves a key typed for a provider that is no longer shown", async (t) => {
  const panel = await mount(t);
  await panel.type(KEY, "sk-typed");
  await panel.setProps({ localReasoningProvider: "anthropic" }); // the field stays focused
  await panel.unmount();
  assert.equal(panel.state().openaiApiKey, "sk-typed");
});

test("a refused key typed again is held back before its new answer", async (t) => {
  const panel = await mount(t, { secrets: { openaiApiKey: "sk-saved" } });
  await panel.wait(0);
  await panel.answer({ success: true });
  await panel.type(KEY, "sk-bad");
  await panel.wait(500);
  await panel.answer(REJECTED);
  await panel.type(KEY, "sk-saved");
  await panel.wait(500);
  await panel.answer({ success: true });
  await panel.type(KEY, "sk-bad"); // pasted back, and Settings closes before the check
  await panel.unmount();
  assert.equal(panel.state().openaiApiKey, "sk-saved");
});