mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Navara now matches Cesium where the review found it diverging: a flight holds the camera inputs, camera.changed counts turns as Cesium does, render requests made during a frame survive it, follow pinches zoom, ground widths follow the pixel ratio and Cyber sonar reaches glyph caches and models. On Cesium, a staged imagery swap keeps loading tiles, setView replaces a running flight, and a cleared weather detail goes away. The contract gains MoverSet.failed, maps.terrainRevision, render.maxTextureSize and surface.sampleTerrainMostDetailed on every engine, so layers retry failed models, key road heights by terrain, size weather textures to the GPU and place Bhote Koshi cards on detailed terrain. Engine switches keep the live view, follows, focus, layer options and cards: a pick hands over the exact pose, applies no address options and pans no carried-over card; a history visit still applies its entry. Layers put GhostMaps pins, cable landings, OSM Places and directions on the measured surface without per-frame sampling, draw the Cockpit contact dot, hide disabled CCTV on attach, and keep ALPR running outside secure contexts. KML imports draw raised polygon fills, rotated and coloured ground overlays and north-referenced icon headings, and report files with nothing to draw. QA scripts read the contract instead of Cesium internals (test:track is 109/109 again), wait for the camera to rest before clicking, and give cold switches and parked engines realistic time. Docs follow the code.
557 lines
19 KiB
JavaScript
557 lines
19 KiB
JavaScript
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,
|
||
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],
|
||
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),
|
||
);
|
||
// Until the camera has held still for a second (a focus flight is over).
|
||
const still = () =>
|
||
p.waitForFunction(
|
||
() => {
|
||
const pose = window.__godsEyeView.engine.camera.pose().position;
|
||
const key = [pose.x, pose.y, pose.z].map((v) => v.toFixed(1)).join();
|
||
if (window.__qaWildPose?.key !== key)
|
||
window.__qaWildPose = { key, at: performance.now() };
|
||
return performance.now() - window.__qaWildPose.at > 1000;
|
||
},
|
||
{ timeout: 30000, polling: 100 },
|
||
);
|
||
// 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, []);
|
||
});
|