mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
305 lines
8.7 KiB
JavaScript
305 lines
8.7 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { LayerLifecycle } from './lifecycle.js';
|
|
|
|
// A layer with a renderer lifetime: it outlives scenes through
|
|
// detachRenderer()/attachRenderer(). Hooks replace the default behaviour.
|
|
function sceneLayer(id, hooks = {}) {
|
|
const calls = [];
|
|
const module = {
|
|
id,
|
|
name: id,
|
|
icon: '',
|
|
source: 'test',
|
|
init(viewer, context) {
|
|
calls.push('init');
|
|
module.attachRenderer(viewer, context);
|
|
return true;
|
|
},
|
|
attachRenderer(viewer, context) {
|
|
calls.push(['attach', viewer]);
|
|
return hooks.attach?.(viewer, context);
|
|
},
|
|
detachRenderer(viewer) {
|
|
calls.push(['detach', viewer]);
|
|
return hooks.detach?.(viewer);
|
|
},
|
|
enable: () => true,
|
|
update(viewer) {
|
|
calls.push(['update', viewer]);
|
|
return true;
|
|
},
|
|
disable: () => true,
|
|
destroy: () => true,
|
|
};
|
|
return { module, calls };
|
|
}
|
|
|
|
function catalog(...modules) {
|
|
return {
|
|
layers: modules,
|
|
metadata: modules.map(({ id }) => ({
|
|
id,
|
|
disposition: 'enabled-only',
|
|
token: id,
|
|
})),
|
|
};
|
|
}
|
|
|
|
const engine = (name) => ({ kind: 'test', name });
|
|
const firstViewer = { name: 'first viewer' };
|
|
const secondViewer = { name: 'second viewer' };
|
|
|
|
async function boundManager(...layers) {
|
|
const manager = new LayerLifecycle(firstViewer, {
|
|
engine: engine('first'),
|
|
});
|
|
const modules = layers.map(({ module }) => module);
|
|
await manager.bindCatalog(firstViewer, engine('first'), catalog(...modules));
|
|
for (const { module } of layers)
|
|
assert.equal(
|
|
await manager.setEnabled(module.id, true, { origin: 'user' }),
|
|
true,
|
|
);
|
|
return { manager, modules };
|
|
}
|
|
|
|
// Detach failures are also logged; keep the test output to the assertions.
|
|
async function quietly(run) {
|
|
const warn = console.warn;
|
|
console.warn = () => {};
|
|
try {
|
|
return await run();
|
|
} finally {
|
|
console.warn = warn;
|
|
}
|
|
}
|
|
|
|
const detaches = (calls) => calls.filter((call) => call[0] === 'detach');
|
|
const attaches = (calls) => calls.filter((call) => call[0] === 'attach');
|
|
|
|
test('one failing detachRenderer leaves the others released and the manager unbound', async () => {
|
|
let failures = 1;
|
|
const broken = sceneLayer('broken', {
|
|
detach() {
|
|
if (failures-- > 0) throw new Error('release failed');
|
|
},
|
|
});
|
|
const after = sceneLayer('after');
|
|
const { manager, modules } = await boundManager(broken, after);
|
|
|
|
await assert.rejects(
|
|
quietly(() => manager.detachScene()),
|
|
(error) => {
|
|
assert.ok(error instanceof AggregateError);
|
|
assert.deepEqual(
|
|
error.errors.map(({ message }) => message),
|
|
['release failed'],
|
|
);
|
|
return true;
|
|
},
|
|
);
|
|
assert.deepEqual(detaches(after.calls), [['detach', firstViewer]]);
|
|
assert.equal(manager.viewer, null);
|
|
assert.equal(manager.engine, null);
|
|
assert.equal(manager.registrationsFinalized, false);
|
|
|
|
// A repeated detach retries only the failed release, on its own viewer.
|
|
await manager.detachScene();
|
|
assert.deepEqual(detaches(broken.calls), [
|
|
['detach', firstViewer],
|
|
['detach', firstViewer],
|
|
]);
|
|
assert.equal(detaches(after.calls).length, 1);
|
|
|
|
// The next scene binds and both retained layers attach to it.
|
|
await manager.bindCatalog(
|
|
secondViewer,
|
|
engine('second'),
|
|
catalog(...modules),
|
|
);
|
|
assert.equal(manager.viewer, secondViewer);
|
|
assert.deepEqual(attaches(broken.calls).at(-1), ['attach', secondViewer]);
|
|
assert.deepEqual(attaches(after.calls).at(-1), ['attach', secondViewer]);
|
|
assert.equal(manager.isEnabled('broken'), true);
|
|
});
|
|
|
|
test('bindCatalog after a failed detach retries the release before attaching', async () => {
|
|
let failures = 1;
|
|
const broken = sceneLayer('broken', {
|
|
detach() {
|
|
if (failures-- > 0) throw new Error('release failed');
|
|
},
|
|
});
|
|
const { manager, modules } = await boundManager(broken);
|
|
await assert.rejects(
|
|
quietly(() => manager.detachScene()),
|
|
AggregateError,
|
|
);
|
|
|
|
await manager.bindCatalog(
|
|
secondViewer,
|
|
engine('second'),
|
|
catalog(...modules),
|
|
);
|
|
assert.deepEqual(broken.calls.slice(-3), [
|
|
['detach', firstViewer],
|
|
['detach', firstViewer],
|
|
['attach', secondViewer],
|
|
]);
|
|
// The scene is settled: the next detach releases the second viewer once.
|
|
await manager.detachScene();
|
|
assert.deepEqual(broken.calls.at(-1), ['detach', secondViewer]);
|
|
});
|
|
|
|
test('an asynchronous attach detached mid-flight stops before the release', async () => {
|
|
let resume;
|
|
let attachSignal;
|
|
let attachFinished = false;
|
|
let sawAbortBeforeFinishing = null;
|
|
const slow = sceneLayer('slow', {
|
|
async attach(viewer, { signal }) {
|
|
if (viewer !== secondViewer) return;
|
|
attachSignal = signal;
|
|
await new Promise((resolve) => {
|
|
resume = resolve;
|
|
});
|
|
sawAbortBeforeFinishing = signal.aborted;
|
|
attachFinished = true;
|
|
},
|
|
detach() {
|
|
assert.equal(
|
|
attachFinished || attachSignal === undefined,
|
|
true,
|
|
'the release waits for the attachment to stop',
|
|
);
|
|
},
|
|
});
|
|
const { manager, modules } = await boundManager(slow);
|
|
await manager.detachScene();
|
|
|
|
const bound = manager.bindCatalog(
|
|
secondViewer,
|
|
engine('second'),
|
|
catalog(...modules),
|
|
);
|
|
assert.ok(bound?.then, 'an asynchronous attachment is awaited');
|
|
assert.equal(attachSignal.aborted, false);
|
|
|
|
const detached = manager.detachScene();
|
|
assert.equal(attachSignal.aborted, true);
|
|
let released = false;
|
|
void detached.then(() => {
|
|
released = true;
|
|
});
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(released, false, 'the detach waits for the attachment');
|
|
assert.equal(detaches(slow.calls).length, 1);
|
|
|
|
resume();
|
|
await detached;
|
|
await bound;
|
|
assert.equal(sawAbortBeforeFinishing, true);
|
|
assert.deepEqual(detaches(slow.calls).at(-1), ['detach', secondViewer]);
|
|
});
|
|
|
|
test('periodic refreshes due while no scene is bound run after the next bind', async () => {
|
|
const layer = sceneLayer('feed');
|
|
const { manager, modules } = await boundManager(layer);
|
|
const entry = manager.layers.get('feed');
|
|
const updates = () =>
|
|
layer.calls.filter((call) => call[0] === 'update').length;
|
|
const before = updates();
|
|
|
|
await manager.detachScene();
|
|
assert.equal(await manager._runPeriodicUpdate('feed', entry), false);
|
|
assert.equal(updates(), before, 'no refresh against a detached scene');
|
|
assert.equal(entry.refreshDeferred, true);
|
|
|
|
await manager.bindCatalog(
|
|
secondViewer,
|
|
engine('second'),
|
|
catalog(...modules),
|
|
);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(updates(), before + 1);
|
|
assert.deepEqual(layer.calls.at(-1), ['update', secondViewer]);
|
|
assert.equal(entry.refreshDeferred, false);
|
|
});
|
|
|
|
test('a legacy layer that cannot be destroyed is dropped so the next catalog binds', async () => {
|
|
const legacy = {
|
|
id: 'legacy',
|
|
name: 'legacy',
|
|
icon: '',
|
|
source: 'test',
|
|
init: () => true,
|
|
enable: () => true,
|
|
update: () => true,
|
|
disable() {
|
|
throw new Error('disable failed');
|
|
},
|
|
destroy: () => true,
|
|
};
|
|
const retained = sceneLayer('retained');
|
|
const manager = new LayerLifecycle(firstViewer, { engine: engine('first') });
|
|
await manager.bindCatalog(
|
|
firstViewer,
|
|
engine('first'),
|
|
catalog(legacy, retained.module),
|
|
);
|
|
await manager.setEnabled('legacy', true, { origin: 'user' });
|
|
await manager.setEnabled('retained', true, { origin: 'user' });
|
|
const warn = console.warn;
|
|
console.warn = () => {};
|
|
try {
|
|
await assert.rejects(manager.detachScene(), /could not detach/);
|
|
} finally {
|
|
console.warn = warn;
|
|
}
|
|
assert.equal(manager.layers.has('legacy'), false);
|
|
assert.deepEqual(detaches(retained.calls), [['detach', firstViewer]]);
|
|
|
|
const fresh = { ...legacy, disable: () => true };
|
|
await manager.bindCatalog(
|
|
secondViewer,
|
|
engine('second'),
|
|
catalog(fresh, retained.module),
|
|
);
|
|
assert.equal(manager.layers.get('legacy').module, fresh);
|
|
});
|
|
|
|
test('QA layers are reported when a scene switch drops them', async () => {
|
|
const retained = sceneLayer('retained');
|
|
const manager = new LayerLifecycle(firstViewer, {
|
|
engine: engine('first'),
|
|
allowQaRegistration: true,
|
|
});
|
|
await manager.bindCatalog(
|
|
firstViewer,
|
|
engine('first'),
|
|
catalog(retained.module),
|
|
);
|
|
manager.registerForQa({
|
|
id: 'qa-probe',
|
|
name: 'QA',
|
|
icon: '',
|
|
source: 'test',
|
|
init: () => true,
|
|
enable: () => true,
|
|
update: () => true,
|
|
disable: () => true,
|
|
destroy: () => true,
|
|
});
|
|
const warnings = [];
|
|
const warn = console.warn;
|
|
console.warn = (...args) => warnings.push(args.join(' '));
|
|
try {
|
|
await manager.detachScene();
|
|
} finally {
|
|
console.warn = warn;
|
|
}
|
|
assert.equal(manager.layers.has('qa-probe'), false);
|
|
assert.ok(warnings.some((line) => line.includes('qa-probe')));
|
|
});
|