import test from 'node:test';
import assert from 'node:assert/strict';
import { JSDOM } from 'jsdom';
import { createBackgroundRuntime } from '../extension/background-runtime.js';
import { installContentRuntime } from '../extension/content-runtime.js';
import { DEFAULT_CONFIG, publicConfig } from '../extension/config.js';
const extensionId = 'runtime-test';
const settings = { ...DEFAULT_CONFIG, enabled: true, accountId: 'work', token: 'test-local-secret', selectors: {} };
const trusted = { id: extensionId, url: `chrome-extension://${extensionId}/options.html` };
const tab = { id: 17, url: 'https://teams.cloud.microsoft/', active: true };
const pageSender = { id: extensionId, frameId: 0, url: tab.url, tab };
const event = () => {
const listeners = new Set();
return { listeners, addListener: listener => listeners.add(listener), removeListener: listener => listeners.delete(listener) };
};
function backgroundFixture({ failInjection = false, saved = settings } = {}) {
const local = { config: structuredClone(saved) }, requests = [], injections = [], messages = [];
let attached = false, configError = '';
const chrome = {
storage: { local: { setAccessLevel: async () => {}, get: async key => ({ [key]: structuredClone(local[key]) }), set: async values => Object.assign(local, structuredClone(values)) } },
runtime: { id: extensionId, getURL: path => `chrome-extension://${extensionId}/${path}`, getManifest: () => ({ version: '0.1.1' }), onMessage: event(), onInstalled: event() },
tabs: { query: async () => [tab, { id: 19, url: 'https://example.com/' }], get: async () => tab, sendMessage: async (id, message, options) => {
messages.push({ id, message, options });
if (!attached) throw new Error('Receiving end does not exist');
if (message.type === 'CONFIG_CHANGED' && configError) return { ok: false, error: configError };
return message.type === 'PROBE' ? { ok: true, ready: true, runtimeError: '' } : { ok: true };
} },
scripting: { executeScript: async options => { injections.push(options); if (failInjection) throw new Error('Access denied'); attached = true; } }
};
const background = createBackgroundRuntime({ chrome, sleep: async () => {}, fetch: async (url, options) => { requests.push({ url, ...options, body: JSON.parse(options.body) }); return { ok: true }; } });
return { background, chrome, local, requests, injections, messages, failConfig: value => { configError = value; } };
}
function contentFixture({ send, collect } = {}) {
const dom = new JSDOM('
Loading', { url: tab.url });
const messages = [], listeners = event(), scope = {}, timers = new Map();
let timerId = 0, intervals = 0, observers = 0;
dom.window.setTimeout = fn => { timers.set(++timerId, fn); return timerId; };
dom.window.clearTimeout = id => timers.delete(id);
dom.window.setInterval = () => { intervals++; return ++timerId; };
dom.window.clearInterval = () => {};
dom.window.MutationObserver = class { constructor() { observers++; } observe() {} disconnect() {} };
const chrome = { runtime: { id: extensionId, onMessage: listeners, sendMessage: async message => {
messages.push(message);
if (send) return send(message);
return message.type === 'GET_CONFIG' ? { ok: true, config: publicConfig(settings) } : { ok: true };
} } };
const dependencies = { chrome, window: dom.window, document: dom.window.document, scope, ...(collect ? { collect } : {}) };
const runtime = installContentRuntime(dependencies);
const message = input => new Promise(resolve => {
const listener = [...listeners.listeners][0];
assert.equal(listener(input, { id: extensionId }, resolve), true);
});
return { runtime, dependencies, messages, message, listeners, timers, counts: () => ({ intervals, observers }), close: () => { scope.__teamsLocalCollectorRuntime?.dispose(); dom.window.close(); } };
}
test('saving enabled config probes an existing Teams tab, injects once in its top frame, then applies config and reports readiness', async () => {
const fixture = backgroundFixture();
const result = await fixture.background.dispatch({ type: 'SAVE_CONFIG', config: settings }, trusted);
assert.deepEqual(result.connection, { teamsTabCount: 1, readyTabCount: 1, error: '' });
assert.deepEqual(fixture.injections, [{ target: { tabId: tab.id, frameIds: [0] }, files: ['content.js'] }]);
assert.deepEqual(fixture.messages.map(item => item.message.type), ['PROBE', 'PROBE', 'CONFIG_CHANGED']);
assert.ok(fixture.messages.every(item => item.options.frameId === 0));
const state = await fixture.background.dispatch({ type: 'GET_STATE' }, trusted);
assert.equal(state.readyTabCount, 1); assert.equal(fixture.injections.length, 1);
assert.equal(fixture.requests.at(-1).url, 'http://127.0.0.1:4318/api/extension/status');
assert.equal(fixture.requests.at(-1).headers.Authorization, 'Bearer test-local-secret');
assert.doesNotMatch(JSON.stringify(fixture.requests.at(-1).body), /test-local-secret|records|Loading/);
});
test('startup and installation repair already-open tabs and register a working async runtime message listener', async () => {
const fixture = backgroundFixture();
fixture.background.start(); fixture.background.start();
await new Promise(resolve => setImmediate(resolve));
assert.equal(fixture.injections.length, 1);
assert.equal(fixture.chrome.runtime.onMessage.listeners.size, 1);
assert.equal(fixture.chrome.runtime.onInstalled.listeners.size, 1);
[...fixture.chrome.runtime.onInstalled.listeners][0]();
const response = await new Promise(resolve => {
assert.equal([...fixture.chrome.runtime.onMessage.listeners][0]({ type: 'GET_STATE' }, trusted, resolve), true);
});
assert.equal(response.ok, true); assert.equal(response.readyTabCount, 1); assert.equal(fixture.injections.length, 1);
});
test('injection and page configuration failures remain visible after saving without discarding enabled settings', async () => {
const fixture = backgroundFixture({ failInjection: true });
const result = await fixture.background.dispatch({ type: 'SAVE_CONFIG', config: settings }, trusted);
assert.equal(result.ok, true); assert.equal(result.connection.readyTabCount, 0);
assert.match(result.connection.error, /网站访问权限/);
assert.equal(fixture.local.config.enabled, true); assert.match(fixture.local.status.connectionError, /网站访问权限/);
assert.match(fixture.requests.at(-1).body.error, /网站访问权限/);
const second = backgroundFixture(); second.failConfig('页面未能读取配置');
const failed = await second.background.dispatch({ type: 'SAVE_CONFIG', config: settings }, trusted);
assert.match(failed.connection.error, /页面未能读取配置/);
second.failConfig('');
const repaired = await second.background.dispatch({ type: 'RECONNECT' }, trusted);
assert.equal(repaired.connection.error, ''); assert.equal(repaired.readyTabCount, 1);
});
test('CAPTURE validation errors are recorded and diagnostic reporting always uses saved credentials', async () => {
const fixture = backgroundFixture();
await assert.rejects(fixture.background.dispatch({ type: 'CAPTURE', accountId: 'wrong', records: [], page: { url: tab.url } }, pageSender), /账号/);
assert.match(fixture.local.status.lastError, /账号/);
assert.match(fixture.requests.at(-1).body.error, /账号/);
await assert.rejects(fixture.background.dispatch({ type: 'SAVE_CONFIG', config: { ...settings, port: 0, token: 'unsaved-secret' } }, trusted), /端口/);
assert.deepEqual(fixture.local.config, settings);
assert.ok(fixture.requests.every(request => request.headers.Authorization === 'Bearer test-local-secret'));
await assert.rejects(fixture.background.ensureContentScript({ id: 22, url: 'https://example.com/' }), /Teams/);
assert.equal(fixture.injections.length, 0);
const repaired = await fixture.background.dispatch({ type: 'SAVE_CONFIG', config: settings }, trusted);
assert.equal(repaired.connection.error, ''); assert.equal(fixture.local.status.lastError, '');
assert.equal(fixture.requests.at(-1).body.error, '');
});
test('page runtime errors returned by PROBE are visible even when its earlier diagnostic message failed', async () => {
const fixture = backgroundFixture();
fixture.chrome.tabs.sendMessage = async () => ({ ok: true, ready: true, runtimeError: '页面解析失败' });
const response = await fixture.background.dispatch({ type: 'GET_STATE' }, trusted);
assert.equal(response.readyTabCount, 1); assert.equal(response.status.runtimeError, '页面解析失败');
assert.equal(fixture.requests.at(-1).body.error, '页面解析失败');
fixture.chrome.tabs.sendMessage = async () => ({ ok: true, ready: true, runtimeError: '' });
const recovered = await fixture.background.dispatch({ type: 'GET_STATE' }, trusted);
assert.equal(recovered.status.runtimeError, ''); assert.equal(fixture.requests.at(-1).body.error, '');
});
test('duplicate content initialization reuses one observer, heartbeat timer and listener; empty pages still send CAPTURE', async () => {
const fixture = contentFixture();
try {
const duplicate = installContentRuntime(fixture.dependencies);
assert.equal(duplicate, fixture.runtime);
await fixture.runtime.ready;
assert.deepEqual(fixture.counts(), { intervals: 1, observers: 1 });
assert.equal(fixture.listeners.listeners.size, 1);
await fixture.runtime.scan();
const captures = fixture.messages.filter(message => message.type === 'CAPTURE');
assert.equal(captures.length, 1); assert.deepEqual(captures[0].records, []);
assert.equal(captures[0].page.signedIn, null);
assert.equal((await fixture.message({ type: 'PROBE' })).ready, true);
assert.doesNotMatch(JSON.stringify(fixture.messages), /test-local-secret/);
} finally { fixture.close(); }
});
test('PROBE waits for async content initialization and does not falsely report a missing script', async () => {
let release;
const configReady = new Promise(resolve => { release = resolve; });
const fixture = contentFixture({ send: async message => message.type === 'GET_CONFIG' ? configReady : { ok: true } });
try {
let responded = false;
const result = fixture.message({ type: 'PROBE' }).then(reply => { responded = true; return reply; });
await Promise.resolve(); assert.equal(responded, false);
release({ ok: true, config: publicConfig(settings) });
assert.equal((await result).ready, true);
assert.deepEqual(fixture.counts(), { intervals: 1, observers: 1 });
} finally { fixture.close(); }
});
test('initialization errors are reported and reinjection can replace a failed instance', async () => {
let fail = true;
const fixture = contentFixture({ send: async message => message.type === 'GET_CONFIG' ? (fail ? { ok: false, error: '配置格式无效' } : { ok: true, config: publicConfig(settings) }) : { ok: true } });
try {
await assert.rejects(fixture.runtime.ready, /配置格式无效/);
assert.equal((await fixture.message({ type: 'PROBE' })).ok, false);
assert.ok(fixture.messages.some(message => message.type === 'REPORT_STATUS' && message.runtimeError === '配置格式无效'));
fail = false;
const repaired = installContentRuntime(fixture.dependencies);
await repaired.ready;
assert.notEqual(repaired, fixture.runtime); assert.equal(fixture.listeners.listeners.size, 1);
assert.equal((await fixture.message({ type: 'PROBE' })).ready, true);
} finally { fixture.close(); }
});
test('rejected capture stays in the content queue, reports failure, and clears the error only after successful retry', async () => {
let fail = true;
const fixture = contentFixture({ send: async message => {
if (message.type === 'GET_CONFIG') return { ok: true, config: publicConfig(settings) };
if (message.type === 'CAPTURE' && fail) return { ok: false, error: '来源页面不匹配' };
return { ok: true };
} });
try {
await fixture.runtime.ready;
fixture.dependencies.document.body.innerHTML = 'Message
';
await fixture.runtime.scan();
const errorStatus = fixture.messages.filter(message => message.type === 'REPORT_STATUS').at(-1);
assert.equal(errorStatus.runtimeError, '来源页面不匹配'); assert.equal(errorStatus.pending, 1);
fail = false; await fixture.runtime.scan();
const successStatus = fixture.messages.filter(message => message.type === 'REPORT_STATUS').at(-1);
assert.equal(successStatus.runtimeError, ''); assert.equal(successStatus.pending, 0);
assert.equal(fixture.messages.filter(message => message.type === 'CAPTURE').length, 2);
} finally { fixture.close(); }
});