Files
gods-eye-view/src/render/cesium/imageryFrames.test.mjs
T

339 lines
11 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import test, { mock } from 'node:test';
import {
createTileVideos,
framesOf,
heldFrames,
layerDrawn,
shownAt,
VIDEO_DURATION_TIMEOUT_MS,
VIDEO_RETRY_MS,
VIDEO_SEEK_TIMEOUT_MS,
VIDEO_STEP_MS,
videoProvider,
} from './imageryFrames.js';
test('frames come in time order; video segments are seen at steps from start to end', () => {
assert.deepEqual(
framesOf({
kind: 'frames',
frames: [
{ time: 20, url: 'b' },
{ time: 10, url: 'a' },
{ time: NaN, url: 'x' },
],
}),
[
{ time: 10, url: 'a' },
{ time: 20, url: 'b' },
],
);
const video = framesOf({
kind: 'video',
segments: [
{ url: 'late', start: 5000, end: 5000 + 2 * VIDEO_STEP_MS },
{ url: 'early', start: 0, end: VIDEO_STEP_MS },
],
});
assert.deepEqual(
video.map((f) => [f.time, f.url, f.fraction]),
[
[0, 'early', 0],
[VIDEO_STEP_MS, 'early', 1],
[5000, 'late', 0],
[5000 + VIDEO_STEP_MS, 'late', 0.5],
[5000 + 2 * VIDEO_STEP_MS, 'late', 1],
],
);
assert.throws(() => framesOf({ kind: 'nope' }), /Unknown timed source/);
});
test('a time shows its nearest frame, or in blend mode the two either side', () => {
const frames = [0, 100, 200].map((time) => ({ time, url: String(time) }));
assert.deepEqual(shownAt(frames, 40), {
nearest: 0,
shown: [{ index: 0, weight: 1 }],
});
assert.equal(shownAt(frames, 160).nearest, 2);
assert.equal(shownAt(frames, -50).nearest, 0, 'before the first');
assert.equal(shownAt(frames, 900).nearest, 2, 'after the last');
assert.deepEqual(shownAt(frames, 140, 'blend'), {
nearest: 1,
shown: [
{ index: 1, weight: 1 },
{ index: 2, weight: 0.4 },
],
});
assert.deepEqual(shownAt(frames, 60, 'blend').shown, [
{ index: 0, weight: 1 },
{ index: 1, weight: 0.6 },
]);
assert.deepEqual(shownAt(frames, 100, 'blend').shown, [
{ index: 1, weight: 1 },
]);
assert.deepEqual(shownAt(frames, 900, 'blend').shown, [
{ index: 2, weight: 1 },
]);
assert.equal(shownAt([], 0), null);
assert.equal(shownAt(frames, NaN), null, 'no time yet');
});
test('the frames held are those shown and the next ones to prefetch', () => {
const frames = [0, 1, 2, 3, 4].map((time) => ({ time, url: '' }));
assert.deepEqual(heldFrames(frames, shownAt(frames, 1), 2), [1, 2, 3]);
assert.deepEqual(
heldFrames(frames, shownAt(frames, 1.5, 'blend'), 1),
[1, 2, 3],
);
assert.deepEqual(heldFrames(frames, shownAt(frames, 4), 3), [4]);
});
test('a video provider asks for each tile’s video at the frame’s place in it', async () => {
const asked = [];
const videos = {
frame: (url, fraction) => (asked.push([url, fraction]), 'canvas'),
};
const tiled = videoProvider(
{ kind: 'xyz', url: '', tiling: 'geographic' },
{ url: 'v/{z}/{x}/{y}.webm', fraction: 0.25 },
videos,
);
assert.equal(await tiled.requestImage(3, 1, 2), 'canvas');
const single = videoProvider(
{
kind: 'single-image',
url: '',
rectangle: { west: -10, south: -5, east: 10, north: 5 },
},
{ url: 'one.webm', fraction: 0.5 },
videos,
);
await single.requestImage(0, 0, 0);
assert.deepEqual(asked, [
['v/2/3/1.webm', 0.25],
['one.webm', 0.5],
]);
assert.equal(single.maximumLevel, 0, 'one tile');
assert.ok(Math.abs(Cesium.Math.toDegrees(single.rectangle.east) - 10) < 1e-9);
});
test('a layer is drawn once every tile drawn shows its own imagery', () => {
const layer = { ready: true, isDestroyed: () => false, rectangle: undefined };
const other = { ready: true };
const { READY, TRANSITIONING, FAILED } = Cesium.ImageryState;
const world = Cesium.Rectangle.MAX_VALUE;
const tile = (...imagery) => ({ rectangle: world, data: { imagery } });
const own = (state, ready = true) => {
const imagery = { imageryLayer: layer, state };
return {
loadingImagery: imagery,
readyImagery: ready ? imagery : { imageryLayer: layer, state: READY },
};
};
const scene = (tiles) => ({ globe: { _surface: { _tilesToRender: tiles } } });
const theirs = { loadingImagery: { imageryLayer: other, state: READY } };
assert.equal(layerDrawn(scene([tile(own(READY), theirs)]), layer), true);
assert.equal(
layerDrawn(scene([tile(own(READY)), tile(own(TRANSITIONING))]), layer),
false,
'one still loading',
);
assert.equal(
layerDrawn(scene([tile(own(READY, false))]), layer),
false,
'drawn from an ancestor still',
);
assert.equal(
layerDrawn(scene([tile(own(FAILED, false))]), layer),
true,
'failed: nothing better to come',
);
assert.equal(
layerDrawn(scene([tile(theirs)]), layer),
false,
'its imagery not made yet',
);
assert.equal(layerDrawn(scene([]), layer), false, 'nothing drawn');
assert.equal(
layerDrawn(scene([tile(own(READY))]), { ...layer, ready: false }),
false,
);
});
/** A page whose videos load (or never do) as the test says. */
function fakeVideoPage() {
const made = [];
const original = globalThis.document;
globalThis.document = {
createElement(tag) {
if (tag === 'canvas') return { getContext: () => ({ drawImage() {} }) };
const target = new EventTarget();
let time = 0;
// Setting the time starts a seek, which the test ends (`seeked`).
Object.defineProperty(target, 'currentTime', {
get: () => time,
set: (t) => {
time = t;
target.seeking = true;
},
});
const video = Object.assign(target, {
duration: NaN,
seeking: false,
videoWidth: 2,
videoHeight: 2,
src: '',
removeAttribute(name) {
if (name === 'src') video.src = '';
},
load() {},
});
made.push(video);
return video;
},
};
return { made, restore: () => (globalThis.document = original) };
}
test('frames waiting on a tile video that is let go fail, never wait forever', async () => {
const { made, restore } = fakeVideoPage();
try {
const videos = createTileVideos(1);
// Never loads.
const first = videos.frame('a.webm', 0);
const queued = videos.frame('a.webm', 0.5);
// A second video past the limit lets the first go.
const other = videos.frame('b.webm', 0);
assert.equal(made[0].src, '', 'the first is emptied');
await assert.rejects(first, /let go/);
await assert.rejects(queued, /let go/);
videos.clear();
await assert.rejects(other, /let go/);
} finally {
restore();
}
});
test('a tile video seek that never ends fails its frame after the seek timeout', async () => {
const { made, restore } = fakeVideoPage();
mock.timers.enable({ apis: ['setTimeout'] });
try {
const videos = createTileVideos(4);
const frame = videos.frame('a.webm', 0.5);
made[0].duration = 10;
made[0].dispatchEvent(new Event('loadeddata'));
// Let the load settle and the seek start; it never sends `seeked`.
for (let i = 0; i < 5; i++) await Promise.resolve();
let failed = null;
frame.catch((error) => (failed = error));
mock.timers.tick(VIDEO_SEEK_TIMEOUT_MS);
for (let i = 0; i < 5; i++) await Promise.resolve();
assert.match(String(failed), /did not seek/);
} finally {
mock.timers.reset();
restore();
}
});
/** Let promise callbacks run. */
const flush = async () => {
for (let i = 0; i < 10; i++) await Promise.resolve();
};
/** End a fake video's seek. */
const endSeek = (video) => {
video.seeking = false;
video.dispatchEvent(new Event('seeked'));
};
test('after a seek that timed out, the video is not loaded again for a while, then afresh rather than drawing what shows', async () => {
const { made, restore } = fakeVideoPage();
mock.timers.enable({ apis: ['setTimeout', 'Date'] });
try {
const videos = createTileVideos(4);
const first = videos.frame('a.webm', 0.5);
first.catch(() => {});
made[0].duration = 10;
made[0].dispatchEvent(new Event('loadeddata'));
await flush();
mock.timers.tick(VIDEO_SEEK_TIMEOUT_MS);
await assert.rejects(first, /did not seek/);
assert.equal(made[0].src, '', 'the stuck video is let go');
// Asked again soon: failed at once, never waited on for another timeout.
await assert.rejects(videos.frame('a.webm', 0.5), /failed to load lately/);
assert.equal(made.length, 1, 'not loaded again');
mock.timers.tick(VIDEO_RETRY_MS);
let drawn = false;
const second = videos.frame('a.webm', 0.5).then(() => (drawn = true));
assert.equal(made.length, 2, 'a fresh video');
made[1].duration = 10;
made[1].dispatchEvent(new Event('loadeddata'));
await flush();
assert.equal(drawn, false, 'waits for its own seek');
endSeek(made[1]);
await second;
assert.equal(drawn, true);
} finally {
mock.timers.reset();
restore();
}
});
test('clear forgets the videos that failed, so each is loaded again at once', async () => {
const { made, restore } = fakeVideoPage();
mock.timers.enable({ apis: ['setTimeout', 'Date'] });
try {
const videos = createTileVideos(4);
const first = videos.frame('a.webm', 0.5);
made[0].dispatchEvent(new Event('error'));
await assert.rejects(first, /did not load/);
await assert.rejects(videos.frame('a.webm', 0.5), /failed to load lately/);
videos.clear();
const again = videos.frame('a.webm', 0.5);
assert.equal(made.length, 2, 'loaded again');
made[1].duration = 10;
made[1].dispatchEvent(new Event('loadeddata'));
await flush();
endSeek(made[1]);
assert.ok(await again);
} finally {
mock.timers.reset();
restore();
}
});
test('a video’s length is learnt with a longer wait, and a failed one is not loaded again for a while', async () => {
const { made, restore } = fakeVideoPage();
mock.timers.enable({ apis: ['setTimeout', 'Date'] });
try {
const videos = createTileVideos(4);
let failed = null;
videos.frame('a.webm', 0.5).catch((error) => (failed = error));
// No duration: it seeks past its end to learn it.
made[0].dispatchEvent(new Event('loadeddata'));
await flush();
mock.timers.tick(VIDEO_SEEK_TIMEOUT_MS);
await flush();
assert.equal(failed, null, 'not on the short seek wait');
mock.timers.tick(VIDEO_DURATION_TIMEOUT_MS);
await flush();
assert.match(String(failed), /did not seek/);
// Asked again soon: failed at once, not downloaded again.
await assert.rejects(videos.frame('a.webm', 0.5), /failed to load lately/);
assert.equal(made.length, 1);
// Later: a fresh video, which loads this time.
mock.timers.tick(VIDEO_RETRY_MS);
const again = videos.frame('a.webm', 0.5);
assert.equal(made.length, 2, 'started over');
made[1].duration = 10;
made[1].dispatchEvent(new Event('loadeddata'));
await flush();
endSeek(made[1]);
assert.ok(await again);
} finally {
mock.timers.reset();
restore();
}
});