Files
gods-eye-view/src/data/analystEngine.test.mjs
T
Bilawal SidhuandBilawal Sidhu ce671ce500 fix(data): load bundled region packs in the browser; bound region lookups (#743)
The Natural Earth and neighborhood packs were loaded with a JSON-attributed
import(). The Vite dev server answers that request with a JavaScript module,
which the browser rejects, so every analyst region scope failed and fell
through to a geocode lookup that could take 12-28 s.

- src/data/bundledJson.js fetches the pack from a new URL(..., import.meta.url)
  asset in the browser; under Node the caller's attributed import runs.
- resolveRegionRingForQuery caps the geocode + admin-boundary rung at 3 s and
  returns { error: 'region-timeout' }; the lookup keeps running and fills the
  cache. The analyst query reports it as code 'region-timeout'. The Nepal
  locator opts out of the budget.
- Unit tests for the loader, the timeout and the analyst error; the behavior
  harness checks the Gulf of Mexico scope and retries Texas on region-timeout.

Co-authored-by: Bilawal Sidhu <[email protected]>
2026-09-24 01:52:41 -05:00

296 lines
13 KiB
JavaScript

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createAnalystEngine, applyScope, haversineKm } from './analystEngine.js';
// Stub world: a square "Texland" region, flights + ships + fires around it.
const TEXLAND = { name: 'Texland', ring: [[-100, 28], [-94, 28], [-94, 33], [-100, 33]] };
const FLIGHTS = [
{ id: 'SWA1', lat: 30.2, lon: -97.7, altitudeM: 11000, speedMps: 240, military: false, onGround: false, routeOrigin: 'AUS', routeDestination: 'LAX' },
{ id: 'RCH01', lat: 31.0, lon: -97.0, altitudeM: 13500, speedMps: 250, military: true, onGround: false, routeOrigin: null, routeDestination: null },
{ id: 'N123', lat: 45.0, lon: -122.0, altitudeM: 2000, speedMps: 80, military: false, onGround: false, routeOrigin: null, routeDestination: null },
{ id: 'GND1', lat: 30.19, lon: -97.66, altitudeM: 150, speedMps: 5, military: false, onGround: true, routeOrigin: null, routeDestination: null },
];
const SHIPS = [
{ id: 'EVERGIVEN', lat: 29.5, lon: -94.9, speedKts: 12, shipType: 'Cargo', destination: 'OAKLAND', navStatus: 'under way' },
{ id: 'SLOWBOAT', lat: 29.6, lon: -95.0, speedKts: 0.2, shipType: 'Tanker', destination: 'HOUSTON', navStatus: 'anchored' },
];
const FIRES = [
{ id: 'FIRE-1', lat: 30.5, lon: -98.2, frp: 1500 },
{ id: 'FIRE-2', lat: 30.6, lon: -98.1, frp: 90 },
{ id: 'FIRE-3', lat: 51.9, lon: -121.9, frp: 2400 },
];
function makeEngine() {
return createAnalystEngine({
getRecords: (key) => ({ flights: FLIGHTS, 'ais-live-vessels': SHIPS, 'local-firms': FIRES }[key] || []),
resolveRegionRing: async (name) => (/texland/i.test(name) ? TEXLAND : null),
getViewContext: () => ({ lat: 30.27, lon: -97.74, viewRadiusKm: 150 }),
});
}
/** Same world, but Contacts is up with a subject far from the parked camera. */
function makeContactsEngine(subject) {
return createAnalystEngine({
getRecords: (key) => ({ flights: FLIGHTS, 'ais-live-vessels': SHIPS, 'local-firms': FIRES }[key] || []),
resolveRegionRing: async (name) => (/texland/i.test(name) ? TEXLAND : null),
// Parked far away, as a high-altitude camera often is.
getViewContext: () => ({ lat: 45.0, lon: -122.0, viewRadiusKm: 150 }),
getContextSubject: () => subject,
});
}
test('analyst: a radius query centers on the active contact, not the parked camera', async () => {
// Field case: the Contacts panel counted a contact-centred window while the
// camera sat off-coast at 441 km, so "how many within 250 km" answered from
// the camera and disagreed with what the operator could see.
const subject = { lat: 30.2, lon: -97.7, label: 'SWA1' };
const r = await makeContactsEngine(subject).query({
layers: ['flights'],
scope: { kind: 'radius', km: 250 },
limit: 50,
});
assert.equal(r.ok, true);
// Austin-area flights, not the Oregon one the camera is parked over.
assert.equal(r.count, 3);
assert.equal(r.centeredOn, 'SWA1', 'the answer names the centre it measured from');
assert.ok(r.coverage.scope.includes('@SWA1'));
});
test('analyst: an explicit center still wins over the active contact', async () => {
const subject = { lat: 30.2, lon: -97.7, label: 'SWA1' };
const r = await makeContactsEngine(subject).query({
layers: ['flights'],
scope: { kind: 'radius', km: 250, center: { lat: 45.0, lon: -122.0 } },
limit: 50,
});
assert.equal(r.count, 1, 'only the Oregon flight is within 250 km of the given center');
assert.equal(r.centeredOn, undefined, 'an explicit center is not relabelled');
});
test('analyst: with Contacts off, radius still centers on the view', async () => {
const r = await makeContactsEngine(null).query({
layers: ['flights'],
scope: { kind: 'radius', km: 250 },
limit: 50,
});
assert.equal(r.count, 1, 'view-centred behaviour is unchanged outside Contacts');
assert.equal(r.centeredOn, undefined);
assert.equal(r.coverage.scope, 'radius:250km');
});
test('analyst: a subject without usable coordinates cannot lend its name to a camera-centred count', async () => {
// The label is the only thing telling the operator WHICH centre produced the
// number. A subject present but position-less fell back to the camera and
// kept the contact's name on the answer, so a camera-centred count read as
// contact-centred with nothing in the payload to catch it.
const r = await makeContactsEngine({ lat: null, lon: null, label: 'SWA1' }).query({
layers: ['flights'],
scope: { kind: 'radius', km: 250 },
limit: 50,
});
assert.equal(r.count, 1, 'the count is the camera-centred one it actually measured');
assert.equal(r.centeredOn, undefined, 'and it must not claim a centre it did not use');
assert.equal(r.coverage.scope, 'radius:250km');
assert.equal(r.scopeLabel, 'within 250 km');
});
test('analyst: every scope names itself in words', async () => {
// Rule 3 of the counting contract: a bare number is what made two honest
// answers look like a contradiction, so each scope carries its own phrasing.
const subject = { lat: 30.2, lon: -97.7, label: 'DYNO11' };
const centred = await makeContactsEngine(subject).query({
layers: ['flights'], scope: { kind: 'radius', km: 250 }, limit: 1,
});
assert.equal(centred.scopeLabel, 'within 250 km of DYNO11');
const plainRadius = await makeContactsEngine(null).query({
layers: ['flights'], scope: { kind: 'radius', km: 250 }, limit: 1,
});
assert.equal(plainRadius.scopeLabel, 'within 250 km');
const inView = await makeEngine().query({
layers: ['flights'], scope: { kind: 'view' }, limit: 1,
});
assert.equal(inView.scopeLabel, 'in view');
const region = await makeEngine().query({
layers: ['flights'], scope: { kind: 'region', name: 'Texland' }, limit: 1,
});
assert.equal(region.scopeLabel, 'over Texland');
const anywhere = await makeEngine().query({
layers: ['flights'], scope: { kind: 'anywhere' }, limit: 1,
});
assert.equal(anywhere.scopeLabel, 'anywhere in the loaded data');
});
test('analyst: count flights over a region', async () => {
const r = await makeEngine().query({ layers: ['flights'], scope: { kind: 'region', name: 'Texland' }, limit: 50 });
assert.equal(r.ok, true);
assert.equal(r.count, 3, 'Oregon flight excluded');
assert.ok(r.coverage.scope.includes('Texland'));
});
test('analyst: attribute filter — above 40,000 ft (~12,192 m)', async () => {
const r = await makeEngine().query({
layers: ['flights'], scope: { kind: 'anywhere' },
filters: [{ field: 'altitudeM', op: 'gt', value: 12192 }],
});
assert.deepEqual(r.items.map((i) => i.id), ['RCH01']);
});
test('analyst: military flag + region compose', async () => {
const r = await makeEngine().query({
layers: ['flights'], scope: { kind: 'region', name: 'Texland' },
filters: [{ field: 'military', op: 'eq', value: true }],
});
assert.equal(r.count, 1);
assert.equal(r.items[0].id, 'RCH01');
});
test('analyst: ships headed to Oakland (destination contains)', async () => {
const r = await makeEngine().query({
layers: ['ais-live-vessels'], scope: { kind: 'anywhere' },
filters: [{ field: 'destination', op: 'contains', value: 'oakland' }],
});
assert.deepEqual(r.items.map((i) => i.id), ['EVERGIVEN']);
});
test('analyst: superlative — biggest fire in view radius', async () => {
const r = await makeEngine().query({
layers: ['local-firms'], scope: { kind: 'view' }, sortBy: 'frp', limit: 1,
});
assert.equal(r.items[0].id, 'FIRE-1', 'BC monster is out of view scope');
assert.equal(r.summary.frpMax, 1500);
});
test('analyst: nearest sorting attaches distanceKm ascending', async () => {
const r = await makeEngine().query({
layers: ['flights'], scope: { kind: 'view' }, sortBy: 'distance', limit: 3,
});
assert.ok(r.items[0].distanceKm <= r.items[1].distanceKm);
assert.ok(Number.isFinite(r.items[0].distanceKm));
});
test('analyst: follow-up re-filters the remembered set without re-snapshot', async () => {
const eng = makeEngine();
await eng.query({ layers: ['flights'], scope: { kind: 'region', name: 'Texland' } });
const r = await eng.query({ followUp: true, filters: [{ field: 'onGround', op: 'eq', value: true }] });
assert.equal(r.count, 1);
assert.equal(r.items[0].id, 'GND1');
assert.equal(r.coverage.followUp, true);
});
test('analyst: unresolved region is an honest failure, not empty success', async () => {
const r = await makeEngine().query({ layers: ['flights'], scope: { kind: 'region', name: 'Atlantis' } });
assert.equal(r.ok, false);
assert.match(r.error, /Atlantis/);
});
test('analyst: a region lookup timeout is reported as region-timeout', async () => {
const eng = createAnalystEngine({
getRecords: () => FLIGHTS,
resolveRegionRing: async (name) => ({ name, ring: null, error: 'region-timeout' }),
getViewContext: () => ({ lat: 30.27, lon: -97.74, viewRadiusKm: 150 }),
});
const r = await eng.query({ layers: ['flights'], scope: { kind: 'region', name: 'Texas' } });
assert.equal(r.ok, false);
assert.equal(r.code, 'region-timeout');
assert.match(r.error, /Texas/);
assert.equal(r.coverage.scope, 'region:Texas:timeout');
});
test('analyst: route fields queryable from cached enrichment only', async () => {
const r = await makeEngine().query({
layers: ['flights'], scope: { kind: 'anywhere' },
filters: [{ field: 'routeDestination', op: 'eq', value: 'LAX' }],
});
assert.deepEqual(r.items.map((i) => i.id), ['SWA1'], 'null route fields never match');
});
test('analyst: satellites and local infrastructure are queryable layers', async () => {
const SATS = [
{ id: 'ISS (ZARYA)', noradId: '25544', name: 'ISS (ZARYA)', lat: 30.3, lon: -97.7, altitudeM: 410000, satelliteClass: 'STATION · ISS', group: 'stations' },
{ id: 'GPS BIIR-2', noradId: '24876', name: 'GPS BIIR-2', lat: 51.0, lon: 0.0, altitudeM: 20200000, satelliteClass: 'NAV · GPS', group: 'gps-ops' },
];
const DAMS = [
{ id: 'Austin Dam', name: 'Austin Dam', lat: 30.27, lon: -97.74, operator: 'LCRA', river: 'Colorado', output: '2 MW' },
{ id: 'Far Dam', name: 'Far Dam', lat: 45.0, lon: -122.0, operator: 'USACE', river: 'Columbia', output: '1000 MW' },
];
const DCS = [
{ id: 'AUS-1', name: 'AUS-1', lat: 30.28, lon: -97.75, operator: 'Example Cloud', capacity: '27 MW' },
];
const eng = createAnalystEngine({
getRecords: (key) => ({ satellites: SATS, 'local-dams': DAMS, 'local-datacenters': DCS }[key] || []),
resolveRegionRing: async (name) => (/texland/i.test(name) ? TEXLAND : null),
getViewContext: () => ({ lat: 30.27, lon: -97.74, viewRadiusKm: 150 }),
});
const sats = await eng.query({
layers: ['satellites'], scope: { kind: 'view' }, sortBy: 'distance', limit: 2,
});
assert.equal(sats.ok, true);
assert.equal(sats.count, 1, 'GPS sat is out of the Austin view radius');
assert.equal(sats.items[0].noradId, '25544');
assert.ok(Number.isFinite(sats.items[0].distanceKm));
const nav = await eng.query({
layers: ['satellites'], scope: { kind: 'anywhere' },
filters: [{ field: 'satelliteClass', op: 'contains', value: 'NAV' }],
});
assert.deepEqual(nav.items.map((i) => i.id), ['GPS BIIR-2']);
const dams = await eng.query({
layers: ['local-dams'], scope: { kind: 'view' }, sortBy: 'distance', limit: 5,
});
assert.equal(dams.count, 1);
assert.equal(dams.items[0].id, 'Austin Dam');
assert.equal(dams.items[0].river, 'Colorado');
const dcs = await eng.query({
layers: ['local-datacenters'], scope: { kind: 'region', name: 'Texland' },
filters: [{ field: 'operator', op: 'contains', value: 'cloud' }],
});
assert.equal(dcs.count, 1);
assert.equal(dcs.items[0].id, 'AUS-1');
});
test('helpers: haversine sanity + scope radius', () => {
const km = haversineKm(30.2672, -97.7431, 29.7604, -95.3698); // Austin→Houston
assert.ok(km > 200 && km < 280, `Austin-Houston ~235km, got ${km}`);
const scoped = applyScope(FLIGHTS, { kind: 'radius' }, { center: { lat: 30.27, lon: -97.74 }, km: 50 });
assert.deepEqual(scoped.map((f) => f.id).sort(), ['GND1', 'SWA1']);
});
test('bounded loaded cohorts disclose truncation before filtering and retain it on follow-up', async () => {
const engine = createAnalystEngine({
getRecords: () => [{ id: 'sample dam', lat: 0, lon: 0, name: 'sample' }],
getRecordCoverage: () => ({ basis: 'bounded-loaded-records', recordsExamined: 1, loadedCount: 3000, sourceTruncated: true }),
getViewContext: () => ({ lat: 0, lon: 0, viewRadiusKm: 25 }),
});
const result = await engine.query({ layers: ['local-dams'], scope: { kind: 'anywhere' }, sortBy: 'distance' });
assert.equal(result.count, 1);
assert.equal(result.coverage.layersQueried[0].sourceTruncated, true);
assert.match(result.coverage.note, /omitted records may change the nearest item or count/);
const followUp = await engine.query({ followUp: true });
assert.equal(followUp.coverage.layersQueried[0].loadedCount, 3000);
});
test('follow-up provenance stays attached to old rows after a feed recovers', async () => {
let state = 'stale';
const engine = createAnalystEngine({
getRecords: () => [{ id: 'A', lat: 0, lon: 0 }],
getLayerSnapshot: () => ({ id: 'flights', enabled: true, feedState: state }),
getViewContext: () => ({ lat: 0, lon: 0, viewRadiusKm: 25 }),
});
const first = await engine.query();
state = 'nominal';
const followUp = await engine.query({ followUp: true });
assert.equal(first.coverage.feedProvenance.overall, 'stale');
assert.equal(followUp.coverage.feedProvenance.overall, 'stale');
engine.reset();
assert.equal(engine.hasMemory(), false);
assert.equal((await engine.query()).coverage.feedProvenance.overall, 'nominal');
});