mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
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:
1 parent
fa736a7cd5
commit
edb5837ae5
27 files changed
+1343
-154
No files matched your search
@@ -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')) },
|
||||
|
||||
Reference in new issue
Block a user