Files
gods-eye-view/src/layers/shipwrecks/index.test.mjs
T
Sameh KhamisandManjunath Paparaju 0e5c5e624c Merge origin/main into space-missions-fixes
Main's single click rule (the card or label on top takes the click, read
once per click through clickCard and isUnderOtherCard in
src/data/pickRegistry.js) covers a click on a Space Missions label: a
mission marker label is an interactive world-overlay entry, so the
host's hit test names it as the card on top for every other layer. The
per-layer label guards in CCTV, Drone Airspace, FIRMS, Ghost Maps, News,
Perimeters, Shipwrecks, Vessels, Wildlife Sightings, ALPR, Local ADS-B
and the cockpit orbital focus are dropped for main's versions.

The mission-label tests are kept on main's API: fakeInputUnderLabel now
also names the label as the card on top, and each test shows a click on
the label never acts on the card, camera, vessel, fire, reader, aircraft
or report under it, and leaves the selection as it is. A launches test
checks that a mission label is interactive and is the card on top for
every other layer. Docs, changelog and the dispatcher's `overlay` note
describe the merged behaviour.

Co-authored-by: Manjunath Paparaju <[email protected]>
2026-11-18 20:00:25 -08:00

493 lines
14 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
import * as picking from '../../data/pickRegistry.js';
import { fakeInputUnderLabel } from '../../input/testDoubles.mjs';
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 };
}
function harness({ snapshots, now = () => 1, cardHit = () => null } = {}) {
const cards = [];
const handlers = [];
const opened = [];
let pickResult = null;
// A touch's wider contact search, when it finds what the exact pick missed.
let nearResult = null;
const viewer = {};
const { draw } = bindFakeDraw(viewer);
const queue = [...(snapshots || [])];
const requests = [];
// The card on top at a click, as the host answers the pick registry.
picking.setClickCardHitTest((x, y) => cardHit(x, y));
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);
},
},
overlayHost: {
setEntries: (_source, entries) => cards.push(entries),
setVisible() {},
hitTest: cardHit,
},
// The globe's clicks: one listener per click handler installed.
input: () => ({
onClick(callback) {
const handler = {
click: (event) =>
callback({
...event,
topHit: pickResult
? { set: 'shipwrecks:', id: pickResult, surface: false }
: null,
id: pickResult ?? nearResult,
}),
destroyed: false,
};
handlers.push(handler);
return () => {
handler.destroyed = true;
};
},
}),
picking,
pointer: { isPointerFree: () => true },
openExternal: (url) => opened.push(url),
now: () => now(),
});
layer.init(viewer);
const markerSet = () => draw.find('shipwrecks:');
return {
layer,
// The markers' set, its items in drawing order.
markers: {
get set() {
return markerSet();
},
get show() {
return markerSet()?.show;
},
get billboards() {
const set = markerSet();
return set && !set.disposed ? [...set.items.values()] : [];
},
},
cards,
handlers,
requests,
opened,
pick(id) {
pickResult = id ? `shipwreck:${id}` : null;
},
// What a touch's contact search finds near the tap, the exact pick
// being `pick`'s.
near(pickId) {
nearResult = pickId;
},
lastCard: () => cards.at(-1),
};
}
test('markers live in one set, shown only while the layer is on', async () => {
const h = harness({ snapshots: [snapshot([wreck('a'), wreck('b')])] });
assert.ok(h.markers.set, 'one set for every marker');
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.equal(h.markers.set, undefined, 'the set is disposed');
});
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.deepEqual(h.markers.billboards[2].size, [
markerPixelSize(1500),
markerPixelSize(1500),
]);
});
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.set.writes, 1);
await h.layer.update();
assert.equal(h.markers.set.writes, 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({ screenPosition: { 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('a tap selects only the wreck exactly under it, as a click does', async () => {
const h = harness({ snapshots: [snapshot([wreck('a')])] });
h.layer.enable();
await h.layer.update();
// Near a wreck but on nothing: no card.
h.near('shipwreck:a');
h.handlers[0].click({ screenPosition: { x: 1, y: 1 } });
assert.equal(h.cards.flat().length, 0);
h.pick('a');
h.handlers[0].click({ screenPosition: { x: 1, y: 1 } });
assert.equal(h.lastCard()[0].id, 'shipwreck-card:a');
// On nothing, near another layer's contact: the card is closed.
h.pick(null);
h.near('flight:abc');
h.handlers[0].click({ screenPosition: { x: 1, y: 1 } });
assert.deepEqual(h.lastCard(), []);
});
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');
});
test("a click on a mission label over the open card never opens the card's link, and keeps the card open", async (t) => {
let picked = null;
const viewer = { scene: { canvas: {}, pick: () => picked } };
bindFakeDraw(viewer);
let cardUnder = null;
const fake = fakeInputUnderLabel(viewer, {
beneath: () =>
cardUnder ? { sourceId: 'shipwrecks', entryId: cardUnder } : null,
});
t.after(() => fake.destroy());
const cards = [];
const opened = [];
const layer = createShipwrecksLayer({
source: { getSnapshot: () => Promise.resolve(snapshot([wreck('a')])) },
overlayHost: {
setEntries: (_source, entries) => cards.push(entries),
setVisible() {},
},
input: () => fake.input,
picking,
pointer: { isPointerFree: () => true },
openExternal: (url) => opened.push(url),
now: () => 1,
});
layer.init(viewer);
t.after(() => layer.destroy());
layer.enable();
await layer.update();
picked = { primitive: {}, id: { set: 'shipwrecks:', id: 'shipwreck:a' } };
fake.click();
const [card] = cards.at(-1);
assert.equal(card.id, 'shipwreck-card:a');
// The open card lies under the label: the click opens nothing, and the
// label on top is its own click, so the card stays open.
picked = null;
cardUnder = card.id;
fake.label.over = true;
fake.click();
assert.deepEqual(opened, [], 'the link beneath the label is not opened');
assert.equal(cards.at(-1)[0]?.id, card.id, 'the card stays open');
// Off the label, a click on the open card opens its link.
fake.label.over = false;
fake.click();
assert.equal(opened.length, 1);
});
test('a covered selected card and covered markers yield; bare markers select', async () => {
let painted = [];
const h = harness({
snapshots: [
snapshot([
wreck('a', { url: 'https://example.com/a' }),
wreck('b', { url: 'https://example.com/b' }),
]),
],
cardHit: (_x, _y, { sourceId } = {}) =>
painted.find((hit) => !sourceId || hit.sourceId === sourceId) ?? null,
});
try {
h.layer.enable();
await h.layer.update();
const click = () => h.handlers[0].click({ screenPosition: { x: 1, y: 1 } });
h.pick('a');
click();
const first = h.lastCard()[0];
painted = [
{ sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' },
{ sourceId: 'shipwrecks', entryId: first.id },
];
h.pick(null);
click();
assert.deepEqual(h.opened, []);
assert.equal(h.lastCard()[0].id, first.id);
// A marker under another layer's card is that card's click too.
h.pick('b');
click();
assert.equal(h.lastCard()[0].id, first.id, 'a covered marker yields');
painted = [];
click();
assert.equal(h.lastCard()[0].id, 'shipwreck-card:b');
painted = [{ sourceId: 'shipwrecks', entryId: 'shipwreck-card:b' }];
h.pick(null);
click();
assert.deepEqual(h.opened, ['https://example.com/b']);
painted = [];
click();
assert.deepEqual(h.lastCard(), [], 'bare map still clears the selection');
} finally {
h.layer.destroy();
}
});