browser-extension-manager 1.3.49 → 1.5.0

package/dist/popup.js

@@ -3,6 +3,7 @@ import webManager from 'web-manager';
 import extension from './lib/extension.js';
 import LoggerLite from './lib/logger-lite.js';
 import { syncWithBackground, setupAuthBroadcastListener, setupSignOutListener, setupAuthEventListeners, openAuthPage as openAuthPageHelper } from './lib/auth-helpers.js';
+import { attachTo as attachModeHelpers } from './utils/mode-helpers.js';
 
 // Import theme (exposes Bootstrap to window.bootstrap)
 import '__theme__/_theme.js';
@@ -59,5 +60,8 @@ class Manager {
   }
 }
 
+// Cross-context helpers — Manager.isTesting() / isDevelopment() / etc.
+attachModeHelpers(Manager);
+
 // Export
 export default Manager;

package/dist/sidepanel.js

@@ -3,6 +3,7 @@ import webManager from 'web-manager';
 import extension from './lib/extension.js';
 import LoggerLite from './lib/logger-lite.js';
 import { syncWithBackground, setupAuthBroadcastListener, setupSignOutListener, setupAuthEventListeners, openAuthPage as openAuthPageHelper } from './lib/auth-helpers.js';
+import { attachTo as attachModeHelpers } from './utils/mode-helpers.js';
 
 // Import theme (exposes Bootstrap to window.bootstrap)
 import '__theme__/_theme.js';
@@ -59,5 +60,8 @@ class Manager {
   }
 }
 
+// Cross-context helpers — Manager.isTesting() / isDevelopment() / etc.
+attachModeHelpers(Manager);
+
 // Export
 export default Manager;

package/dist/test/assert.js

@@ -0,0 +1,120 @@
+// Tiny expect() — Jest/Vitest-compatible subset.
+// Each matcher throws on failure; the runner catches.
+
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== 'object') return false;
+
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((x, i) => deepEqual(x, b[i]));
+  }
+
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => deepEqual(a[k], b[k]));
+}
+
+function fmt(v) {
+  if (typeof v === 'string') return JSON.stringify(v);
+  if (v === undefined) return 'undefined';
+  try {
+    return JSON.stringify(v);
+  } catch (e) {
+    return String(v);
+  }
+}
+
+function fail(message) {
+  const err = new Error(message);
+  err.name = 'AssertionError';
+  throw err;
+}
+
+function buildMatchers(actual, negated) {
+  const not = negated ? 'not ' : '';
+
+  function check(cond, message) {
+    if (negated) cond = !cond;
+    if (!cond) fail(message);
+  }
+
+  return {
+    toBe(expected) {
+      check(actual === expected, `expected ${fmt(actual)} ${not}to be ${fmt(expected)}`);
+    },
+    toEqual(expected) {
+      check(deepEqual(actual, expected), `expected ${fmt(actual)} ${not}to deeply equal ${fmt(expected)}`);
+    },
+    toBeTruthy() {
+      check(!!actual, `expected ${fmt(actual)} ${not}to be truthy`);
+    },
+    toBeFalsy() {
+      check(!actual, `expected ${fmt(actual)} ${not}to be falsy`);
+    },
+    toBeDefined() {
+      check(actual !== undefined, `expected ${fmt(actual)} ${not}to be defined`);
+    },
+    toBeUndefined() {
+      check(actual === undefined, `expected ${fmt(actual)} ${not}to be undefined`);
+    },
+    toBeNull() {
+      check(actual === null, `expected ${fmt(actual)} ${not}to be null`);
+    },
+    toContain(item) {
+      const has = Array.isArray(actual)
+        ? actual.includes(item)
+        : (typeof actual === 'string' && actual.includes(item));
+      check(has, `expected ${fmt(actual)} ${not}to contain ${fmt(item)}`);
+    },
+    toHaveProperty(key) {
+      const has = actual != null && Object.prototype.hasOwnProperty.call(actual, key);
+      check(has, `expected ${fmt(actual)} ${not}to have property "${key}"`);
+    },
+    toMatch(regex) {
+      check(regex.test(actual), `expected ${fmt(actual)} ${not}to match ${regex}`);
+    },
+    toBeInstanceOf(cls) {
+      check(actual instanceof cls, `expected value ${not}to be instance of ${cls.name}`);
+    },
+    toBeGreaterThan(n) {
+      check(actual > n, `expected ${fmt(actual)} ${not}to be > ${n}`);
+    },
+    toBeLessThan(n) {
+      check(actual < n, `expected ${fmt(actual)} ${not}to be < ${n}`);
+    },
+    async toThrow(matcher) {
+      let threw = false;
+      let thrown;
+      try {
+        if (typeof actual === 'function') {
+          await actual();
+        }
+      } catch (e) {
+        threw = true;
+        thrown = e;
+      }
+      if (!threw) {
+        return check(false, `expected function ${not}to throw`);
+      }
+      if (matcher instanceof RegExp) {
+        check(matcher.test(thrown.message), `expected thrown message ${not}to match ${matcher} (got: ${thrown.message})`);
+      } else if (typeof matcher === 'string') {
+        check(thrown.message.includes(matcher), `expected thrown message ${not}to contain "${matcher}" (got: ${thrown.message})`);
+      } else {
+        check(true, '');
+      }
+    },
+  };
+}
+
+function expect(actual) {
+  const m = buildMatchers(actual, false);
+  m.not = buildMatchers(actual, true);
+  return m;
+}
+
+module.exports = expect;

package/dist/test/fixtures/consumer-extension/dist/background.js

@@ -0,0 +1,15 @@
+// BXM fixture consumer — pretends to be a real BXM-based extension's background.
+// Boot tests verify this SW comes up cleanly and exposes a couple of probe hooks.
+
+globalThis.__bxmFixtureBooted = true;
+globalThis.__bxmFixtureBootedAt = Date.now();
+
+chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
+  if (msg && msg.type === 'fixture:hello') {
+    sendResponse({ ok: true, version: chrome.runtime.getManifest().version });
+    return false;
+  }
+  return false;
+});
+
+console.log('[bxm-fixture] background ready');

package/dist/test/fixtures/consumer-extension/dist/manifest.json

@@ -0,0 +1,20 @@
+{
+  "manifest_version": 3,
+  "name": "BXM Fixture Consumer",
+  "version": "0.1.0",
+  "description": "Used by BXM's boot-layer tests as a stand-in for a real consumer extension.",
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_popup": "popup.html",
+    "default_title": "BXM Fixture Consumer"
+  },
+  "options_ui": {
+    "page": "options.html",
+    "open_in_tab": true
+  },
+  "permissions": [
+    "storage"
+  ]
+}

package/dist/test/fixtures/consumer-extension/dist/options.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>BXM Fixture Consumer — Options</title>
+</head>
+<body>
+  <h1>Fixture Options</h1>
+</body>
+</html>

package/dist/test/fixtures/consumer-extension/dist/popup.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>BXM Fixture Consumer — Popup</title>
+</head>
+<body>
+  <h1 id="main-content">Fixture Popup</h1>
+  <p>Boot tests assert that this page renders inside Chromium when loaded as an unpacked extension.</p>
+</body>
+</html>

package/dist/test/harness/extension/background.js

@@ -0,0 +1,26 @@
+// BXM test-harness background service worker.
+//
+// This SW does ONE job: stay alive long enough for the chromium runner to attach
+// a CDP session and inject test code via Runtime.evaluate. The runner discovers
+// this SW via Puppeteer's service-worker target API, then drives test execution
+// directly from the parent Node process — this file is intentionally minimal.
+//
+// We set a couple of globals the injected test code can rely on:
+//   globalThis.BXM_TEST_MODE — picked up by Manager.isTesting()
+//   globalThis.__bxmTestEmit — defined by the runner before each test;
+//                              used by injected code to report results
+//
+// We also publish a `chrome.runtime.onMessage` ping handler so view-layer tests
+// (running in popup/options/sidepanel tabs) can verify the SW is alive.
+
+globalThis.BXM_TEST_MODE = true;
+
+chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
+  if (msg && msg.type === 'bxm:test:ping') {
+    sendResponse({ pong: true, ts: Date.now() });
+    return false; // sync response
+  }
+  return false;
+});
+
+console.log('[bxm-harness] service worker ready');

package/dist/test/harness/extension/manifest.json

@@ -0,0 +1,27 @@
+{
+  "manifest_version": 3,
+  "name": "BXM Test Harness",
+  "version": "1.0.0",
+  "description": "Loaded by the chromium runner to host background + view layer tests.",
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_popup": "popup.html",
+    "default_title": "BXM Test Harness"
+  },
+  "options_ui": {
+    "page": "options.html",
+    "open_in_tab": true
+  },
+  "side_panel": {
+    "default_path": "sidepanel.html"
+  },
+  "permissions": [
+    "storage",
+    "sidePanel"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ]
+}

package/dist/test/harness/extension/options.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>BXM Test Harness — Options</title>
+</head>
+<body data-bxm-context="options">
+  <h3 id="title">BXM Test Harness — Options</h3>
+  <p id="status">ready</p>
+  <pre id="log"></pre>
+</body>
+</html>

package/dist/test/harness/extension/popup.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>BXM Test Harness — Popup</title>
+</head>
+<body data-bxm-context="popup">
+  <h3 id="title">BXM Test Harness</h3>
+  <p id="status">ready</p>
+  <pre id="log"></pre>
+</body>
+</html>

package/dist/test/harness/extension/sidepanel.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>BXM Test Harness — Side Panel</title>
+</head>
+<body data-bxm-context="sidepanel">
+  <h3 id="title">BXM Test Harness — Side Panel</h3>
+  <p id="status">ready</p>
+  <pre id="log"></pre>
+</body>
+</html>

package/dist/test/index.js

@@ -0,0 +1,63 @@
+// Public test API — what consumers see.
+//
+// Test files export a test definition. Three forms:
+//
+// Standalone:
+//   module.exports = {
+//     layer: 'build',                  // 'build' | 'background' | 'view' | 'boot'
+//     description: 'config has brand.id',
+//     timeout: 5000,
+//     run: async (ctx) => {
+//       const cfg = Manager.getConfig();
+//       ctx.expect(cfg.brand.id).toBeTruthy();
+//     },
+//     cleanup: async (ctx) => { ... },
+//   };
+//
+// Boot layer — spawns Chromium with the consumer's actual built `dist/` loaded as an
+// unpacked extension and runs `inspect` against the live extension surface. Replaces
+// shell-level smoke tests with deterministic, signal-driven pass/fail. Use this to
+// verify the WHOLE integration: consumer scaffolds, brand config, real manifest, real boot.
+//
+//   module.exports = {
+//     layer: 'boot',
+//     description: 'extension loads and SW boots',
+//     timeout: 20000,
+//     inspect: async ({ extension, page, expect, projectRoot }) => {
+//       expect(extension.id).toBeTruthy();
+//       expect(extension.manifest.manifest_version).toBe(3);
+//     },
+//   };
+//
+// Suite (sequential, shared state, stop on first failure):
+//   module.exports = {
+//     type: 'suite',
+//     layer: 'background',
+//     description: 'messaging round-trip',
+//     tests: [
+//       { name: 'send',  run: async (ctx) => { ctx.state.echo = await chrome.runtime.sendMessage({ ping: 1 }); } },
+//       { name: 'reply', run: async (ctx) => { ctx.expect(ctx.state.echo.pong).toBe(1); } },
+//     ],
+//   };
+//
+// Group (sequential, shared state, runs ALL tests even if some fail):
+//   module.exports = {
+//     type: 'group',
+//     layer: 'build',
+//     tests: [ ... ],
+//   };
+//
+// Array form (treated as group):
+//   module.exports = [ { name, run }, ... ];
+//
+// The ctx (context) provided to every run/cleanup includes:
+//   - ctx.expect       — Jest-compatible assertion library
+//   - ctx.state        — shared object across tests in a suite/group
+//   - ctx.skip(reason) — throw to skip the current test at runtime
+//   - ctx.layer        — current layer name
+//   - ctx.manager      — BXM Manager instance (background / view layers only)
+//   - ctx.page         — Puppeteer Page (view layer only)
+
+module.exports = {
+  expect: require('./assert.js'),
+};