mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
- When showing the photoreal base fails and the stack before it stays, its tile-failure listener is bound again for the switch that kept it, so Esri's OSM fallback still runs. - The Cockpit test of a ride handed to another aircraft checks that the follow's change adopted it (the Cockpit took the camera).
217 lines
8.2 KiB
JavaScript
217 lines
8.2 KiB
JavaScript
import test from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { globeMapEngine as engine } from './globeEngine.js';
|
||
import { mapEngineFor, provideMapEngine } from './engine.js';
|
||
import { bindRenderer } from '../render/rendererOf.js';
|
||
import { provideApplicationHooks } from '../render/applicationHooks.js';
|
||
import { createStubRenderer } from '../render/stub/index.js';
|
||
import { MapSourceController } from './controller.js';
|
||
import { createDefaultMapSources } from './defaultSources.js';
|
||
|
||
function scene(capabilities) {
|
||
const renderer = createStubRenderer(capabilities ? { capabilities } : {});
|
||
const host = {};
|
||
bindRenderer(host, renderer);
|
||
return { host, renderer };
|
||
}
|
||
|
||
const calls = (renderer, member) =>
|
||
renderer.testing.calls.filter(
|
||
(call) => call.port === 'globe' && call.member === member,
|
||
);
|
||
|
||
test('a renderer without a map engine of its own switches through its globe port', () => {
|
||
const { host, renderer } = scene();
|
||
assert.equal(mapEngineFor(host), engine);
|
||
const own = { own: true };
|
||
provideApplicationHooks(renderer, { mapEngine: own });
|
||
assert.equal(mapEngineFor(host), own, "the plugin's own comes first");
|
||
const provided = { provided: true };
|
||
provideMapEngine(provided);
|
||
assert.equal(mapEngineFor({}), provided, 'a viewer with no renderer');
|
||
});
|
||
|
||
test('imagery layers go through the port, lowest first, and come off again', () => {
|
||
const { host, renderer } = scene();
|
||
const spec = engine.imagery.esri();
|
||
assert.equal(spec.kind, 'xyz');
|
||
assert.match(
|
||
spec.url,
|
||
/World_Imagery\/MapServer\/tile\/\{z\}\/\{y\}\/\{x\}$/,
|
||
);
|
||
const layer = engine.createImageryLayer(spec);
|
||
engine.addImageryLayer(host, layer, 0);
|
||
assert.deepEqual(calls(renderer, 'imagery.add')[0].args, [spec, 0]);
|
||
assert.equal(renderer.globe.imagery.list().length, 1);
|
||
let errors = 0;
|
||
const off = engine.onTileError(spec, () => (errors += 1));
|
||
assert.equal(typeof off, 'function', 'tile errors are heard');
|
||
off();
|
||
engine.removeImageryLayer(host, layer);
|
||
assert.equal(renderer.globe.imagery.list().length, 0);
|
||
assert.equal(
|
||
engine.onTileError(spec, () => {}),
|
||
null,
|
||
'none once removed',
|
||
);
|
||
assert.equal(errors, 0);
|
||
});
|
||
|
||
test('the globe is shown and hidden through the port, read back without globe visibility', () => {
|
||
const { host, renderer } = scene([]);
|
||
assert.equal(engine.globeShown(host), true);
|
||
engine.setGlobeShown(host, false);
|
||
assert.equal(engine.globeShown(host), false);
|
||
assert.deepEqual(calls(renderer, 'setGlobeVisible').at(-1).args, [false]);
|
||
const visible = scene(['globeVisibility']);
|
||
engine.setGlobeShown(visible.host, false);
|
||
assert.equal(visible.renderer.globe.isGlobeVisible(), false);
|
||
assert.equal(engine.globeShown(visible.host), false);
|
||
});
|
||
|
||
test('terrain is the port’s world terrain, or the ellipsoid without a token', async () => {
|
||
const { host, renderer } = scene();
|
||
await assert.rejects(engine.terrain.world(''), /ion token/);
|
||
const world = await engine.terrain.world('token');
|
||
engine.applyTerrain(host, world);
|
||
assert.deepEqual(calls(renderer, 'setTerrain').at(-1).args, [
|
||
{ kind: 'world', requestVertexNormals: true },
|
||
]);
|
||
engine.applyTerrain(host, await engine.terrain.keyless());
|
||
assert.deepEqual(calls(renderer, 'setTerrain').at(-1).args, [
|
||
{ kind: 'ellipsoid' },
|
||
]);
|
||
assert.throws(() => engine.imagery.ion(2, ''), /token/);
|
||
assert.deepEqual(engine.imagery.ion(3, 'token'), {
|
||
kind: 'world',
|
||
worldStyle: 'aerialLabels',
|
||
});
|
||
});
|
||
|
||
test('photoreal loads through the port, hides and shows, and is released', async () => {
|
||
const { host, renderer } = scene(['photoreal']);
|
||
const none = await engine.loadPhotoreal(host, {});
|
||
assert.deepEqual(none, { tileset: null, route: 'none', errors: [] });
|
||
assert.equal(calls(renderer, 'setPhotoreal').length, 0, 'no credentials');
|
||
|
||
const tokens = { token: async () => 'session' };
|
||
const loaded = await engine.loadPhotoreal(host, { googleTokens: tokens });
|
||
assert.equal(loaded.route, 'google');
|
||
const handle = loaded.tileset;
|
||
assert.equal(engine.tilesetShown(handle), true);
|
||
const spec = calls(renderer, 'setPhotoreal')[0].args[0];
|
||
assert.equal(spec.provider, 'google');
|
||
assert.equal(await spec.token(), 'session');
|
||
assert.equal(spec.fallback, false);
|
||
|
||
engine.showTileset(handle, false);
|
||
assert.equal(engine.tilesetShown(handle), false);
|
||
assert.equal(calls(renderer, 'setPhotoreal').at(-1).args[0], null);
|
||
await engine.tilesetReady(handle);
|
||
engine.showTileset(handle, true);
|
||
assert.equal(calls(renderer, 'setPhotoreal').at(-1).args[0], spec);
|
||
engine.release(handle);
|
||
assert.equal(engine.isDestroyed(handle), true);
|
||
assert.equal(calls(renderer, 'setPhotoreal').at(-1).args[0], null);
|
||
const count = calls(renderer, 'setPhotoreal').length;
|
||
engine.showTileset(handle, true);
|
||
assert.equal(calls(renderer, 'setPhotoreal').length, count, 'never again');
|
||
});
|
||
|
||
test('a renderer without photoreal reports none, with the reason it gave', async () => {
|
||
const { host } = scene([]);
|
||
const result = await engine.loadPhotoreal(host, { googleApiKey: 'key' });
|
||
assert.equal(result.tileset, null);
|
||
assert.equal(result.route, 'none');
|
||
});
|
||
|
||
test('photoreal that fails to come back leaves the globe shown, and is tried again', async () => {
|
||
const { host, renderer } = scene(['photoreal']);
|
||
const loaded = await engine.loadPhotoreal(host, { googleApiKey: 'key' });
|
||
const handle = loaded.tileset;
|
||
engine.showTileset(handle, false);
|
||
engine.setGlobeShown(host, false);
|
||
// The port cannot draw photoreal any more.
|
||
renderer.globe.setPhotoreal = async (spec) => ({
|
||
route: 'none',
|
||
error: { code: 'refused', message: 'refused' },
|
||
spec,
|
||
});
|
||
const warn = console.warn;
|
||
console.warn = () => {};
|
||
try {
|
||
engine.showTileset(handle, true);
|
||
await assert.rejects(
|
||
engine.tilesetReady(handle),
|
||
/refused/,
|
||
'the map stack hears it failed',
|
||
);
|
||
} finally {
|
||
console.warn = warn;
|
||
}
|
||
assert.equal(engine.tilesetShown(handle), false, 'off again');
|
||
assert.equal(engine.globeShown(host), true, 'the base is not blank');
|
||
let tried = 0;
|
||
renderer.globe.setPhotoreal = async () => {
|
||
tried += 1;
|
||
return { route: 'google' };
|
||
};
|
||
engine.showTileset(handle, true);
|
||
assert.equal(tried, 1, 'a later switch tries again');
|
||
});
|
||
|
||
test('a photoreal stack that fails to come back leaves the stack before it in place', async () => {
|
||
const { host, renderer } = scene(['photoreal']);
|
||
const loaded = await engine.loadPhotoreal(host, { googleApiKey: 'key' });
|
||
const errors = [];
|
||
const controller = new MapSourceController(host, {
|
||
registry: createDefaultMapSources({
|
||
googleTileset: loaded.tileset,
|
||
engine,
|
||
}),
|
||
engine,
|
||
googleTileset: loaded.tileset,
|
||
onError: (message) => errors.push(message),
|
||
});
|
||
// The tile-failure listeners of the layers it adds, to fail their tiles.
|
||
const tileErrors = new Set();
|
||
const add = renderer.globe.imagery.add;
|
||
renderer.globe.imagery.add = (...args) => {
|
||
const layer = add(...args);
|
||
const on = layer.on;
|
||
layer.on = (event, listener) => {
|
||
const off = on(event, listener);
|
||
if (event !== 'tileError') return off;
|
||
tileErrors.add(listener);
|
||
return () => {
|
||
tileErrors.delete(listener);
|
||
off();
|
||
};
|
||
};
|
||
return layer;
|
||
};
|
||
await controller.setStack('esri-imagery', { silent: true });
|
||
assert.equal(renderer.globe.imagery.list().length, 1);
|
||
renderer.globe.setPhotoreal = async (spec) => ({
|
||
route: spec ? 'none' : 'google',
|
||
error: { code: 'refused', message: 'refused' },
|
||
});
|
||
const warn = console.warn;
|
||
console.warn = () => {};
|
||
try {
|
||
await controller.setStack('photoreal', { silent: true });
|
||
} finally {
|
||
console.warn = warn;
|
||
}
|
||
assert.equal(controller.getState().activeId, 'esri-imagery');
|
||
assert.equal(renderer.globe.imagery.list().length, 1, 'its imagery stays');
|
||
assert.equal(engine.globeShown(host), true, 'on the shown globe');
|
||
assert.match(errors.at(-1), /refused/);
|
||
// Its tile failures still fall back, heard for the switch that kept it.
|
||
for (const listener of [...tileErrors]) listener({});
|
||
for (const listener of [...tileErrors]) listener({});
|
||
for (let i = 0; i < 20; i++) await new Promise((r) => setTimeout(r, 0));
|
||
assert.equal(controller.getState().activeId, 'osm');
|
||
controller.destroy();
|
||
});
|