mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 08:42:21 +00:00
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.
238 lines
6.5 KiB
JavaScript
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();
|
|
});
|