Files
gods-eye-view/src/layers/news/layer.test.mjs
T
Sameh Khamis bb3bf9858b fix(click): the card or label on top takes the click in every layer
Review fixes for #1781:

- One rule for cards: the world-overlay host hands its hit test to the
  pick registry, and every click handler reads the topmost interactive
  card or label once per click (`clickCard`, `isUnderOtherCard` in
  src/data/pickRegistry.js), so all handlers agree in any listener order.
  A layer whose own card or label is on top acts on it whatever is drawn
  under it; a layer under another layer's card neither acts nor treats
  the click as empty space (a tracked aircraft stays tracked, a selection
  stays selected); Context names nothing under a card. A selected news
  card over a vessel no longer opens the link and selects the vessel.
- With one rule, the per-owner arbitration options are no longer read
  and are removed: `passive`, `expanded` and `declinesClick` pick owners,
  `rememberClickPickActions`, `isActedOnByOtherLayer`, card backgrounds
  and `cardKeepsClick`. The dispatcher is unchanged from main.
- A drag that ends on a quake disc, label or card does nothing; opening
  the USGS page or clearing the selection needs a clean click.
- A click on the map under another layer's card opens no Street Level
  ground image.
- A CCTV card that is going away is still not the scene under it.
- Docs and changelog describe the new rule.
2026-11-18 18:23:41 -08:00

1379 lines
43 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 test from 'node:test';
import assert from 'node:assert/strict';
import { KEY_SETUP_KEYS } from '../../keySetupCore.mjs';
import { fromDegrees } from '../../geo/ellipsoid.js';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs';
import { NEWS_KEY_PROVIDERS, createNewsLayer } from './index.js';
import {
findPickOwner,
registerPickOwner,
setClickCardHitTest,
unregisterPickOwner,
} from '../../data/pickRegistry.js';
// Registers the shared `gev-trail:` no-op owner, as the app does.
import '../../data/trailRenderer.js';
import { getSelectedEntityContext } from '../../data/contextStore.js';
const NOW = Date.parse('2026-10-28T10:00:00Z');
const hotspotsPayload = {
hotspots: [
{
id: 'ua-ru-war',
name: 'Russia–Ukraine war',
bbox: [22, 44, 42, 56],
focus: { lat: 48.6, lon: 35.5 },
last24h: 3,
parties: ['UA', 'RU'],
},
],
categories: [],
lastRunAt: null,
};
const report = (id, extra = {}) => ({
id,
title: `Report ${id}`,
url: `https://example.com/${id}`,
publishedAt: '2026-10-28T09:00:00.000Z',
publisher: 'Example',
side: 'UA',
category: 'strike',
hotspotId: 'ua-ru-war',
hotspotIds: ['ua-ru-war'],
severity: 2,
geo: { lat: 50, lon: 36, place: 'Kharkiv', mappable: true },
pins: [{ lat: 50, lon: 36, place: 'Kharkiv', mappable: true }],
event: null,
media: [],
...extra,
});
function fixture(
t,
{
source: overrides = {},
height = 20_000_000,
reduced = false,
centre = () => ({ lat: 49, lon: 36 }),
credits = [],
now = () => NOW,
quality,
pictureCards,
hitTestOverlay = () => null,
} = {},
) {
const calls = { feed: [], hotspots: 0, outline: 0 };
const reports = [
report('major', {
severity: 3,
attribution: 'GDELT Project',
event: {
size: 3,
severity: 3,
status: 'both-sides',
lastAt: '2026-10-28T09:30:00.000Z',
sides: [],
image: null,
},
}),
report('minor', { severity: 1 }),
report('old', { publishedAt: '2026-10-26T09:00:00.000Z', severity: 3 }),
report('far', {
severity: 2,
pins: [{ lat: 31.5, lon: 34.4, place: 'Gaza', mappable: true }],
}),
];
const source = {
getHotspots: async () => {
calls.hotspots++;
return hotspotsPayload;
},
getFeed: async (query) => {
calls.feed.push(query);
return { reports, nextBefore: null };
},
getOutline: async () => {
calls.outline++;
return { polygons: [], borders: [], disputed: [] };
},
...overrides,
};
const entries = [];
const overlayHost = {
setEntries: (_id, list) => entries.push(list),
setVisible() {},
clearSource: () => entries.push([]),
};
const flights = [];
// The renderer's camera over (36° E, 49° N) at `height`, its frame and
// its draw sets.
const cameraPort = fakeCameraPort({
pose: { lon: 36, lat: 49, height, position: fromDegrees(36, 49, height) },
});
cameraPort.port.flyTo = (destination, options = {}) =>
flights.push({ destination, ...options });
const camera = {
setHeight: (next) =>
cameraPort.setPose({
height: next,
position: fromDegrees(36, 49, next),
}),
moveEnd: () => cameraPort.emit('moveEnd'),
};
const viewer = {};
const { draw, unbind } = bindFakeDraw(viewer, {
camera: cameraPort.port,
frame: { requestRender() {}, on: () => () => {} },
...(quality ? { quality } : {}),
});
// The items of the layer's draw set named `part` (`points`, `icons`, …).
const items = (part) => [
...(draw.find('news:')
? [...draw.sets.values()]
.filter((set) => !set.disposed && set.spec.id.endsWith(`:${part}`))
.flatMap((set) => [...set.items.values()])
: []),
];
// The scene's click dispatcher: `click(hit)` clicks over a drawn item.
const clickHandlers = new Set();
const input = {
onClick(fn) {
clickHandlers.add(fn);
return () => clickHandlers.delete(fn);
},
};
const click = (topHit) => {
for (const fn of [...clickHandlers])
fn({ screenPosition: { x: 10, y: 10 }, topHit });
};
// The card on top at a click, as the host answers the pick registry.
setClickCardHitTest((x, y) => hitTestOverlay(x, y));
const layer = createNewsLayer({
source,
overlayHost,
inputFor: () => input,
now,
matchMedia: () => ({ matches: reduced }),
getViewCentre: () => centre(),
registerCredit: (_viewer, credit) => {
credits.push(credit.key);
return true;
},
...(pictureCards ? { pictureCards } : {}),
});
// The context store announces selections on `window`, which Node lacks.
const originalWindow = globalThis.window;
globalThis.window = new EventTarget();
layer.init(viewer);
layer.attachShellServices({ runNavigation: (navigate) => navigate() });
t.after(() => {
layer.destroy();
setClickCardHitTest(null);
unbind();
if (originalWindow === undefined) delete globalThis.window;
else globalThis.window = originalWindow;
});
return {
layer,
viewer,
camera,
calls,
entries,
flights,
items,
click,
clickHandlers,
};
}
const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
const flush = async () => {
for (let i = 0; i < 6; i++) await Promise.resolve();
};
const keyError = (key, extra = {}) =>
Object.assign(new Error('News key required'), {
keyRequired: true,
keyRejected: false,
keyId: key,
retryable: true,
...extra,
});
const ukraine = {
area: { key: 'UA', name: 'Ukraine', kind: 'country', country: 'UA' },
polygons: [
{
outer: [
[35, 48],
[37, 48],
[37, 50.5],
[35, 50.5],
],
holes: [],
},
],
borders: [],
disputed: [],
};
const noArea = { area: null, polygons: [], borders: [], disputed: [] };
test('the feed shows the last 24 h at significant and above, beacons when zoomed out', async (t) => {
const { layer, calls, entries } = fixture(t);
layer.enable();
assert.equal(await layer.update(), true);
await settle();
assert.equal(calls.hotspots, 1);
// The map read and the panel's feed read both ask for the last day only.
assert.ok(calls.feed.every((query) => query.today === true));
const view = layer.getRowControls().feed;
assert.deepEqual(
view.items.map((item) => item.id),
['major', 'far'],
);
assert.deepEqual(
view.hotspots.map((chip) => [chip.id, chip.label, chip.active]),
[
['all', 'All', true],
['ua-ru-war', 'Ukraine–Russia', false],
],
);
const labels = entries.at(-1);
assert.ok(labels.some((entry) => entry.id === 'hotspot:ua-ru-war'));
assert.equal(layer.getStats().error, null);
// Zoomed out, the camera is too high for "In view".
assert.equal(view.inView.active, false);
});
test('choosing a card selects it and flies straight down from 150 km; reduced motion jumps', async (t) => {
const { layer, flights, entries } = fixture(t, { reduced: true });
layer.enable();
await layer.update();
layer.setParams({ reportId: 'major', focus: true });
assert.equal(flights.length, 1);
assert.equal(flights[0].durationS, 0);
const at = flights[0].destination;
assert.equal(at.height, 150_000);
assert.equal(at.lat, 50);
const card = entries.at(-1).find((e) => e.id === 'selected-report:major');
assert.ok(card.details.includes('Source: example.com ↗'));
// The service the report came through is credited where it shows.
assert.ok(card.details.includes('via GDELT Project'));
assert.equal(layer.getRowControls().feed.selected.via, 'via GDELT Project');
assert.equal(layer.getRowControls().feed.selected.id, 'major');
layer.setParams({ clear: true });
assert.equal(layer.getRowControls().feed.selected, null);
});
test('a selected report carries the point voice projects to find what is in view', async (t) => {
const { layer } = fixture(t);
layer.enable();
await layer.update();
layer.setParams({ reportId: 'major' });
const record = getSelectedEntityContext();
assert.equal(record?.id, 'news-report:major');
assert.ok(record.targetPosition, 'a position voice can project');
assert.equal(record.targetPosition, record.entity.__localBaseCartesian);
});
test('the severity floor changes what is shown, not what is read', async (t) => {
const { layer, entries, calls } = fixture(t, { height: 500_000 });
layer.enable();
await layer.update();
const cards = () =>
entries.at(-1).filter((entry) => entry.id.startsWith('event-card:'));
// No canvas in Node: cards need one, so none are painted, and nothing throws.
assert.deepEqual(cards(), []);
await settle();
const reads = calls.feed.length;
layer.setParams({ filters: { minSeverity: 0 } });
assert.equal(calls.feed.length, reads);
assert.deepEqual(
layer.getRowControls().feed.items.map((item) => item.id),
['major', 'minor', 'far'],
);
});
test('a host that draws the picture cards is handed one card per pictured event on the map, most severe first', async (t) => {
const picture = (url, extra = {}) => ({
size: 1,
lastAt: '2026-10-28T09:00:00.000Z',
sides: [],
image: { url, publisher: 'Example', ...extra },
});
const reports = [
report('single', {
severity: 1,
event: picture('https://example.com/single.jpg', {
video: 'https://example.com/single.mp4',
}),
}),
report('major', {
severity: 3,
event: {
...picture('https://example.com/major.jpg'),
id: 'event-major',
size: 3,
},
}),
// Another report of the same event: its picture stands once.
report('repeat', {
severity: 2,
event: {
...picture('https://example.com/major.jpg'),
id: 'event-major',
size: 3,
},
}),
report('bare', { severity: 2 }),
];
const handed = [];
const { layer, entries } = fixture(t, {
height: 500_000,
source: { getFeed: async () => ({ reports, nextBefore: null }) },
pictureCards: (cards, state) => handed.push({ cards, ...state }),
});
layer.enable();
await layer.update();
layer.setParams({ filters: { minSeverity: 0 } });
const { cards, selectedId } = handed.at(-1);
assert.equal(selectedId, null);
// A single source is enough; a report without a picture has none.
assert.deepEqual(
cards.map((card) => card.id),
['major', 'single'],
);
assert.equal(cards[1].image, 'https://example.com/single.jpg');
assert.equal(cards[1].video, 'https://example.com/single.mp4');
assert.equal(cards[0].video, null);
assert.equal(cards[0].credit, 'Example');
assert.ok(
Math.abs(cards[0].lat - 50) < 0.5 && Math.abs(cards[0].lon - 36) < 0.5,
);
// The layer paints none of its own.
assert.ok(
entries.flat().every((entry) => !entry.id.startsWith('event-card:')),
);
// The selected report is named, pictured or not.
layer.setParams({ reportId: 'bare' });
assert.equal(handed.at(-1).selectedId, 'bare');
layer.disable();
assert.deepEqual(handed.at(-1), { cards: [], selectedId: null });
});
test("a host's picture cards stay at every height, beacons or markers", async (t) => {
const reports = [
report('major', {
severity: 3,
event: {
size: 1,
lastAt: '2026-10-28T09:00:00.000Z',
sides: [],
image: { url: 'https://example.com/major.jpg', publisher: 'Example' },
},
}),
];
const handed = [];
const { layer } = fixture(t, {
// The whole globe: the hotspot stands as one beacon, its reports unmarked.
height: 20_000_000,
source: { getFeed: async () => ({ reports, nextBefore: null }) },
pictureCards: (cards) => handed.push(cards),
});
layer.enable();
await layer.update();
layer.setParams({ filters: { minSeverity: 0 } });
assert.deepEqual(
handed.at(-1).map((card) => card.id),
['major'],
);
});
test('picture cards must be drawn by a function', () => {
assert.throws(
() =>
createNewsLayer({
source: { getHotspots() {}, getFeed() {} },
overlayHost: {},
pictureCards: 'yes',
}),
TypeError,
);
});
test('Local reads every report once, lists those near the view and takes the map over', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let centre = { lat: 49, lon: 36 };
let fail = false;
const localReads = [];
const { layer, camera, items } = fixture(t, {
height: 1_000_000,
centre: () => centre,
source: {
getFeed: async (query) => {
if (query.relevance === '' && query.limit === 500) {
localReads.push(query);
if (fail) throw new Error('boom');
return {
reports: [
report('broad', { severity: 1, relevance: 'minor' }),
report('south', {
severity: 2,
pins: [{ lat: 31.5, lon: 34.4, place: 'Gaza', mappable: true }],
}),
],
nextBefore: null,
};
}
return {
reports: [report('major', { severity: 3 })],
nextBefore: null,
};
},
},
});
const markers = () =>
[...items('points'), ...items('icons')]
.map((item) => String(item.id))
.filter((id) => /~\d+$/.test(id))
.map((id) => id.replace(/^.*:/, '').replace(/~\d+$/, ''));
layer.enable();
await layer.update();
for (let i = 0; i < 4; i++) await Promise.resolve();
// Conflicts: no read of minor news, the hotspots' news on the map.
assert.equal(localReads.length, 0);
assert.equal(layer.getRowControls().feed.inView.active, true);
assert.deepEqual(markers(), ['major']);
layer.setParams({ filters: { section: 'local' } });
for (let i = 0; i < 4; i++) await Promise.resolve();
assert.equal(localReads.length, 1);
let view = layer.getRowControls().feed;
// Every severity near the centre; Gaza is beyond 500 km; no older pages.
assert.deepEqual(
view.inView.items.map((item) => item.id),
['broad'],
);
assert.equal(view.hasMore, false);
assert.deepEqual(markers(), ['broad']);
// A pan reads nothing more and follows the camera once it settles.
centre = { lat: 31.5, lon: 34.4 };
camera.moveEnd();
t.mock.timers.tick(800);
await Promise.resolve();
assert.equal(localReads.length, 1);
assert.deepEqual(
layer.getRowControls().feed.inView.items.map((item) => item.id),
['south'],
);
assert.deepEqual(markers(), ['south']);
// Up above 3,000 km there is no "near here": the map shows conflicts again.
camera.setHeight(5_000_000);
camera.moveEnd();
t.mock.timers.tick(800);
view = layer.getRowControls().feed;
assert.equal(view.inView.active, false);
assert.ok(!markers().includes('south'));
// Back to Conflicts and to Local again with the server failing: it shows.
camera.setHeight(1_000_000);
layer.setParams({ filters: { section: 'conflicts' } });
fail = true;
layer.setParams({ filters: { section: 'local' } });
for (let i = 0; i < 4; i++) await Promise.resolve();
assert.equal(localReads.length, 2);
view = layer.getRowControls().feed;
assert.equal(view.inView.error, 'News feed unavailable');
assert.deepEqual(view.inView.items, []);
});
test('Local reads the area at the view centre, lists its reports and outlines it faintly', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let centre = { lat: 49, lon: 36 };
const areaReads = [];
const feedReads = [];
const box = [
[35, 48],
[37, 48],
[37, 50.5],
[35, 50.5],
];
const { layer, camera, items } = fixture(t, {
height: 1_000_000,
centre: () => centre,
source: {
getFeed: async (query) => {
feedReads.push(query);
return {
reports: [
report('inside', { severity: 1, relevance: 'minor' }),
report('beyond', {
severity: 2,
pins: [{ lat: 49, lon: 39, place: 'Luhansk', mappable: true }],
}),
],
nextBefore: null,
};
},
getAreaOutline: async (point) => {
areaReads.push(point);
return point.lat > 45
? {
area: {
key: 'UA',
name: 'Ukraine',
kind: 'country',
country: 'UA',
},
polygons: [{ outer: box, holes: [] }],
borders: [],
disputed: [],
}
: { area: null, polygons: [], borders: [], disputed: [] };
},
},
});
const outline = () =>
[...items('outline-fills'), ...items('outline-lines')].filter((item) =>
String(item.id).includes('local:UA'),
);
layer.enable();
await layer.update();
await flush();
// Conflicts reads no area.
assert.equal(areaReads.length, 0);
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.equal(areaReads.length, 1);
// The read asks the server for the area's reports, at the point named.
const localRead = () => feedReads.filter((q) => q.relevance === '').at(-1);
assert.deepEqual(localRead().at, { lat: 49, lon: 36 });
let view = layer.getRowControls().feed;
assert.equal(view.inView.area, 'Ukraine');
// Luhansk is within 500 km, outside the area.
assert.deepEqual(
view.inView.items.map((item) => item.id),
['inside'],
);
assert.ok(outline().length > 0);
assert.ok(outline().every((item) => item.show && item.widthPx === 1.5));
// A pan inside the area reads it again only once the centre leaves it.
centre = { lat: 50, lon: 36.5 };
camera.moveEnd();
t.mock.timers.tick(800);
await flush();
assert.equal(areaReads.length, 1);
// At sea: no area, the radius, and the outline hidden.
centre = { lat: 43, lon: 34 };
camera.moveEnd();
t.mock.timers.tick(800);
await flush();
assert.equal(areaReads.length, 2);
assert.equal(localRead().at, undefined);
view = layer.getRowControls().feed;
assert.equal(view.inView.area, null);
assert.equal(view.inView.radiusKm, 500);
assert.ok(outline().every((e) => !e.show));
// Conflicts hides the area's outline too.
centre = { lat: 49, lon: 36 };
camera.moveEnd();
t.mock.timers.tick(800);
await flush();
assert.ok(outline().every((e) => e.show));
layer.setParams({ filters: { section: 'conflicts' } });
await flush();
assert.ok(outline().every((e) => !e.show));
});
test('a shorter window narrows the feed and reads the hotspot counts for it', async (t) => {
const asked = [];
const { layer } = fixture(t, {
source: {
getHotspots: async ({ hours } = {}) => {
asked.push(hours);
return {
...hotspotsPayload,
windowHours: hours ?? 12,
maxWindowHours: 12,
};
},
getFeed: async () => ({
reports: [
report('recent', { publishedAt: '2026-10-28T09:30:00.000Z' }),
report('earlier', { publishedAt: '2026-10-28T05:00:00.000Z' }),
],
nextBefore: null,
}),
},
});
layer.enable();
await layer.update();
await settle();
let view = layer.getRowControls().feed;
assert.deepEqual(view.windowChoices, [12, 6, 3, 1]);
assert.equal(view.windowHours, 12);
assert.deepEqual(
view.items.map((item) => item.id),
['recent', 'earlier'],
);
layer.setParams({ filters: { hours: 3 } });
view = layer.getRowControls().feed;
assert.equal(view.windowHours, 3);
assert.deepEqual(
view.items.map((item) => item.id),
['recent'],
);
for (let i = 0; i < 3; i++) await settle();
assert.deepEqual(asked, [undefined, 3]);
// The server's own window still bounds the choices.
assert.deepEqual(layer.getRowControls().feed.windowChoices, [12, 6, 3, 1]);
// A choice longer than the server serves shows all it serves.
layer.setParams({ filters: { hours: 24 } });
assert.equal(layer.getRowControls().feed.windowHours, 12);
});
test('a server without news is unavailable once and is not asked again', async (t) => {
const failure = Object.assign(
new Error('News feed not configured on this server'),
{
unavailable: true,
},
);
let reads = 0;
const { layer } = fixture(t, {
source: {
getHotspots: async () => {
reads++;
throw failure;
},
},
});
layer.enable();
assert.equal(await layer.update(), true);
assert.equal(await layer.update(), true);
assert.equal(reads, 1);
const stats = layer.getStats();
assert.equal(stats.sourceUnavailable, true);
assert.equal(stats.status, 'unavailable');
assert.equal(layer.getRowControls().feed.error, failure.message);
// Turning the layer off and on asks again.
layer.disable();
layer.enable();
await layer.update();
assert.equal(reads, 2);
});
test('a section read from a key the server lacks says which key, and the other still reads', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let liveuamap = keyError('liveuamap');
let worldNews = keyError('worldnewsapi');
let hotspotReads = 0;
const { layer } = fixture(t, {
height: 1_000_000,
source: {
getHotspots: async () => {
hotspotReads++;
if (liveuamap) throw liveuamap;
return hotspotsPayload;
},
getFeed: async (query) => {
if (query.at && worldNews) throw worldNews;
if (!query.at && liveuamap) throw liveuamap;
return {
reports: [report('inside', { relevance: 'minor' })],
nextBefore: null,
};
},
getAreaOutline: async () => ukraine,
},
});
layer.enable();
assert.equal(await layer.update(), true);
await flush();
let view = layer.getRowControls().feed;
assert.equal(view.key.title, 'Liveuamap key required');
assert.match(view.key.hint, /LIVEUAMAP_API_KEY/);
assert.equal(view.error, null, 'a missing key is no failure');
assert.equal(layer.getStats().sourceUnavailable, undefined);
layer.setParams({ filters: { section: 'local' } });
await flush();
view = layer.getRowControls().feed;
assert.equal(view.inView.key.title, 'World News API key required');
assert.match(view.inView.key.hint, /WORLDNEWSAPI_KEY/);
assert.equal(view.inView.error, null);
// A key set meanwhile is picked up by the next refresh.
worldNews = null;
await layer.update();
await flush();
view = layer.getRowControls().feed;
assert.equal(view.inView.key, null);
assert.deepEqual(
view.inView.items.map((item) => item.id),
['inside'],
);
assert.equal(view.key.title, 'Liveuamap key required');
liveuamap = keyError('liveuamap', { keyRejected: true });
await layer.update();
view = layer.getRowControls().feed;
assert.equal(view.key.title, 'Liveuamap refused its key');
assert.equal(view.key.hint, 'Check LIVEUAMAP_API_KEY in Provider Settings');
liveuamap = null;
await layer.update();
await flush();
view = layer.getRowControls().feed;
assert.equal(view.key, null);
assert.equal(hotspotReads, 4, 'a missing key is asked again each refresh');
});
test("Local says when its provider's allowance for the day is spent, until a read passes", async (t) => {
let quota = true;
const { layer } = fixture(t, {
height: 1_000_000,
source: {
getFeed: async (query) => {
if (query.at && quota)
throw keyError('worldnewsapi', { keyQuota: true });
return {
reports: [report('inside', { relevance: 'minor' })],
nextBefore: null,
};
},
getAreaOutline: async () => ukraine,
},
});
layer.enable();
await layer.update();
await flush();
layer.setParams({ filters: { section: 'local' } });
await flush();
let view = layer.getRowControls().feed;
assert.deepEqual(view.inView.key, {
title: 'World News API limit reached for today',
hint: 'News resumes tomorrow, or with a paid plan',
});
assert.equal(view.inView.error, null, 'a spent allowance is no failure');
quota = false;
await layer.update();
await flush();
view = layer.getRowControls().feed;
assert.equal(view.inView.key, null);
assert.deepEqual(
view.inView.items.map((item) => item.id),
['inside'],
);
});
test('a Conflicts feed read that passes clears its key notice', async (t) => {
let refuse = true;
const { layer } = fixture(t, {
source: {
getFeed: async (query) => {
// The panel's feed page, not the map's read.
if (query.limit === 60 && refuse) throw keyError('liveuamap');
return {
reports: [report('major', { severity: 3 })],
nextBefore: null,
};
},
},
});
layer.enable();
await layer.update();
await settle();
assert.equal(layer.getRowControls().feed.key.title, 'Liveuamap key required');
refuse = false;
layer.setParams({ filters: { category: 'strike' } });
await settle();
const view = layer.getRowControls().feed;
assert.equal(view.key, null);
assert.deepEqual(
view.items.map((item) => item.id),
['major'],
);
});
test('the key providers the layer names match the key registry', () => {
for (const [id, { envVar }] of Object.entries(NEWS_KEY_PROVIDERS)) {
const entry = KEY_SETUP_KEYS.find((key) => key.id === id);
assert.ok(entry, `${id} is in the key registry`);
assert.deepEqual([...entry.envVars], [envVar]);
}
});
test('a slower area read for where the camera was never lands over the area it came back to', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let centre = { lat: 49, lon: 36 };
const pending = [];
const { layer, camera } = fixture(t, {
height: 1_000_000,
centre: () => centre,
source: {
getAreaOutline: (point) =>
point.lat > 45
? Promise.resolve(ukraine)
: new Promise((resolve) => pending.push(resolve)),
},
});
const look = async (at) => {
centre = at;
camera.moveEnd();
t.mock.timers.tick(800);
await flush();
};
layer.enable();
await layer.update();
await flush();
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.equal(layer.getRowControls().feed.inView.area, 'Ukraine');
// Out to sea, where the area read is slow, and back before it answers.
await look({ lat: 43, lon: 34 });
assert.equal(pending.length, 1);
assert.equal(layer.getRowControls().feed.inView.areaLoading, true);
await look({ lat: 49.6, lon: 36.2 });
pending[0](noArea);
await flush();
const view = layer.getRowControls().feed;
assert.equal(view.inView.area, 'Ukraine');
assert.equal(view.inView.areaLoading, false);
assert.equal(view.inView.loading, false);
});
test('leaving Local while its area is read sends no Local read', async (t) => {
let answer = null;
const localReads = [];
// The camera stays put: only the section changes.
const here = { lat: 49, lon: 36 };
const { layer } = fixture(t, {
height: 1_000_000,
centre: () => here,
source: {
getFeed: async (query) => {
if (query.relevance === '') localReads.push(query);
return { reports: [], nextBefore: null };
},
getAreaOutline: () =>
new Promise((resolve) => {
answer = resolve;
}),
},
});
layer.enable();
await layer.update();
await flush();
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.equal(layer.getRowControls().feed.inView.loading, true);
layer.setParams({ filters: { section: 'conflicts' } });
await flush();
assert.equal(layer.getRowControls().feed.inView.loading, false);
answer(ukraine);
await flush();
assert.equal(localReads.length, 0);
assert.equal(layer.getRowControls().feed.inView.loading, false);
});
test('a server without the area route keeps Local to the radius and is asked once', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let centre = { lat: 49, lon: 36 };
let areaReads = 0;
const localReads = [];
const { layer, camera } = fixture(t, {
height: 1_000_000,
centre: () => centre,
source: {
getFeed: async (query) => {
if (query.relevance === '') localReads.push(query);
return { reports: [report('near')], nextBefore: null };
},
getAreaOutline: async () => {
areaReads++;
throw Object.assign(
new Error('News feed not configured on this server'),
{ status: 404, code: 'unavailable', unavailable: true },
);
},
},
});
layer.enable();
await layer.update();
await flush();
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.equal(areaReads, 1);
assert.equal(localReads.length, 1);
assert.equal(localReads[0].at, undefined);
let view = layer.getRowControls().feed;
assert.equal(view.inView.area, null);
assert.equal(view.inView.areaLoading, false);
assert.deepEqual(
view.inView.items.map((item) => item.id),
['near'],
);
// The settles that follow do not ask for an area again.
centre = { lat: 47, lon: 31 };
camera.moveEnd();
t.mock.timers.tick(800);
await flush();
assert.equal(areaReads, 1);
// Turning the layer off and on asks again.
layer.disable();
layer.enable();
await layer.update();
await flush();
assert.equal(areaReads, 2);
view = layer.getRowControls().feed;
assert.equal(view.inView.error, null);
});
test('Liveuamap and Natural Earth are credited once what they credit shows', async (t) => {
const credits = [];
const { layer } = fixture(t, {
height: 1_000_000,
credits,
source: {
getFeed: async (query) => ({
reports:
query.relevance === ''
? [report('near', { kind: 'rss' })]
: [report('mapped', { kind: 'liveuamap', severity: 3 })],
nextBefore: null,
}),
getAreaOutline: async () => ukraine,
},
});
layer.enable();
await layer.update();
await flush();
layer.getRowControls();
assert.deepEqual(credits, ['liveuamap']);
// The Local area's outline (the built-in server's are Natural Earth's).
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.deepEqual(credits, ['liveuamap', 'natural-earth']);
// Shown again: registered once.
layer.setParams({ filters: { section: 'conflicts' } });
await layer.update();
await flush();
layer.getRowControls();
assert.deepEqual(credits, ['liveuamap', 'natural-earth']);
});
test('without Liveuamap reports or a Local area, nothing is credited', async (t) => {
const credits = [];
const { layer } = fixture(t, { height: 1_000_000, credits });
layer.enable();
await layer.update();
await flush();
layer.getRowControls();
assert.deepEqual(credits, []);
});
test('a failed Conflicts read leaves Local reading with each refresh', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const failure = () => new Error('News feed unavailable');
let local = failure();
const { layer } = fixture(t, {
height: 1_000_000,
source: {
getHotspots: async () => {
throw failure();
},
getFeed: async (query) => {
if (!query.at) throw failure();
if (local) throw local;
return {
reports: [report('inside', { relevance: 'minor' })],
nextBefore: null,
};
},
getAreaOutline: async () => ukraine,
},
});
layer.enable();
await layer.update();
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.equal(
layer.getRowControls().feed.inView.error,
'News feed unavailable',
);
// The area's read lands meanwhile; Conflicts still fails.
local = null;
await layer.update();
await flush();
const view = layer.getRowControls().feed;
assert.deepEqual(
view.inView.items.map((item) => item.id),
['inside'],
);
assert.equal(view.error, 'News feed unavailable');
});
test("a country's own news is one badge with a count, not markers piled on its centre", async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const anchor = {
lat: 49,
lon: 36,
place: 'Ukraine',
precision: 'country',
mappable: true,
};
const { layer, items } = fixture(t, {
height: 1_000_000,
source: {
getFeed: async () => ({
reports: [
report('own-1', { relevance: 'minor', pins: [anchor] }),
report('own-2', { relevance: 'minor', pins: [anchor] }),
report('placed', { relevance: 'minor' }),
],
nextBefore: null,
}),
},
});
const ids = () =>
[...items('points'), ...items('icons')].map((item) => String(item.id));
layer.enable();
await layer.update();
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.deepEqual(
ids().filter((id) => /~\d+$/.test(id)),
['news:report:placed~0'],
);
assert.deepEqual(
ids().filter((id) => id.startsWith('news:country:')),
['news:country:Ukraine'],
);
// Both are still listed, and one picked there gets its own marker.
assert.equal(layer.getRowControls().feed.inView.items.length, 3);
layer.setParams({ reportId: 'own-1' });
await flush();
assert.ok(ids().includes('news:report:own-1~0'));
});
test("a country badge is painted at the scene's pixel ratio, not the device's", async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
// A canvas that paints nothing and names its size in its data URL.
const context = new Proxy(
{},
{ get: () => () => ({ width: 0 }), set: () => true },
);
const originalDocument = globalThis.document;
const originalRatio = globalThis.devicePixelRatio;
globalThis.document = {
createElement: () => ({
width: 0,
height: 0,
getContext: () => context,
toDataURL() {
return `data:image/png;test,${this.width}`;
},
}),
};
globalThis.devicePixelRatio = 3;
t.after(() => {
if (originalDocument === undefined) delete globalThis.document;
else globalThis.document = originalDocument;
if (originalRatio === undefined) delete globalThis.devicePixelRatio;
else globalThis.devicePixelRatio = originalRatio;
});
const anchor = {
lat: 49,
lon: 36,
place: 'Ukraine',
precision: 'country',
mappable: true,
};
const { layer, items } = fixture(t, {
height: 1_000_000,
quality: { get: () => ({ pixelRatio: 2 }) },
source: {
getFeed: async () => ({
reports: [
report('own-1', { relevance: 'minor', pins: [anchor] }),
report('own-2', { relevance: 'minor', pins: [anchor] }),
],
nextBefore: null,
}),
},
});
layer.enable();
await layer.update();
layer.setParams({ filters: { section: 'local' } });
await flush();
const badge = items('icons').find(
(item) => String(item.id) === 'news:country:Ukraine',
);
assert.ok(badge, 'the badge is an icon');
// 34 CSS px at 2 drawing-buffer pixels each: a 68 px disc on an 84 px
// canvas (64/52 of it). At the device's 3 it would be 126.
assert.equal(badge.image, 'data:image/png;test,84');
assert.deepEqual(badge.size, [42, 42]);
});
test('Local reports are listed an hour at most while they cannot be read again', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let at = NOW;
let failing = false;
const { layer } = fixture(t, {
height: 1_000_000,
now: () => at,
source: {
getFeed: async (query) => {
if (query.at && failing) throw new Error('News feed unavailable');
return {
reports: [report('inside', { relevance: 'minor' })],
nextBefore: null,
};
},
getAreaOutline: async () => ukraine,
},
});
const listed = () =>
layer.getRowControls().feed.inView.items.map((item) => item.id);
layer.enable();
await layer.update();
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.deepEqual(listed(), ['inside']);
// World News API's terms: its news is kept an hour at most, here too.
failing = true;
at += 59 * 60_000;
await layer.update();
await flush();
assert.deepEqual(listed(), ['inside']);
at += 2 * 60_000;
await layer.update();
await flush();
assert.deepEqual(listed(), []);
});
test('a failed read keeps the layer on with an error; disable clears the overlay', async (t) => {
const { layer, entries } = fixture(t, {
source: { getFeed: async () => Promise.reject(new Error('boom')) },
});
layer.enable();
assert.equal(await layer.update(), true);
assert.equal(layer.getStats().error, 'boom');
assert.equal(layer.getStats().sourceUnavailable, undefined);
layer.disable();
assert.deepEqual(entries.at(-1), []);
assert.deepEqual(layer.getRowControls().feed.items, []);
});
test('narrowing the window and widening it again loses no report already read', async (t) => {
const { layer } = fixture(t, {
source: {
// Two pages: the head page, and an older one behind its cursor.
getFeed: async ({ before } = {}) =>
before
? {
reports: [
report('earlier', { publishedAt: '2026-10-28T05:00:00.000Z' }),
],
nextBefore: null,
}
: {
reports: [
report('recent', { publishedAt: '2026-10-28T09:30:00.000Z' }),
],
nextBefore: '2026-10-28T09:30:00.000Z',
},
},
});
const shown = () => layer.getRowControls().feed.items.map((item) => item.id);
layer.enable();
await layer.update();
for (let i = 0; i < 3; i++) await settle();
assert.deepEqual(shown(), ['recent', 'earlier']);
layer.setParams({ filters: { hours: 1 } });
for (let i = 0; i < 3; i++) await settle();
assert.deepEqual(shown(), ['recent']);
layer.setParams({ filters: { hours: 24 } });
for (let i = 0; i < 3; i++) await settle();
assert.deepEqual(shown(), ['recent', 'earlier']);
});
test("a slower Local read for the area just left never replaces the current area's reports", async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let centre = { lat: 49, lon: 36 };
const pending = [];
const russia = {
area: { key: 'RU', name: 'Russia', kind: 'country', country: 'RU' },
polygons: [
{
outer: [
[38, 48],
[40, 48],
[40, 50.5],
[38, 50.5],
],
holes: [],
},
],
borders: [],
disputed: [],
};
const { layer, camera } = fixture(t, {
height: 1_000_000,
centre: () => centre,
source: {
getAreaOutline: async (point) => (point.lon < 37.5 ? ukraine : russia),
getFeed: (query) => {
if (!(query.relevance === '' && query.limit === 500))
return Promise.resolve({ reports: [], nextBefore: null });
if (query.at.lon < 37.5)
return Promise.resolve({
reports: [report('kharkiv', { severity: 1 })],
nextBefore: null,
});
// Russia's read is slow.
return new Promise((resolve) => pending.push(resolve));
},
},
});
const look = async (at) => {
centre = at;
camera.moveEnd();
t.mock.timers.tick(800);
await flush();
};
const shown = () =>
layer.getRowControls().feed.inView.items.map((item) => item.id);
layer.enable();
await layer.update();
await flush();
layer.setParams({ filters: { section: 'local' } });
await flush();
assert.deepEqual(shown(), ['kharkiv']);
await look({ lat: 49, lon: 39 });
assert.equal(pending.length, 1);
await look({ lat: 49, lon: 36 });
pending[0]({
reports: [
report('belgorod', {
severity: 1,
pins: [{ lat: 49, lon: 39, place: 'Rossosh', mappable: true }],
}),
],
nextBefore: null,
});
await flush();
const view = layer.getRowControls().feed;
assert.equal(view.inView.area, 'Ukraine');
assert.equal(view.inView.loading, false);
assert.deepEqual(shown(), ['kharkiv']);
});
test('a click on a marker selects its report, on a beacon chooses its hotspot, on the map clears', async (t) => {
const { layer, items, click, clickHandlers, flights } = fixture(t, {
height: 500_000,
});
layer.enable();
await layer.update();
await flush();
const marker = [...items('points'), ...items('icons')].find((item) =>
String(item.id).startsWith('news:report:major~'),
);
assert.ok(marker, 'the report has a marker');
// Drawn over terrain, clamped to the ground, at an ECEF position.
assert.equal(marker.height, 'clampGround');
assert.equal(marker.disableDepthTest, Number.POSITIVE_INFINITY);
assert.ok(Number.isFinite(marker.pos.x));
click({ set: 'news:1:points', id: marker.id, surface: false });
assert.equal(layer.getRowControls().feed.selected.id, 'major');
click(null);
assert.equal(layer.getRowControls().feed.selected, null);
click({ set: 'news:1:boxes', id: 'news:hotspot:ua-ru-war', surface: false });
assert.equal(layer.getRowControls().feed.filters.hotspot, 'ua-ru-war');
// Choosing the hotspot flies over its box.
assert.deepEqual(flights.at(-1).destination, {
rect: { west: 22, south: 44, east: 42, north: 56 },
});
layer.disable();
assert.equal(clickHandlers.size, 0);
});
test('a covered news card and pin yield; the top news card acts over a trail or a vessel', async (t) => {
let hits = [];
const { layer, items, entries, click, flights } = fixture(t, {
height: 500_000,
hitTestOverlay: (_x, _y, { sourceId } = {}) =>
hits.find((hit) => !sourceId || hit.sourceId === sourceId) || null,
});
layer.enable();
await layer.update();
await flush();
const marker = [...items('points'), ...items('icons')].find((item) =>
String(item.id).startsWith('news:report:major~'),
);
click({ set: 'news:1:points', id: marker.id, surface: false });
const card = entries.flat().find((entry) => entry.activate);
assert.ok(card, 'an actionable news card was published');
let activations = 0;
const activate = card.activate;
card.activate = () => {
activations++;
return activate();
};
hits = [
{ sourceId: 'earthquakes', entryId: 'quake:cover' },
{ sourceId: 'news', entry: card },
];
const before = layer.getRowControls().feed;
const flightCount = flights.length;
click(null);
assert.equal(activations, 0, 'a covered news card does not activate');
assert.equal(layer.getRowControls().feed.selected.id, 'major');
assert.deepEqual(layer.getRowControls().feed.filters, before.filters);
assert.equal(flights.length, flightCount);
// A news pin under another layer's card is that card's click too.
layer.setParams({ clear: true });
click({ set: 'news:1:points', id: marker.id, surface: false });
assert.equal(layer.getRowControls().feed.selected, null, 'covered pin');
hits = [];
click({ set: 'news:1:points', id: marker.id, surface: false });
assert.equal(layer.getRowControls().feed.selected.id, 'major');
hits = [{ sourceId: 'news', entry: card }];
click(null);
assert.equal(activations, 1, 'the unobscured news card acts once');
// A flight trail is registered so every layer reads a click on it as a
// no-op (src/data/trailRenderer.js). Under the top news card it must not
// make the card dead.
assert.equal(findPickOwner('gev-trail:fl-a1b2c3:head'), 'trails');
click({
set: 'trail:1:lines',
id: 'gev-trail:fl-a1b2c3:head',
surface: false,
});
assert.equal(activations, 2, 'the news card acts over a flight trail');
// Over a vessel (a layer that acts on its pick) the card on top acts too;
// the vessel layer stands aside under it, so one click does one thing.
registerPickOwner('test-vessels', (id) => id === '353136000');
try {
click({ set: 'vessels:1', id: '353136000', surface: false });
assert.equal(activations, 3, 'the news card acts over a vessel');
} finally {
unregisterPickOwner('test-vessels');
}
});
test('zoomed out, a hotspot is one beacon; off, nothing draws; destroyed, the sets go', async (t) => {
const { layer, items } = fixture(t);
assert.deepEqual(items('points'), []);
layer.enable();
await layer.update();
const beacon = items('points').find(
(item) => item.id === 'news:hotspot:ua-ru-war',
);
assert.ok(beacon);
assert.equal(beacon.outlineWidth, 2);
assert.equal(beacon.color.length, 4);
layer.disable();
assert.deepEqual(items('points'), []);
layer.destroy();
assert.deepEqual(items('points'), []);
});