Check that an engine switch draws what a cold start from the share link draws

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.
This commit is contained in:
German Khokhlov committed 2026-11-10 17:08:05 +04:00
1 parent 59ff0b38a2
commit 7c5ebf4814
12 files changed
+2020

No files matched your search

+263
View File
@@ -0,0 +1,263 @@
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();
}
});