mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
qa-switch-equals-cold-start switches engines in both directions with each layer on deterministic fixtures, then opens the share link of the same state in a new page on the target engine, and compares the draw ledgers and the probe's view of the layer. It runs as 19 acceptance groups covering all 38 layers. State a layer keeps through a switch but the share link does not carry is declared as sessionState (the directions route, Radio's selected station and audio state, the wind reading, local ADS-B's and OSM Places' local toggles and results); a test checks each declaration against what the layer really retains, so a declaration cannot hide a regression.
264 lines
8.5 KiB
JavaScript
264 lines
8.5 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { execFileSync } from 'node:child_process';
|
|
import { readFileSync } from 'node:fs';
|
|
import { optionSpecs, REGISTRY_BY_ID } from '../../src/data/layerState.js';
|
|
import { createFakeEngine } from '../../src/globe/testing/fakeEngine.js';
|
|
import { createOsmPlacesLayer } from '../../src/layers/osmPlaces/index.js';
|
|
import { createWindLayer } from '../../src/layers/wind/index.js';
|
|
import { createApplicationLocalAdsb } from '../../src/app/layers/localAdsb.js';
|
|
import { radioLayer } from '../../src/data/radio.js';
|
|
import {
|
|
withRadioLayer,
|
|
radioStationRow,
|
|
} from '../../src/testSupport/radioLayerHarness.mjs';
|
|
import { radioTestEngine } from '../../src/testSupport/radioTestEngine.mjs';
|
|
import { loadLayerRenderers } from '../../src/app/layers/renderers.js';
|
|
import { createApplicationDirectionsLayer } from '../../src/data/directions.js';
|
|
import { createDirectionsDisplay } from '../../src/layers/directions/render/display.js';
|
|
|
|
// Each entry has a non-default retention exercise below. A new declaration
|
|
// needs an exercise; spelling a plausible field name alone cannot suppress QA.
|
|
const declarations = {
|
|
'src/layers/radio/index.js': ['selected', 'audioState'],
|
|
'src/layers/wind/index.js': ['reading'],
|
|
'src/layers/osmPlaces/index.js': ['enabled', 'results'],
|
|
'src/layers/localAdsb/index.js': ['enabled'],
|
|
'src/layers/directions/index.js': ['route'],
|
|
};
|
|
test('every declaration is covered by a real handoff exercise, without extra fields', () => {
|
|
const files = execFileSync(
|
|
'git',
|
|
['ls-files', '--cached', '--others', '--exclude-standard', 'src'],
|
|
{ encoding: 'utf8' },
|
|
)
|
|
.trim()
|
|
.split('\n');
|
|
const found = {};
|
|
for (const file of files.filter((file) => file.endsWith('.js'))) {
|
|
const text = readFileSync(file, 'utf8');
|
|
for (const match of text.matchAll(/sessionState\s*:\s*(\[[^\]]*\])/g)) {
|
|
assert.ok(!found[file], `Duplicate declaration in ${file}`);
|
|
found[file] = JSON.parse(match[1].replaceAll("'", '"'));
|
|
}
|
|
}
|
|
assert.deepEqual(found, declarations);
|
|
});
|
|
|
|
function verifyFields(layer, before, after) {
|
|
assert.deepEqual([...layer.sessionState].sort(), Object.keys(before).sort());
|
|
for (const field of layer.sessionState) {
|
|
assert.notEqual(before[field], undefined, field);
|
|
assert.deepEqual(
|
|
after[field],
|
|
before[field],
|
|
`${layer.id}.${field} survived detach/attach`,
|
|
);
|
|
assert.ok(
|
|
!optionSpecs(layer.id).some((spec) => spec.key === field),
|
|
`${field} is not a share option`,
|
|
);
|
|
}
|
|
}
|
|
|
|
test('radio selection and playback survive reattachment; volume is shareable', async () => {
|
|
await loadLayerRenderers('cesium');
|
|
const station = radioStationRow();
|
|
await withRadioLayer({ stations: [station] }, async () => {
|
|
radioLayer.selectStation(station.id, {
|
|
autoplay: true,
|
|
focus: false,
|
|
origin: 'user',
|
|
});
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const state = () => {
|
|
const { selected, audioState } = radioLayer.getUIState();
|
|
return { selected, audioState };
|
|
};
|
|
const before = state();
|
|
assert.equal(before.selected.id, station.id);
|
|
assert.notEqual(before.audioState, 'idle');
|
|
radioLayer.detachRenderer();
|
|
radioLayer.attachRenderer({ engine: radioTestEngine() });
|
|
verifyFields(radioLayer, before, state());
|
|
assert.ok(optionSpecs('radio').some((spec) => spec.key === 'volume'));
|
|
});
|
|
});
|
|
|
|
test('wind inspection survives reattachment; pause is a share option', async () => {
|
|
const field = {
|
|
model: 'gfs',
|
|
grid: { nx: 2, ny: 2, lo1: 0, la1: 90, dx: 180, dy: 180 },
|
|
u: new Float32Array(4).fill(4),
|
|
v: new Float32Array(4).fill(3),
|
|
cycle: { validIso: '2026-11-02T12:00:00Z' },
|
|
};
|
|
const layer = createWindLayer({
|
|
feed: { getSnapshot: async () => field },
|
|
createNativeRendering: () => ({
|
|
attach() {},
|
|
start() {},
|
|
stop() {},
|
|
clear() {},
|
|
destroy() {},
|
|
setField() {},
|
|
getDiagnostics: () => ({}),
|
|
}),
|
|
});
|
|
try {
|
|
layer.init(null, { engine: createFakeEngine() });
|
|
layer.enable();
|
|
await layer.update();
|
|
layer.setParams({ inspect: true });
|
|
const before = { reading: layer.getRowControls().summary.reading };
|
|
assert.ok(before.reading);
|
|
layer.detachRenderer();
|
|
layer.attachRenderer({ engine: createFakeEngine() });
|
|
verifyFields(layer, before, {
|
|
reading: layer.getRowControls().summary.reading,
|
|
});
|
|
assert.ok(optionSpecs('wind').some((spec) => spec.key === 'paused'));
|
|
} finally {
|
|
layer.destroy();
|
|
}
|
|
});
|
|
|
|
test('OSM results and visibility survive reattachment but have no share registry entry', () => {
|
|
const host = { clearSource() {}, setEntries() {}, setVisible() {} };
|
|
const layer = createOsmPlacesLayer({
|
|
overlayHost: host,
|
|
overpassConfigured: async () => true,
|
|
});
|
|
const first = createFakeEngine(),
|
|
second = createFakeEngine();
|
|
const records = [
|
|
{ id: 'node/1', lat: 38.9, lon: -77.03, name: 'Fixture Clinic' },
|
|
];
|
|
try {
|
|
layer.init(null, { engine: first });
|
|
layer.setResults(records, { label: 'Clinics', area: 'Washington' });
|
|
layer.enable();
|
|
const before = {
|
|
enabled: first.movers.list()[0].shown,
|
|
results: layer.getAnalystRecords(),
|
|
};
|
|
assert.equal(before.enabled, true);
|
|
assert.equal(before.results.length, 1);
|
|
layer.detachRenderer();
|
|
layer.attachRenderer({ engine: second });
|
|
verifyFields(layer, before, {
|
|
enabled: second.movers.list()[0].shown,
|
|
results: layer.getAnalystRecords(),
|
|
});
|
|
assert.equal(second.movers.list()[0].count, 1);
|
|
assert.equal(REGISTRY_BY_ID.has(layer.id), false);
|
|
} finally {
|
|
layer.destroy();
|
|
first.destroy();
|
|
second.destroy();
|
|
}
|
|
});
|
|
|
|
test('local receiver visibility survives reattachment without restarting its session', async () => {
|
|
let starts = 0,
|
|
visible = false;
|
|
const layer = createApplicationLocalAdsb({
|
|
receiver: { getState: () => ({ mode: 'adsb', aircraft: [] }) },
|
|
feeds: { getState: () => ({ records: [] }), start: () => starts++ },
|
|
renderer: {
|
|
create: ({ engine }) => ({
|
|
engine,
|
|
attach() {},
|
|
detach() {},
|
|
destroy() {},
|
|
setVisible: (value) => {
|
|
visible = value;
|
|
},
|
|
view: { on: () => () => {} },
|
|
}),
|
|
},
|
|
});
|
|
const first = createFakeEngine(),
|
|
second = createFakeEngine();
|
|
try {
|
|
layer.init(null, { engine: first });
|
|
await layer.enable();
|
|
const before = { enabled: visible };
|
|
assert.equal(visible, true);
|
|
layer.detachRenderer();
|
|
visible = false;
|
|
layer.attachRenderer({ engine: second });
|
|
verifyFields(layer, before, { enabled: visible });
|
|
assert.equal(starts, 1);
|
|
assert.equal(REGISTRY_BY_ID.has(layer.id), false);
|
|
} finally {
|
|
layer.destroy();
|
|
first.destroy();
|
|
second.destroy();
|
|
}
|
|
});
|
|
|
|
test('directions retain the route and its markers; a cold layer has no route', async () => {
|
|
const geometry = [
|
|
[10.78, 55.32],
|
|
[10.8, 55.325],
|
|
[10.82, 55.33],
|
|
];
|
|
const layer = createApplicationDirectionsLayer({
|
|
source: {
|
|
getRoute: async () => ({
|
|
ok: true,
|
|
geometry,
|
|
distanceM: 9000,
|
|
durationS: 800,
|
|
steps: geometry.map(([lon, lat], i) => ({
|
|
lon,
|
|
lat,
|
|
instruction: `Step ${i}`,
|
|
distanceM: 3000,
|
|
durationS: 120,
|
|
})),
|
|
}),
|
|
},
|
|
groundFloor: {
|
|
GROUND_FLOOR_LIFT_M: 2,
|
|
cachedGroundFloor: () => 0,
|
|
warmGroundFloor() {},
|
|
},
|
|
rendererFactory: createDirectionsDisplay,
|
|
});
|
|
layer._setOverlayHostForTest({
|
|
setEntries() {},
|
|
setVisible() {},
|
|
clearSource() {},
|
|
});
|
|
const first = createFakeEngine(),
|
|
second = createFakeEngine();
|
|
try {
|
|
layer.init(null, { engine: first });
|
|
layer.enable();
|
|
const cold = layer.getRowControls().list;
|
|
layer.placeEndpoint('a', { lat: 55.32, lon: 10.78 });
|
|
layer.placeEndpoint('b', { lat: 55.33, lon: 10.82 });
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const before = { route: layer.getRowControls().list };
|
|
assert.notDeepEqual(before.route, cold);
|
|
assert.equal(layer.getStats().count, 3);
|
|
layer.detachRenderer();
|
|
layer.attachRenderer({ engine: second });
|
|
verifyFields(layer, before, { route: layer.getRowControls().list });
|
|
assert.equal(
|
|
second.ground.list().find(({ id }) => id === 'directions-route').count,
|
|
1,
|
|
);
|
|
assert.equal(
|
|
second.movers.list().find(({ id }) => id === 'directions-markers').count,
|
|
2,
|
|
);
|
|
} finally {
|
|
layer.destroy();
|
|
first.destroy();
|
|
second.destroy();
|
|
}
|
|
});
|