Name the Local area, say what each News section needs, and credit its sources

Local reads the area at the view centre (`/outline?at=`) and asks the feed
for its reports (`at`): the area is outlined faintly on the globe and named
at the top of the section ("News from Kazakhstan"; within 500 km at sea).
A disputed area is named as itself. A read that a newer look replaced, or
one left behind by a switch to Conflicts, is dropped, and a server without
the area route is asked once.

A section read from a key the server lacks says which key it needs
(503 `no_key`), that the key was refused (`key_rejected`) or that its
daily allowance is spent (`key_quota`); the other section keeps reading.
Liveuamap and World News API join the key registry.

Cards name the service a report came through ("via GDELT Project"), and
Liveuamap and Natural Earth are credited once their data shows. Economy is
a category of its own. Disputed-area labels are smaller and show the name
only; outlines keep up to 300 parts.
This commit is contained in:
Denis Groshev committed 2026-11-06 00:45:31 +01:00
1 parent fa736a7cd5
commit edb5837ae5
27 files changed
+1343 -154

No files matched your search

+449 -1
View File
@@ -1,7 +1,8 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { createNewsLayer } from './index.js';
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 = {
@@ -43,12 +44,14 @@ function fixture(
height = 20_000_000,
reduced = false,
centre = () => ({ lat: 49, lon: 36 }),
credits = [],
} = {},
) {
const calls = { feed: [], hotspots: 0, outline: 0 };
const reports = [
report('major', {
severity: 3,
attribution: 'GDELT Project',
event: {
size: 3,
severity: 3,
@@ -110,6 +113,10 @@ function fixture(
now: () => 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;
@@ -125,6 +132,34 @@ function fixture(
}
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);
@@ -165,6 +200,9 @@ test('choosing a card selects it and flies straight down from 150 km; reduced mo
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);
@@ -273,6 +311,106 @@ test('Local reads every report once, lists those near the view and takes the map
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, {
@@ -351,6 +489,316 @@ test('a server without news is unavailable once and is not asked again', async (
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 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')) },