mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
The globe viewer's own double-click tracked a picked entity with a position or zoomed to one without. Layers moving onto the draw port had it re-created one by one (data/stockFollow.js); following is a click in GEV, so the viewer's handler is removed where the viewer is made and every re-creation goes: earthquakes, cyclones, air quality, news, perimeters, drone airspace, ghost maps, places, radio, cables, CCTV, ALPR, launches, bikeshare, Local ADS-B, installations, directions, trails, data packs, annotations, the library's view and local GeoJSON. The Cockpit's own double-click and the draw tool's finishing double-click stay.
325 lines
11 KiB
JavaScript
325 lines
11 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { createAirQualityLayer } from './index.js';
|
|
import { layerFeedState } from '../../data/feedState.js';
|
|
import { STALE_AFTER_MS } from './model.js';
|
|
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
|
|
|
|
function harness(source, renderer = {}) {
|
|
const events = [];
|
|
const viewer = {};
|
|
const { draw } = bindFakeDraw(viewer, renderer);
|
|
const layer = createAirQualityLayer({
|
|
source,
|
|
overlayHost: {
|
|
setEntries(...args) {
|
|
events.push(args);
|
|
},
|
|
setVisible() {},
|
|
clearSource() {},
|
|
},
|
|
});
|
|
layer.init(viewer);
|
|
layer.enable(viewer);
|
|
const markers = () => draw.find('air-quality:');
|
|
return { layer, viewer, draw, markers, events };
|
|
}
|
|
|
|
const reading = (id, value, overrides = {}) => ({
|
|
id: `eccc:${id}`,
|
|
provider: 'eccc',
|
|
scale: 'AQHI',
|
|
value,
|
|
band: 'low',
|
|
stationId: id,
|
|
name: id,
|
|
zone: 'ont',
|
|
lat: 43.65,
|
|
lon: -79.38,
|
|
observedMs: 1_700_000_000_000,
|
|
color: '#4cc9f0',
|
|
label: String(value),
|
|
risk: 'Low health risk',
|
|
note: null,
|
|
...overrides,
|
|
});
|
|
|
|
const staticSource = (rows) => ({ getSnapshot: async () => rows });
|
|
|
|
test('a layer requires both a snapshot source and an overlay host', () => {
|
|
assert.throws(() => createAirQualityLayer(), /snapshot source/);
|
|
assert.throws(
|
|
() => createAirQualityLayer({ source: staticSource([]) }),
|
|
/overlay host/,
|
|
);
|
|
});
|
|
|
|
test('initialization is single-use and owns exactly one draw set', () => {
|
|
const { layer, viewer, draw, markers } = harness(staticSource([]));
|
|
const owned = markers();
|
|
assert.equal(owned.kind, 'shapes');
|
|
assert.equal(
|
|
[...draw.sets.values()].filter((set) => !set.disposed).length,
|
|
1,
|
|
);
|
|
assert.throws(() => layer.init(viewer), /already initialized/);
|
|
layer.destroy(viewer);
|
|
assert.equal(owned.disposed, true);
|
|
});
|
|
|
|
test('stations are ground discs in their band colour, shown only while enabled', async () => {
|
|
const { layer, markers } = harness(
|
|
staticSource([reading('A', 2), reading('B', 7, { color: '#c1121f' })]),
|
|
);
|
|
assert.equal(await layer.update(), true);
|
|
const set = markers();
|
|
assert.equal(set.show, true);
|
|
assert.deepEqual(
|
|
[...set.items.keys()],
|
|
['air-quality:eccc:A', 'air-quality:eccc:B'],
|
|
);
|
|
const disc = set.items.get('air-quality:eccc:B');
|
|
assert.deepEqual(disc.geometry, {
|
|
kind: 'ellipse',
|
|
center: { lon: -79.38, lat: 43.65 },
|
|
semiMajor: 6_000,
|
|
semiMinor: 6_000,
|
|
});
|
|
assert.equal(disc.height, 'clampGround');
|
|
assert.equal(disc.clampTo, 'both');
|
|
assert.deepEqual(disc.fill, [0xc1 / 255, 0x12 / 255, 0x1f / 255, 0.35]);
|
|
assert.equal(disc.outline, undefined);
|
|
assert.equal(disc.meta.name, 'B');
|
|
assert.equal(disc.meta.value, 7);
|
|
layer.disable();
|
|
assert.equal(set.show, false);
|
|
layer.enable();
|
|
assert.equal(set.show, true);
|
|
assert.equal(await layer.update(), true);
|
|
assert.equal(set.items.size, 2, 'a refresh replaces, not appends');
|
|
});
|
|
|
|
test('the readout lists only readings inside the camera port view rectangle', async () => {
|
|
const { layer } = harness(
|
|
staticSource([
|
|
reading('Toronto', 2),
|
|
reading('Vancouver', 4, { lat: 49.28, lon: -123.12 }),
|
|
]),
|
|
{
|
|
camera: {
|
|
viewRectangle: () => ({ west: -90, south: 40, east: -70, north: 50 }),
|
|
},
|
|
},
|
|
);
|
|
await layer.update();
|
|
assert.deepEqual(
|
|
layer.getRowControls().list.items.map((item) => item.text),
|
|
['Toronto · Low health risk'],
|
|
);
|
|
});
|
|
|
|
test('a refresh renders readings and publishes an overlay cohort', async () => {
|
|
const { layer, events } = harness(
|
|
staticSource([reading('A', 2), reading('B', 7)]),
|
|
);
|
|
assert.equal(await layer.update(), true);
|
|
assert.equal(layer.getStats().count, 2);
|
|
assert.equal(layer.getStats().error, null);
|
|
assert.equal(events.at(-1)[0], 'air-quality');
|
|
});
|
|
|
|
// ── the abort + enabled guard ──────────────────────────────────────────────
|
|
|
|
test('a response landing after disable cannot redraw the scene', async () => {
|
|
// The failure this prevents: disable() clears the overlay, then an in-flight
|
|
// response resolves and repopulates it behind the user's back.
|
|
let release;
|
|
const gate = new Promise((resolve) => {
|
|
release = resolve;
|
|
});
|
|
const { layer, events } = harness({
|
|
getSnapshot: async ({ signal } = {}) => {
|
|
await gate;
|
|
signal?.throwIfAborted();
|
|
return [reading('A', 5)];
|
|
},
|
|
});
|
|
const pending = layer.update();
|
|
layer.disable();
|
|
const publishedBefore = events.length;
|
|
release();
|
|
assert.equal(await pending, false, 'a late response must not be applied');
|
|
assert.equal(
|
|
events.length,
|
|
publishedBefore,
|
|
'no overlay write after disable',
|
|
);
|
|
assert.equal(layer.getStats().count, 0);
|
|
});
|
|
|
|
test('disable aborts the request in flight', async () => {
|
|
let seenSignal = null;
|
|
const { layer } = harness({
|
|
getSnapshot: async ({ signal } = {}) => {
|
|
seenSignal = signal;
|
|
await new Promise((resolve) => setTimeout(resolve, 40));
|
|
signal?.throwIfAborted();
|
|
return [];
|
|
},
|
|
});
|
|
const pending = layer.update();
|
|
layer.disable();
|
|
await pending;
|
|
assert.ok(seenSignal, 'a signal was passed through to the source');
|
|
assert.equal(seenSignal.aborted, true);
|
|
});
|
|
|
|
test('a superseded refresh does not clobber the newer one', async () => {
|
|
let call = 0;
|
|
const { layer } = harness({
|
|
getSnapshot: async ({ signal } = {}) => {
|
|
call += 1;
|
|
const mine = call;
|
|
await new Promise((resolve) => setTimeout(resolve, mine === 1 ? 40 : 1));
|
|
signal?.throwIfAborted();
|
|
return [reading(`call-${mine}`, mine)];
|
|
},
|
|
});
|
|
const first = layer.update();
|
|
const second = layer.update();
|
|
const [firstResult, secondResult] = await Promise.all([first, second]);
|
|
assert.equal(firstResult, false, 'the superseded call reports no update');
|
|
assert.equal(secondResult, true);
|
|
assert.equal(layer.getAnalystRecords()[0].name, 'call-2');
|
|
});
|
|
|
|
test('update is a no-op while the layer is disabled', async () => {
|
|
const { layer } = harness(staticSource([reading('A', 2)]));
|
|
layer.disable();
|
|
assert.equal(await layer.update(), false);
|
|
assert.equal(layer.getStats().count, 0);
|
|
});
|
|
|
|
// ── readout descriptor ─────────────────────────────────────────────────────
|
|
|
|
test('the readout descriptor carries the band legend and coverage', async () => {
|
|
const { layer } = harness(staticSource([reading('A', 2), reading('B', 9)]));
|
|
await layer.update();
|
|
const controls = layer.getRowControls();
|
|
assert.equal(controls.readout, true);
|
|
assert.match(controls.summary.coverage, /Canada only/);
|
|
// The Weather panel's legend shape: one {color, label} per band.
|
|
assert.equal(controls.legendCategorical, true);
|
|
assert.deepEqual(
|
|
controls.legend.map((entry) => entry.label),
|
|
['Low', 'Moderate', 'High', 'Very High'],
|
|
);
|
|
assert.ok(
|
|
controls.legend.every((entry) => /^#[0-9a-f]{6}$/i.test(entry.color)),
|
|
);
|
|
// Worst first, and every item keyed.
|
|
assert.deepEqual(
|
|
controls.list.items.map((i) => i.text),
|
|
['B · Low health risk', 'A · Low health risk'],
|
|
);
|
|
assert.ok(controls.list.items.every((i) => i.id));
|
|
assert.match(controls.summary.status, /2 stations reporting/);
|
|
});
|
|
|
|
test('the readout reports an error rather than a silent empty card', async () => {
|
|
const { layer } = harness({
|
|
getSnapshot: async () => {
|
|
throw new Error('ECCC HTTP 503');
|
|
},
|
|
});
|
|
await layer.update();
|
|
assert.match(layer.getRowControls().summary.status, /503/);
|
|
});
|
|
|
|
test('row-control listeners are notified on refresh and teardown-safe', async () => {
|
|
const { layer, viewer } = harness(staticSource([reading('A', 2)]));
|
|
let calls = 0;
|
|
layer.setRowControlsListener(() => {
|
|
calls += 1;
|
|
});
|
|
await layer.update();
|
|
assert.ok(calls >= 1, 'a refresh notifies the card');
|
|
layer.destroy(viewer);
|
|
const after = calls;
|
|
layer.setRowControlsListener(() => {
|
|
calls += 1;
|
|
});
|
|
assert.equal(calls, after);
|
|
});
|
|
|
|
// ── feed-state honesty ─────────────────────────────────────────────────────
|
|
|
|
test('freshness is judged on observation time, not on when we last fetched', async () => {
|
|
// lastUpdate stays current every time the network answers, even when it
|
|
// answers with nothing new. Judging freshness on it would let the HUD and
|
|
// voice describe hours-old air quality as live.
|
|
const aged = Date.now() - STALE_AFTER_MS - 60_000;
|
|
const { layer } = harness(
|
|
staticSource([reading('A', 2, { observedMs: aged })]),
|
|
);
|
|
await layer.update();
|
|
const stats = layer.getStats();
|
|
assert.ok(
|
|
stats.lastUpdate >= Date.now() - 5_000,
|
|
'we did just receive a response',
|
|
);
|
|
assert.equal(stats.observedAt, aged, 'but the observation itself is old');
|
|
assert.equal(stats.stale, true);
|
|
assert.equal(
|
|
layerFeedState(stats),
|
|
'stale',
|
|
'provenance must not read this as nominal',
|
|
);
|
|
});
|
|
|
|
test('a current reading reports nominal', async () => {
|
|
const { layer } = harness(
|
|
staticSource([reading('A', 2, { observedMs: Date.now() - 10 * 60_000 })]),
|
|
);
|
|
await layer.update();
|
|
const stats = layer.getStats();
|
|
assert.equal(stats.stale, false);
|
|
assert.equal(layerFeedState(stats), 'nominal');
|
|
});
|
|
|
|
test('a refresh that kept no current observation reports stale, not nominal', async () => {
|
|
// Every observation older than OBSERVATION_MAX_AGE_MS is dropped, so a feed
|
|
// that only has hours-old rows yields an empty snapshot. That is the
|
|
// stalest a feed can be; it must not read as a healthy empty layer.
|
|
const { layer } = harness(staticSource([]));
|
|
assert.equal(layer.getStats().stale, false, 'no refresh yet, no verdict');
|
|
await layer.update();
|
|
const stats = layer.getStats();
|
|
assert.equal(stats.count, 0);
|
|
assert.equal(stats.observedAt, null);
|
|
assert.equal(stats.stale, true);
|
|
assert.equal(layerFeedState(stats), 'stale');
|
|
assert.equal(layer.getRowControls().summary.status, 'No current readings');
|
|
});
|
|
|
|
test('a failed refresh over good readings reports degraded, not nominal', async () => {
|
|
let fail = false;
|
|
const { layer } = harness({
|
|
getSnapshot: async () => {
|
|
if (fail) throw new Error('ECCC HTTP 503');
|
|
return [reading('A', 2, { observedMs: Date.now() - 10 * 60_000 })];
|
|
},
|
|
});
|
|
await layer.update();
|
|
assert.equal(layerFeedState(layer.getStats()), 'nominal');
|
|
fail = true;
|
|
await layer.update();
|
|
const stats = layer.getStats();
|
|
assert.ok(stats.count > 0, 'the previous readings are still displayed');
|
|
assert.equal(
|
|
layerFeedState(stats),
|
|
'degraded',
|
|
'showing old data after a failure is degraded',
|
|
);
|
|
});
|