Files
gods-eye-view/scripts/qa-wildlife-switch.mjs
T
German Khokhlov ed6ae54ef6 Stop the strict acceptance from waiting for itself
A scenario whose body ran past about 19 s idled until 45 s after its
start, and twice one never exited and hit the runner's 300 s timeout
after it had passed: something of Chrome outlived Browser.close and kept
its stdout and stderr open.

- scripts/qa/browser.mjs closes Chrome within 5 s, kills its process
  group and closes its pipes; the harness then finishes and exits with
  the scenario's code. QA_EXIT_DIAGNOSTICS=1 keeps the old ending and
  prints the open handles and Chrome's process tree 5 s after finish.
- Every strict page starts with its clock at the 18:30 UTC nearest to
  the real time, so Navara's sun is up over the test cities whenever the
  acceptance runs; a scenario can ask for its own instant or the real
  clock (Wildlife does, for its freshness fixtures).
- The runner records a scenario that passed but did not exit as hung,
  kills the whole process group on a timeout, runs a failed scenario
  once more and reports one that passes then as flaky, and appends each
  run to --history=FILE; scripts/report-acceptance-flake.mjs reads it.
2026-11-10 14:10:46 +04:00

549 lines
19 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import assert from 'node:assert/strict';
import { fromDegrees } from '../src/geo/cartesian3.js';
import { fromCartesian } from '../src/geo/cartographic.js';
import {
WILDLIFE_SIGHTINGS,
WILDLIFE_VIEW,
wildlifeRoutes,
} from './fixtures/wildlife.mjs';
import {
createStrict,
localPreview,
openPage,
waitForCameraAtRest,
waitForEngine,
} from './qa-strict-harness.mjs';
// Wildlife Sightings over Cesium → Navara → Cesium → Navara: on each engine
// the four fixture sightings are badges in engine.movers at their positions
// (each one picks as itself), the density glow is its own sprite set, and
// the obscured record's privacy cell is a fill and outline on engine.ground; a
// pointer click on a badge selects that sighting and opens its card.
//
// The first two switches are made from the keyboard with the card open (Tab
// to the Globe Engine picker, then type-ahead): the layer keeps its model,
// the selection and the card. A pointer on the picker is a click outside the
// card, which closes it by design, so the last switch (pointer and keyboard
// on the picker) checks that instead, with the model kept.
//
// node scripts/qa-wildlife-switch.mjs http://127.0.0.1:4260
const LAYER = 'wildlife-sightings';
const BADGES = 'wildlife-sightings';
const GLOW = 'wildlife-sightings-density';
const CELL_SET = 'wildlife-sightings-cells';
// One density cell per iNaturalist observation (Acartia has no grid).
const GLOW_CELLS = WILDLIFE_SIGHTINGS.filter((s) =>
s.id.startsWith('inat:'),
).length;
const CELLS = WILDLIFE_SIGHTINGS.filter((s) => s.cell);
const byId = new Map(WILDLIFE_SIGHTINGS.map((s) => [s.id, s]));
// Each leg: its engine, how the switch to it is made, and the sighting it
// clicks (an iNaturalist badge, the Acartia report, the obscured record).
const LEGS = [
{ kind: 'cesium', click: 'inat:910001' },
{ kind: 'navara', via: 'keyboard', click: 'acartia:qa-orca-1' },
{ kind: 'cesium', via: 'keyboard', click: 'inat:910003' },
{ kind: 'navara', via: 'pointer', click: 'inat:910002' },
];
const base = localPreview(process.argv[2]);
base.search = '?engine=cesium&welcome=0';
base.hash =
`v=2&lat=${WILDLIFE_VIEW.lat.toFixed(4)}&lon=${WILDLIFE_VIEW.lon.toFixed(4)}` +
`&alt=${WILDLIFE_VIEW.alt}&heading=0&pitch=-90&roll=0&map=sentinel2&l=`;
const fixture = wildlifeRoutes(base.origin);
const strict = createStrict({
origin: base.origin,
layers: [LAYER],
// Wildlife freshness is checked against fixtures timestamped in Node.
time: 'real',
routes: fixture.routes,
});
await strict.run({}, async (b) => {
const { page: p, errors } = await openPage(b);
await p.goto(base.href);
await waitForEngine(p, 'cesium');
await p.evaluate(async (id) => {
const { dataManager } = window.__godsEyeView;
await dataManager.setEnabled(id, true, { origin: 'user' });
window.qaWild = dataManager.layers.get(id).module;
// Every selection the layer reports, in order.
window.qaWildSelected = [];
window.qaWild.subscribeSelection((row) =>
window.qaWildSelected.push(row?.stableId ?? null),
);
}, LAYER);
// The framing view, straight down over the fixture.
const frame = () =>
p.evaluate(
(destination) => {
const { camera, render } = window.__godsEyeView.engine;
camera.setView({
destination,
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
});
render.request('qa-wildlife-frame');
},
fromDegrees(WILDLIFE_VIEW.lon, WILDLIFE_VIEW.lat, WILDLIFE_VIEW.alt),
);
const still = () => waitForCameraAtRest(p, { timeout: 30000 });
// What the engine draws for the layer, and what its picker answers at each
// sighting's anchor.
const drawing = () =>
p.evaluate(
(ids, prefix) => {
const { engine } = window.__godsEyeView;
const canvas = engine.host.canvas;
const box = canvas.getBoundingClientRect();
const sets = Object.fromEntries(
engine.movers
.list()
.filter((set) => set.id.startsWith('wildlife-sightings'))
.map((set) => [set.id, { kind: set.kind, count: set.count }]),
);
const cells = engine.ground
.list()
.filter((set) => set.id === prefix)
.map(({ kind, count, shown }) => ({ kind, count, shown }));
const badges = ids.map((id) => {
const position = window.qaWild.getSightingPosition(id);
const screen =
position && engine.projector.worldToWindow(position, {});
const picked = screen && engine.picker.pick(screen);
return {
id,
position: position && {
x: position.x,
y: position.y,
z: position.z,
},
screen: screen && { x: screen.x, y: screen.y },
onCanvas:
!!screen &&
canvas.contains(
document.elementFromPoint(
box.left + screen.x,
box.top + screen.y,
),
),
picked: picked
? {
id: typeof picked.id === 'string' ? picked.id : picked.id?.id,
owner: picked.owner ?? null,
}
: null,
};
});
return { sets, cells, badges };
},
[...byId.keys()],
CELL_SET,
);
// Every badge in engine.movers and picked as itself, the glow drawn and
// the privacy cell outlined (the engines draw a few frames after the data).
const settled = async () => {
const deadline = Date.now() + 45000;
let drawn;
for (;;) {
await p.evaluate(() =>
window.__godsEyeView.engine.render.request('qa-wildlife'),
);
drawn = await drawing();
const ok =
drawn.sets[BADGES]?.count === byId.size &&
drawn.sets[GLOW]?.count === GLOW_CELLS &&
drawn.cells.length === 1 &&
drawn.cells[0].count === CELLS.length &&
drawn.badges.every(
(badge) => badge.picked?.id === `wildlife:${badge.id}`,
);
if (ok || Date.now() > deadline) return drawn;
await new Promise((resolve) => setTimeout(resolve, 500));
}
};
const degrees = (position) => {
const c = fromCartesian(position);
return {
lat: (c.latitude * 180) / Math.PI,
lon: (c.longitude * 180) / Math.PI,
height: c.height,
};
};
const card = () =>
p.evaluate(() => {
const hosts = document.querySelectorAll(
'[data-wildlife-sighting-card-host]',
);
const host = hosts[hosts.length - 1];
const section = host?.querySelector('[data-wildlife-sighting-card]');
const box = section?.getBoundingClientRect();
return {
hosts: hosts.length,
shown:
host?.style.display === 'block' && box?.width > 0 && box?.height > 0,
name: section?.getAttribute('aria-label') ?? null,
text: section?.textContent.replace(/\s+/g, ' ').trim() ?? '',
};
});
const selection = () =>
p.evaluate(() => ({
context: window.__gevContextStore?.selectedEntityId ?? null,
layer: window.qaWildSelected.at(-1) ?? null,
}));
const cardFor = (name) =>
p.waitForFunction(
(name) => {
const host = [
...document.querySelectorAll('[data-wildlife-sighting-card-host]'),
].at(-1);
const section = host?.querySelector('[data-wildlife-sighting-card]');
return (
host?.style.display === 'block' &&
section?.getBoundingClientRect().width > 0 &&
section.textContent.includes(name)
);
},
{ timeout: 15000 },
name,
);
const session = () =>
p.evaluate(
(id) => ({
same:
window.qaWild ===
window.__godsEyeView.dataManager.layers.get(id).module,
enabled: window.__godsEyeView.dataManager.isEnabled(id),
selected: window.__gevContextStore?.selectedEntityId ?? null,
reported: window.qaWildSelected.at(-1) ?? null,
}),
LAYER,
);
// The Globe Engine picker from the keyboard alone: Tab until it has the
// focus, then type-ahead (no pointer, so nothing clicks outside the card).
strict.extra.keyboardPicks = [];
const keyboardSwitch = async (kind) => {
const origin = await p.evaluate(() => performance.timeOrigin);
const picker = () =>
p.evaluate(() => {
const el = document.querySelector('#globe-engine');
const box = el?.getBoundingClientRect();
return {
panel: document
.querySelector('#control-panel-toggle')
?.getAttribute('aria-expanded'),
disabled: el?.disabled ?? null,
box: box ? [box.x, box.y, box.width, box.height] : null,
};
});
// The picker sits in VISUAL PRESETS, out of the Tab order while that
// panel is collapsed: open it from the keyboard too.
if ((await picker()).panel !== 'true') {
await p.focus('#control-panel-toggle');
await p.keyboard.press('Enter');
}
await p
.waitForFunction(
() => {
const el = document.querySelector('#globe-engine');
return (
el &&
!el.disabled &&
el.checkVisibility({ visibilityProperty: true })
);
},
{ timeout: 30000 },
)
.catch(async (error) => {
throw Error(
`the picker is not ready: ${JSON.stringify(await picker())}`,
{ cause: error },
);
});
// Each focus stop, as tag#id and label (the path is in the failure).
const path = [];
for (;;) {
const at = await p.evaluate(() => {
const el = document.activeElement;
return {
id: el?.id ?? null,
stop: el
? `${el.tagName.toLowerCase()}#${el.id} ${(
el.getAttribute('aria-label') ||
el.textContent ||
''
)
.trim()
.slice(0, 30)}`
: 'none',
picker: (({ disabled, tabIndex } = {}) => ({ disabled, tabIndex }))(
document.querySelector('#globe-engine') ?? undefined,
),
};
});
if (at.id === 'globe-engine') break;
path.push(at.stop);
assert.ok(
path.length <= 200,
`Tab never reaches the Globe Engine picker ${JSON.stringify({ picker: at.picker, path: path.slice(0, 80) })}`,
);
await p.keyboard.press('Tab');
}
const tabs = path.length;
const from = await p.$eval('#globe-engine', (el) => el.value);
await p.keyboard.type(kind[0]);
await waitForEngine(p, kind).catch(async (error) => {
const state = await p.evaluate(() => ({
engine: window.__godsEyeView?.engine?.kind ?? null,
picker: document.querySelector('#globe-engine')?.value ?? null,
focus: document.activeElement?.id ?? null,
busy: Boolean(
document.querySelector(
'#globe-engine:is([disabled], [aria-busy="true"])',
),
),
frame: Boolean(document.querySelector('.engine-switch-frame')),
loading: document.querySelector('#loading-screen')?.className ?? null,
}));
throw Error(
`no ${kind} globe after typing ${kind[0]}: ${JSON.stringify({ from, tabs: path.length, ...state })}`,
{ cause: error },
);
});
assert.equal(
await p.evaluate(() => performance.timeOrigin),
origin,
'same document after switching globes',
);
strict.extra.keyboardPicks.push({ from, to: kind, tabs });
};
const expandPanel = async () => {
const expanded = () =>
p.$eval(
'#control-panel-toggle',
(el) => el.getAttribute('aria-expanded') === 'true',
);
if (await expanded()) return;
await p.click('#control-panel-toggle');
await p.waitForFunction(
() =>
document
.querySelector('#control-panel-toggle')
?.getAttribute('aria-expanded') === 'true',
);
};
let selected = null;
for (const { kind, via, click: id } of LEGS) {
if (via) {
const poseBefore = await p.evaluate(() =>
window.__godsEyeView.engine.camera.pose(),
);
const reads = { ...fixture.asked };
const sighting = byId.get(selected);
if (via === 'keyboard') {
await keyboardSwitch(kind);
// The session carries over: the same layer model, still on, the
// clicked sighting still selected, and the new globe's card shows it.
await cardFor(sighting.name);
const kept = await session();
const shown = await card();
await strict.check(
p,
LAYER,
`a switch keeps the layer model on, ${sighting.name} selected and its card open`,
kept.same &&
kept.enabled &&
kept.selected === selected &&
kept.reported === selected &&
shown.hosts === 1 &&
shown.shown &&
shown.name === sighting.name,
{ ...kept, card: shown, readsBefore: reads, reads: fixture.asked },
);
console.log('PASS', kind, 'selection kept', selected);
} else {
await strict.switchTo(p, kind);
// The pointer on the picker clicked outside the card: it closed and
// the selection cleared; the layer model stayed on.
const kept = await session();
const shown = await card();
await strict.check(
p,
LAYER,
`a pointer on the picker closes the ${sighting.name} card; the layer model stays on`,
kept.same &&
kept.enabled &&
kept.selected === null &&
kept.reported === null &&
shown.hosts === 1 &&
!shown.shown,
{ ...kept, card: shown, readsBefore: reads, reads: fixture.asked },
);
console.log('PASS', kind, 'picker click closed the card');
selected = null;
}
const poseAfter = await p.evaluate(() =>
window.__godsEyeView.engine.camera.pose(),
);
const positionErrorM = Math.hypot(
...['x', 'y', 'z'].map(
(axis) => poseAfter.position[axis] - poseBefore.position[axis],
),
);
const angleError = (key) =>
Math.abs(
Math.atan2(
Math.sin(poseAfter[key] - poseBefore[key]),
Math.cos(poseAfter[key] - poseBefore[key]),
),
);
await strict.check(
p,
LAYER,
'switch preserves the camera position and orientation',
positionErrorM < 1 &&
['heading', 'pitch', 'roll'].every((key) => angleError(key) < 1e-4),
{ poseBefore, poseAfter, positionErrorM },
);
await frame();
}
// Drawn through the contract: badges, glow, privacy cell.
await still();
const drawn = await settled();
const badges = drawn.badges.map((badge) => ({
...badge,
at: badge.position && degrees(badge.position),
}));
for (const badge of badges) {
const expected = byId.get(badge.id);
assert.ok(badge.at, `${kind}: ${badge.id} has no anchor`);
assert.ok(
Math.abs(badge.at.lat - expected.lat) < 1e-6 &&
Math.abs(badge.at.lon - expected.lon) < 1e-6 &&
badge.at.height > -500 &&
badge.at.height < 3000,
`${kind}: ${badge.id} anchored at ${JSON.stringify(badge.at)}`,
);
}
await strict.check(
p,
LAYER,
`${byId.size} badges live in engine.movers at their sightings, each picked as itself`,
drawn.sets[BADGES]?.kind === 'sprite' &&
drawn.sets[BADGES].count === byId.size &&
badges.every(
(badge) =>
badge.picked?.id === `wildlife:${badge.id}` &&
badge.picked.owner === BADGES,
),
{
set: drawn.sets[BADGES],
badges: badges.map(({ id, at, screen, picked }) => ({
id,
at,
screen,
picked,
})),
},
);
await strict.check(
p,
LAYER,
`the density glow is its own sprite set with ${GLOW_CELLS} cells`,
drawn.sets[GLOW]?.kind === 'sprite' &&
drawn.sets[GLOW].count === GLOW_CELLS,
drawn.sets[GLOW],
);
await strict.check(
p,
LAYER,
'the obscured record’s privacy cell is a shown fill and outline on engine.ground',
drawn.cells.length === 1 &&
drawn.cells[0].count === CELLS.length &&
drawn.cells.every((set) => set.shown && set.kind === 'cell'),
drawn.cells,
);
console.log(
'PASS',
kind,
'drawn',
JSON.stringify(drawn.sets),
JSON.stringify(drawn.cells),
);
// Escape closes the carried-over card and clears the selection.
if (selected) {
await p.keyboard.press('Escape');
await p.waitForFunction(
() =>
!window.__gevContextStore?.selectedEntityId &&
window.qaWildSelected.at(-1) === null &&
[
...document.querySelectorAll('[data-wildlife-sighting-card-host]'),
].every((host) => host.style.display === 'none'),
{ timeout: 10000 },
);
await strict.passed(
p,
LAYER,
'Escape closes the card and clears the selection',
);
}
// The keyboard switches reach the picker in the expanded control panel
// (opened with no card up, so the click closes nothing).
await expandPanel();
// A pointer click on a badge selects its sighting and opens its card.
const sighting = byId.get(id);
const target = (await drawing()).badges.find((badge) => badge.id === id);
assert.ok(
target.onCanvas && target.picked?.id === `wildlife:${id}`,
`${kind}: the ${id} badge is covered or not picked`,
);
const box = await p.evaluate(() => {
const r = window.__godsEyeView.engine.host.canvas.getBoundingClientRect();
return { left: r.left, top: r.top };
});
await p.mouse.click(box.left + target.screen.x, box.top + target.screen.y);
await p.waitForFunction(
(id) =>
window.__gevContextStore?.selectedEntityId === id &&
window.qaWildSelected.at(-1) === id,
{ timeout: 15000 },
id,
);
await cardFor(sighting.name);
const opened = { selection: await selection(), card: await card() };
await strict.check(
p,
LAYER,
`a click on the ${sighting.name} badge selects it and opens its card`,
opened.selection.context === id &&
opened.selection.layer === id &&
opened.card.hosts === 1 &&
opened.card.shown &&
opened.card.name === sighting.name,
{ at: target.screen, ...opened },
);
console.log('PASS', kind, 'click', id, JSON.stringify(opened.card.text));
selected = id;
// The click flies to the sighting; switch once it has landed.
await still();
}
console.log(
'requests',
JSON.stringify(fixture.asked),
'upstream',
JSON.stringify(fixture.upstream),
);
assert.ok(fixture.asked.observations && fixture.asked.grid);
assert.ok(fixture.asked.acartia);
assert.deepEqual(errors, []);
});