mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
Every Cesium read that a Navara page made was surveyed with the strict acceptance (GEV_QA_CESIUM_TRAP=record). Math on those paths now uses src/geo: screen annotations, weather and wind center readings, cyclone picks, scene data pack polygons and images (new navaraGeometry.js), the awareness subject, the orbit offset of camera verbs, voice frame_overhead, the agent world packet and Directions colours and ground picks. The celestial ring's Sun and Moon come from a bit-identical port of Cesium's Simon1994 model, JulianDate and TEME rotation (src/geo/simon1994.js, julianDate.js, transforms.js); a Cesium globe still applies its ICRF rotation once loaded. Traffic, Street Level, the Nepal event and locator and geo import build on Cesium's math or entity model on either globe; their enable (or the import) now loads the SDK first through src/app/loadCesium.js, synchronously when it is already there. A production page guards the global so a missed read is reported and starts the load. No module reads Cesium while it loads (scripts/check-cesium-load-time.mjs, run by npm test). Cesium.js is still loaded by index.html here.
451 lines
17 KiB
JavaScript
451 lines
17 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createWindLayer, formatWindValidTime, windStats } from './index.js';
|
|
import { useWindInspectionStore } from '../../ui/stores/windInspection.js';
|
|
import { applicationPinia } from '../../ui/vueRuntime.js';
|
|
import * as geo from '../../geo/index.js';
|
|
|
|
const snapshot = (model) => ({
|
|
model,
|
|
grid: { nx: 2, ny: 2 },
|
|
cycle: { runIso: '2026-09-14T12:00:00Z', validIso: '2026-09-14T18:00:00Z' },
|
|
});
|
|
function harness(feed, diagnostics = {}) {
|
|
const calls = [];
|
|
const rendering = Object.fromEntries(
|
|
['attach', 'start', 'stop', 'clear', 'destroy', 'setField'].map((name) => [
|
|
name,
|
|
(...args) => calls.push([name, ...args]),
|
|
]),
|
|
);
|
|
rendering.getDiagnostics = () => diagnostics;
|
|
const layer = createWindLayer({ feed, createRendering: () => rendering });
|
|
layer.init({ container: {} });
|
|
layer.enable();
|
|
return { layer, calls };
|
|
}
|
|
test('forecast valid time and source age stay distinct', () => {
|
|
assert.equal(formatWindValidTime('invalid'), null);
|
|
assert.equal(
|
|
formatWindValidTime('2026-01-05T06:30:00Z'),
|
|
'2026-01-05 06:30 UTC',
|
|
);
|
|
assert.equal(
|
|
windStats(snapshot('gfs')).lastUpdate,
|
|
Date.parse('2026-09-14T12:00:00Z'),
|
|
);
|
|
});
|
|
test('switching models clears old data and ignores an abort-insensitive late source', async () => {
|
|
const pending = [];
|
|
const { layer, calls } = harness({
|
|
getSnapshot: (args) =>
|
|
new Promise((resolve) => pending.push({ ...args, resolve })),
|
|
});
|
|
const first = layer.update();
|
|
layer.setParams({ model: 'ifs' });
|
|
await Promise.resolve();
|
|
assert.equal(pending.length, 2);
|
|
assert.equal(pending[0].signal.aborted, true);
|
|
assert.equal(layer.getStats().count, 0);
|
|
assert.equal(layer.getStats().model, 'IFS');
|
|
pending[0].resolve(snapshot('gfs'));
|
|
await first;
|
|
assert.equal(calls.filter(([name]) => name === 'setField').length, 0);
|
|
pending[1].resolve(snapshot('ifs'));
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
assert.equal(calls.find(([name]) => name === 'setField')[1].model, 'ifs');
|
|
assert.match(
|
|
layer.getRowControls().info,
|
|
/IFS forecast[\s\S]*Valid: 2026-09-14 18:00 UTC[\s\S]*Issued: 2026-09-14 12:00 UTC/,
|
|
);
|
|
layer.destroy();
|
|
});
|
|
test('external and owned cancellation both cancel source work; queued switches stop on disable', async () => {
|
|
let signal;
|
|
const { layer } = harness({
|
|
getSnapshot: (args) => {
|
|
signal = args.signal;
|
|
return new Promise((resolve) =>
|
|
signal.addEventListener('abort', () => resolve(snapshot('gfs')), {
|
|
once: true,
|
|
}),
|
|
);
|
|
},
|
|
});
|
|
const external = new AbortController();
|
|
const update = layer.update(null, { signal: external.signal });
|
|
layer.disable();
|
|
assert.equal(signal.aborted, true);
|
|
assert.equal(external.signal.aborted, false);
|
|
assert.equal(await update, false);
|
|
layer.enable();
|
|
const other = layer.update(null, { signal: external.signal });
|
|
external.abort();
|
|
assert.equal(signal.aborted, true);
|
|
await other;
|
|
layer.setParams({ model: 'ifs' });
|
|
layer.disable();
|
|
await Promise.resolve();
|
|
assert.equal(layer.getStats().loading, false);
|
|
layer.destroy();
|
|
});
|
|
|
|
const complete = (model, extra = {}) => ({
|
|
...snapshot(model),
|
|
grid: { nx: 2, ny: 2, lo1: 0, la1: 90, dx: 180, dy: 180 },
|
|
u: new Float32Array(4).fill(4),
|
|
v: new Float32Array(4).fill(3),
|
|
...extra,
|
|
});
|
|
test('local appearance and units reuse the loaded field; optional scalar requests remain separate', async () => {
|
|
const requests = [];
|
|
const { layer } = harness({
|
|
getSnapshot: async (args) => {
|
|
requests.push(args);
|
|
return complete(
|
|
args.model,
|
|
args.overlay === 'pressure'
|
|
? {
|
|
scalar: {
|
|
kind: 'pressure',
|
|
units: 'hPa',
|
|
values: new Float32Array(4).fill(1013),
|
|
},
|
|
}
|
|
: {},
|
|
);
|
|
},
|
|
});
|
|
await layer.update();
|
|
layer.setParams({ overlay: 'none' });
|
|
layer.setParams({ overlay: 'speed', units: 'mph', paused: true });
|
|
await Promise.resolve();
|
|
assert.equal(requests.length, 1, 'speed/units/pause do not download weather');
|
|
assert.deepEqual(layer.getParams(), {
|
|
model: 'gfs',
|
|
overlay: 'speed',
|
|
units: 'mph',
|
|
paused: true,
|
|
});
|
|
layer.setParams({ overlay: 'pressure' });
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
assert.equal(requests.length, 2);
|
|
assert.equal(requests[1].overlay, 'pressure');
|
|
assert.equal(layer.getStats().overlay, 'pressure');
|
|
assert.ok(layer.getRowControls().info.includes('(hPa)'));
|
|
assert.equal(layer.getRowControls().legend.at(-1).label, '1050+');
|
|
layer.destroy();
|
|
});
|
|
test('local appearance changes preserve an in-flight first load', async () => {
|
|
const requests = [];
|
|
const { layer } = harness({
|
|
getSnapshot: (args) =>
|
|
new Promise((resolve) => requests.push({ ...args, resolve })),
|
|
});
|
|
const first = layer.update();
|
|
layer.setParams({ overlay: 'none' });
|
|
await Promise.resolve();
|
|
assert.equal(requests.length, 1);
|
|
assert.equal(requests[0].signal.aborted, false);
|
|
assert.equal(layer.getStats().loading, true);
|
|
requests[0].resolve(complete('gfs'));
|
|
await first;
|
|
assert.equal(layer.getStats().count, 4);
|
|
assert.equal(layer.getStats().loading, false);
|
|
layer.destroy();
|
|
});
|
|
test('re-enable and an appearance change cannot reuse a released renderer field', async () => {
|
|
const requests = [];
|
|
const { layer, calls } = harness({
|
|
getSnapshot: (args) =>
|
|
new Promise((resolve) => requests.push({ ...args, resolve })),
|
|
});
|
|
const first = layer.update();
|
|
requests[0].resolve(complete('gfs'));
|
|
await first;
|
|
layer.disable();
|
|
assert.equal(layer.getStats().count, 0);
|
|
layer.enable();
|
|
const second = layer.update();
|
|
layer.setParams({ overlay: 'none' });
|
|
await Promise.resolve();
|
|
assert.equal(requests.length, 2);
|
|
assert.equal(requests[1].signal.aborted, false);
|
|
assert.equal(layer.getStats().loading, true);
|
|
requests[1].resolve(complete('gfs'));
|
|
await second;
|
|
assert.equal(
|
|
calls.filter(([name]) => name === 'setField').length,
|
|
2,
|
|
'new field must reach the cleared renderer',
|
|
);
|
|
assert.equal(layer.getStats().count, 4);
|
|
assert.equal(layer.getStats().loading, false);
|
|
layer.destroy();
|
|
});
|
|
test('missing optional scalar retains valid wind and labels the field unavailable', async () => {
|
|
const { layer } = harness({
|
|
getSnapshot: async () =>
|
|
complete('gfs', {
|
|
overlay: 'pressure',
|
|
scalarError: 'Mean sea level pressure field unavailable',
|
|
}),
|
|
});
|
|
layer.setParams({ overlay: 'pressure' });
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
assert.equal(layer.getStats().count, 4);
|
|
assert.match(layer.getStats().error, /pressure field unavailable/);
|
|
assert.match(layer.getRowControls().info, /Selected field unavailable/);
|
|
assert.deepEqual(layer.getRowControls().legend, []);
|
|
layer.destroy();
|
|
});
|
|
|
|
test('a pending companion does not claim that it is already unavailable', async () => {
|
|
let resolve;
|
|
const { layer } = harness({
|
|
getSnapshot: (args) =>
|
|
args.overlay === 'none'
|
|
? Promise.resolve(complete('gfs'))
|
|
: new Promise((done) => {
|
|
resolve = done;
|
|
}),
|
|
});
|
|
await layer.update();
|
|
layer.setParams({ overlay: 'pressure' });
|
|
await Promise.resolve();
|
|
assert.equal(layer.getStats().loading, true);
|
|
assert.doesNotMatch(
|
|
layer.getRowControls().info,
|
|
/Selected field unavailable/,
|
|
);
|
|
resolve(
|
|
complete('gfs', {
|
|
scalarError: 'Mean sea level pressure field unavailable',
|
|
}),
|
|
);
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
assert.match(layer.getRowControls().info, /Selected field unavailable/);
|
|
layer.destroy();
|
|
});
|
|
test('an imagery failure appears in status and cannot retain a misleading field legend', async () => {
|
|
const diagnostics = { imageryError: null };
|
|
const { layer } = harness(
|
|
{ getSnapshot: async () => complete('gfs') },
|
|
diagnostics,
|
|
);
|
|
await layer.update();
|
|
diagnostics.imageryError = 'Globe field image unavailable';
|
|
assert.equal(layer.getStats().error, 'Globe field image unavailable');
|
|
assert.match(layer.getRowControls().info, /Globe field image unavailable/);
|
|
assert.deepEqual(layer.getRowControls().legend, []);
|
|
layer.destroy();
|
|
});
|
|
test('renderer readiness pushes fresh loading stats and controls to the displayed row', async () => {
|
|
let ready = false;
|
|
let statusChanged;
|
|
const rendering = {
|
|
attach() {},
|
|
start() {},
|
|
stop() {},
|
|
clear() {},
|
|
destroy() {},
|
|
setField() {},
|
|
getDiagnostics: () => ({
|
|
renderMode: 'gpu-streamlines',
|
|
gpu: { pathCount: 10, ready },
|
|
}),
|
|
};
|
|
const layer = createWindLayer({
|
|
feed: { getSnapshot: async () => snapshot('gfs') },
|
|
createRendering(options) {
|
|
statusChanged = options.onStatusChange;
|
|
return rendering;
|
|
},
|
|
});
|
|
layer.init({ container: {} });
|
|
layer.enable();
|
|
let displayed;
|
|
layer.setRowControlsListener(() => {
|
|
displayed = {
|
|
loading: layer.getStats().loading,
|
|
info: layer.getRowControls().info,
|
|
};
|
|
});
|
|
const update = layer.update();
|
|
const loadingInfo = layer.getRowControls().info;
|
|
assert.match(loadingInfo, /Valid: [^\n]+ · loading/);
|
|
await update;
|
|
assert.equal(displayed.loading, true);
|
|
assert.match(displayed.info, /Valid: [^\n]+ · preparing/);
|
|
assert.equal(displayed.info.split('\n').length, loadingInfo.split('\n').length);
|
|
ready = true;
|
|
statusChanged();
|
|
assert.equal(displayed.loading, false);
|
|
assert.doesNotMatch(displayed.info, / · preparing| · loading/);
|
|
assert.equal(displayed.info.split('\n').length, loadingInfo.split('\n').length);
|
|
layer.destroy();
|
|
});
|
|
|
|
test('weather summary describes the selected forecast and count remains numeric', async () => {
|
|
const { layer } = harness({ getSnapshot: async () => complete('gfs') });
|
|
await layer.update();
|
|
assert.equal(typeof layer.getStats().count, 'number');
|
|
assert.equal(layer.getStats().countLabel, 'Forecast');
|
|
const summary = layer.getRowControls().summary;
|
|
assert.equal(summary.label, 'Wind motion');
|
|
assert.equal(summary.units, 'km/h');
|
|
assert.match(summary.detail, /GFS forecast.*UTC/);
|
|
assert.equal((summary.detail.match(/UTC/g) || []).length, 1);
|
|
assert.equal(layer.getRowControls().chips.find(c => c.id === 'overlay-temperature').label, 'Temperature');
|
|
layer.destroy();
|
|
});
|
|
|
|
test('sample stays fixed across model, field and unit changes; dismissal and disable clear marker', async () => {
|
|
// The marker the scene chrome renders, as the wind layer presents it.
|
|
const marker = () => useWindInspectionStore(applicationPinia()).marker;
|
|
let listener;
|
|
let samples = 0;
|
|
const container = {
|
|
ownerDocument: {},
|
|
getBoundingClientRect: () => ({ left: 0, top: 0 }),
|
|
};
|
|
const viewer = {
|
|
container,
|
|
camera: { positionWC: {}, pickEllipsoid: () => { samples++; return geo.cartesian3.fromDegrees(0, 0); } },
|
|
scene: {
|
|
mode: 3,
|
|
canvas: { clientWidth: 800, clientHeight: 600, getBoundingClientRect: () => ({ left: 0, top: 0 }) },
|
|
cartesianToCanvasCoordinates: () => ({ x: 400, y: 300 }),
|
|
postRender: { addEventListener(fn) { listener = fn; return () => { listener = null; }; } },
|
|
requestRender() {},
|
|
},
|
|
};
|
|
const rendering = Object.fromEntries(['attach', 'start', 'stop', 'clear', 'destroy', 'setField'].map(name => [name, () => {}]));
|
|
const layer = createWindLayer({
|
|
feed: { getSnapshot: async ({ model }) => complete(model) },
|
|
cesium: {
|
|
Cartesian2: class {}, Ellipsoid: { WGS84: {} }, SceneMode: { SCENE3D: 3 },
|
|
Cartographic: { fromCartesian: point => point }, Math: { toDegrees: value => value },
|
|
EllipsoidalOccluder: class { isPointVisible() { return true; } },
|
|
},
|
|
createRendering: () => rendering,
|
|
|
|
});
|
|
layer.init(viewer);
|
|
layer.enable();
|
|
await layer.update();
|
|
layer.setParams({ inspect: true });
|
|
const captured = layer.getRowControls().summary.reading;
|
|
assert.equal(samples, 1);
|
|
const retained = marker().owner;
|
|
layer.setParams({ units: 'mph' });
|
|
assert.ok(marker().owner === retained);
|
|
const changed = layer.getRowControls().summary.reading;
|
|
assert.equal(changed.speed, captured.speed);
|
|
assert.equal(changed.coordinates, captured.coordinates);
|
|
assert.match(changed.wind, /mph/);
|
|
assert.equal(samples, 1, 'units do not resample');
|
|
assert.equal(layer.getRowControls().summary.result.id, 'reading');
|
|
assert.deepEqual(layer.getRowControls().summary.settings.map(({ label }) => label), ['MODEL', 'FIELD', 'UNITS', 'MOTION']);
|
|
assert.ok(marker());
|
|
assert.equal(typeof listener, 'function');
|
|
viewer.camera.pickEllipsoid = () => { samples++; return geo.cartesian3.fromDegrees(70, 20); };
|
|
layer.setParams({ overlay: 'speed' });
|
|
assert.equal(layer.getRowControls().summary.reading.coordinates, captured.coordinates);
|
|
layer.setParams({ model: 'ifs' });
|
|
await new Promise(resolve => setImmediate(resolve));
|
|
const resampled = layer.getRowControls().summary.reading;
|
|
assert.equal(resampled.coordinates, captured.coordinates);
|
|
assert.equal(resampled.model, 'ECMWF');
|
|
assert.equal(resampled.position, captured.position);
|
|
assert.equal(samples, 1, 'model and field changes never sample the moved camera');
|
|
assert.match(layer.getRowControls().summary.result.lines.find(({ id }) => id === 'meta').text, /ECMWF · valid/);
|
|
await layer.update();
|
|
assert.equal(layer.getRowControls().summary.reading.coordinates, captured.coordinates);
|
|
layer.setParams({ inspect: true });
|
|
assert.equal(layer.getRowControls().summary.reading.coordinates, '20.00°N · 70.00°E');
|
|
assert.equal(samples, 2, 'the next explicit read samples the new center');
|
|
for (const change of [() => layer.setParams({ inspect: false }), () => layer.disable()]) {
|
|
layer.setParams({ inspect: true });
|
|
assert.ok(marker());
|
|
change();
|
|
assert.equal(marker(), null);
|
|
assert.equal(layer.getRowControls().summary.reading, null);
|
|
assert.equal(layer.getRowControls().summary.result, null);
|
|
assert.equal(listener, null);
|
|
}
|
|
layer.destroy();
|
|
});
|
|
|
|
test('observed history labels wind as a forecast without changing its data or parameters', async () => {
|
|
const { createWeatherClock } = await import('../weather/clock.js');
|
|
const clock = createWeatherClock();
|
|
const layer = createWindLayer({ feed: { getSnapshot: async () => snapshot('gfs') }, clock });
|
|
let changes = 0;
|
|
layer.setRowControlsListener(() => changes++);
|
|
const params = layer.getParams();
|
|
await clock.setTarget('2026-09-14T12:00:00.000Z');
|
|
assert.equal(layer.getRowControls().summary.status, null, 'history does not mask source status');
|
|
assert.ok(changes > 0);
|
|
assert.match(layer.getRowControls().info, /Forecast · does not follow history/);
|
|
assert.deepEqual(layer.getParams(), params);
|
|
await clock.latest();
|
|
assert.equal(layer.getRowControls().summary.status, null);
|
|
layer.destroy();
|
|
const before = changes;
|
|
await clock.setTarget('2026-09-14T12:00:00.000Z');
|
|
assert.equal(changes, before);
|
|
clock.destroy();
|
|
});
|
|
|
|
test('wind unit chips appear only alongside a speed legend, including canvas trails', async () => {
|
|
let renderMode = 'gpu-streamlines'; let imageryError = null;
|
|
const layer = createWindLayer({ feed: { getSnapshot: async () => complete('gfs') }, createRendering: () => ({ attach() {}, start() {}, clear() {}, setField() {}, setOptions() {}, getDiagnostics: () => ({ renderMode, imageryError }), stop() {}, destroy() {} }) });
|
|
layer.init({ container: {} }); layer.enable(); await layer.update();
|
|
const unitChips = () => layer.getRowControls().chips.filter(({ id }) => id.startsWith('units-'));
|
|
assert.equal(layer.getRowControls().readout, true); assert.equal(layer.getRowControls().summary.coverage, 'Global · 1° grid');
|
|
assert.deepEqual(unitChips(), []); assert.deepEqual(layer.getRowControls().legend, []);
|
|
renderMode = 'canvas-fallback'; assert.equal(unitChips().length, 3); assert.ok(layer.getRowControls().legend.length);
|
|
renderMode = 'gpu-streamlines'; layer.setParams({ overlay: 'speed' }); assert.equal(unitChips().length, 3);
|
|
imageryError = 'Unavailable'; assert.deepEqual(unitChips(), []); imageryError = null;
|
|
for (const overlay of ['pressure', 'temperature', 'none']) { layer.setParams({ overlay }); assert.deepEqual(unitChips(), []); }
|
|
layer.destroy();
|
|
});
|
|
|
|
test('a parameter replacement during manager enable does not roll the layer back', async () => {
|
|
const { LayerLifecycle } = await import('../../data/lifecycle.js');
|
|
const pending = [];
|
|
const rendering = Object.fromEntries(
|
|
['attach', 'start', 'stop', 'clear', 'destroy', 'setField'].map((name) => [
|
|
name,
|
|
() => {},
|
|
]),
|
|
);
|
|
const layer = createWindLayer({
|
|
feed: {
|
|
getSnapshot: (args) =>
|
|
new Promise((resolve) => pending.push({ ...args, resolve })),
|
|
},
|
|
createRendering: () => rendering,
|
|
});
|
|
const manager = new LayerLifecycle({ container: {} });
|
|
manager.register(layer);
|
|
const enabled = manager.setEnabled('wind', true);
|
|
for (let i = 0; i < 20 && !pending.length; i++) await Promise.resolve();
|
|
layer.setParams({ model: 'ifs' });
|
|
await Promise.resolve();
|
|
pending[0].resolve(snapshot('gfs'));
|
|
assert.equal(await enabled, true);
|
|
assert.equal(manager.isEnabled('wind'), true);
|
|
assert.equal(layer.getStats().loading, true);
|
|
pending[1].resolve(snapshot('ifs'));
|
|
for (let i = 0; i < 10; i++) await Promise.resolve();
|
|
assert.equal(layer.getStats().model, 'IFS');
|
|
assert.equal(layer.getStats().count, 4);
|
|
await manager.destroyAll();
|
|
});
|