Files
gods-eye-view/src/standalone/sceneSwitcher.test.mjs
T
German Khokhlov 225c1c25c7 Build test engines from the shared fake instead of literals
Tests that made their own engine object now use createFakeEngine() with
its scripting hooks or an override of the one member under test, so they
follow the contract when it changes. 125 such literals in 74 test files
go down to two that are not globe engines on purpose; report-qa-harness
counts them, and the baseline keeps the number from growing.
2026-11-10 17:07:27 +04:00

238 lines
6.5 KiB
JavaScript

import { createFakeEngine } from '../globe/testing/fakeEngine.js';
import test from 'node:test';
import assert from 'node:assert/strict';
import { createSceneSwitcher } from './sceneSwitcher.js';
import { createLayerSession } from '../app/layerSession.js';
function fixture({ failResume = false, changeTarget = false } = {}) {
const session = createLayerSession();
const log = [];
let current = 'first';
let address = 'first';
const target = { id: 'track', layerId: 'flights' };
const style = {
initialRestorePromise: Promise.resolve(),
getCockpitState: () => ({
active: true,
subject: target,
visionMode: 'ir',
}),
getAircraftTrackingTarget: () =>
changeTarget ? { ...target, id: 'other' } : target,
controlCockpit: () => {
log.push('cockpit');
return { ok: true };
},
cockpitView: { setVisionMode: (mode) => log.push(mode) },
shareLinkManager: {
currentLayerState: () => ({ enabledLayerIds: ['flights'] }),
resumeNavigation: () => log.push('navigation'),
},
};
const entry = {
module: {
attachRenderer() {},
resumeViewport() {
log.push('viewport');
},
},
};
session.manager = {
layers: new Map([['flights', entry]]),
isEffectivelyEnabled: () => true,
resumeScene: () => entry.module.resumeViewport(),
};
session.director = {
suspendScene: () => log.push('suspend-director'),
resumeScene: () => {
log.push('resume-director');
if (failResume && current === 'navara') throw new Error('resume failed');
},
};
const app = {
getState: () => ({ status: 'ready' }),
getComponents: () => ({
scene: { engine: current ? { kind: current } : null },
controls: { styleManager: style },
}),
async detachScene({ handoff }) {
log.push(['detach', current, handoff]);
current = null;
},
async attachScene(kind, { resume }) {
current = kind;
log.push(['attach', kind]);
try {
await resume();
} catch (error) {
log.push(['release', kind]);
current = null;
throw error;
}
},
};
const switcher = createSceneSwitcher({
kind: 'first',
requested: () => address,
layerSession: session,
getApplication: () => app,
renderers: { retain: (kind) => log.push(['park', kind]) },
address: {
select: () => 'old-entry',
commit: (token, kind) => {
address = kind;
log.push(['commit', token, kind]);
},
restore: (kind) => {
address = kind;
},
},
onSettled: () => log.push('settled'),
onFailure: (error, { recovered }) =>
log.push(['failure', error.message, recovered]),
});
return { switcher, session, log, current: () => current };
}
test('a scene switch parks once, resumes the session and cockpit, then returns navigation', async () => {
const { switcher, session, log, current } = fixture();
await switcher.select('navara');
assert.equal(current(), 'navara');
assert.equal(session.handoff, null);
await session.viewRestored;
assert.deepEqual(log, [
'suspend-director',
['park', 'first'],
['detach', 'first', true],
['attach', 'navara'],
'viewport',
'resume-director',
'cockpit',
'ir',
['commit', 'old-entry', 'navara'],
'settled',
'navigation',
]);
});
test('resume failure has one candidate release and one rollback on the retained session', async () => {
const { switcher, session, log, current } = fixture({ failResume: true });
await switcher.select('navara');
assert.equal(current(), 'first');
assert.deepEqual(log.filter(Array.isArray), [
['park', 'first'],
['detach', 'first', true],
['attach', 'navara'],
['release', 'navara'],
['attach', 'first'],
['failure', 'resume failed', true],
]);
assert.equal(session.handoff, null);
assert.equal(switcher.state().busy, false);
});
test('a changed tracking target does not resume the outgoing cockpit', async () => {
const { switcher, log } = fixture({ changeTarget: true });
await switcher.select('navara');
assert.equal(log.includes('cockpit'), false);
assert.equal(log.includes('ir'), false);
});
test('the restored camera precedes retained follow and replay', async () => {
const { LayerLifecycle } = await import('../data/lifecycle.js');
const session = createLayerSession();
const log = [];
let restoreCamera;
const restored = new Promise((resolve) => {
restoreCamera = resolve;
});
const layers = ['follow', 'replay'].map((id) => ({
id,
name: id,
icon: '',
source: 'test',
init() {},
enable() {},
disable() {},
update() {},
destroy() {},
attachRenderer() {
log.push(`attach:${id}`);
},
detachRenderer() {},
cameraOwner: {
suspend() {
log.push(`suspend:${id}`);
},
resume() {
log.push(`resume:${id}`);
},
},
}));
const catalog = {
layers,
metadata: layers.map(({ id }) => ({
id,
token: id,
disposition: 'enabled-only',
})),
};
const manager = new LayerLifecycle(null);
session.manager = manager;
await manager.bindCatalog({ kind: 'first' }, catalog);
for (const layer of layers) await manager.setEnabled(layer.id, true);
let current = 'first';
let attached;
const attachment = new Promise((resolve) => {
attached = resolve;
});
const style = {
initialRestorePromise: restored,
getCockpitState: () => null,
getAircraftTrackingTarget: () => null,
};
const app = {
getState: () => ({ status: 'ready' }),
getComponents: () => ({
scene: { engine: createFakeEngine({ kind: current }) },
controls: { styleManager: style },
}),
async detachScene() {
await manager.detachScene();
},
async attachScene(kind, { resume }) {
current = kind;
await manager.bindCatalog({ kind }, catalog, {
viewRestored: session.viewRestored,
});
attached();
await resume();
},
};
const switcher = createSceneSwitcher({
kind: 'first',
requested: () => current,
layerSession: session,
getApplication: () => app,
renderers: { retain() {} },
address: { select() {}, commit() {}, restore() {} },
});
const switching = switcher.select('navara');
await attachment;
assert.deepEqual(log, [
'suspend:follow',
'suspend:replay',
'attach:follow',
'attach:replay',
]);
log.push('camera-restored');
restoreCamera();
await switching;
assert.deepEqual(log.slice(-3), [
'camera-restored',
'resume:follow',
'resume:replay',
]);
await manager.destroyAll();
});