mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 09:42:21 +00:00
339 lines
11 KiB
JavaScript
339 lines
11 KiB
JavaScript
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();
|
||
}
|
||
});
|