Files
gods-eye-view/src/layers/weather/infraredImage.test.mjs
T
Sameh Khamis e18353f769 feat(weather): a host can supply decoded frames to the weather layers
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.
2026-11-10 21:54:08 -08:00

338 lines
9.7 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import {
acquireInfraredMosaic,
acquireWeatherImage,
decodeInfraredImage,
processInfraredImage,
MAX_MOSAIC_BYTES,
} from './infraredImage.js';
function canvas() {
const output = {};
output.getContext = () => ({
setTransform: (...matrix) => {
output.transforms = [...(output.transforms ?? []), matrix];
},
drawImage: (image) => {
output.image = image;
output.drawnWith = output.transforms?.at(-1) ?? null;
},
getImageData: () => ({ data: new Uint8ClampedArray([194, 0, 0, 200]) }),
putImageData: (pixels) => {
output.pixels = pixels.data;
},
});
return output;
}
test('decoded pixels are processed once on a same-sized canvas', () => {
const image = { width: 1, height: 1 };
const output = processInfraredImage(image, 'filtered', canvas);
assert.equal(output.width, 1);
assert.equal(output.height, 1);
assert.equal(output.image, image);
assert.deepEqual([...output.pixels], [194, 0, 0, 98]);
assert.deepEqual(
[...processInfraredImage(image, 50, canvas).pixels],
[194, 0, 0, 149],
'half-strength filter retains a midpoint haze',
);
assert.deepEqual(
[...processInfraredImage(image, 0, canvas).pixels],
[194, 0, 0, 200],
);
assert.deepEqual(
[...processInfraredImage(image, 'full', canvas).pixels],
[194, 0, 0, 200],
);
});
test('flipY draws a bottom-up image upright, then restores the transform', () => {
const image = { width: 4, height: 8 };
assert.equal(processInfraredImage(image, 'full', canvas).drawnWith, null);
const output = processInfraredImage(image, 'full', canvas, { flipY: true });
assert.deepEqual(output.drawnWith, [1, 0, 0, -1, 0, 8]);
assert.deepEqual(output.transforms.at(-1), [1, 0, 0, 1, 0, 0]);
});
test('mosaic fetch is capped at 4 MiB, forwards cancellation, and releases decoded images', async () => {
const controller = new AbortController();
let closes = 0,
fetches = 0,
clock = 10,
fetched = false;
const options = {
signal: controller.signal,
mode: 'filtered',
createCanvas: canvas,
now: () => clock,
onFetched: () => {
fetched = true;
},
fetchImpl: async (url, { signal }) => {
fetches++;
assert.match(url, /^\/api\/weather\/image\?product=clouds&time=/);
assert.equal(signal, controller.signal);
return new Response(new Uint8Array([1, 2, 3]));
},
decodeImage: async (blob) => {
assert.equal(fetched, true);
assert.equal(blob.size, 3);
assert.equal(blob.type, 'image/png');
clock = 25;
return {
width: 2048,
height: 1024,
close() {
closes++;
},
};
},
};
const result = await acquireInfraredMosaic(
'2026-09-15T20:00:00.000Z',
options,
);
assert.equal(fetches, 1);
assert.equal(closes, 1);
assert.equal(result.decodeMs, 15);
assert.equal(result.texture.width, 2048);
for (const response of [
new Response('', {
headers: { 'content-length': String(MAX_MOSAIC_BYTES + 1) },
}),
new Response(new Uint8Array(MAX_MOSAIC_BYTES + 1)),
]) {
await assert.rejects(
acquireInfraredMosaic('2026-09-15', {
...options,
fetchImpl: async () => response,
decodeImage: () => assert.fail('oversized image must not decode'),
}),
{ code: 'RESPONSE_TOO_LARGE' },
);
}
await assert.rejects(
acquireInfraredMosaic('2026-09-15', {
...options,
decodeImage: async () => {
controller.abort();
return {
width: 2048,
height: 1024,
close() {
closes++;
},
};
},
}),
{ name: 'AbortError' },
);
assert.equal(closes, 2);
});
test('bitmap decoding and Image fallback release resources on success, error and abort', async (t) => {
const original = Object.getOwnPropertyDescriptor(
globalThis,
'createImageBitmap',
);
t.after(() => {
if (original)
Object.defineProperty(globalThis, 'createImageBitmap', original);
else delete globalThis.createImageBitmap;
});
const bitmap = {};
globalThis.createImageBitmap = async () => bitmap;
assert.equal(
await decodeInfraredImage(new Blob(), new AbortController().signal),
bitmap,
);
globalThis.createImageBitmap = undefined;
const images = [],
revoked = [];
const originalImage = globalThis.Image;
globalThis.Image = class {
constructor() {
images.push(this);
}
};
t.after(() => {
if (originalImage) globalThis.Image = originalImage;
else delete globalThis.Image;
});
t.mock.method(URL, 'createObjectURL', () => 'blob:test');
t.mock.method(URL, 'revokeObjectURL', (url) => revoked.push(url));
for (const action of ['load', 'error', 'abort']) {
const controller = new AbortController();
const pending = decodeInfraredImage(new Blob(), controller.signal);
const image = images.at(-1);
assert.equal(image.src, 'blob:test');
if (action === 'load') {
image.onload();
assert.equal(await pending, image);
} else if (action === 'error') {
image.onerror();
await assert.rejects(pending, /decode failed/);
} else {
controller.abort();
await assert.rejects(pending, { name: 'AbortError' });
assert.equal(image.src, '');
}
assert.equal(image.onload, null);
assert.equal(image.onerror, null);
}
assert.deepEqual(revoked, ['blob:test', 'blob:test', 'blob:test']);
});
const pixels = (width, height) => ({
width,
height,
closes: 0,
close() {
this.closes++;
},
});
test('a frame source supplies the image: nothing is fetched or decoded and the pixels are released', async () => {
const controller = new AbortController();
const requests = [];
const bitmap = pixels(2048, 1024);
let clock = 5,
fetched = false;
const result = await acquireInfraredMosaic('2026-09-15T20:00:00.000Z', {
signal: controller.signal,
mode: 'filtered',
createCanvas: canvas,
now: () => clock,
onFetched: () => {
fetched = true;
},
fetchImpl: () => assert.fail('a supplied frame is not fetched'),
decodeImage: () => assert.fail('a supplied frame is not decoded'),
frameSource: {
getImage: async (request) => {
requests.push(request);
clock = 12;
return bitmap;
},
},
});
assert.deepEqual(requests, [
{
product: 'clouds',
time: '2026-09-15T20:00:00.000Z',
size: { width: 2048, height: 1024 },
bbox: null,
signal: controller.signal,
},
]);
assert.equal(fetched, true);
assert.equal(result.decodeMs, 7);
assert.equal(result.texture.width, 2048);
assert.equal(result.texture.height, 1024);
assert.equal(result.texture.image, bitmap);
assert.deepEqual(
[...result.texture.pixels],
[194, 0, 0, 98],
'infrared frames get the display transfer',
);
assert.equal(bitmap.closes, 1);
});
test('supplied detail windows carry their bbox; ImageData is put, radar keeps its pixels', async (t) => {
const had = Object.hasOwn(globalThis, 'ImageData');
const previous = globalThis.ImageData;
globalThis.ImageData = class ImageData {
width = 4096;
height = 2048;
data = new Uint8ClampedArray([1, 2, 3, 4]);
};
t.after(() => {
if (had) globalThis.ImageData = previous;
else delete globalThis.ImageData;
});
const data = new globalThis.ImageData();
const bbox = { west: -102, south: 34, east: -96, north: 37 };
let request;
const { texture } = await acquireWeatherImage('radar', 't', {
signal: new AbortController().signal,
size: { width: 4096, height: 2048 },
bbox,
createCanvas: canvas,
fetchImpl: () => assert.fail('no fetch'),
frameSource: {
getImage: async (value) => {
request = value;
return data;
},
},
});
assert.equal(request.bbox, bbox);
assert.equal(
texture.pixels,
data.data,
'ImageData is put as it is; radar has no transfer',
);
assert.equal(texture.image, undefined, 'ImageData is not drawn as an image');
assert.equal(texture.width, 4096);
});
test('a supplied frame of the wrong size is refused and still released', async () => {
const wrong = pixels(1024, 512);
await assert.rejects(
acquireInfraredMosaic('t', {
signal: new AbortController().signal,
mode: 'filtered',
createCanvas: canvas,
frameSource: { getImage: async () => wrong },
}),
/Invalid weather image dimensions/,
);
assert.equal(wrong.closes, 1);
await assert.rejects(
acquireInfraredMosaic('t', {
signal: new AbortController().signal,
mode: 'filtered',
createCanvas: canvas,
frameSource: { getImage: async () => undefined },
}),
/Invalid weather image dimensions/,
);
});
test('cancellation reaches the frame source, and a frame that arrives after it is released', async () => {
const controller = new AbortController();
const late = pixels(2048, 1024);
let seen;
const pending = acquireInfraredMosaic('t', {
signal: controller.signal,
mode: 'filtered',
createCanvas: () => assert.fail('a cancelled frame is not drawn'),
frameSource: {
getImage: async ({ signal }) => {
seen = signal;
await flushMicrotasks();
return late;
},
},
});
controller.abort();
await assert.rejects(pending, { name: 'AbortError' });
assert.equal(seen, controller.signal);
assert.equal(late.closes, 1);
const aborted = new AbortController();
aborted.abort();
await assert.rejects(
acquireInfraredMosaic('t', {
signal: aborted.signal,
frameSource: { getImage: () => assert.fail('already cancelled') },
}),
{ name: 'AbortError' },
);
});
async function flushMicrotasks() {
for (let i = 0; i < 5; i++) await Promise.resolve();
}