mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 00:32:21 +00:00
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]>
398 lines
11 KiB
JavaScript
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');
|
|
});
|