keepassgo/browser/extension/background.test.cjs

const test = require("node:test");
const assert = require("node:assert/strict");

const background = require("./background.js");

test("normalizePageState preserves focused and pending field targets", () => {
  const state = background.normalizePageState({
    tabId: 7,
    pageUrl: "https://vault.example.invalid/login",
    focusTarget: { role: "username", formIndex: 0, fieldIndex: 1 },
    pendingTarget: { role: "password", formIndex: 0, fieldIndex: 2 }
  });

  assert.deepEqual(state.focusTarget, { role: "username", formIndex: 0, fieldIndex: 1 });
  assert.deepEqual(state.pendingTarget, { role: "password", formIndex: 0, fieldIndex: 2 });
});

test("shouldReuseMatches only reuses recent non-pending page matches", () => {
  const recentState = {
    pageHasLoginForm: true,
    matches: [{ id: "vault-console" }],
    pendingFill: false,
    updatedAt: Date.now()
  };
  assert.equal(background.shouldReuseMatches(recentState, false), true);

  assert.equal(background.shouldReuseMatches({ ...recentState, pendingFill: true }, false), false);
  assert.equal(background.shouldReuseMatches({ ...recentState, pageHasLoginForm: false }, false), false);
  assert.equal(background.shouldReuseMatches(recentState, true), false);
});

test("actionPresentationForState prioritizes approval visibility", () => {
  const presentation = background.actionPresentationForState({
    pendingFill: true,
    pendingMessage: "Approve the browser fill request in KeePassGO.",
    configured: true,
    success: true,
    pageHasLoginForm: true,
    matches: [{ id: "vault-console" }]
  });

  assert.equal(presentation.badgeText, "!");
  assert.equal(presentation.color, "#9f5f0e");
  assert.match(presentation.title, /approve/i);
});

test("tokenPendingApprovalCount reads token-scoped approval state", () => {
  assert.equal(background.tokenPendingApprovalCount({ tokenPendingApprovalCount: 2 }), 2);
  assert.equal(background.tokenPendingApprovalCount({}), 0);
});

test("shouldContinueWatchingState keeps polling locked login pages", () => {
  assert.equal(background.shouldContinueWatchingState({
    pageHasLoginForm: true,
    pendingFill: false,
    status: { locked: true }
  }), true);
  assert.equal(background.shouldContinueWatchingState({
    pageHasLoginForm: true,
    pendingFill: true,
    status: { locked: false }
  }), true);
  assert.equal(background.shouldContinueWatchingState({
    pageHasLoginForm: true,
    pendingFill: false,
    status: { locked: false }
  }), false);
});

test("default settings include a blank bearer token that can be overridden by harness patching", () => {
  assert.equal(background.defaultSettings.bearerToken, "");
  assert.equal(background.defaultSettings.bestMatchOnly, false);
  assert.equal(background.defaultSettings.requireSchemeMatch, false);
  assert.equal(background.defaultSettings.sortResults, "quality");
});

test("savePlanForObservedLogin prefers updating an exact username match", () => {
  const plan = background.savePlanForObservedLogin({
    username: "dannyocean",
    password: "bellagio-safe",
    url: "https://vault.example.invalid/login"
  }, [
    {
      id: "vault-console",
      title: "Vault Console",
      username: "dannyocean",
      url: "vault.example.invalid",
      path: ["Crew", "Internet"]
    },
    {
      id: "bellagio-backup",
      title: "Bellagio Backup",
      username: "rustyryan",
      url: "vault.example.invalid",
      path: ["Crew", "Internet"]
    }
  ]);

  assert.deepEqual(plan, {
    mode: "update",
    entryId: "vault-console",
    title: "Vault Console",
    path: ["Crew", "Internet"],
    username: "dannyocean",
    password: "bellagio-safe",
    url: "https://vault.example.invalid/login"
  });
});

test("savePlanForObservedLogin falls back to saving into the current page group", () => {
  const plan = background.savePlanForObservedLogin({
    username: "linuscaldwell",
    password: "yellow-chip",
    url: "https://vault.example.invalid/login"
  }, [
    {
      id: "vault-console",
      title: "Vault Console",
      username: "dannyocean",
      url: "vault.example.invalid",
      path: ["Crew", "Internet"]
    }
  ]);

  assert.deepEqual(plan, {
    mode: "save",
    entryId: "",
    title: "vault.example.invalid",
    path: ["Crew", "Internet"],
    username: "linuscaldwell",
    password: "yellow-chip",
    url: "https://vault.example.invalid/login"
  });
});

test("applyMatchControls keeps only the strongest quality band when best-match-only is enabled", () => {
  const filtered = background.applyMatchControls([
    { id: "livingston", title: "Livingston Dell", quality: "exact" },
    { id: "rusty", title: "Rusty Ryan", quality: "host" },
    { id: "linus", title: "Linus Caldwell", quality: "scheme" }
  ], {
    bestMatchOnly: true,
    requireSchemeMatch: false,
    sortResults: "quality"
  }, "https://vault.example.invalid/login");

  assert.deepEqual(filtered.map((match) => match.id), ["livingston"]);
});

test("applyMatchControls removes explicit scheme mismatches but keeps scheme-less matches", () => {
  const filtered = background.applyMatchControls([
    { id: "yen", title: "The Amazing Yen", url: "https://vault.example.invalid/login", quality: "exact" },
    { id: "saul", title: "Saul Bloom", url: "http://vault.example.invalid/login", quality: "exact" },
    { id: "basher", title: "Basher Tarr", url: "vault.example.invalid", quality: "host" }
  ], {
    bestMatchOnly: false,
    requireSchemeMatch: true,
    sortResults: "quality"
  }, "https://vault.example.invalid/login");

  assert.deepEqual(filtered.map((match) => match.id), ["yen", "basher"]);
});

test("applyMatchControls sorts by path when requested", () => {
  const filtered = background.applyMatchControls([
    { id: "linus", title: "Linus Caldwell", path: ["Crew", "Inside"] },
    { id: "rusty", title: "Rusty Ryan", path: ["Crew", "Casino"] },
    { id: "danny", title: "Danny Ocean", path: ["Crew"] }
  ], {
    bestMatchOnly: false,
    requireSchemeMatch: false,
    sortResults: "path"
  }, "https://vault.example.invalid/login");

  assert.deepEqual(filtered.map((match) => match.id), ["danny", "rusty", "linus"]);
});