401 lines
14 KiB
JavaScript
401 lines
14 KiB
JavaScript
#!/usr/bin/env node
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const vm = require('vm');
|
|
|
|
const root = path.resolve(__dirname, '..');
|
|
const sourcePath = path.join(root, 'plugins', 'browser-inbox', 'frontend', 'src', 'index.js');
|
|
const source = fs.readFileSync(sourcePath, 'utf8');
|
|
|
|
class FakeNode {
|
|
constructor(tagName) {
|
|
this.tagName = String(tagName || '').toUpperCase();
|
|
this.children = [];
|
|
this.attributes = {};
|
|
this.listeners = {};
|
|
this.style = {};
|
|
this.className = '';
|
|
this.id = '';
|
|
this.value = '';
|
|
this.parentNode = null;
|
|
this._innerHTML = '';
|
|
this._textContent = '';
|
|
}
|
|
|
|
appendChild(node) {
|
|
if (!(node instanceof FakeNode)) throw new TypeError('appendChild expects FakeNode');
|
|
this.children.push(node);
|
|
node.parentNode = this;
|
|
return node;
|
|
}
|
|
|
|
removeChild(node) {
|
|
this.children = this.children.filter((child) => child !== node);
|
|
node.parentNode = null;
|
|
return node;
|
|
}
|
|
|
|
setAttribute(name, value) {
|
|
this.attributes[name] = String(value);
|
|
if (name === 'id') this.id = String(value);
|
|
}
|
|
|
|
getAttribute(name) {
|
|
return this.attributes[name];
|
|
}
|
|
|
|
addEventListener(type, handler) {
|
|
this.listeners[type] = this.listeners[type] || [];
|
|
this.listeners[type].push(handler);
|
|
}
|
|
|
|
dispatchEvent(type, event = {}) {
|
|
const handlers = this.listeners[type] || [];
|
|
handlers.forEach((handler) => handler({
|
|
stopPropagation() {},
|
|
preventDefault() {},
|
|
target: this,
|
|
...event,
|
|
}));
|
|
}
|
|
|
|
click() {
|
|
this.dispatchEvent('click');
|
|
}
|
|
|
|
set innerHTML(value) {
|
|
this._innerHTML = String(value || '');
|
|
this.children = [];
|
|
}
|
|
|
|
get innerHTML() {
|
|
return this._innerHTML;
|
|
}
|
|
|
|
set textContent(value) {
|
|
this._textContent = String(value || '');
|
|
this.children = [];
|
|
}
|
|
|
|
get textContent() {
|
|
if (this.tagName === '#TEXT') return this._textContent;
|
|
return this._textContent + this.children.map((child) => child.textContent).join('');
|
|
}
|
|
}
|
|
|
|
function walk(node, fn) {
|
|
if (fn(node)) return node;
|
|
for (const child of node.children) {
|
|
const found = walk(child, fn);
|
|
if (found) return found;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function makeDocument() {
|
|
return {
|
|
body: new FakeNode('body'),
|
|
head: new FakeNode('head'),
|
|
createElement(tagName) {
|
|
return new FakeNode(tagName);
|
|
},
|
|
createTextNode(text) {
|
|
const node = new FakeNode('#text');
|
|
node.textContent = text;
|
|
return node;
|
|
},
|
|
getElementById() {
|
|
return null;
|
|
},
|
|
};
|
|
}
|
|
|
|
function loadComponent(document) {
|
|
const registry = {};
|
|
const sandbox = {
|
|
console,
|
|
Date,
|
|
document,
|
|
window: {
|
|
VerstakPluginRegister(pluginId, bundle) {
|
|
registry[pluginId] = bundle.components || {};
|
|
},
|
|
},
|
|
};
|
|
sandbox.window.window = sandbox.window;
|
|
sandbox.window.document = document;
|
|
vm.runInNewContext(source, sandbox, { filename: sourcePath });
|
|
const component = registry['verstak.browser-inbox'] && registry['verstak.browser-inbox'].BrowserInboxView;
|
|
if (!component) throw new Error('BrowserInboxView was not registered');
|
|
return component;
|
|
}
|
|
|
|
function makeApi(initialSettings = {}) {
|
|
const settings = { ...initialSettings };
|
|
const handlers = {};
|
|
const unsubscribed = [];
|
|
return {
|
|
settings,
|
|
handlers,
|
|
unsubscribed,
|
|
events: {
|
|
subscribe: async (name, handler) => {
|
|
handlers[name] = handler;
|
|
return () => {
|
|
unsubscribed.push(name);
|
|
delete handlers[name];
|
|
};
|
|
},
|
|
},
|
|
settings: {
|
|
read: async (key) => (key ? settings[key] : { ...settings }),
|
|
write: async (key, value) => {
|
|
settings[key] = value;
|
|
return { ...settings };
|
|
},
|
|
},
|
|
getStoredCaptures(key = 'captures') {
|
|
return settings[key] || [];
|
|
},
|
|
};
|
|
}
|
|
|
|
async function flush() {
|
|
for (let i = 0; i < 8; i += 1) await Promise.resolve();
|
|
}
|
|
|
|
async function mountWithApi(api, props = { workspaceNode: { name: 'Project' }, workspaceRootPath: 'Project' }, document = makeDocument()) {
|
|
const component = loadComponent(document);
|
|
const container = new FakeNode('div');
|
|
component.mount(container, props, api);
|
|
await flush();
|
|
return { component, container, document };
|
|
}
|
|
|
|
(async () => {
|
|
const api = makeApi();
|
|
const { component, container } = await mountWithApi(api);
|
|
|
|
for (const name of ['browser.capture.page', 'browser.capture.selection', 'browser.capture.link']) {
|
|
if (typeof api.handlers[name] !== 'function') throw new Error(`${name} subscription missing`);
|
|
}
|
|
|
|
await api.handlers['browser.capture.selection']({
|
|
name: 'browser.capture.selection',
|
|
timestamp: '2026-06-27T00:00:00Z',
|
|
payload: {
|
|
captureId: 'capture-1',
|
|
capturedAt: '2026-06-27T00:00:00.000Z',
|
|
kind: 'selection',
|
|
url: 'https://example.com/article',
|
|
title: 'Example Article',
|
|
domain: 'example.com',
|
|
text: 'Selected text from the page',
|
|
browserName: 'Firefox',
|
|
},
|
|
});
|
|
await flush();
|
|
|
|
const projectKey = 'captures:workspace:Project';
|
|
const clientKey = 'captures:workspace:ClientA';
|
|
const globalKey = 'captures:global';
|
|
const captures = api.getStoredCaptures(projectKey);
|
|
if (captures.length !== 1) throw new Error(`expected one stored capture, got ${captures.length}`);
|
|
if (captures[0].captureId !== 'capture-1') throw new Error('stored capture id mismatch');
|
|
if (api.getStoredCaptures(globalKey).length !== 0) throw new Error('workspace capture leaked into global storage');
|
|
|
|
const row = walk(container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'capture-1');
|
|
if (!row) throw new Error('capture row was not rendered');
|
|
if (!container.textContent.includes('Selected text from the page')) {
|
|
throw new Error('selection text was not rendered');
|
|
}
|
|
|
|
await api.handlers['browser.capture.selection']({
|
|
name: 'browser.capture.selection',
|
|
timestamp: '2026-06-27T00:00:00Z',
|
|
payload: {
|
|
captureId: 'capture-1',
|
|
capturedAt: '2026-06-27T00:00:00.000Z',
|
|
kind: 'selection',
|
|
url: 'https://example.com/article',
|
|
title: 'Example Article',
|
|
domain: 'example.com',
|
|
text: 'Duplicate selected text',
|
|
},
|
|
});
|
|
await flush();
|
|
if (api.getStoredCaptures(projectKey).length !== 1) throw new Error('duplicate capture was stored');
|
|
|
|
const clientView = await mountWithApi(api, { workspaceNode: { name: 'ClientA' }, workspaceRootPath: 'ClientA' });
|
|
if (walk(clientView.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'capture-1')) {
|
|
throw new Error('Project capture leaked into ClientA workspace view');
|
|
}
|
|
await api.handlers['browser.capture.page']({
|
|
name: 'browser.capture.page',
|
|
timestamp: '2026-06-27T00:10:00Z',
|
|
payload: {
|
|
captureId: 'capture-2',
|
|
capturedAt: '2026-06-27T00:10:00.000Z',
|
|
kind: 'page',
|
|
url: 'https://client.example.com/',
|
|
title: 'Client Page',
|
|
domain: 'client.example.com',
|
|
workspaceRootPath: 'ClientA',
|
|
},
|
|
});
|
|
await flush();
|
|
if (api.getStoredCaptures(clientKey).length !== 1) throw new Error('ClientA capture was not stored under ClientA workspace key');
|
|
if (!walk(clientView.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'capture-2')) {
|
|
throw new Error('ClientA capture was not rendered');
|
|
}
|
|
component.unmount && component.unmount(clientView.container);
|
|
|
|
const globalView = await mountWithApi(api, {});
|
|
if (!walk(globalView.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'capture-1')) {
|
|
throw new Error('global browser inbox did not aggregate Project capture');
|
|
}
|
|
if (!walk(globalView.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'capture-2')) {
|
|
throw new Error('global browser inbox did not aggregate ClientA capture');
|
|
}
|
|
component.unmount && component.unmount(globalView.container);
|
|
|
|
const clearButton = walk(container, (node) => node.getAttribute && node.getAttribute('data-browser-inbox-action') === 'clear');
|
|
if (!clearButton) throw new Error('clear button not found');
|
|
clearButton.click();
|
|
await flush();
|
|
if (api.getStoredCaptures(projectKey).length !== 0) throw new Error('clear action did not empty stored captures');
|
|
|
|
component.unmount && component.unmount(container);
|
|
if (api.unsubscribed.length !== 9) throw new Error('component did not unsubscribe all capture handlers');
|
|
|
|
const persistedApi = makeApi({ 'captures:workspace:Project': [captures[0]] });
|
|
const persisted = await mountWithApi(persistedApi);
|
|
if (!walk(persisted.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'capture-1')) {
|
|
throw new Error('persisted capture was not rendered on mount');
|
|
}
|
|
|
|
const legacyApi = makeApi({
|
|
captures: [
|
|
{
|
|
captureId: 'legacy-global-capture',
|
|
capturedAt: '2026-06-27T02:00:00.000Z',
|
|
kind: 'page',
|
|
url: 'https://legacy.example.com/',
|
|
title: 'Legacy Global Capture',
|
|
domain: 'legacy.example.com',
|
|
},
|
|
{
|
|
captureId: 'legacy-project-capture',
|
|
capturedAt: '2026-06-27T02:10:00.000Z',
|
|
kind: 'page',
|
|
url: 'https://project.example.com/',
|
|
title: 'Legacy Project Capture',
|
|
domain: 'project.example.com',
|
|
workspaceRootPath: 'Project',
|
|
},
|
|
],
|
|
});
|
|
const legacyGlobal = await mountWithApi(legacyApi, {});
|
|
if (!walk(legacyGlobal.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'legacy-global-capture')) {
|
|
throw new Error('legacy global capture was not rendered in global view');
|
|
}
|
|
if (!walk(legacyGlobal.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'legacy-project-capture')) {
|
|
throw new Error('legacy workspace capture was not rendered in global view');
|
|
}
|
|
component.unmount && component.unmount(legacyGlobal.container);
|
|
|
|
const legacyProject = await mountWithApi(legacyApi, { workspaceNode: { name: 'Project' }, workspaceRootPath: 'Project' });
|
|
if (!walk(legacyProject.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'legacy-project-capture')) {
|
|
throw new Error('legacy workspace capture was not rendered in matching workspace');
|
|
}
|
|
if (walk(legacyProject.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'legacy-global-capture')) {
|
|
throw new Error('legacy global capture leaked into workspace view');
|
|
}
|
|
|
|
const taggedGlobalApi = makeApi({
|
|
'captures:global': [
|
|
{
|
|
captureId: 'global-project-capture',
|
|
capturedAt: '2026-06-27T03:00:00.000Z',
|
|
kind: 'page',
|
|
url: 'https://project.example.com/global',
|
|
title: 'Global Project Capture',
|
|
domain: 'project.example.com',
|
|
workspaceRootPath: 'Project',
|
|
},
|
|
],
|
|
});
|
|
const taggedGlobalProject = await mountWithApi(taggedGlobalApi, { workspaceNode: { name: 'Project' }, workspaceRootPath: 'Project' });
|
|
if (!walk(taggedGlobalProject.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'global-project-capture')) {
|
|
throw new Error('workspace did not render workspace-tagged global capture');
|
|
}
|
|
const taggedGlobalClient = await mountWithApi(taggedGlobalApi, { workspaceNode: { name: 'ClientA' }, workspaceRootPath: 'ClientA' });
|
|
if (walk(taggedGlobalClient.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'global-project-capture')) {
|
|
throw new Error('workspace-tagged global capture leaked into another workspace');
|
|
}
|
|
|
|
const bindingApi = makeApi({
|
|
domainBindings: {
|
|
'client.example.com': 'ClientA',
|
|
'project.example.com': 'Project',
|
|
},
|
|
});
|
|
const bindingGlobal = await mountWithApi(bindingApi, {});
|
|
await bindingApi.handlers['browser.capture.page']({
|
|
name: 'browser.capture.page',
|
|
timestamp: '2026-06-29T00:00:00Z',
|
|
payload: {
|
|
captureId: 'bound-client-capture',
|
|
capturedAt: '2026-06-29T00:00:00.000Z',
|
|
kind: 'page',
|
|
url: 'https://client.example.com/page',
|
|
title: 'Bound Client Page',
|
|
domain: 'client.example.com',
|
|
},
|
|
});
|
|
await flush();
|
|
if (bindingApi.getStoredCaptures('captures:workspace:ClientA').length !== 1) {
|
|
throw new Error('domain-bound capture was not stored under ClientA workspace key');
|
|
}
|
|
if (bindingApi.getStoredCaptures('captures:global').length !== 0) {
|
|
throw new Error('domain-bound capture was stored in global queue');
|
|
}
|
|
const bindingClient = await mountWithApi(bindingApi, { workspaceNode: { name: 'ClientA' }, workspaceRootPath: 'ClientA' });
|
|
if (!walk(bindingClient.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'bound-client-capture')) {
|
|
throw new Error('domain-bound capture was not rendered in bound workspace');
|
|
}
|
|
const bindingAggregate = await mountWithApi(bindingApi, {});
|
|
if (!walk(bindingAggregate.container, (node) => node.getAttribute && node.getAttribute('data-browser-capture-id') === 'bound-client-capture')) {
|
|
throw new Error('global browser inbox did not aggregate domain-bound capture');
|
|
}
|
|
|
|
await bindingApi.handlers['browser.capture.page']({
|
|
name: 'browser.capture.page',
|
|
timestamp: '2026-06-29T00:10:00Z',
|
|
payload: {
|
|
captureId: 'explicit-project-capture',
|
|
capturedAt: '2026-06-29T00:10:00.000Z',
|
|
kind: 'page',
|
|
url: 'https://client.example.com/explicit',
|
|
title: 'Explicit Project Page',
|
|
domain: 'client.example.com',
|
|
workspaceRootPath: 'Project',
|
|
},
|
|
});
|
|
await flush();
|
|
if (!bindingApi.getStoredCaptures('captures:workspace:Project').some((capture) => capture.captureId === 'explicit-project-capture')) {
|
|
throw new Error('explicit workspace capture was not stored under its payload workspace');
|
|
}
|
|
if (bindingApi.getStoredCaptures('captures:workspace:ClientA').some((capture) => capture.captureId === 'explicit-project-capture')) {
|
|
throw new Error('domain binding overrode explicit workspaceRootPath');
|
|
}
|
|
component.unmount && component.unmount(bindingGlobal.container);
|
|
component.unmount && component.unmount(bindingClient.container);
|
|
component.unmount && component.unmount(bindingAggregate.container);
|
|
|
|
console.log('browser inbox plugin smoke passed');
|
|
})().catch((err) => {
|
|
console.error(err);
|
|
process.exit(1);
|
|
});
|