Files
gods-eye-view/src/layers/shipwrecks/index.test.mjs
T
Mazeyar Moeini FeizabadiandClaude Fable 5.2 7b6ec7f963 perf(shipwrecks): place markers without a terrain height read each
Each of the 7,958 wreck billboards was ground-clamped, and a clamped
billboard reads the terrain height as it is created. Switching the layer
on after the globe had loaded froze the page for about 3 s in one task.
The markers now sit on the ellipsoid with no height reference; the depth
test is already off and the card already used that position.

Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-13 14:36:21 +01:00

398 lines
11 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import * as picking from '../../data/pickRegistry.js';
import {
createShipwrecksLayer,
markerPixelSize,
snapshotDeadline,
} from './index.js';
const wreck = (id, extra = {}) => ({
id,
source: 'wikidata',
name: id,
lat: 50,
lon: -1,
year: 1912,
date: null,
casualties: null,
...extra,
});
const snapshot = (records, version = 'v1') => ({
records,
fetchedAt: 1,
stale: false,
version,
sources: { emodnet: true, wikidata: true },
});
function deferred() {
let resolve;
const promise = new Promise((done) => {
resolve = done;
});
return { promise, resolve };
}
/** A fake billboard collection that records what the layer adds. */
function fakeMarkers() {
const collection = {
show: true,
billboards: [],
rebuilds: 0,
add(options) {
const billboard = { show: true, ...options };
collection.billboards.push(billboard);
return billboard;
},
removeAll() {
collection.rebuilds++;
collection.billboards = [];
},
};
return collection;
}
function harness({ snapshots, now = () => 1 } = {}) {
const markers = fakeMarkers();
const primitives = [];
const cards = [];
const handlers = [];
const opened = [];
let pickResult = null;
const viewer = {
camera: { positionWC: Cesium.Cartesian3.fromDegrees(-1, 50, 2e6) },
scene: {
canvas: {},
requestRender() {},
pick: () => pickResult,
preRender: { addEventListener: () => () => {} },
primitives: {
add: (primitive) => primitives.push(primitive),
remove: (primitive) =>
primitives.splice(primitives.indexOf(primitive), 1),
raiseToTop() {},
contains: (primitive) => primitives.includes(primitive),
},
},
};
const queue = [...(snapshots || [])];
const requests = [];
const layer = createShipwrecksLayer({
source: {
getSnapshot({ signal }) {
requests.push(signal);
const next = queue.shift();
if (next instanceof Error) return Promise.reject(next);
return next instanceof Promise ? next : Promise.resolve(next);
},
},
createMarkers: () => markers,
overlayHost: {
setEntries: (_source, entries) => cards.push(entries),
setVisible() {},
hitTest: () => null,
},
screenSpaceEventHandlerFactory: () => {
const handler = {
setInputAction(callback) {
handler.click = callback;
},
destroy() {
handler.destroyed = true;
},
};
handlers.push(handler);
return handler;
},
picking,
pointer: { isPointerFree: () => true },
openExternal: (url) => opened.push(url),
now: () => now(),
});
layer.init(viewer);
return {
layer,
markers,
primitives,
cards,
handlers,
requests,
opened,
pick(id) {
pickResult = id ? { id: `shipwreck:${id}` } : null;
},
lastCard: () => cards.at(-1),
};
}
test('markers live in one collection, shown only while the layer is on', async () => {
const h = harness({ snapshots: [snapshot([wreck('a'), wreck('b')])] });
assert.deepEqual(h.primitives, [h.markers]);
assert.equal(h.markers.show, false);
h.layer.enable();
assert.equal(h.markers.show, true);
assert.equal(await h.layer.update(), true);
assert.equal(h.markers.billboards.length, 2);
assert.equal(h.layer.getStats().count, 2);
h.layer.disable();
assert.equal(h.markers.show, false);
assert.equal(h.handlers[0].destroyed, true);
h.layer.destroy();
assert.deepEqual(h.primitives, [], 'the collection leaves the scene');
});
test('markers sit on the wreck: no eye offset, bigger toll drawn last', async () => {
const h = harness({
snapshots: [
snapshot([
wreck('big', { casualties: 1500 }),
wreck('none'),
wreck('small', { casualties: 3 }),
]),
],
});
h.layer.enable();
await h.layer.update();
const ids = h.markers.billboards.map((billboard) => billboard.id);
assert.deepEqual(ids, ['shipwreck:none', 'shipwreck:small', 'shipwreck:big']);
for (const billboard of h.markers.billboards)
assert.equal(billboard.eyeOffset, undefined);
assert.equal(h.markers.billboards[2].width, markerPixelSize(1500));
});
test('markers are placed without a terrain height read each', async () => {
// A ground-clamped billboard reads the terrain height when it is created;
// for every wreck in one pass that froze the page for seconds.
const h = harness({ snapshots: [snapshot([wreck('a'), wreck('b')])] });
h.layer.enable();
await h.layer.update();
assert.equal(h.markers.billboards.length, 2);
for (const billboard of h.markers.billboards) {
assert.equal(billboard.heightReference, undefined);
const { height } = Cesium.Cartographic.fromCartesian(billboard.position);
assert.equal(Math.abs(height) < 1e-6, true);
}
});
test('an unchanged snapshot does not rebuild the markers', async () => {
const records = [wreck('a')];
const h = harness({
snapshots: [
snapshot(records, 'v1'),
snapshot(records, 'v1'),
snapshot([wreck('a'), wreck('b')], 'v2'),
],
});
h.layer.enable();
await h.layer.update();
await h.layer.update();
assert.equal(h.markers.rebuilds, 1);
await h.layer.update();
assert.equal(h.markers.rebuilds, 2);
assert.equal(h.markers.billboards.length, 2);
});
test('a response that arrives after the layer is turned off is ignored', async () => {
const late = deferred();
const h = harness({ snapshots: [late.promise] });
h.layer.enable();
const pending = h.layer.update();
h.layer.disable();
assert.equal(h.requests[0].aborted, true);
late.resolve(snapshot([wreck('a')]));
assert.equal(await pending, false);
assert.equal(h.markers.billboards.length, 0);
});
test('a click opens the card; a period that excludes the wreck closes it', async () => {
const h = harness({
snapshots: [
snapshot([wreck('old', { year: 1850 }), wreck('new', { year: 1990 })]),
],
});
h.layer.enable();
await h.layer.update();
h.pick('old');
h.handlers[0].click({ position: { x: 1, y: 1 } });
const [card] = h.lastCard();
assert.equal(card.id, 'shipwreck-card:old');
h.layer.setParams({ from: 1900, to: 1990 });
assert.deepEqual(h.lastCard(), [], 'the hidden wreck loses its card');
const shown = h.markers.billboards.filter((billboard) => billboard.show);
assert.deepEqual(
shown.map((billboard) => billboard.id),
['shipwreck:new'],
);
assert.equal(h.layer.getStats().count, 1);
});
test('the year pickers list only years with a wreck, and each era is counted', async () => {
const h = harness({
snapshots: [
snapshot([
wreck('a', { year: 300 }),
wreck('b', { year: 1912 }),
wreck('c', { year: 1912 }),
wreck('d', { year: 1990 }),
wreck('e', { year: null }),
]),
],
});
h.layer.enable();
await h.layer.update();
let controls = h.layer.getRowControls();
assert.deepEqual(
controls.range.options.map((option) => option.value),
[1990, 1912, 300],
);
assert.deepEqual(
controls.legend.map((era) => era.count),
[1, 2, 1, 1],
);
h.layer.setParams({ from: 1900, to: 1950 });
controls = h.layer.getRowControls();
assert.deepEqual(
controls.range.options.map((option) => option.value),
[1990, 1950, 1912, 1900, 300],
'the chosen ends are listed too',
);
assert.deepEqual(
controls.legend.map((era) => era.count),
[0, 2, 0, 0],
);
});
test('a source without a version rebuilds on every new snapshot', async () => {
const bare = (records) => {
const value = snapshot(records);
delete value.version;
return value;
};
const h = harness({
snapshots: [
bare([wreck('a')]),
bare([wreck('a'), wreck('b')]),
{ ...snapshot([wreck('a')]), version: null },
{ ...snapshot([wreck('a'), wreck('b'), wreck('c')]), version: null },
],
});
h.layer.enable();
for (const expected of [1, 2, 1, 3]) {
await h.layer.update();
assert.equal(h.markers.billboards.length, expected);
}
});
test('a failed refresh marks the shown wrecks stale, and clears them after seven days', async () => {
const DAY = 24 * 60 * 60 * 1000;
let clock = 1;
const h = harness({
now: () => clock,
snapshots: [
snapshot([wreck('a')]),
new Error('Shipwrecks unavailable (HTTP 502)'),
new Error('Shipwrecks unavailable (HTTP 502)'),
],
});
h.layer.enable();
await h.layer.update();
assert.equal(h.layer.getStats().stale, false);
clock = 1 + 2 * DAY;
assert.equal(await h.layer.update(), false);
assert.equal(h.layer.getStats().stale, true);
assert.equal(h.layer.getStats().count, 1, 'still shown, as stale');
clock = 1 + 8 * DAY;
await h.layer.update();
assert.equal(h.layer.getStats().count, 0, 'expired wrecks leave the map');
assert.equal(h.markers.billboards.length, 0);
});
test('expiry runs on the page clock and keeps every wreck until the newest source is too old', async () => {
const DAY = 24 * 60 * 60 * 1000;
const down = () => new Error('Shipwrecks unavailable (HTTP 502)');
// The page clock is far from the proxy's fetchedAt: only reported ages count.
let clock = 5e12;
const h = harness({
now: () => clock,
snapshots: [
{
...snapshot([
wreck('fresh', { source: 'emodnet' }),
wreck('merged', { source: 'wikidata', alsoIn: 'emodnet' }),
]),
fetchedAt: 1,
ages: { emodnet: 0, wikidata: 6.5 * DAY },
maxAgeMs: 7 * DAY,
},
down(),
down(),
],
});
h.layer.enable();
await h.layer.update();
clock += 1 * DAY;
await h.layer.update();
assert.equal(
h.layer.getStats().count,
2,
'nothing leaves while EMODnet is in date',
);
assert.equal(h.layer.getStats().stale, true);
clock += 6.5 * DAY;
await h.layer.update();
assert.equal(
h.layer.getStats().count,
0,
'all leave once the newest is too old',
);
});
test('a snapshot with no timestamp or ages still expires seven days after it arrived', async () => {
const DAY = 24 * 60 * 60 * 1000;
let clock = 100;
const h = harness({
now: () => clock,
snapshots: [
{ ...snapshot([wreck('a')]), fetchedAt: null },
new Error('down'),
],
});
h.layer.enable();
await h.layer.update();
clock += 8 * DAY;
await h.layer.update();
assert.equal(h.layer.getStats().count, 0);
});
test('the page deadline subtracts the newest available source age from the limit', () => {
const DAY = 24 * 60 * 60 * 1000;
const both = { emodnet: true, wikidata: true };
assert.equal(
snapshotDeadline(
{
sources: both,
ages: { emodnet: 2 * DAY, wikidata: 6.5 * DAY },
maxAgeMs: 5 * DAY,
},
100,
),
100 + 3 * DAY,
);
assert.equal(
snapshotDeadline(
{
sources: { emodnet: false, wikidata: true },
ages: { emodnet: null, wikidata: 4 * DAY },
maxAgeMs: 5 * DAY,
},
0,
),
1 * DAY,
'an unavailable source does not count',
);
assert.equal(snapshotDeadline({ sources: both }, 0), 7 * DAY, 'defaults');
});