Files
gods-eye-view/src/layers/news/layer.test.mjs
T
Mazeyar Moeini FeizabadiandClaude Fable 5.2 16b1bc7b74 feat(news): larger markers, and a country's own news as one badge with a count
A report placed no closer than a country was a marker at the country's
centre, so a country's news piled there. They are now one disc with the
number of reports, named, and a click opens the Local list over the
country. Markers are 24 px at least: the category icon was unreadable at 16.

Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-10 22:28:08 +01:00

1040 lines
32 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 * as Cesium from 'cesium';
import { KEY_SETUP_KEYS } from '../../keySetupCore.mjs';
import { NEWS_KEY_PROVIDERS, createNewsLayer } from './index.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,
} = {},
) {
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 = [];
const camera = {
positionCartographic: { height },
positionWC: Cesium.Cartesian3.fromDegrees(36, 49, height),
moveEnd: new Cesium.Event(),
flyTo: (options) => flights.push(options),
};
const viewer = {
camera,
scene: { requestRender() {}, preRender: new Cesium.Event() },
added: [],
dataSources: {
add(source) {
viewer.added.push(source);
},
remove() {},
},
};
const layer = createNewsLayer({
source,
overlayHost,
now,
matchMedia: () => ({ matches: reduced }),
getViewCentre: () => centre(),
registerCredit: (_viewer, credit) => {
credits.push(credit.key);
return true;
},
});
// 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();
if (originalWindow === undefined) delete globalThis.window;
else globalThis.window = originalWindow;
});
return { layer, viewer, camera, calls, entries, flights };
}
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].duration, 0);
const at = Cesium.Cartographic.fromCartesian(flights[0].destination);
assert.ok(Math.abs(at.height - 150_000) < 1);
assert.ok(Math.abs(Cesium.Math.toDegrees(at.latitude) - 50) < 1e-6);
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('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('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, viewer } = 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 = () =>
// The layer adds its outlines' source first, then its markers'.
viewer.added[1].entities.values
.map((entity) => String(entity.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.raiseEvent();
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.positionCartographic.height = 5_000_000;
camera.moveEnd.raiseEvent();
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.positionCartographic.height = 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, viewer } = 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 = () =>
viewer.added[0].entities.values.filter((e) =>
String(e.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((e) => e.show && e.polyline.width.getValue() === 1.5),
);
// A pan inside the area reads it again only once the centre leaves it.
centre = { lat: 50, lon: 36.5 };
camera.moveEnd.raiseEvent();
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.raiseEvent();
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.raiseEvent();
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.raiseEvent();
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.raiseEvent();
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, viewer } = 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 = () =>
viewer.added[1].entities.values.map((entity) => String(entity.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('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.raiseEvent();
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']);
});