Files
gods-eye-view/src/layers/wind/index.test.mjs
T
German Khokhlov b8305de14b Run the Navara paths without the Cesium SDK, and load it on demand for the features that still build on it
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.
2026-11-04 17:15:21 +04:00

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();
});