mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 01:32:19 +00:00
Main brings the reviewed one-time-control and timeline-mark changes. They keep this branch's renderer work: earthquakes draw through the draw port and register their strong quakes as marks; the weather clock keeps `follows` beside `world`; the weather layer measures ages and delays from the timeline time; the Visual panel keeps its sky and weather groups under Effects. Tests that moved time through the weather clock now move it on the world clock.
478 lines
18 KiB
JavaScript
478 lines
18 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 { fromDegrees } from '../../geo/ellipsoid.js';
|
|
import { bindRenderer } from '../../render/rendererOf.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 }),
|
|
};
|
|
let center = fromDegrees(0, 0);
|
|
const viewer = {
|
|
container,
|
|
get canvas() {
|
|
return this.scene?.canvas;
|
|
},
|
|
scene: {
|
|
canvas: { clientWidth: 800, clientHeight: 600, getBoundingClientRect: () => ({ left: 0, top: 0 }) },
|
|
},
|
|
};
|
|
bindRenderer(viewer, {
|
|
query: {
|
|
pickEllipsoid: () => { samples++; return center; },
|
|
project: () => ({ x: 400, y: 300 }),
|
|
isOccluded: () => false,
|
|
},
|
|
frame: {
|
|
on(phase, 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) },
|
|
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');
|
|
center = 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 { world } = clock;
|
|
const layer = createWindLayer({ feed: { getSnapshot: async () => snapshot('gfs') }, clock });
|
|
let changes = 0;
|
|
layer.setRowControlsListener(() => changes++);
|
|
const params = layer.getParams();
|
|
world.seek(Date.parse('2026-09-14T12:00:00.000Z'));
|
|
await Promise.resolve();
|
|
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);
|
|
world.goLive();
|
|
await Promise.resolve();
|
|
assert.equal(layer.getRowControls().summary.status, null);
|
|
layer.destroy();
|
|
const before = changes;
|
|
world.seek(Date.parse('2026-09-14T12:00:00.000Z'));
|
|
await Promise.resolve();
|
|
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();
|
|
});
|
|
|
|
test('wind whose source follows the timeline drops the note that it does not follow the timeline', async () => {
|
|
const { createWeatherClock } = await import('../weather/clock.js');
|
|
const { createWorldClock } = await import('../../time/worldClock.js');
|
|
const world = createWorldClock();
|
|
const clock = createWeatherClock({ world });
|
|
const layer = createWindLayer({ feed: { getSnapshot: async () => snapshot('gfs') }, clock });
|
|
world.follow('wind');
|
|
world.seek(Date.parse('2026-09-14T12:00:00.000Z'));
|
|
for (let i = 0; i < 10; i++) await Promise.resolve();
|
|
assert.equal(clock.getState().mode, 'history');
|
|
assert.doesNotMatch(layer.getRowControls().info, /does not follow history/);
|
|
world.follow('wind', false);
|
|
assert.match(layer.getRowControls().info, /Forecast · does not follow history/);
|
|
layer.destroy();
|
|
clock.destroy();
|
|
});
|