mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
A weather feed may also be a frame source. With an optional
getFrameImage({ product, time, size, bbox, signal }) the layers take
whole-extent images, detail windows and the global mosaic from it; with an
optional getFrameTile({ product, time, z, x, y, size, signal }) regional
tiles and their prefetch come from it, null being a transparent tile. Pixels
may be an ImageBitmap, ImageData, canvas or VideoFrame of exactly the
requested size; the layer draws them once and closes them. Cancellation
reaches the source, and a feed without these methods reads the image and
tile routes as before.
2640 lines
84 KiB
JavaScript
2640 lines
84 KiB
JavaScript
import test from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { createWeatherRendering, READY_WAKE_MS } from './rendering.js';
|
||
import { createWeatherLayer } from './index.js';
|
||
import { createWeatherClock } from './clock.js';
|
||
import * as Cesium from 'cesium';
|
||
import { Color, ImageryLayerCollection, GeographicTilingScheme } from 'cesium';
|
||
import { NO_IMAGERY_HOST } from './imageryHost.js';
|
||
import { orderWeatherImagery } from './imageryOrder.js';
|
||
import {
|
||
createShellCesium,
|
||
createShellScene,
|
||
renderShells,
|
||
} from './shellFixture.mjs';
|
||
|
||
const times = [
|
||
'2026-09-15T20:00:00.000Z',
|
||
'2026-09-15T20:05:00.000Z',
|
||
'2026-09-15T20:10:00.000Z',
|
||
];
|
||
const snapshot = {
|
||
product: 'radar',
|
||
times,
|
||
latest: times[2],
|
||
bounds: { west: -130, south: 20, east: -60, north: 55 },
|
||
};
|
||
const deferred = () => {
|
||
let resolve, reject;
|
||
const promise = new Promise((yes, no) => {
|
||
resolve = yes;
|
||
reject = no;
|
||
});
|
||
return { promise, resolve, reject };
|
||
};
|
||
const flush = async () => {
|
||
for (let i = 0; i < 30; i++) await Promise.resolve();
|
||
};
|
||
function event() {
|
||
const listeners = new Set();
|
||
return {
|
||
addEventListener(fn) {
|
||
listeners.add(fn);
|
||
return () => listeners.delete(fn);
|
||
},
|
||
emit(...args) {
|
||
for (const fn of [...listeners]) fn(...args);
|
||
},
|
||
get size() {
|
||
return listeners.size;
|
||
},
|
||
};
|
||
}
|
||
function target(extra = {}) {
|
||
const listeners = new Map();
|
||
return {
|
||
...extra,
|
||
addEventListener(name, fn) {
|
||
if (!listeners.has(name)) listeners.set(name, new Set());
|
||
listeners.get(name).add(fn);
|
||
},
|
||
removeEventListener(name, fn) {
|
||
listeners.get(name)?.delete(fn);
|
||
},
|
||
emit(name) {
|
||
for (const fn of [...(listeners.get(name) || [])]) fn();
|
||
},
|
||
get size() {
|
||
return [...listeners.values()].reduce(
|
||
(sum, entries) => sum + entries.size,
|
||
0,
|
||
);
|
||
},
|
||
};
|
||
}
|
||
function mockCanvas() {
|
||
const canvas = { width: 0, height: 0 };
|
||
canvas.getContext = () => ({
|
||
setTransform(...matrix) {
|
||
canvas.transforms = [...(canvas.transforms ?? []), matrix];
|
||
},
|
||
drawImage(source, ...crop) {
|
||
canvas.source = source;
|
||
canvas.crop = crop;
|
||
canvas.drawnWith = canvas.transforms?.at(-1) ?? null;
|
||
},
|
||
getImageData: () => ({ data: new Uint8ClampedArray([194, 100, 0, 200]) }),
|
||
putImageData(pixels) {
|
||
canvas.pixels = pixels.data;
|
||
},
|
||
});
|
||
return canvas;
|
||
}
|
||
const mockResponse = () => ({
|
||
ok: true,
|
||
headers: new Headers(),
|
||
arrayBuffer: async () => new ArrayBuffer(1),
|
||
});
|
||
function renderingHarness(options = {}) {
|
||
const layers = [];
|
||
const providers = [];
|
||
const postRender = event();
|
||
let renderRequests = 0;
|
||
class Provider {
|
||
constructor(options) {
|
||
this.options = options;
|
||
this.tilingScheme = new GeographicTilingScheme();
|
||
this.errorEvent = event();
|
||
this.response = null;
|
||
providers.push(this);
|
||
}
|
||
requestImage(...args) {
|
||
this.requestArgs = args;
|
||
return this.response?.promise;
|
||
}
|
||
}
|
||
const collection = {
|
||
add(layer) {
|
||
layers.push(layer);
|
||
return layer;
|
||
},
|
||
addImageryProvider(provider) {
|
||
if (!providers.includes(provider)) providers.push(provider);
|
||
const layer = { imageryProvider: provider, alpha: 1, show: true };
|
||
layers.push(layer);
|
||
return layer;
|
||
},
|
||
contains(layer) {
|
||
return layers.includes(layer);
|
||
},
|
||
remove(layer, destroy) {
|
||
const index = layers.indexOf(layer);
|
||
if (index < 0) return false;
|
||
layers.splice(index, 1);
|
||
layer.destroyed = destroy;
|
||
return true;
|
||
},
|
||
get length() {
|
||
return layers.length;
|
||
},
|
||
get(index) {
|
||
return layers[index];
|
||
},
|
||
lower(layer) {
|
||
const i = layers.indexOf(layer);
|
||
if (i > 0) [layers[i - 1], layers[i]] = [layers[i], layers[i - 1]];
|
||
},
|
||
raiseToTop(layer) {
|
||
const i = layers.indexOf(layer);
|
||
if (i >= 0) layers.push(...layers.splice(i, 1));
|
||
},
|
||
isDestroyed: () => false,
|
||
};
|
||
const viewer = {
|
||
clock: { untouched: true },
|
||
imageryLayers: collection,
|
||
scene: {
|
||
postRender,
|
||
primitives: createShellScene().primitives,
|
||
globe: { tilesLoaded: true },
|
||
requestRender() {
|
||
renderRequests++;
|
||
},
|
||
},
|
||
};
|
||
const cesium = {
|
||
...createShellCesium(),
|
||
Color,
|
||
UrlTemplateImageryProvider: Provider,
|
||
GeographicTilingScheme,
|
||
Event: Cesium.Event,
|
||
Credit: Cesium.Credit,
|
||
Rectangle: Cesium.Rectangle,
|
||
};
|
||
const rendering = createWeatherRendering({
|
||
viewer,
|
||
cesium,
|
||
fetchImpl: async () => mockResponse(),
|
||
decodeImage: async () => ({ width: 2048, height: 1024, close() {} }),
|
||
createCanvas: mockCanvas,
|
||
...options,
|
||
});
|
||
const settle = () => {
|
||
postRender.emit();
|
||
postRender.emit();
|
||
};
|
||
return {
|
||
rendering,
|
||
viewer,
|
||
cesium,
|
||
providers,
|
||
layers,
|
||
postRender,
|
||
settle,
|
||
shells: () => viewer.scene.primitives.items,
|
||
renderShells: () => renderShells(cesium, viewer.scene),
|
||
renders: () => renderRequests,
|
||
};
|
||
}
|
||
|
||
test('a ready weather frame does not wait for unrelated terrain, but requires successful quiet tiles', async () => {
|
||
let now = 0;
|
||
const h = renderingHarness({ now: () => now });
|
||
h.viewer.scene.globe.tilesLoaded = false;
|
||
const loaded = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().loading,
|
||
true,
|
||
'no successful tiles is not ready',
|
||
);
|
||
const tile = deferred();
|
||
h.providers[0].response = tile;
|
||
const request = h.providers[0].requestImage(0, 0, 0, {});
|
||
tile.resolve({});
|
||
await request;
|
||
now = 199;
|
||
h.settle();
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().loading,
|
||
true,
|
||
'scheduler quiet interval is required',
|
||
);
|
||
h.providers[0].response = null;
|
||
assert.equal(h.providers[0].requestImage(1, 0, 0, {}), undefined);
|
||
now = 500;
|
||
h.settle();
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().loading,
|
||
true,
|
||
'a scheduler-deferred own tile prevents premature commit',
|
||
);
|
||
const delayed = deferred();
|
||
h.providers[0].response = delayed;
|
||
const admitted = h.providers[0].requestImage(1, 0, 0, {});
|
||
delayed.resolve({});
|
||
await admitted;
|
||
now = 701;
|
||
h.settle();
|
||
assert.equal(await loaded, true);
|
||
assert.equal(h.rendering.getDiagnostics().loadedTiles, 2);
|
||
assert.equal(h.rendering.getDiagnostics().frameLoadMs, 701);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('a staged frame waiting out its quiet interval wakes on a timer, not every render', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
let now = 0;
|
||
const h = renderingHarness({ now: () => now });
|
||
h.viewer.scene.globe.tilesLoaded = false;
|
||
const loaded = h.rendering.setFrame(snapshot, times[0]);
|
||
const tile = deferred();
|
||
h.providers[0].response = tile;
|
||
const request = h.providers[0].requestImage(0, 0, 0, {});
|
||
tile.resolve({});
|
||
await request;
|
||
const before = h.renders();
|
||
for (let i = 0; i < 10; i++) h.postRender.emit();
|
||
assert.equal(
|
||
h.renders(),
|
||
before,
|
||
'renders while waiting do not request further renders',
|
||
);
|
||
t.mock.timers.tick(READY_WAKE_MS - 1);
|
||
assert.equal(h.renders(), before);
|
||
t.mock.timers.tick(1);
|
||
assert.equal(h.renders(), before + 1, 'one wake per interval');
|
||
now = 200;
|
||
h.postRender.emit();
|
||
h.postRender.emit();
|
||
assert.equal(await loaded, true);
|
||
const settledRenders = h.renders();
|
||
t.mock.timers.tick(READY_WAKE_MS * 4);
|
||
assert.equal(h.renders(), settledRenders, 'commit clears the wake timer');
|
||
|
||
const abandoned = h.rendering.setFrame(snapshot, times[1]);
|
||
const second = deferred();
|
||
h.providers.at(-1).response = second;
|
||
const secondRequest = h.providers.at(-1).requestImage(0, 0, 0, {});
|
||
second.resolve({});
|
||
await secondRequest;
|
||
h.postRender.emit();
|
||
h.rendering.clear();
|
||
assert.equal(await abandoned, false);
|
||
const clearedRenders = h.renders();
|
||
t.mock.timers.tick(READY_WAKE_MS * 4);
|
||
assert.equal(h.renders(), clearedRenders, 'clear cancels the wake timer');
|
||
});
|
||
|
||
test('camera movement drops abandoned deferred tiles but still waits for admitted requests', async () => {
|
||
let now = 0;
|
||
const h = renderingHarness({ now: () => now });
|
||
const moveEnd = event();
|
||
h.viewer.camera = { moveEnd };
|
||
h.viewer.scene.globe.tilesLoaded = false;
|
||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||
assert.equal(moveEnd.size, 1);
|
||
const provider = h.providers[0];
|
||
const first = deferred();
|
||
provider.response = first;
|
||
const firstRequest = provider.requestImage(0, 0, 0, {});
|
||
first.resolve({});
|
||
await firstRequest;
|
||
provider.response = null;
|
||
assert.equal(provider.requestImage(1, 0, 0, {}), undefined);
|
||
const pending = deferred();
|
||
provider.response = pending;
|
||
const admitted = provider.requestImage(2, 0, 0, {});
|
||
assert.equal(h.rendering.getDiagnostics().deferredTiles, 1);
|
||
assert.equal(h.rendering.getDiagnostics().pendingTiles, 1);
|
||
now = 500;
|
||
moveEnd.emit();
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().deferredTiles,
|
||
0,
|
||
'an unadmitted tile abandoned by the old viewport no longer blocks the stage',
|
||
);
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().pendingTiles,
|
||
1,
|
||
'camera movement does not erase admitted request ownership',
|
||
);
|
||
now = 800;
|
||
h.settle();
|
||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||
assert.equal(
|
||
h.layers[0].alpha,
|
||
0,
|
||
'the new observation stays invisible while a request is pending',
|
||
);
|
||
pending.resolve({});
|
||
await admitted;
|
||
now = 999;
|
||
h.settle();
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().loading,
|
||
true,
|
||
'completion starts a new quiet interval',
|
||
);
|
||
now = 1000;
|
||
h.postRender.emit();
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().loading,
|
||
true,
|
||
'commit still requires two settled renders',
|
||
);
|
||
h.postRender.emit();
|
||
assert.equal(await stage, true);
|
||
assert.equal(h.rendering.getDiagnostics().loadedTiles, 2);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
assert.equal(moveEnd.size, 0, 'committing releases the stage listener');
|
||
const abandoned = h.rendering.setFrame(snapshot, times[1]);
|
||
assert.equal(moveEnd.size, 1);
|
||
h.rendering.clear();
|
||
assert.equal(await abandoned, false);
|
||
assert.equal(
|
||
moveEnd.size,
|
||
0,
|
||
'teardown also releases the stage camera listener',
|
||
);
|
||
});
|
||
|
||
test('weather stages invisibly, waits for pending tiles and render readiness, and replaces atomically', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = renderingHarness();
|
||
const first = h.rendering.setFrame(snapshot, times[0]);
|
||
const layer = h.layers[0];
|
||
assert.equal(layer.alpha, 0);
|
||
assert.equal(layer.show, true);
|
||
assert.equal(h.rendering.getDiagnostics().time, null);
|
||
const tile = deferred();
|
||
h.providers[0].response = tile;
|
||
const requested = h.providers[0].requestImage(0, 0, 0, { cancel() {} });
|
||
h.settle();
|
||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||
tile.resolve({});
|
||
await requested;
|
||
h.viewer.scene.globe.tilesLoaded = false;
|
||
h.settle();
|
||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||
h.viewer.scene.globe.tilesLoaded = true;
|
||
h.postRender.emit();
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().time,
|
||
null,
|
||
'one settled frame is insufficient',
|
||
);
|
||
h.postRender.emit();
|
||
assert.equal(await first, true);
|
||
assert.equal(layer.alpha, 0.7);
|
||
const second = h.rendering.setFrame(snapshot, times[1]);
|
||
assert.equal(h.layers.length, 2);
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().time,
|
||
times[0],
|
||
'displayed time remains old until commit',
|
||
);
|
||
h.settle();
|
||
assert.equal(await second, true);
|
||
assert.equal(h.layers.length, 2, 'old layer survives the admission render');
|
||
assert.equal(
|
||
h.layers[1].alpha,
|
||
0.7,
|
||
'new layer is visible before retirement',
|
||
);
|
||
assert.equal(layer.destroyed, undefined);
|
||
h.postRender.emit();
|
||
assert.equal(h.layers.length, 1);
|
||
assert.equal(layer.destroyed, true);
|
||
assert.equal(h.providers[0].errorEvent.size, 0);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[1]);
|
||
assert.deepEqual(h.viewer.clock, { untouched: true });
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('superseded stages cancel requests and cannot resurrect after a late tile response', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = renderingHarness();
|
||
const first = h.rendering.setFrame(snapshot, times[0]);
|
||
const tile = deferred();
|
||
const oldProvider = h.providers[0];
|
||
oldProvider.response = tile;
|
||
let cancellations = 0;
|
||
const requested = oldProvider.requestImage(0, 0, 0, {
|
||
cancel() {
|
||
cancellations++;
|
||
},
|
||
});
|
||
const second = h.rendering.setFrame(snapshot, times[1]);
|
||
assert.equal(await first, false);
|
||
assert.equal(cancellations, 1);
|
||
assert.equal(h.layers.length, 1);
|
||
assert.equal(oldProvider.errorEvent.size, 0);
|
||
tile.resolve({});
|
||
await requested;
|
||
h.settle();
|
||
assert.equal(await second, true);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[1]);
|
||
assert.equal(oldProvider.requestImage(0, 0, 0, {}), undefined);
|
||
h.rendering.clear();
|
||
assert.equal(h.layers.length, 0);
|
||
assert.equal(h.postRender.size, 0);
|
||
assert.ok(h.providers.every((provider) => provider.errorEvent.size === 0));
|
||
t.mock.timers.tick(30_000);
|
||
assert.equal(h.layers.length, 0);
|
||
});
|
||
|
||
test('failed and timed-out stages retain the previous observation; a healthy replacement clears old errors', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = renderingHarness();
|
||
const first = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
await first;
|
||
const failed = h.rendering.setFrame(snapshot, times[1]);
|
||
h.providers[1].errorEvent.emit(new Error('tile missing'));
|
||
h.postRender.emit();
|
||
assert.equal(await failed, false);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
assert.equal(h.layers.length, 1);
|
||
const timeout = h.rendering.setFrame(snapshot, times[1]);
|
||
h.viewer.scene.globe.tilesLoaded = false;
|
||
t.mock.timers.tick(25_000);
|
||
assert.equal(await timeout, false);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
const healthy = h.rendering.setFrame(snapshot, times[2]);
|
||
h.providers[0].errorEvent.emit(
|
||
new Error('old visible tile failed while replacement loaded'),
|
||
);
|
||
h.viewer.scene.globe.tilesLoaded = true;
|
||
h.settle();
|
||
assert.equal(await healthy, true);
|
||
assert.equal(h.rendering.getDiagnostics().error, null);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
function layerHarness({
|
||
clock,
|
||
reducedMotion = false,
|
||
feed,
|
||
id,
|
||
eventTarget = target(),
|
||
} = {}) {
|
||
const stages = [];
|
||
const motion = target({ matches: reducedMotion });
|
||
const documentRef = target({ hidden: false });
|
||
const moveEnd = event();
|
||
let time = null;
|
||
let infraredMode = 'filtered';
|
||
let active = null;
|
||
let clearCount = 0;
|
||
let hidden = false;
|
||
let alpha = null;
|
||
const rendering = {
|
||
rehome() {
|
||
active?.finish(false);
|
||
},
|
||
setAlpha(value) {
|
||
alpha = value;
|
||
},
|
||
setHidden(value) {
|
||
hidden = value;
|
||
if (value) active?.finish(false);
|
||
},
|
||
setFrame(value, selected, { signal, infrared = 'filtered' } = {}) {
|
||
if (active) active.finish(false);
|
||
const task = deferred();
|
||
const abort = () => stage.finish(false);
|
||
const stage = {
|
||
...task,
|
||
time: selected,
|
||
infrared,
|
||
signal,
|
||
finish(ok = true) {
|
||
signal?.removeEventListener('abort', abort);
|
||
if (active === stage) {
|
||
if (ok) {
|
||
time = selected;
|
||
infraredMode = infrared;
|
||
}
|
||
active = null;
|
||
}
|
||
task.resolve(ok);
|
||
},
|
||
};
|
||
signal?.addEventListener('abort', abort, { once: true });
|
||
stages.push(stage);
|
||
active = stage;
|
||
return stage.promise;
|
||
},
|
||
clear() {
|
||
clearCount++;
|
||
active?.finish(false);
|
||
active = null;
|
||
time = null;
|
||
},
|
||
getDiagnostics: () => ({
|
||
time: hidden ? null : time,
|
||
hidden,
|
||
infrared: infraredMode,
|
||
loading: Boolean(active),
|
||
error: null,
|
||
}),
|
||
};
|
||
const viewer = { camera: { moveEnd } };
|
||
const layer = createWeatherLayer({
|
||
clock,
|
||
id,
|
||
feed: feed ?? { getSnapshot: async () => snapshot },
|
||
documentRef,
|
||
eventTarget,
|
||
matchMedia: () => motion,
|
||
createRendering: () => rendering,
|
||
});
|
||
layer.init(viewer);
|
||
layer.enable();
|
||
return {
|
||
layer,
|
||
rendering,
|
||
stages,
|
||
eventTarget,
|
||
motion,
|
||
documentRef,
|
||
moveEnd,
|
||
clears: () => clearCount,
|
||
getAlpha: () => alpha,
|
||
};
|
||
}
|
||
|
||
test('history has one owned timer, stops while hidden, and releases all work on disable/destroy', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = layerHarness();
|
||
const update = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await update;
|
||
h.layer.setParams({ play: true });
|
||
assert.equal(h.layer.getDiagnostics().timerActive, true);
|
||
t.mock.timers.tick(2000);
|
||
assert.equal(h.stages.length, 2);
|
||
assert.equal(
|
||
h.layer.getDiagnostics().timerActive,
|
||
false,
|
||
'next timer waits for stage settlement',
|
||
);
|
||
h.stages[1].finish();
|
||
await flush();
|
||
assert.equal(h.layer.getDiagnostics().timerActive, true);
|
||
h.documentRef.hidden = true;
|
||
h.documentRef.emit('visibilitychange');
|
||
assert.equal(h.layer.getDiagnostics().playing, false);
|
||
assert.equal(h.layer.getDiagnostics().timerActive, false);
|
||
t.mock.timers.tick(20_000);
|
||
assert.equal(h.stages.length, 2);
|
||
h.documentRef.hidden = false;
|
||
h.documentRef.emit('visibilitychange');
|
||
h.layer.setParams({ play: true });
|
||
h.layer.disable();
|
||
assert.equal(h.layer.getDiagnostics().timerActive, false);
|
||
assert.equal(h.layer.getDiagnostics().historyFrames, 0);
|
||
t.mock.timers.tick(20_000);
|
||
assert.equal(h.stages.length, 2);
|
||
h.layer.destroy();
|
||
assert.equal(h.documentRef.size, 0);
|
||
assert.equal(h.motion.size, 0);
|
||
assert.equal(h.moveEnd.size, 0);
|
||
assert.ok(h.clears() >= 1);
|
||
});
|
||
|
||
test('reduced motion blocks autoplay but permits manual history and stops newly suspended playback', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = layerHarness({ reducedMotion: true });
|
||
const update = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await update;
|
||
h.layer.setParams({ play: true });
|
||
assert.equal(h.layer.getDiagnostics().timerActive, false);
|
||
assert.equal(
|
||
h.layer.getRowControls().chips.some((chip) => chip.id === 'play'),
|
||
false,
|
||
);
|
||
h.layer.setParams({ step: -1 });
|
||
assert.equal(h.stages[1].time, times[1]);
|
||
h.stages[1].finish();
|
||
await flush();
|
||
h.motion.matches = false;
|
||
h.motion.emit('change');
|
||
h.layer.setParams({ play: true });
|
||
assert.equal(h.layer.getDiagnostics().playing, true);
|
||
h.motion.matches = true;
|
||
h.motion.emit('change');
|
||
assert.equal(h.layer.getDiagnostics().playing, false);
|
||
assert.equal(h.layer.getDiagnostics().timerActive, false);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('disable invalidates an abort-insensitive source result and an already staged frame', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const source = deferred();
|
||
let signal;
|
||
const h = layerHarness({
|
||
feed: {
|
||
getSnapshot(options) {
|
||
signal = options.signal;
|
||
return source.promise;
|
||
},
|
||
},
|
||
});
|
||
const update = h.layer.update();
|
||
h.layer.disable();
|
||
assert.equal(signal.aborted, true);
|
||
source.resolve(snapshot);
|
||
assert.equal(await update, false);
|
||
assert.equal(h.stages.length, 0);
|
||
h.layer.enable();
|
||
const next = h.layer.update();
|
||
await flush();
|
||
assert.equal(h.stages.length, 1);
|
||
h.layer.disable();
|
||
await next;
|
||
await flush();
|
||
assert.equal(h.layer.getStats().count, 0);
|
||
assert.equal(h.layer.getDiagnostics().timerActive, false);
|
||
assert.equal(h.layer.getStats().loading, false);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('external abort cancels a staged renderer request and releases its observer and deadline', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = renderingHarness();
|
||
const controller = new AbortController();
|
||
const stage = h.rendering.setFrame(snapshot, times[0], {
|
||
signal: controller.signal,
|
||
});
|
||
const tile = deferred();
|
||
h.providers[0].response = tile;
|
||
let cancellations = 0;
|
||
const requested = h.providers[0].requestImage(0, 0, 0, {
|
||
cancel() {
|
||
cancellations++;
|
||
},
|
||
});
|
||
const before = h.renders();
|
||
controller.abort();
|
||
assert.equal(await stage, false);
|
||
assert.equal(cancellations, 1);
|
||
assert.equal(h.layers.length, 0);
|
||
assert.equal(h.postRender.size, 0);
|
||
assert.equal(h.providers[0].errorEvent.size, 0);
|
||
assert.ok(
|
||
h.renders() > before,
|
||
'cancellation requests a Cesium scheduler update',
|
||
);
|
||
tile.resolve({});
|
||
await requested;
|
||
t.mock.timers.tick(30_000);
|
||
assert.equal(h.rendering.getDiagnostics().time, null);
|
||
await assert.rejects(
|
||
h.rendering.setFrame(snapshot, times[1], { signal: controller.signal }),
|
||
{ name: 'AbortError' },
|
||
);
|
||
assert.equal(
|
||
h.providers.length,
|
||
1,
|
||
'already-aborted work creates no provider',
|
||
);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('update cancellation reaches imagery after source acquisition has completed', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = layerHarness();
|
||
const controller = new AbortController();
|
||
const update = h.layer.update(null, { signal: controller.signal });
|
||
await flush();
|
||
assert.equal(h.stages.length, 1);
|
||
assert.equal(h.stages[0].signal.aborted, false);
|
||
controller.abort();
|
||
assert.equal(await update, false);
|
||
assert.equal(h.stages[0].signal.aborted, true);
|
||
assert.equal(h.layer.getStats().count, 0);
|
||
assert.equal(h.layer.getStats().loading, false);
|
||
assert.equal(h.layer.getDiagnostics().timerActive, false);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('superseding a pending stage preserves the newer manifest loading state', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const later = deferred();
|
||
let fetches = 0;
|
||
const h = layerHarness({
|
||
feed: {
|
||
getSnapshot() {
|
||
return ++fetches === 1 ? Promise.resolve(snapshot) : later.promise;
|
||
},
|
||
},
|
||
});
|
||
const old = h.layer.update();
|
||
await flush();
|
||
const newer = h.layer.update();
|
||
await flush();
|
||
assert.equal(
|
||
await old,
|
||
true,
|
||
'replacement is accepted by the enable lifecycle',
|
||
);
|
||
assert.equal(
|
||
h.layer.getStats().loading,
|
||
true,
|
||
'old stage finally must not clear a newer source loading state',
|
||
);
|
||
later.resolve(snapshot);
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
assert.equal(await newer, true);
|
||
assert.equal(h.layer.getStats().loading, false);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('global infrared is acquired before staging and cropped from one processed mosaic', async () => {
|
||
let fetches = 0;
|
||
const decode = deferred();
|
||
const h = renderingHarness({
|
||
fetchImpl: async () => {
|
||
fetches++;
|
||
return mockResponse();
|
||
},
|
||
decodeImage: () => decode.promise,
|
||
});
|
||
const task = h.rendering.setFrame(
|
||
{ ...snapshot, product: 'clouds' },
|
||
times[0],
|
||
);
|
||
await flush();
|
||
assert.equal(h.layers.length, 0);
|
||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||
assert.deepEqual(h.rendering.getDiagnostics().mosaic, {
|
||
fetched: true,
|
||
decodeMs: null,
|
||
cached: false,
|
||
});
|
||
decode.resolve({ width: 2048, height: 1024 });
|
||
await flush();
|
||
const provider = h.layers[0].imageryProvider;
|
||
assert.equal(provider.maximumLevel, 3);
|
||
assert.equal(provider.tileWidth, 256);
|
||
assert.equal(provider.tileHeight, 256);
|
||
assert.equal(provider.tilingScheme.getNumberOfXTilesAtLevel(0), 2);
|
||
assert.deepEqual(provider.tilingScheme.rectangle, provider.rectangle);
|
||
const first = await provider.requestImage(0, 0, 0);
|
||
const next = await provider.requestImage(1, 0, 0);
|
||
assert.equal(first.source, next.source);
|
||
assert.deepEqual(
|
||
first.source.pixels,
|
||
new Uint8ClampedArray([194, 100, 0, 98]),
|
||
);
|
||
assert.equal(fetches, 1);
|
||
h.settle();
|
||
assert.equal(await task, true);
|
||
assert.equal(h.rendering.getDiagnostics().mosaic.fetched, true);
|
||
assert.equal(typeof h.rendering.getDiagnostics().mosaic.decodeMs, 'number');
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('coverage navigation requires the shared shell handoff and detaches cleanly', async () => {
|
||
const h = layerHarness();
|
||
const update = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await update;
|
||
assert.equal(
|
||
h.layer.getRowControls().chips.find((chip) => chip.id === 'coverage')
|
||
.disabled,
|
||
true,
|
||
);
|
||
let handoffs = 0;
|
||
h.layer.attachShellServices({
|
||
runNavigation(navigate) {
|
||
handoffs++;
|
||
assert.equal(typeof navigate, 'function');
|
||
},
|
||
});
|
||
h.layer.setParams({ focus: true });
|
||
assert.equal(handoffs, 1);
|
||
h.layer.attachShellServices(null);
|
||
h.layer.setParams({ focus: true });
|
||
assert.equal(handoffs, 1);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('manifest refresh during a manual history stage does not strand loading controls', async () => {
|
||
const h = layerHarness();
|
||
const first = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await first;
|
||
h.layer.setParams({ step: -1 });
|
||
assert.equal(h.layer.getStats().loading, true);
|
||
await h.layer.update();
|
||
assert.equal(
|
||
h.stages.length,
|
||
2,
|
||
'metadata refresh preserves the staged manual selection',
|
||
);
|
||
h.stages[1].finish();
|
||
await flush();
|
||
assert.equal(h.layer.getStats().loading, false);
|
||
assert.equal(h.layer.getStats().observedAt, times[1]);
|
||
assert.equal(
|
||
h.layer.getRowControls().chips.some((chip) => chip.id === 'previous'),
|
||
false,
|
||
);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('historical observations do not relabel a fresh lightning feed as stale', async () => {
|
||
const now = Date.now();
|
||
const old = new Date(now - 90 * 60_000).toISOString();
|
||
const recent = new Date(now - 5 * 60_000).toISOString();
|
||
const h = layerHarness({
|
||
id: 'weather-lightning',
|
||
feed: {
|
||
getSnapshot: async () => ({
|
||
...snapshot,
|
||
product: 'lightning',
|
||
times: [old, recent],
|
||
latest: recent,
|
||
}),
|
||
},
|
||
});
|
||
const first = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await first;
|
||
h.layer.setParams({ step: -1 });
|
||
h.stages[1].finish();
|
||
await flush();
|
||
assert.equal(h.layer.getStats().stale, false);
|
||
assert.match(h.layer.getRowControls().summary.detail, /History/);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('history loading updates an existing info line and preserves summary status', async (t) => {
|
||
t.mock.method(Date, 'now', () => Date.parse(times[2]));
|
||
const h = layerHarness();
|
||
const update = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await update;
|
||
h.layer.setParams({ step: -1 });
|
||
await flush();
|
||
const loading = h.layer.getRowControls();
|
||
assert.match(loading.info, /History: [^\n]+\n[^\n]+ · loading/);
|
||
assert.equal(loading.summary.status, 'Loading next frame…');
|
||
h.stages.at(-1).finish();
|
||
await flush();
|
||
const ready = h.layer.getRowControls();
|
||
assert.equal(ready.info.split('\n').length, loading.info.split('\n').length);
|
||
assert.doesNotMatch(ready.info, / · loading/);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('no host cancels a globe stage, detaches the layer and restores it in weather order', async () => {
|
||
let host;
|
||
const h = renderingHarness({ getHost: () => host });
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
assert.equal(await stage, true);
|
||
const radar = h.layers[0];
|
||
const cloud = h.viewer.imageryLayers.add({ name: 'cloud' });
|
||
const lightning = h.viewer.imageryLayers.add({ name: 'lightning' });
|
||
orderWeatherImagery(h.viewer.imageryLayers, lightning, 3);
|
||
orderWeatherImagery(h.viewer.imageryLayers, cloud, 1);
|
||
const incoming = h.rendering.setFrame(snapshot, times[1]);
|
||
host = { collection: null, kind: 'none' };
|
||
assert.equal(h.rendering.rehome(), true);
|
||
assert.equal(await incoming, false);
|
||
assert.deepEqual(h.layers, [cloud, lightning]);
|
||
assert.equal(await h.rendering.setFrame(snapshot, times[2]), false);
|
||
assert.equal(h.rendering.getDiagnostics().error, NO_IMAGERY_HOST);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
h.rendering.rehome();
|
||
assert.deepEqual(h.layers, [cloud, radar, lightning]);
|
||
assert.equal(h.rendering.getDiagnostics().error, null);
|
||
h.rendering.clear();
|
||
assert.deepEqual(h.layers, [cloud, lightning]);
|
||
assert.equal(radar.destroyed, true);
|
||
});
|
||
|
||
const shellDecode = async () => ({ width: 4096, height: 2048, close() {} });
|
||
|
||
test('the tileset host draws a raised shell and drapes nothing, at any camera height', async () => {
|
||
const tiles = new ImageryLayerCollection();
|
||
const h = renderingHarness({
|
||
getHost: () => ({ collection: tiles, kind: 'tileset' }),
|
||
decodeImage: shellDecode,
|
||
});
|
||
h.viewer.camera = {
|
||
moveEnd: event(),
|
||
positionCartographic: { height: 1200 },
|
||
};
|
||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||
await flush();
|
||
assert.equal(tiles.length, 0);
|
||
assert.equal(h.layers.length, 0);
|
||
assert.equal(h.providers.length, 0);
|
||
assert.equal(h.shells().length, 1);
|
||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||
h.renderShells();
|
||
assert.equal(await stage, true);
|
||
const diagnostics = h.rendering.getDiagnostics();
|
||
assert.equal(diagnostics.host, 'shell');
|
||
assert.equal(diagnostics.height, 6_200);
|
||
assert.equal(diagnostics.time, times[0]);
|
||
assert.equal(diagnostics.error, null);
|
||
assert.equal(
|
||
h.viewer.camera.moveEnd.size,
|
||
1,
|
||
'one camera listener, for the detail window only',
|
||
);
|
||
assert.equal(await h.rendering.prefetch(snapshot, times[1]), true);
|
||
assert.equal(h.rendering.getDiagnostics().cache.mosaics, 2);
|
||
h.rendering.clear();
|
||
assert.equal(h.shells().length, 0);
|
||
assert.equal(h.postRender.size, 0);
|
||
assert.equal(h.viewer.camera.moveEnd.size, 0);
|
||
assert.equal(h.rendering.getDiagnostics().cache.mosaics, 0);
|
||
});
|
||
|
||
test('a switch to 3D Tiles windows the current view; the globe host never requests a window', async () => {
|
||
let host;
|
||
const urls = [];
|
||
const h = renderingHarness({
|
||
getHost: () => host,
|
||
decodeImage: shellDecode,
|
||
fetchImpl: async (url) => {
|
||
urls.push(url);
|
||
return mockResponse();
|
||
},
|
||
});
|
||
h.viewer.camera = {
|
||
moveEnd: event(),
|
||
computeViewRectangle: () => Cesium.Rectangle.fromDegrees(-100, 35, -98, 36),
|
||
};
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
const globe = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
assert.equal(await globe, true);
|
||
assert.equal(await h.rendering.prefetch(snapshot, times[1]), true);
|
||
h.viewer.camera.moveEnd.emit();
|
||
await flush();
|
||
assert.equal(h.shells().length, 0);
|
||
assert.equal(h.viewer.camera.moveEnd.size, 0);
|
||
assert.equal(h.rendering.getDiagnostics().shell, undefined);
|
||
assert.ok(urls.length > 0);
|
||
assert.ok(urls.every((url) => !url.includes('bbox=')));
|
||
|
||
host = { collection: new ImageryLayerCollection(), kind: 'tileset' };
|
||
assert.equal(h.rendering.rehome(), true);
|
||
await flush();
|
||
h.renderShells();
|
||
await flush();
|
||
h.renderShells();
|
||
const detail = urls.filter((url) => url.includes('bbox='));
|
||
assert.deepEqual(
|
||
detail.map((url) =>
|
||
new URL(url, 'https://example.test').searchParams.get('bbox'),
|
||
),
|
||
['-102,34,-96,37'],
|
||
);
|
||
const diagnostics = h.rendering.getDiagnostics();
|
||
assert.equal(diagnostics.time, times[0]);
|
||
assert.equal(diagnostics.shell.detail.ready, true);
|
||
assert.equal(h.shells().length, 1, 'the detail draws on the shell surface');
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
assert.equal(h.rendering.rehome(), true);
|
||
assert.equal(h.shells().length, 0, 'the shell surface goes with the host');
|
||
await flush();
|
||
h.settle();
|
||
await flush();
|
||
assert.equal(h.rendering.getDiagnostics().host, 'globe');
|
||
assert.equal(h.rendering.getDiagnostics().loading, false);
|
||
assert.equal(h.viewer.camera.moveEnd.size, 0);
|
||
assert.equal(urls.filter((url) => url.includes('bbox=')).length, 1);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('host switches tear one renderer down and restage the retained frame on the other', async () => {
|
||
let host;
|
||
const tiles = new ImageryLayerCollection();
|
||
const h = renderingHarness({
|
||
getHost: () => host,
|
||
decodeImage: async () => ({ width: 2048, height: 1024, close() {} }),
|
||
});
|
||
const clouds = { ...snapshot, product: 'clouds' };
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
h.rendering.setAlpha(0.4);
|
||
const first = h.rendering.setFrame(clouds, times[1], { infrared: 'full' });
|
||
await flush();
|
||
h.settle();
|
||
assert.equal(await first, true);
|
||
const layer = h.layers[0];
|
||
host = { collection: tiles, kind: 'tileset' };
|
||
assert.equal(h.rendering.rehome(), true);
|
||
assert.equal(h.layers.length, 0);
|
||
assert.equal(layer.destroyed, true);
|
||
assert.equal(tiles.length, 0);
|
||
assert.equal(
|
||
h.rendering.getDiagnostics().time,
|
||
times[1],
|
||
'the retained time is reported while restaging',
|
||
);
|
||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||
await flush();
|
||
const [shell] = h.shells();
|
||
h.renderShells();
|
||
await flush();
|
||
let diagnostics = h.rendering.getDiagnostics();
|
||
assert.equal(diagnostics.host, 'shell');
|
||
assert.equal(diagnostics.height, 5_500);
|
||
assert.equal(diagnostics.loading, false);
|
||
assert.equal(diagnostics.time, times[1]);
|
||
assert.equal(diagnostics.infrared, 'full');
|
||
assert.equal(shell.appearance.material.uniforms.alpha, 0.4);
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
assert.equal(h.rendering.rehome(), true);
|
||
assert.equal(shell.destroyed, true);
|
||
assert.equal(shell.appearance.material.destroyed, true);
|
||
assert.equal(h.shells().length, 0);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[1]);
|
||
await flush();
|
||
assert.equal(h.layers.length, 1);
|
||
h.settle();
|
||
await flush();
|
||
diagnostics = h.rendering.getDiagnostics();
|
||
assert.equal(diagnostics.host, 'globe');
|
||
assert.equal(diagnostics.loading, false);
|
||
assert.equal(diagnostics.time, times[1]);
|
||
assert.equal(diagnostics.infrared, 'full');
|
||
assert.equal(h.layers[0].alpha, 0.4);
|
||
assert.equal(h.layers[0].imageryProvider.tileWidth, 256);
|
||
h.rendering.clear();
|
||
assert.equal(h.layers.length, 0);
|
||
assert.equal(h.postRender.size, 0);
|
||
});
|
||
|
||
test('a host without imagery keeps the active shell and its frame', async () => {
|
||
let host = { collection: new ImageryLayerCollection(), kind: 'tileset' };
|
||
let fetches = 0;
|
||
const h = renderingHarness({
|
||
getHost: () => host,
|
||
decodeImage: shellDecode,
|
||
fetchImpl: async () => {
|
||
fetches++;
|
||
return mockResponse();
|
||
},
|
||
});
|
||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||
await flush();
|
||
h.renderShells();
|
||
assert.equal(await stage, true);
|
||
const [shell] = h.shells();
|
||
host = { collection: null, kind: 'none' };
|
||
h.rendering.rehome();
|
||
assert.equal(shell.show, false);
|
||
assert.equal(shell.destroyed, false);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
assert.equal(h.rendering.getDiagnostics().error, NO_IMAGERY_HOST);
|
||
assert.equal(await h.rendering.setFrame(snapshot, times[1]), false);
|
||
host = { collection: new ImageryLayerCollection(), kind: 'tileset' };
|
||
h.rendering.rehome();
|
||
assert.equal(shell.show, true);
|
||
assert.deepEqual(h.shells(), [shell]);
|
||
assert.equal(fetches, 1);
|
||
assert.equal(h.rendering.getDiagnostics().error, null);
|
||
h.rendering.setHidden(true);
|
||
assert.equal(shell.show, false);
|
||
assert.equal(h.rendering.getDiagnostics().time, null);
|
||
h.rendering.setHidden(false);
|
||
assert.equal(shell.show, true);
|
||
h.rendering.clear();
|
||
assert.equal(h.shells().length, 0);
|
||
});
|
||
|
||
test('each product owns its shell height; a product change replaces the shell', async () => {
|
||
let width = 2048;
|
||
const h = renderingHarness({
|
||
getHost: () => ({ collection: null, kind: 'tileset' }),
|
||
decodeImage: async () => ({ width, height: width / 2, close() {} }),
|
||
});
|
||
const global = h.rendering.setFrame(
|
||
{ ...snapshot, product: 'clouds' },
|
||
times[0],
|
||
);
|
||
await flush();
|
||
h.renderShells();
|
||
assert.equal(await global, true);
|
||
const [first] = h.shells();
|
||
assert.equal(h.rendering.getDiagnostics().height, 5_500);
|
||
width = 4096;
|
||
const lightning = h.rendering.setFrame(
|
||
{ ...snapshot, product: 'lightning' },
|
||
times[0],
|
||
);
|
||
assert.equal(first.destroyed, true);
|
||
await flush();
|
||
h.renderShells();
|
||
assert.equal(await lightning, true);
|
||
assert.equal(h.rendering.getDiagnostics().height, 6_600);
|
||
assert.equal(h.rendering.getDiagnostics().product, 'lightning');
|
||
assert.equal(h.shells().length, 1);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('a stage without a current frame is cancelled on host change and detached frames are destroyed', async () => {
|
||
const tiles = new ImageryLayerCollection();
|
||
let host = { collection: tiles, kind: 'tileset' };
|
||
const h = renderingHarness({ getHost: () => host });
|
||
const first = h.rendering.setFrame(snapshot, times[0]);
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
h.rendering.rehome();
|
||
assert.equal(await first, false);
|
||
assert.equal(tiles.length, 0);
|
||
const ready = h.rendering.setFrame(snapshot, times[1]);
|
||
h.settle();
|
||
await ready;
|
||
const layer = h.layers[0];
|
||
let destroyed = false;
|
||
layer.destroy = () => {
|
||
destroyed = true;
|
||
};
|
||
host = { collection: null, kind: 'none' };
|
||
h.rendering.rehome();
|
||
h.rendering.clear();
|
||
assert.equal(destroyed, true);
|
||
});
|
||
|
||
for (const product of ['clouds', 'clouds-regional', 'radar', 'lightning']) {
|
||
test(`${product} does not use a hard layer alpha cut on the globe host`, async () => {
|
||
const collection = new ImageryLayerCollection();
|
||
const h = renderingHarness({
|
||
getHost: () => ({ collection, kind: 'globe' }),
|
||
});
|
||
const stage = h.rendering.setFrame({ ...snapshot, product }, times[0]);
|
||
await flush();
|
||
const layer = collection.get(0);
|
||
assert.equal(layer.colorToAlpha, undefined);
|
||
assert.equal(layer.alpha, 0);
|
||
h.rendering.clear();
|
||
assert.equal(await stage, false);
|
||
});
|
||
}
|
||
|
||
for (const statusCode of [429, 503]) {
|
||
test(`${statusCode} retries up to three times without failing a healthy frame`, async () => {
|
||
let now = 0;
|
||
const h = renderingHarness({ now: () => now });
|
||
h.viewer.scene.globe.tilesLoaded = false;
|
||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||
h.providers[0].response = deferred();
|
||
const rejected = h.providers[0].requestImage(0, 0, 0, {});
|
||
h.providers[0].response.reject(new Error('throttled'));
|
||
await assert.rejects(rejected, /throttled/);
|
||
for (let timesRetried = 0; timesRetried < 3; timesRetried++) {
|
||
const error = {
|
||
error: { statusCode },
|
||
x: 0,
|
||
y: 0,
|
||
level: 0,
|
||
timesRetried,
|
||
retry: false,
|
||
};
|
||
h.providers[0].errorEvent.emit(error);
|
||
assert.equal(error.retry, true);
|
||
assert.equal(h.rendering.getDiagnostics().error, null);
|
||
}
|
||
h.settle();
|
||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||
h.providers[0].response = deferred();
|
||
const retried = h.providers[0].requestImage(0, 0, 0, {});
|
||
h.providers[0].response.resolve({});
|
||
await retried;
|
||
now = 250;
|
||
h.settle();
|
||
assert.equal(await stage, true);
|
||
const exhausted = h.rendering.setFrame(snapshot, times[1]);
|
||
const error = { error: { statusCode }, timesRetried: 3, retry: false };
|
||
for (let i = 0; i < 4; i++) h.providers[1].errorEvent.emit(error);
|
||
h.settle();
|
||
assert.equal(error.retry, false);
|
||
assert.equal(await exhausted, false);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
h.rendering.clear();
|
||
});
|
||
}
|
||
|
||
test('404 fails a frame without retry', async () => {
|
||
const h = renderingHarness();
|
||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||
const error = { error: { statusCode: 404 }, timesRetried: 0, retry: false };
|
||
h.providers[0].errorEvent.emit(error);
|
||
h.settle();
|
||
assert.equal(error.retry, false);
|
||
assert.equal(await stage, false);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('no host pauses history, refreshes metadata, and restores retained time and playback', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
let refreshes = 0;
|
||
const h = layerHarness({
|
||
feed: {
|
||
getSnapshot: async () => {
|
||
refreshes++;
|
||
return snapshot;
|
||
},
|
||
},
|
||
});
|
||
let host = { collection: {}, kind: 'tileset' };
|
||
h.layer.attachShellServices({ imageryHost: () => host });
|
||
const update = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await update;
|
||
h.layer.setParams({ play: true });
|
||
t.mock.timers.tick(2000);
|
||
assert.equal(h.stages.length, 2);
|
||
host = { collection: null, kind: 'none' };
|
||
h.eventTarget.emit('gev:map-stack-changed');
|
||
await flush();
|
||
assert.equal(h.layer.getDiagnostics().playing, false);
|
||
assert.equal(h.layer.getDiagnostics().timerActive, false);
|
||
assert.equal(h.layer.getRowControls().summary.status, NO_IMAGERY_HOST);
|
||
assert.equal(h.layer.getRowControls().info, NO_IMAGERY_HOST);
|
||
await h.layer.update();
|
||
assert.equal(refreshes, 2);
|
||
t.mock.timers.tick(10_000);
|
||
assert.equal(h.stages.length, 2);
|
||
assert.equal(h.layer.getDiagnostics().time, times[2]);
|
||
host = { collection: {}, kind: 'globe' };
|
||
h.eventTarget.emit('gev:map-stack-changed');
|
||
assert.equal(h.layer.getDiagnostics().playing, true);
|
||
assert.equal(h.layer.getDiagnostics().timerActive, true);
|
||
t.mock.timers.tick(2000);
|
||
assert.equal(h.stages.length, 3);
|
||
assert.equal(h.stages[2].time, times[0]);
|
||
h.layer.destroy();
|
||
assert.equal(h.eventTarget.size, 0);
|
||
});
|
||
|
||
test('host restore through update stages latest after a no-host start', async () => {
|
||
const h = layerHarness();
|
||
let host = { collection: null, kind: 'none' };
|
||
h.layer.attachShellServices({ imageryHost: () => host });
|
||
await h.layer.update();
|
||
assert.equal(h.stages.length, 0);
|
||
host = { collection: {}, kind: 'tileset' };
|
||
const update = h.layer.update();
|
||
await flush();
|
||
assert.equal(h.stages[0].time, snapshot.latest);
|
||
h.stages[0].finish();
|
||
await update;
|
||
assert.notEqual(h.layer.getRowControls().summary.status, NO_IMAGERY_HOST);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('real Cesium global infrared provider supports the globe host', async () => {
|
||
const collection = new Cesium.ImageryLayerCollection();
|
||
const h = renderingHarness({
|
||
cesium: Cesium,
|
||
getHost: () => ({ collection, kind: 'globe' }),
|
||
});
|
||
const stage = h.rendering.setFrame(
|
||
{
|
||
...snapshot,
|
||
product: 'clouds',
|
||
bounds: { west: -180, south: -60, east: 180, north: 60 },
|
||
},
|
||
times[0],
|
||
);
|
||
await flush();
|
||
const layer = collection.get(0);
|
||
const provider = layer.imageryProvider;
|
||
assert.ok(provider.tilingScheme instanceof Cesium.GeographicTilingScheme);
|
||
assert.equal(provider.maximumLevel, 3);
|
||
assert.equal(provider.tileWidth, 256);
|
||
assert.equal(provider.tileHeight, 256);
|
||
assert.equal(provider.tilingScheme.getNumberOfXTilesAtLevel(0), 2);
|
||
assert.equal(provider.tilingScheme.getNumberOfYTilesAtLevel(0), 1);
|
||
assert.ok(
|
||
Cesium.Rectangle.equals(
|
||
provider.rectangle,
|
||
Cesium.Rectangle.fromDegrees(-180, -60, 180, 60),
|
||
),
|
||
);
|
||
assert.equal(layer.colorToAlpha, undefined);
|
||
assert.ok(provider.requestImage(0, 0, 0) instanceof Promise);
|
||
h.rendering.clear();
|
||
assert.equal(await stage, false);
|
||
});
|
||
|
||
for (const statusCode of [429, 503]) {
|
||
test(`${statusCode} retries belong to tiles, regardless of the layer-wide counter`, async () => {
|
||
const h = renderingHarness();
|
||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||
const provider = h.providers[0];
|
||
const fail = (x, timesRetried = 0) => {
|
||
const error = { x, y: 0, level: 2, timesRetried, error: { statusCode } };
|
||
provider.errorEvent.emit(error);
|
||
return error.retry;
|
||
};
|
||
// A shared counter may exceed three even though these are first failures.
|
||
for (let x = 0; x < 4; x++) assert.equal(fail(x, x + 4), true);
|
||
provider.response = { promise: Promise.resolve({}) };
|
||
await provider.requestImage(0, 0, 2);
|
||
for (let i = 0; i < 3; i++)
|
||
assert.equal(fail(0), true, 'own success reset the count');
|
||
for (let i = 0; i < 2; i++) {
|
||
await provider.requestImage(2, 0, 2);
|
||
assert.equal(fail(1), true);
|
||
}
|
||
await provider.requestImage(3, 0, 2);
|
||
assert.equal(
|
||
fail(1),
|
||
false,
|
||
'four failures exhaust this tile despite other successes',
|
||
);
|
||
h.settle();
|
||
assert.equal(await stage, false);
|
||
assert.equal(provider.errorEvent.size, 0);
|
||
h.rendering.clear();
|
||
});
|
||
}
|
||
|
||
for (const [id, product] of [
|
||
['weather-radar', 'radar'],
|
||
['weather-satellite', 'clouds-regional'],
|
||
['weather-satellite', 'clouds'],
|
||
['weather-lightning', 'lightning'],
|
||
]) {
|
||
test(`${product} shows on 3D Tiles at street level and keeps its history through host changes`, async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
t.mock.method(Date, 'now', () => Date.parse(times[2]));
|
||
const size =
|
||
product === 'clouds'
|
||
? { width: 2048, height: 1024 }
|
||
: { width: 4096, height: 2048 };
|
||
let host;
|
||
const h = renderingHarness({
|
||
getHost: () => host,
|
||
decodeImage: async () => ({ ...size, close() {} }),
|
||
});
|
||
host = { collection: new ImageryLayerCollection(), kind: 'tileset' };
|
||
const camera = {
|
||
moveEnd: event(),
|
||
positionCartographic: { height: 1200 },
|
||
};
|
||
h.viewer.camera = camera;
|
||
const events = target();
|
||
const layer = createWeatherLayer({
|
||
id,
|
||
feed: { getSnapshot: async () => ({ ...snapshot, product }) },
|
||
createRendering: () => h.rendering,
|
||
documentRef: target({ hidden: false }),
|
||
eventTarget: events,
|
||
matchMedia: () => target({ matches: false }),
|
||
});
|
||
layer.init(h.viewer);
|
||
layer.attachShellServices({ imageryHost: () => host });
|
||
layer.setParams({ product });
|
||
layer.enable();
|
||
const update = layer.update();
|
||
await flush();
|
||
h.renderShells();
|
||
await update;
|
||
assert.equal(layer.getDiagnostics().time, times[2]);
|
||
assert.equal(layer.getDiagnostics().host, 'shell');
|
||
assert.equal(layer.getRowControls().summary.status, null);
|
||
assert.doesNotMatch(layer.getRowControls().info, /Hidden/);
|
||
const [shell] = h.shells();
|
||
assert.equal(shell.show, true);
|
||
|
||
layer.setParams({ play: true });
|
||
t.mock.timers.tick(2000);
|
||
await flush();
|
||
assert.equal(
|
||
layer.getDiagnostics().time,
|
||
times[0],
|
||
'history advances at street level',
|
||
);
|
||
camera.positionCartographic.height = 59_999;
|
||
camera.moveEnd.emit();
|
||
assert.equal(shell.show, true, 'no height gate');
|
||
assert.equal(layer.getDiagnostics().playing, true);
|
||
assert.equal(layer.getDiagnostics().timerActive, true);
|
||
|
||
host = { collection: null, kind: 'none' };
|
||
events.emit('gev:map-stack-changed');
|
||
assert.equal(shell.show, false);
|
||
assert.equal(layer.getRowControls().summary.status, NO_IMAGERY_HOST);
|
||
assert.equal(layer.getDiagnostics().timerActive, false);
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
events.emit('gev:map-stack-changed');
|
||
assert.equal(shell.destroyed, true);
|
||
assert.equal(
|
||
layer.getDiagnostics().time,
|
||
times[0],
|
||
'the switch restages the shown history frame',
|
||
);
|
||
await flush();
|
||
h.settle();
|
||
await flush();
|
||
assert.equal(layer.getDiagnostics().host, 'globe');
|
||
assert.equal(layer.getDiagnostics().time, times[0]);
|
||
assert.equal(layer.getDiagnostics().loading, false);
|
||
layer.destroy();
|
||
assert.equal(camera.moveEnd.size, 0);
|
||
assert.equal(events.size, 0);
|
||
assert.equal(h.shells().length, 0);
|
||
assert.equal(h.postRender.size, 0);
|
||
});
|
||
}
|
||
|
||
for (const outcome of [
|
||
'fetch failure',
|
||
'decode failure',
|
||
'timeout',
|
||
'abort',
|
||
'supersede',
|
||
'rehome',
|
||
]) {
|
||
test(`mosaic ${outcome} retains the displayed frame and never installs a late decode`, async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const decode = deferred();
|
||
let signal,
|
||
closed = 0,
|
||
host;
|
||
const h = renderingHarness({
|
||
getHost: () => host,
|
||
fetchImpl: async (_url, options) => {
|
||
signal = options.signal;
|
||
if (outcome === 'fetch failure') throw new Error('offline');
|
||
return mockResponse();
|
||
},
|
||
decodeImage: () => decode.promise,
|
||
});
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
const first = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
await first;
|
||
const original = h.layers[0];
|
||
const controller = new AbortController();
|
||
const pending = h.rendering.setFrame(
|
||
{ ...snapshot, product: 'clouds' },
|
||
times[1],
|
||
{ signal: controller.signal },
|
||
);
|
||
await flush();
|
||
assert.deepEqual(h.layers, [original]);
|
||
if (outcome === 'decode failure') decode.reject(new Error('bad png'));
|
||
if (outcome === 'timeout') t.mock.timers.tick(25_000);
|
||
if (outcome === 'abort') controller.abort();
|
||
if (outcome === 'supersede')
|
||
assert.equal(await h.rendering.setFrame(snapshot, times[0]), true);
|
||
if (outcome === 'rehome') {
|
||
host = {
|
||
collection: renderingHarness().viewer.imageryLayers,
|
||
kind: 'globe',
|
||
};
|
||
h.rendering.rehome();
|
||
}
|
||
assert.equal(await pending, false);
|
||
assert.equal(signal.aborted, true);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
assert.equal(original.alpha, 0.7);
|
||
if (outcome !== 'decode failure') {
|
||
decode.resolve({
|
||
width: 2048,
|
||
height: 1024,
|
||
close() {
|
||
closed++;
|
||
},
|
||
});
|
||
await flush();
|
||
if (outcome !== 'fetch failure') assert.equal(closed, 1);
|
||
}
|
||
assert.equal(host.collection.length, 1);
|
||
h.rendering.clear();
|
||
assert.equal(h.postRender.size, 0);
|
||
});
|
||
}
|
||
|
||
test('regional transfer preserves deferrals, original Request, rejection and cancellation', async () => {
|
||
const h = renderingHarness();
|
||
const stage = h.rendering.setFrame(
|
||
{ ...snapshot, product: 'clouds-regional' },
|
||
times[0],
|
||
);
|
||
const provider = h.providers[0];
|
||
let cancelled = 0;
|
||
const request = {
|
||
cancel() {
|
||
cancelled++;
|
||
},
|
||
};
|
||
assert.equal(provider.requestImage(1, 2, 3, request), undefined);
|
||
assert.deepEqual(provider.requestArgs, [1, 2, 3, request]);
|
||
const image = { width: 256, height: 256 };
|
||
provider.response = { promise: Promise.resolve(image) };
|
||
const processed = await provider.requestImage(1, 2, 3, request);
|
||
assert.equal(processed.source, image);
|
||
assert.deepEqual([...processed.pixels], [194, 100, 0, 98]);
|
||
const error = new Error('cancelled upstream');
|
||
provider.response = { promise: Promise.reject(error) };
|
||
await assert.rejects(
|
||
provider.requestImage(0, 0, 0, request),
|
||
(cause) => cause === error,
|
||
);
|
||
provider.response = deferred();
|
||
const late = provider.requestImage(0, 0, 0, request);
|
||
h.rendering.clear();
|
||
assert.equal(cancelled, 1);
|
||
provider.response.resolve(image);
|
||
assert.equal(await late, image, 'closed frames do not process late images');
|
||
assert.equal(await stage, false);
|
||
});
|
||
|
||
test('regional tiles decoded as flipped ImageBitmaps are drawn back upright', async () => {
|
||
const hadBitmap = Object.hasOwn(globalThis, 'ImageBitmap');
|
||
const previous = globalThis.ImageBitmap;
|
||
globalThis.ImageBitmap = class ImageBitmap {
|
||
width = 256;
|
||
height = 256;
|
||
};
|
||
try {
|
||
const h = renderingHarness();
|
||
void h.rendering.setFrame(
|
||
{ ...snapshot, product: 'clouds-regional' },
|
||
times[0],
|
||
);
|
||
const provider = h.providers[0];
|
||
// Cesium decodes with imageOrientation 'flipY'; the canvas upload flips again.
|
||
provider.response = { promise: Promise.resolve(new ImageBitmap()) };
|
||
const bitmapTile = await provider.requestImage(0, 0, 0, {});
|
||
assert.deepEqual(bitmapTile.drawnWith, [1, 0, 0, -1, 0, 256]);
|
||
// An HTMLImageElement fallback is not pre-flipped.
|
||
provider.response = {
|
||
promise: Promise.resolve({ width: 256, height: 256 }),
|
||
};
|
||
const imageTile = await provider.requestImage(1, 0, 0, {});
|
||
assert.equal(imageTile.drawnWith, null);
|
||
h.rendering.clear();
|
||
} finally {
|
||
if (hadBitmap) globalThis.ImageBitmap = previous;
|
||
else delete globalThis.ImageBitmap;
|
||
}
|
||
});
|
||
|
||
for (const kind of ['globe']) {
|
||
test(`infrared mode restages the same time on ${kind}, retaining the old layer for one rendered frame`, async () => {
|
||
let host,
|
||
now = 0;
|
||
const h = renderingHarness({ getHost: () => host, now: () => now });
|
||
host = { collection: h.viewer.imageryLayers, kind };
|
||
const clouds = { ...snapshot, product: 'clouds' };
|
||
const first = h.rendering.setFrame(clouds, times[0]);
|
||
await flush();
|
||
await h.providers[0].requestImage(0, 0, 0);
|
||
now = 250;
|
||
h.settle();
|
||
await first;
|
||
const previous = h.layers[0];
|
||
assert.equal(await h.rendering.setFrame(clouds, times[0]), true);
|
||
assert.equal(h.providers.length, 1);
|
||
const full = h.rendering.setFrame(clouds, times[0], { infrared: 'full' });
|
||
await flush();
|
||
const tile = await h.providers[1].requestImage(0, 0, 0);
|
||
assert.deepEqual([...tile.source.pixels], [194, 100, 0, 200]);
|
||
now = 500;
|
||
h.settle();
|
||
assert.equal(await full, true);
|
||
assert.equal(h.layers.length, 2);
|
||
assert.equal(h.layers[1].alpha, 0.7);
|
||
assert.equal(previous.destroyed, undefined);
|
||
assert.equal(h.rendering.getDiagnostics().infrared, 'full');
|
||
h.postRender.emit();
|
||
assert.equal(h.layers.length, 1);
|
||
assert.equal(previous.destroyed, true);
|
||
h.rendering.clear();
|
||
assert.equal(h.postRender.size, 0);
|
||
});
|
||
}
|
||
|
||
test('satellite mode chips restage history without changing time or latest-follow intent', async () => {
|
||
const h = layerHarness({ id: 'weather-satellite' });
|
||
const update = h.layer.update();
|
||
await flush();
|
||
h.stages[0].finish();
|
||
await update;
|
||
h.layer.setParams({ step: -1 });
|
||
h.stages[1].finish();
|
||
await flush();
|
||
h.layer.setParams({ infrared: 'full' });
|
||
assert.equal(h.stages[2].time, times[1]);
|
||
assert.equal(h.stages[2].infrared, 0);
|
||
assert.equal(h.layer.getParams().infrared, 0);
|
||
assert.deepEqual(
|
||
h.layer
|
||
.getRowControls()
|
||
.chips.slice(0, 4)
|
||
.map((chip) => chip.label),
|
||
['N. America', 'Global', 'Clouds only', 'Full'],
|
||
);
|
||
h.stages[2].finish();
|
||
await flush();
|
||
assert.equal(h.layer.getDiagnostics().followLatest, false);
|
||
assert.equal(h.layer.getDiagnostics().time, times[1]);
|
||
h.layer.setParams({ infrared: 'invalid' });
|
||
assert.equal(h.layer.getParams().infrared, 0);
|
||
assert.equal(h.stages.length, 3);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('satellite cloud filter spans Full to Clouds only without changing layer opacity', () => {
|
||
const h = layerHarness({ id: 'weather-satellite' });
|
||
assert.equal(h.layer.getParams().infrared, 100);
|
||
assert.equal(h.layer.getParams().opacity, 'strong');
|
||
assert.equal(h.getAlpha(), 0.7);
|
||
const setting = h.layer
|
||
.getRowControls()
|
||
.summary.settings.find(({ id }) => id === 'image');
|
||
assert.equal(setting.range.param, 'infrared');
|
||
assert.equal(setting.range.value, 100);
|
||
assert.equal(setting.range.min, 0);
|
||
assert.equal(setting.range.max, 100);
|
||
assert.equal(setting.range.step, 1);
|
||
assert.equal(setting.range.commitOnChange, true);
|
||
|
||
const full = h.layer.getRowControls().chips.find(({ id }) => id === 'full');
|
||
h.layer.setParams(full.params);
|
||
assert.equal(h.layer.getParams().infrared, 0);
|
||
assert.equal(h.getAlpha(), 0.7);
|
||
assert.equal(
|
||
h.layer.getRowControls().chips.find(({ id }) => id === 'full').active,
|
||
true,
|
||
);
|
||
|
||
h.layer.setParams({ infrared: 53 });
|
||
assert.equal(h.layer.getParams().infrared, 53);
|
||
assert.equal(h.getAlpha(), 0.7, 'filter strength is not overall opacity');
|
||
assert.equal(
|
||
h.layer.getRowControls().summary.settings.find(({ id }) => id === 'image')
|
||
.range.value,
|
||
53,
|
||
);
|
||
h.layer.setParams({ opacity: 'light' });
|
||
assert.equal(h.layer.getParams().opacity, 'light');
|
||
assert.equal(
|
||
h.getAlpha(),
|
||
0.4,
|
||
'Soft remains the independent opacity preset',
|
||
);
|
||
h.layer.setParams({ infrared: 101 });
|
||
assert.equal(
|
||
h.layer.getParams().infrared,
|
||
53,
|
||
'invalid filter values are ignored',
|
||
);
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('a rapid third selection waits for retirement before installing, and clear cancels that wait', async () => {
|
||
for (const clear of [false, true]) {
|
||
const h = renderingHarness();
|
||
const first = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
await first;
|
||
const second = h.rendering.setFrame(snapshot, times[1]);
|
||
h.settle();
|
||
await second;
|
||
assert.equal(h.layers.length, 2);
|
||
const third = h.rendering.setFrame(snapshot, times[2]);
|
||
assert.equal(h.layers.length, 2);
|
||
assert.equal(
|
||
h.providers.length,
|
||
2,
|
||
'third provider waits for outgoing retirement',
|
||
);
|
||
if (clear) {
|
||
h.rendering.clear();
|
||
assert.equal(await third, false);
|
||
h.postRender.emit();
|
||
assert.equal(h.layers.length, 0);
|
||
assert.equal(h.postRender.size, 0);
|
||
} else {
|
||
h.postRender.emit();
|
||
assert.equal(h.layers.length, 2);
|
||
assert.equal(h.providers.length, 3);
|
||
h.settle();
|
||
assert.equal(await third, true);
|
||
h.postRender.emit();
|
||
assert.equal(h.layers.length, 1);
|
||
h.rendering.clear();
|
||
}
|
||
}
|
||
});
|
||
|
||
test('a delayed installation failure retains the replacement and does not throw from postRender', async () => {
|
||
const h = renderingHarness();
|
||
for (const time of times.slice(0, 2)) {
|
||
const stage = h.rendering.setFrame(snapshot, time);
|
||
h.settle();
|
||
assert.equal(await stage, true);
|
||
}
|
||
const third = h.rendering.setFrame(snapshot, times[2]);
|
||
h.viewer.imageryLayers.addImageryProvider = () => {
|
||
throw new Error('upload unavailable');
|
||
};
|
||
assert.doesNotThrow(() => h.postRender.emit());
|
||
assert.equal(await third, false);
|
||
assert.equal(h.layers.length, 1);
|
||
assert.equal(h.layers[0].alpha, 0.7);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[1]);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('one row steps every registered observation; missing frames hide and latest restores each product', async (t) => {
|
||
const clock = createWeatherClock();
|
||
const radar = layerHarness({ clock });
|
||
const satellite = layerHarness({
|
||
clock,
|
||
id: 'weather-satellite',
|
||
feed: {
|
||
getSnapshot: async () => ({
|
||
...snapshot,
|
||
product: 'clouds-regional',
|
||
times: [times[1]],
|
||
latest: times[1],
|
||
}),
|
||
},
|
||
});
|
||
t.after(() => {
|
||
radar.layer.destroy();
|
||
satellite.layer.destroy();
|
||
clock.destroy();
|
||
});
|
||
const updates = [radar.layer.update(), satellite.layer.update()];
|
||
await flush();
|
||
radar.stages.at(-1).finish();
|
||
satellite.stages.at(-1).finish();
|
||
await Promise.all(updates);
|
||
let satelliteChanges = 0;
|
||
satellite.layer.setRowControlsListener(() => satelliteChanges++);
|
||
const transport = (h) =>
|
||
h.layer
|
||
.getRowControls()
|
||
.chips.filter(({ id }) =>
|
||
['previous', 'play', 'next', 'latest'].includes(id),
|
||
);
|
||
radar.layer.setParams({ step: -1 });
|
||
await flush();
|
||
assert.equal(clock.getState().target, times[1]);
|
||
assert.equal(radar.stages.at(-1).time, times[1]);
|
||
assert.equal(satellite.stages.at(-1).time, times[1]);
|
||
radar.stages.at(-1).finish();
|
||
satellite.stages.at(-1).finish();
|
||
await flush();
|
||
assert.match(satellite.layer.getRowControls().summary.detail, /synced/);
|
||
assert.ok(satelliteChanges > 0);
|
||
assert.deepEqual(transport(radar), []);
|
||
assert.deepEqual(transport(satellite), []);
|
||
satellite.layer.setParams({ step: -1 });
|
||
await flush();
|
||
radar.stages.at(-1).finish();
|
||
await flush();
|
||
assert.equal(clock.getState().target, times[0]);
|
||
assert.equal(satellite.layer.getDiagnostics().hidden, true);
|
||
assert.match(
|
||
satellite.layer.getRowControls().summary.status,
|
||
/No frame within 30 min of 09-15 20:00 UTC/,
|
||
);
|
||
radar.layer.setParams({ step: 1 });
|
||
await flush();
|
||
radar.stages.at(-1).finish();
|
||
satellite.stages.at(-1).finish();
|
||
await flush();
|
||
assert.equal(satellite.layer.getDiagnostics().hidden, false);
|
||
radar.layer.setParams({ latest: true });
|
||
await flush();
|
||
radar.stages.at(-1).finish();
|
||
satellite.stages.at(-1).finish();
|
||
await flush();
|
||
assert.deepEqual(
|
||
[radar.layer.getDiagnostics().time, satellite.layer.getDiagnostics().time],
|
||
[times[2], times[1]],
|
||
);
|
||
assert.deepEqual(radar.layer.getDiagnostics().clock, {
|
||
mode: 'latest',
|
||
target: null,
|
||
playing: false,
|
||
});
|
||
assert.deepEqual(
|
||
radar.layer.getParams(),
|
||
{ opacity: 'strong' },
|
||
'history is never serialized',
|
||
);
|
||
satellite.layer.disable();
|
||
assert.equal(clock.getState().products.length, 1);
|
||
});
|
||
|
||
test('history manifest expiry hides imagery without jumping to latest; host resume keeps the target', async (t) => {
|
||
const clock = createWeatherClock();
|
||
let value = snapshot;
|
||
const h = layerHarness({ clock, feed: { getSnapshot: async () => value } });
|
||
t.after(() => {
|
||
h.layer.destroy();
|
||
clock.destroy();
|
||
});
|
||
let update = h.layer.update();
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await update;
|
||
const history = clock.setTarget(times[0]);
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await history;
|
||
value = { ...snapshot, times: [times[2]] };
|
||
await h.layer.update();
|
||
assert.equal(h.layer.getDiagnostics().hidden, true);
|
||
assert.equal(clock.getState().target, times[0]);
|
||
h.documentRef.hidden = true;
|
||
h.documentRef.emit('visibilitychange');
|
||
await flush();
|
||
assert.deepEqual(clock.getTimeline(), []);
|
||
h.documentRef.hidden = false;
|
||
h.documentRef.emit('visibilitychange');
|
||
await flush();
|
||
assert.equal(clock.getState().target, times[0]);
|
||
assert.equal(h.layer.getDiagnostics().hidden, true);
|
||
value = snapshot;
|
||
update = h.layer.update();
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await update;
|
||
assert.equal(h.layer.getDiagnostics().time, times[0]);
|
||
});
|
||
|
||
test('hidden renderer retains the frame without displaying it and rehome cannot reveal it', async () => {
|
||
const h = renderingHarness();
|
||
const first = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
await first;
|
||
const layer = h.layers[0];
|
||
const pending = h.rendering.setFrame(snapshot, times[1]);
|
||
h.rendering.setHidden(true);
|
||
assert.equal(await pending, false);
|
||
assert.equal(h.layers.length, 1);
|
||
assert.equal(h.layers[0], layer);
|
||
assert.equal(layer.show, false);
|
||
assert.equal(h.rendering.getDiagnostics().time, null);
|
||
h.rendering.rehome();
|
||
assert.equal(layer.show, false);
|
||
h.rendering.setHidden(false);
|
||
assert.equal(layer.show, true);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('satellite global selection uses the three-hour gap and preserves the shared target on product changes', async (t) => {
|
||
const clock = createWeatherClock();
|
||
const earlier = '2026-09-15T18:00:00.000Z';
|
||
const h = layerHarness({
|
||
clock,
|
||
id: 'weather-satellite',
|
||
feed: {
|
||
getSnapshot: async ({ product }) => ({
|
||
...snapshot,
|
||
product,
|
||
times: [earlier],
|
||
latest: earlier,
|
||
}),
|
||
},
|
||
});
|
||
t.after(() => {
|
||
h.layer.destroy();
|
||
clock.destroy();
|
||
});
|
||
const update = h.layer.update();
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await update;
|
||
await clock.setTarget(times[0]);
|
||
assert.equal(
|
||
h.layer.getDiagnostics().hidden,
|
||
true,
|
||
'two-hour regional gap is ineligible',
|
||
);
|
||
h.layer.setParams({ product: 'clouds' });
|
||
await flush();
|
||
assert.equal(h.stages.at(-1).time, earlier);
|
||
h.stages.at(-1).finish();
|
||
await flush();
|
||
assert.equal(clock.getState().target, times[0]);
|
||
assert.equal(h.layer.getDiagnostics().hidden, false);
|
||
assert.match(h.layer.getRowControls().summary.detail, /18:00 UTC.*nearest/);
|
||
const params = h.layer.getParams();
|
||
assert.equal(params.product, 'clouds');
|
||
assert.equal(params.target, undefined);
|
||
});
|
||
|
||
test('switching to history cancels a still-loading latest refresh and a later target cancels the first history load', async (t) => {
|
||
const clock = createWeatherClock();
|
||
const h = layerHarness({ clock });
|
||
t.after(() => {
|
||
h.layer.destroy();
|
||
clock.destroy();
|
||
});
|
||
const update = h.layer.update();
|
||
await flush();
|
||
const latest = h.stages.at(-1);
|
||
const oldHistory = clock.setTarget(times[0]);
|
||
await flush();
|
||
assert.equal(latest.signal.aborted, true);
|
||
const oldStage = h.stages.at(-1);
|
||
const current = clock.setTarget(times[1]);
|
||
await flush();
|
||
assert.equal(oldStage.signal.aborted, true);
|
||
h.stages.at(-1).finish();
|
||
await current;
|
||
latest.finish();
|
||
oldStage.finish();
|
||
await oldHistory;
|
||
await update;
|
||
assert.equal(h.layer.getDiagnostics().time, times[1]);
|
||
assert.equal(h.layer.getDiagnostics().clock.target, times[1]);
|
||
});
|
||
|
||
test('observed descriptors keep configuration only and label satellite clouds by coverage', () => {
|
||
for (const [id, coverage] of [
|
||
['weather-radar', 'CONUS'],
|
||
['weather-satellite', 'North America'],
|
||
['weather-lightning', 'Americas + Pacific'],
|
||
]) {
|
||
const h = layerHarness({ id });
|
||
const controls = h.layer.getRowControls();
|
||
assert.equal(controls.readout, true);
|
||
assert.equal(controls.summary.coverage, coverage);
|
||
assert.equal(controls.summary.sections, undefined);
|
||
assert.deepEqual(
|
||
controls.summary.settings.map(({ label }) => label),
|
||
id === 'weather-satellite' ? ['REGION', 'IMAGE', 'OPACITY'] : ['OPACITY'],
|
||
);
|
||
assert.deepEqual(
|
||
controls.summary.settings.flatMap(({ chips }) => chips),
|
||
controls.chips.filter(({ id }) => id !== 'coverage'),
|
||
);
|
||
assert.deepEqual(controls.summary.actions, [
|
||
controls.chips.find(({ id }) => id === 'coverage'),
|
||
]);
|
||
assert.deepEqual(controls.summary.actions[0].params, { focus: true });
|
||
assert.equal(
|
||
controls.chips.some(({ id }) =>
|
||
['previous', 'play', 'next', 'latest'].includes(id),
|
||
),
|
||
false,
|
||
);
|
||
if (id === 'weather-satellite') {
|
||
assert.equal(h.layer.name, 'Satellite clouds');
|
||
assert.equal(controls.summary.label, 'Satellite clouds');
|
||
assert.match(
|
||
controls.infoTitle,
|
||
/GOES-19\/18 longwave infrared Band 14 regional; NESDIS global longwave mosaic/,
|
||
);
|
||
assert.equal(
|
||
controls.chips.find(({ id }) => id === 'filtered').title,
|
||
'Apply the full cloud brightness key; 100% filter strength',
|
||
);
|
||
const imageSetting = controls.summary.settings.find(
|
||
({ id }) => id === 'image',
|
||
);
|
||
assert.equal(imageSetting.range.param, 'infrared');
|
||
assert.equal(imageSetting.range.value, 100);
|
||
assert.equal(imageSetting.range.commitOnChange, true);
|
||
h.layer.setParams({ product: 'clouds' });
|
||
assert.equal(
|
||
h.layer.getRowControls().summary.coverage,
|
||
'Global · 60°S–60°N',
|
||
);
|
||
assert.equal(h.layer.getRowControls().summary.maxGapMinutes, 180);
|
||
}
|
||
h.layer.destroy();
|
||
}
|
||
});
|
||
|
||
const globalSnapshot = { ...snapshot, product: 'clouds' };
|
||
async function showMosaic(h, time, infrared = 'filtered') {
|
||
const pending = h.rendering.setFrame(globalSnapshot, time, { infrared });
|
||
await flush();
|
||
h.settle();
|
||
assert.equal(await pending, true);
|
||
h.settle();
|
||
}
|
||
|
||
test('mosaic cache skips fetch and decode, separates modes, evicts LRU at 6 and clears per instance', async (t) => {
|
||
let fetches = 0,
|
||
decodes = 0;
|
||
const h = renderingHarness({
|
||
fetchImpl: async () => {
|
||
fetches++;
|
||
return mockResponse();
|
||
},
|
||
decodeImage: async () => {
|
||
decodes++;
|
||
return { width: 2048, height: 1024 };
|
||
},
|
||
});
|
||
t.after(() => h.rendering.clear());
|
||
await showMosaic(h, times[0]);
|
||
await showMosaic(h, times[1]);
|
||
await showMosaic(h, times[0]);
|
||
assert.equal(fetches, 2);
|
||
assert.equal(decodes, 2);
|
||
assert.deepEqual(h.rendering.getDiagnostics().mosaic, {
|
||
fetched: false,
|
||
cached: true,
|
||
decodeMs: 0,
|
||
});
|
||
await showMosaic(h, times[0], 'full');
|
||
assert.equal(fetches, 3);
|
||
assert.equal(h.rendering.getDiagnostics().mosaic.cached, false);
|
||
await showMosaic(h, times[0]);
|
||
const extra = Array.from({ length: 4 }, (_, i) =>
|
||
new Date(Date.parse(times[2]) + i * 3600_000).toISOString(),
|
||
);
|
||
for (const time of extra) await showMosaic(h, time);
|
||
assert.deepEqual(h.rendering.getDiagnostics().cache, {
|
||
mosaics: 6,
|
||
prefetching: false,
|
||
});
|
||
await showMosaic(h, times[0]);
|
||
assert.equal(
|
||
fetches,
|
||
7,
|
||
'touching the oldest frame retained it ahead of the second frame',
|
||
);
|
||
await showMosaic(h, times[1]);
|
||
assert.equal(fetches, 8, 'least recently used frame was evicted');
|
||
h.rendering.clear();
|
||
assert.deepEqual(h.rendering.getDiagnostics().cache, {
|
||
mosaics: 0,
|
||
prefetching: false,
|
||
});
|
||
await showMosaic(h, times[0]);
|
||
assert.equal(fetches, 9);
|
||
const other = renderingHarness({
|
||
fetchImpl: async () => {
|
||
fetches++;
|
||
return mockResponse();
|
||
},
|
||
});
|
||
t.after(() => other.rendering.clear());
|
||
await showMosaic(other, times[0]);
|
||
assert.equal(fetches, 10, 'instances do not share canvases');
|
||
});
|
||
|
||
test('global prefetch warms a decoded frame without staging imagery and hits on selection', async (t) => {
|
||
let fetches = 0;
|
||
const h = renderingHarness({
|
||
fetchImpl: async () => {
|
||
fetches++;
|
||
return mockResponse();
|
||
},
|
||
});
|
||
t.after(() => h.rendering.clear());
|
||
await showMosaic(h, times[0]);
|
||
const warm = h.rendering.prefetch(globalSnapshot, times[1]);
|
||
assert.equal(h.rendering.getDiagnostics().cache.prefetching, true);
|
||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||
assert.equal(h.layers.length, 1);
|
||
assert.equal(await warm, true);
|
||
await showMosaic(h, times[1]);
|
||
assert.equal(fetches, 2);
|
||
assert.equal(h.rendering.getDiagnostics().mosaic.cached, true);
|
||
assert.equal(h.rendering.getDiagnostics().mosaic.decodeMs, 0);
|
||
});
|
||
|
||
test('cancelled or cleared speculative decodes cannot repopulate the cache', async () => {
|
||
for (const cancel of ['cancelPrefetch', 'clear', 'setHidden']) {
|
||
const decoded = deferred();
|
||
let signal,
|
||
closes = 0;
|
||
const h = renderingHarness({
|
||
fetchImpl: async (_url, options) => {
|
||
signal = options.signal;
|
||
return mockResponse();
|
||
},
|
||
decodeImage: () => decoded.promise,
|
||
});
|
||
const warm = h.rendering.prefetch(globalSnapshot, times[0]);
|
||
await flush();
|
||
h.rendering[cancel](true);
|
||
assert.equal(signal.aborted, true);
|
||
decoded.resolve({
|
||
width: 2048,
|
||
height: 1024,
|
||
close() {
|
||
closes++;
|
||
},
|
||
});
|
||
assert.equal(await warm, false);
|
||
assert.equal(closes, 1);
|
||
assert.deepEqual(h.rendering.getDiagnostics().cache, {
|
||
mosaics: 0,
|
||
prefetching: false,
|
||
});
|
||
h.rendering.clear();
|
||
}
|
||
});
|
||
|
||
test('tiled prefetch covers only visible product bounds at levels 0/1, caps eight requests and drains bodies', async (t) => {
|
||
const calls = [];
|
||
let bodies = 0;
|
||
const h = renderingHarness({
|
||
fetchImpl: async (url, { signal }) => {
|
||
calls.push({ url: new URL(url, 'http://localhost'), signal });
|
||
return {
|
||
...mockResponse(),
|
||
arrayBuffer: async () => {
|
||
bodies++;
|
||
return new ArrayBuffer(1);
|
||
},
|
||
};
|
||
},
|
||
});
|
||
t.after(() => h.rendering.clear());
|
||
h.viewer.camera = {
|
||
computeViewRectangle: () =>
|
||
Cesium.Rectangle.fromDegrees(-120, 25, -100, 50),
|
||
};
|
||
assert.equal(await h.rendering.prefetch(snapshot, times[1]), true);
|
||
assert.equal(calls.length, 2);
|
||
assert.equal(bodies, 2);
|
||
assert.deepEqual(
|
||
calls.map(({ url }) =>
|
||
['z', 'x', 'y'].map((key) => url.searchParams.get(key)),
|
||
),
|
||
[
|
||
['0', '0', '0'],
|
||
['1', '0', '0'],
|
||
],
|
||
);
|
||
assert.ok(
|
||
calls.every(({ url }) => url.searchParams.get('time') === times[1]),
|
||
);
|
||
assert.equal(
|
||
await h.rendering.prefetch(snapshot, times[1]),
|
||
false,
|
||
'same completed work is not repeated',
|
||
);
|
||
h.viewer.camera.computeViewRectangle = () =>
|
||
Cesium.Rectangle.fromDegrees(100, 25, 120, 50);
|
||
await h.rendering.prefetch(snapshot, times[2]);
|
||
assert.equal(calls.length, 2, 'view outside product bounds fetches nothing');
|
||
h.viewer.camera.computeViewRectangle = () => Cesium.Rectangle.MAX_VALUE;
|
||
const world = {
|
||
...snapshot,
|
||
bounds: { west: -180, south: -90, east: 180, north: 90 },
|
||
};
|
||
await h.rendering.prefetch(world, times[2]);
|
||
assert.equal(
|
||
calls.length,
|
||
10,
|
||
'world view is capped at eight additional requests',
|
||
);
|
||
assert.equal(bodies, 10);
|
||
assert.equal(new Set(calls.slice(2).map(({ url }) => url.href)).size, 8);
|
||
});
|
||
|
||
test('prefetch is best effort, aborts on replacement or host suspension, and skips hidden frames', async (t) => {
|
||
let host = { collection: null, kind: 'globe' };
|
||
const signals = [];
|
||
const h = renderingHarness({
|
||
getHost: () => host,
|
||
fetchImpl: (_url, { signal }) =>
|
||
new Promise((_, reject) => {
|
||
signals.push(signal);
|
||
signal.addEventListener('abort', () => reject(signal.reason), {
|
||
once: true,
|
||
});
|
||
}),
|
||
});
|
||
host.collection = h.viewer.imageryLayers;
|
||
t.after(() => h.rendering.clear());
|
||
const first = h.rendering.prefetch(snapshot, times[1]);
|
||
const shown = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
assert.equal(
|
||
await shown,
|
||
true,
|
||
'current frame never waits for speculative work',
|
||
);
|
||
assert.equal(await first, false);
|
||
assert.ok(signals.every((signal) => signal.aborted));
|
||
const second = h.rendering.prefetch(snapshot, times[1]);
|
||
host = { collection: null, kind: 'none' };
|
||
h.rendering.rehome();
|
||
assert.equal(await second, false);
|
||
const count = signals.length;
|
||
assert.equal(await h.rendering.prefetch(snapshot, times[2]), false);
|
||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||
h.rendering.setHidden(true);
|
||
assert.equal(await h.rendering.prefetch(snapshot, times[2]), false);
|
||
assert.equal(signals.length, count);
|
||
assert.equal(h.rendering.getDiagnostics().cache.prefetching, false);
|
||
});
|
||
|
||
test('failed prefetch leaves the current frame and errors unchanged and releases its deadline', async (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const h = renderingHarness({
|
||
fetchImpl: async () => {
|
||
throw new Error('offline');
|
||
},
|
||
});
|
||
t.after(() => h.rendering.clear());
|
||
const shown = h.rendering.setFrame(snapshot, times[0]);
|
||
h.settle();
|
||
await shown;
|
||
const before = h.rendering.getDiagnostics();
|
||
assert.equal(await h.rendering.prefetch(snapshot, times[1]), false);
|
||
assert.deepEqual(h.rendering.getDiagnostics(), before);
|
||
t.mock.timers.tick(30_000);
|
||
assert.deepEqual(h.rendering.getDiagnostics(), before);
|
||
});
|
||
|
||
test('layer warms the next advertised observation only after a successful playing frame, wrapping at the end', async (t) => {
|
||
const clock = createWeatherClock();
|
||
const h = layerHarness({ clock });
|
||
const warmed = [];
|
||
let cancels = 0;
|
||
h.rendering.prefetch = async (manifest, time, options) => {
|
||
warmed.push({ manifest, time, options });
|
||
};
|
||
h.rendering.cancelPrefetch = () => {
|
||
cancels++;
|
||
};
|
||
t.after(() => {
|
||
h.layer.destroy();
|
||
clock.destroy();
|
||
});
|
||
const updated = h.layer.update();
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await updated;
|
||
assert.equal(warmed.length, 0);
|
||
const play = clock.play();
|
||
await flush();
|
||
assert.equal(warmed.length, 0, 'still staging');
|
||
h.stages.at(-1).finish();
|
||
await play;
|
||
assert.deepEqual(
|
||
warmed.map(({ time }) => time),
|
||
[times[0]],
|
||
);
|
||
assert.deepEqual(warmed[0].options, { infrared: 100 });
|
||
const next = clock.setTarget(times[0]);
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await next;
|
||
assert.deepEqual(
|
||
warmed.map(({ time }) => time),
|
||
[times[0], times[1]],
|
||
);
|
||
const failed = clock.setTarget(times[1]);
|
||
await flush();
|
||
h.stages.at(-1).finish(false);
|
||
await failed;
|
||
assert.equal(warmed.length, 2);
|
||
const priorCancels = cancels;
|
||
clock.pause();
|
||
assert.ok(cancels > priorCancels);
|
||
const paused = clock.setTarget(times[2]);
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await paused;
|
||
assert.equal(warmed.length, 2);
|
||
await clock.play();
|
||
h.documentRef.hidden = true;
|
||
h.documentRef.emit('visibilitychange');
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await flush();
|
||
assert.equal(warmed.length, 2, 'hidden products do not prefetch');
|
||
});
|
||
|
||
for (const product of ['radar', 'clouds-regional', 'lightning']) {
|
||
test(`${product} on the globe host uses 256 px tiles to level 6`, async (t) => {
|
||
const collection = new ImageryLayerCollection();
|
||
const h = renderingHarness({
|
||
getHost: () => ({ collection, kind: 'globe' }),
|
||
});
|
||
t.after(() => h.rendering.clear());
|
||
h.viewer.camera = {
|
||
moveEnd: event(),
|
||
positionCartographic: { height: 60_000 },
|
||
};
|
||
const pending = h.rendering.setFrame({ ...snapshot, product }, times[0]);
|
||
const options = h.providers[0].options;
|
||
assert.equal(options.tileWidth, 256);
|
||
assert.equal(options.tileHeight, 256);
|
||
assert.equal(options.maximumLevel, 6);
|
||
assert.equal(
|
||
new URL(options.url, 'https://example.test').searchParams.get('size'),
|
||
'256',
|
||
);
|
||
assert.equal(h.rendering.getDiagnostics().host, 'globe');
|
||
h.rendering.clear();
|
||
assert.equal(await pending, false);
|
||
assert.equal(h.viewer.camera.moveEnd.size, 0);
|
||
});
|
||
}
|
||
|
||
test('a product replacement accepts supersession but never paints the obsolete first response', async () => {
|
||
const pending = [];
|
||
const h = layerHarness({
|
||
id: 'weather-satellite',
|
||
feed: {
|
||
getSnapshot: (args) => {
|
||
const task = deferred();
|
||
pending.push({ ...args, ...task });
|
||
return task.promise;
|
||
},
|
||
},
|
||
});
|
||
const first = h.layer.update();
|
||
h.layer.setParams({ product: 'clouds' });
|
||
assert.equal(pending.length, 2);
|
||
pending[0].resolve({ ...snapshot, product: 'clouds-regional' });
|
||
assert.equal(await first, true);
|
||
assert.equal(h.stages.length, 0);
|
||
pending[1].resolve({ ...snapshot, product: 'clouds' });
|
||
await flush();
|
||
h.stages.at(-1).finish();
|
||
await flush();
|
||
assert.equal(h.layer.getParams().product, 'clouds');
|
||
h.layer.destroy();
|
||
});
|
||
|
||
test('disabled weather releases its camera listener and re-enabling binds only once', () => {
|
||
const h = layerHarness();
|
||
h.layer.disable();
|
||
assert.equal(h.moveEnd.size, 0, 'disabled layers own no active camera work');
|
||
h.layer.enable();
|
||
h.layer.enable();
|
||
assert.equal(h.moveEnd.size, 1);
|
||
h.layer.disable();
|
||
assert.equal(h.moveEnd.size, 0);
|
||
h.layer.enable();
|
||
assert.equal(h.moveEnd.size, 1);
|
||
h.layer.destroy();
|
||
assert.equal(h.moveEnd.size, 0);
|
||
});
|
||
|
||
const suppliedTile = (size = 256) => ({
|
||
width: size,
|
||
height: size,
|
||
closes: 0,
|
||
close() {
|
||
this.closes++;
|
||
},
|
||
});
|
||
|
||
test('a frame source supplies regional tiles in place of the tile route, through the readiness wrapper', async () => {
|
||
let now = 0;
|
||
const requests = [];
|
||
const supplied = [];
|
||
const h = renderingHarness({
|
||
now: () => now,
|
||
fetchImpl: () => assert.fail('supplied tiles are not fetched'),
|
||
frameSource: {
|
||
getTile: async (request) => {
|
||
requests.push(request);
|
||
const tile = suppliedTile();
|
||
supplied.push(tile);
|
||
return tile;
|
||
},
|
||
},
|
||
});
|
||
h.viewer.scene.globe.tilesLoaded = false;
|
||
const loaded = h.rendering.setFrame(snapshot, times[0]);
|
||
assert.equal(h.providers.length, 1);
|
||
const [provider] = h.providers;
|
||
assert.equal(provider.options, undefined, 'no URL template provider');
|
||
assert.equal(provider.maximumLevel, 6);
|
||
const tile = await provider.requestImage(1, 0, 1, {});
|
||
assert.equal(tile.width, 256);
|
||
assert.equal(tile.source, supplied[0]);
|
||
assert.equal(supplied[0].closes, 1);
|
||
assert.equal(requests[0].product, 'radar');
|
||
assert.equal(requests[0].time, times[0]);
|
||
assert.deepEqual(
|
||
[requests[0].z, requests[0].x, requests[0].y, requests[0].size],
|
||
[1, 1, 0, 256],
|
||
);
|
||
assert.equal(h.rendering.getDiagnostics().loadedTiles, 1);
|
||
now = 500;
|
||
h.settle();
|
||
assert.equal(await loaded, true);
|
||
|
||
const gate = deferred();
|
||
let signal;
|
||
const next = renderingHarness({
|
||
frameSource: {
|
||
getTile: (request) => {
|
||
signal = request.signal;
|
||
return gate.promise;
|
||
},
|
||
},
|
||
});
|
||
const staged = next.rendering.setFrame(snapshot, times[1]);
|
||
const pending = next.providers[0].requestImage(0, 0, 0, {});
|
||
next.rendering.clear();
|
||
assert.equal(signal.aborted, true, 'clearing a frame aborts its tiles');
|
||
const late = suppliedTile();
|
||
gate.resolve(late);
|
||
await assert.rejects(pending, { name: 'AbortError' });
|
||
assert.equal(late.closes, 1);
|
||
assert.equal(await staged, false);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('a failed supplied tile fails the staged frame through errorEvent', async () => {
|
||
const h = renderingHarness({
|
||
frameSource: {
|
||
getTile: async () => {
|
||
throw new Error('frame unavailable');
|
||
},
|
||
},
|
||
});
|
||
const staged = h.rendering.setFrame(snapshot, times[0]);
|
||
const [provider] = h.providers;
|
||
await assert.rejects(provider.requestImage(0, 0, 0, {}));
|
||
provider.errorEvent.raiseEvent({ x: 0, y: 0, level: 0, error: {} });
|
||
h.settle();
|
||
assert.equal(await staged, false);
|
||
assert.match(h.rendering.getDiagnostics().error, /Weather tiles unavailable/);
|
||
h.rendering.clear();
|
||
});
|
||
|
||
test('supplied regional infrared tiles are canvases, so they get the transfer without a flip', async () => {
|
||
const hadBitmap = Object.hasOwn(globalThis, 'ImageBitmap');
|
||
const previous = globalThis.ImageBitmap;
|
||
globalThis.ImageBitmap = class ImageBitmap {
|
||
width = 256;
|
||
height = 256;
|
||
close() {}
|
||
};
|
||
try {
|
||
const h = renderingHarness({
|
||
frameSource: { getTile: async () => new globalThis.ImageBitmap() },
|
||
});
|
||
void h.rendering.setFrame(
|
||
{ ...snapshot, product: 'clouds-regional' },
|
||
times[0],
|
||
);
|
||
const tile = await h.providers[0].requestImage(0, 0, 0, {});
|
||
assert.equal(tile.drawnWith, null, 'drawn upright, not flipped');
|
||
assert.ok(tile.pixels, 'the infrared transfer ran');
|
||
const empty = renderingHarness({
|
||
frameSource: { getTile: async () => null },
|
||
});
|
||
void empty.rendering.setFrame(
|
||
{ ...snapshot, product: 'clouds-regional' },
|
||
times[0],
|
||
);
|
||
const transparent = await empty.providers[0].requestImage(0, 0, 0, {});
|
||
assert.equal(transparent.width, 256, 'a null tile is still a canvas');
|
||
h.rendering.clear();
|
||
empty.rendering.clear();
|
||
} finally {
|
||
if (hadBitmap) globalThis.ImageBitmap = previous;
|
||
else delete globalThis.ImageBitmap;
|
||
}
|
||
});
|
||
|
||
test('tiled prefetch asks the frame source for the same level 0/1 tiles and releases them', async (t) => {
|
||
const requests = [];
|
||
const supplied = [];
|
||
const h = renderingHarness({
|
||
fetchImpl: () => assert.fail('supplied tiles are not fetched'),
|
||
frameSource: {
|
||
getTile: async (request) => {
|
||
requests.push(request);
|
||
if (request.z === 0) return null;
|
||
const tile = suppliedTile();
|
||
supplied.push(tile);
|
||
return tile;
|
||
},
|
||
},
|
||
});
|
||
t.after(() => h.rendering.clear());
|
||
h.viewer.camera = {
|
||
computeViewRectangle: () =>
|
||
Cesium.Rectangle.fromDegrees(-120, 25, -100, 50),
|
||
};
|
||
assert.equal(await h.rendering.prefetch(snapshot, times[1]), true);
|
||
assert.deepEqual(
|
||
requests.map(({ product, time, z, x, y, size }) => [
|
||
product,
|
||
time,
|
||
z,
|
||
x,
|
||
y,
|
||
size,
|
||
]),
|
||
[
|
||
['radar', times[1], 0, 0, 0, 256],
|
||
['radar', times[1], 1, 0, 0, 256],
|
||
],
|
||
);
|
||
assert.ok(requests.every(({ signal }) => signal instanceof AbortSignal));
|
||
assert.equal(supplied[0].closes, 1);
|
||
assert.equal(
|
||
await h.rendering.prefetch(snapshot, times[1]),
|
||
false,
|
||
'same completed work is not repeated',
|
||
);
|
||
assert.equal(requests.length, 2);
|
||
|
||
const gate = deferred();
|
||
let signal;
|
||
const slow = renderingHarness({
|
||
frameSource: {
|
||
getTile: ({ signal: value }) => {
|
||
signal = value;
|
||
return gate.promise;
|
||
},
|
||
},
|
||
});
|
||
t.after(() => slow.rendering.clear());
|
||
slow.viewer.camera = h.viewer.camera;
|
||
const warm = slow.rendering.prefetch(snapshot, times[1]);
|
||
slow.rendering.cancelPrefetch();
|
||
assert.equal(signal.aborted, true, 'cancelling a prefetch aborts its tiles');
|
||
gate.resolve(null);
|
||
assert.equal(await warm, false);
|
||
});
|
||
|
||
test('the global mosaic comes from the frame source image when present', async (t) => {
|
||
const requests = [];
|
||
const h = renderingHarness({
|
||
fetchImpl: () => assert.fail('a supplied mosaic is not fetched'),
|
||
decodeImage: () => assert.fail('a supplied mosaic is not decoded'),
|
||
frameSource: {
|
||
getImage: async (request) => {
|
||
requests.push(request);
|
||
return { width: 2048, height: 1024, close() {} };
|
||
},
|
||
},
|
||
});
|
||
t.after(() => h.rendering.clear());
|
||
await showMosaic(h, times[0]);
|
||
assert.equal(requests.length, 1);
|
||
assert.equal(requests[0].product, 'clouds');
|
||
assert.deepEqual(requests[0].size, { width: 2048, height: 1024 });
|
||
assert.equal(requests[0].bbox, null);
|
||
assert.equal(h.rendering.getDiagnostics().mosaic.fetched, true);
|
||
});
|
||
|
||
test('the layer hands rendering a frame source only when its feed is one', () => {
|
||
const seen = [];
|
||
const createRendering = (args) => {
|
||
seen.push(args.frameSource);
|
||
return {
|
||
setAlpha() {},
|
||
rehome() {},
|
||
clear() {},
|
||
getDiagnostics: () => ({}),
|
||
};
|
||
};
|
||
const options = {
|
||
documentRef: target({ hidden: false }),
|
||
eventTarget: target(),
|
||
matchMedia: () => target({ matches: false }),
|
||
createRendering,
|
||
};
|
||
createWeatherLayer({
|
||
...options,
|
||
feed: { getSnapshot: async () => snapshot },
|
||
}).init({});
|
||
const getFrameTile = async () => null;
|
||
createWeatherLayer({
|
||
...options,
|
||
feed: { getSnapshot: async () => snapshot, getFrameTile },
|
||
}).init({});
|
||
assert.equal(seen[0], null);
|
||
assert.equal(typeof seen[1].getTile, 'function');
|
||
assert.equal(seen[1].getImage, undefined);
|
||
});
|