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);
});

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("applyBestMatchOnly keeps only the strongest quality band when enabled", () => {
  const filtered = background.applyBestMatchOnly([
    { id: "livingston", title: "Livingston Dell", quality: "exact" },
    { id: "rusty", title: "Rusty Ryan", quality: "host" },
    { id: "linus", title: "Linus Caldwell", quality: "scheme" }
  ], true);

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

test("applyBestMatchOnly preserves all matches when disabled", () => {
  const filtered = background.applyBestMatchOnly([
    { id: "livingston", title: "Livingston Dell", quality: "exact" },
    { id: "rusty", title: "Rusty Ryan", quality: "host" }
  ], false);

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

test("matched login credential requests include the page URL for URL validation", () => {
  assert.deepEqual(background.matchedLoginCredentialRequest({
    bearerToken: "token-1"
  }, "vault-console", "https://bellagio.example.invalid/login"), {
    action: "get-login",
    bearerToken: "token-1",
    entryId: "vault-console",
    url: "https://bellagio.example.invalid/login"
  });
});

test("explicit selected credential requests omit the page URL", () => {
  assert.deepEqual(background.selectedLoginCredentialRequest({
    bearerToken: "token-1"
  }, "no-url-entry"), {
    action: "get-login",
    bearerToken: "token-1",
    entryId: "no-url-entry"
  });
});