glagolify/tests/background.test.js

"use strict";

const test = require("node:test");
const assert = require("node:assert/strict");
const { createBackgroundController } = require("../background.js");

function makeBrowser(initialStorage = {}, initialSessionStorage = {}) {
  let messageListener;
  let removedListener;
  const broadcasts = [];
  const stored = { ...initialStorage };
  const sessionStored = { ...initialSessionStorage };
  const storageWrites = [];
  const sessionWrites = [];
  const api = {
    runtime: {
      onMessage: {
        addListener(listener) {
          messageListener = listener;
        }
      }
    },
    storage: {
      local: {
        async get(key) {
          return { [key]: stored[key] };
        },
        async set(values) {
          storageWrites.push({ ...values });
          Object.assign(stored, values);
        }
      },
      session: {
        async get(key) {
          return { [key]: sessionStored[key] };
        },
        async set(values) {
          sessionWrites.push(structuredClone(values));
          Object.assign(sessionStored, structuredClone(values));
        }
      }
    },
    tabs: {
      async sendMessage(tabId, message) {
        broadcasts.push({ tabId, message });
        return { enabled: message.enabled };
      },
      onRemoved: {
        addListener(listener) {
          removedListener = listener;
        }
      }
    }
  };

  return {
    api,
    broadcasts,
    sessionStored,
    sessionWrites,
    stored,
    storageWrites,
    send(message, sender = {}) {
      return new Promise((resolve) => {
        let responded = false;
        const keepChannelOpen = messageListener(message, sender, (response) => {
          responded = true;
          resolve(response);
        });
        if (!keepChannelOpen && !responded) {
          resolve(undefined);
        }
      });
    },
    remove(tabId) {
      return removedListener(tabId);
    }
  };
}

test("owns absolute state per tab and supplies it to new frames", async () => {
  const fake = makeBrowser();
  const controller = createBackgroundController(fake.api);

  assert.deepEqual(
    await fake.send({ type: "glagolify:document-ready" }, { tab: { id: 17 }, frameId: 0 }),
    { enabled: false, fontStyle: "round" }
  );

  assert.deepEqual(
    await fake.send({ type: "glagolify:set-tab-enabled", tabId: 17, enabled: true }),
    { enabled: true, available: true, fontStyle: "round" }
  );
  assert.deepEqual(fake.broadcasts.at(-1), {
    tabId: 17,
    message: { type: "glagolify:set-enabled", enabled: true, fontStyle: "round" }
  });

  assert.deepEqual(
    await fake.send({ type: "glagolify:document-ready" }, { tab: { id: 17 }, frameId: 4 }),
    { enabled: true, fontStyle: "round" }
  );

  await fake.send({ type: "glagolify:set-tab-enabled", tabId: 17, enabled: true });
  assert.equal(controller.tabStates.get(17), true, "repeated absolute enable cannot invert state");

  assert.deepEqual(
    await fake.send({ type: "glagolify:set-tab-enabled", tabId: 17, enabled: false }),
    { enabled: false, available: true, fontStyle: "round" }
  );
  assert.deepEqual(
    await fake.send({ type: "glagolify:document-ready" }, { tab: { id: 17 }, frameId: 5 }),
    { enabled: false, fontStyle: "round" }
  );

  await fake.remove(17);
  assert.equal(controller.tabStates.has(17), false);
});

test("restores tab state after an MV3 background worker restart", async () => {
  const firstWorker = makeBrowser();
  createBackgroundController(firstWorker.api);
  await firstWorker.send({
    type: "glagolify:set-tab-enabled",
    tabId: 23,
    enabled: true
  });

  assert.deepEqual(firstWorker.sessionStored, {
    glagolifyTabStates: { 23: true }
  });

  const restartedWorker = makeBrowser({}, firstWorker.sessionStored);
  createBackgroundController(restartedWorker.api);
  assert.deepEqual(
    await restartedWorker.send(
      { type: "glagolify:document-ready" },
      { tab: { id: 23 } }
    ),
    { enabled: true, fontStyle: "round" }
  );
  assert.deepEqual(
    await restartedWorker.send({
      type: "glagolify:get-tab-state",
      tabId: 23
    }),
    { enabled: true, available: true, fontStyle: "round" }
  );
});

test("keeps states isolated between tabs and reports protected tabs", async () => {
  const fake = makeBrowser();
  createBackgroundController(fake.api);

  await fake.send({ type: "glagolify:set-tab-enabled", tabId: 3, enabled: true });
  assert.deepEqual(
    await fake.send({ type: "glagolify:document-ready" }, { tab: { id: 4 } }),
    { enabled: false, fontStyle: "round" }
  );

  fake.api.tabs.sendMessage = async () => {
    throw new Error("No matching recipient");
  };
  assert.deepEqual(
    await fake.send({ type: "glagolify:get-tab-state", tabId: 99 }),
    { enabled: false, available: false, fontStyle: "round" }
  );
});

test("persists every font style and updates only enabled tabs", async () => {
  const fake = makeBrowser({ glagolifyFontStyle: "missal-angular" });
  const controller = createBackgroundController(fake.api);

  assert.deepEqual(
    await fake.send({ type: "glagolify:document-ready" }, { tab: { id: 7 } }),
    { enabled: false, fontStyle: "missal-angular" }
  );

  await fake.send({ type: "glagolify:set-tab-enabled", tabId: 7, enabled: true });
  await fake.send({ type: "glagolify:set-tab-enabled", tabId: 8, enabled: false });

  for (const fontStyle of ["round", "angular-sans", "angular", "missal-angular"]) {
    const broadcastCount = fake.broadcasts.length;
    assert.deepEqual(
      await fake.send({ type: "glagolify:set-font-style", fontStyle }),
      { fontStyle, accepted: true }
    );
    assert.deepEqual(fake.storageWrites.at(-1), { glagolifyFontStyle: fontStyle });
    assert.equal(controller.getFontStyle(), fontStyle);
    assert.deepEqual(fake.broadcasts.slice(broadcastCount), [
      {
        tabId: 7,
        message: {
          type: "glagolify:set-enabled",
          enabled: true,
          fontStyle
        }
      }
    ]);
  }

  const writesBeforeRejection = fake.storageWrites.length;
  const broadcastsBeforeRejection = fake.broadcasts.length;
  assert.deepEqual(
    await fake.send({ type: "glagolify:set-font-style", fontStyle: "italic" }),
    { fontStyle: "missal-angular", accepted: false }
  );
  assert.equal(fake.storageWrites.length, writesBeforeRejection);
  assert.equal(fake.broadcasts.length, broadcastsBeforeRejection);
});