mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
Cesium switches the map stacks through its globe port, as any renderer does, rather than through a map engine of its own. Every route keeps its behaviour: - Google 3D turned off is kept hidden, and shown again without loading it anew; the key route's tiles take clamped marks, as the token routes' do. - Esri goes to its deepest level (23); its "Map data not yet available" picture is a missing tile, so the parent's imagery stays. - Cesium ion's world imagery is Bing over HTTPS on any page, with ion's credits; a token ion refuses refuses the switch, as before. - Keyless terrain that does not answer is the flat ellipsoid, tried again behind it; world terrain asks ion first, as before. - window.__godsEyeView.tileset is the Cesium photoreal tileset.
470 lines
16 KiB
JavaScript
470 lines
16 KiB
JavaScript
import test from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { globeMapEngine as engine } from './globeEngine.js';
|
||
import { KEYLESS_TERRAIN_URL } from './keylessTerrain.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);
|
||
});
|
||
|
||
/** Answer `fetch` from `answers` (url to response) while `run` runs. */
|
||
async function withFetch(answers, run) {
|
||
const real = globalThis.fetch;
|
||
const asked = [];
|
||
globalThis.fetch = async (url) => {
|
||
asked.push(String(url));
|
||
const answer = answers(String(url));
|
||
if (answer instanceof Error) throw answer;
|
||
return answer;
|
||
};
|
||
try {
|
||
return await run(asked);
|
||
} finally {
|
||
globalThis.fetch = real;
|
||
}
|
||
}
|
||
|
||
const bytesResponse = (bytes, status = 200) => ({
|
||
ok: status >= 200 && status < 300,
|
||
status,
|
||
headers: { get: (name) => (name === 'content-type' ? 'image/jpeg' : null) },
|
||
arrayBuffer: async () => new Uint8Array(bytes).buffer,
|
||
json: async () => JSON.parse(new TextDecoder().decode(new Uint8Array(bytes))),
|
||
});
|
||
|
||
const jsonResponse = (body, status = 200) =>
|
||
bytesResponse([...new TextEncoder().encode(JSON.stringify(body))], status);
|
||
|
||
/** Cesium ion's endpoints as a valid token is answered. */
|
||
const ionAnswers = (url) =>
|
||
/assets\/1\/endpoint/.test(url)
|
||
? jsonResponse({ type: 'TERRAIN', url: 'https://assets.ion.invalid/1/' })
|
||
: jsonResponse({ type: 'IMAGERY', externalType: 'BING', options: {} });
|
||
|
||
// Nothing here reaches the network: ion and the keyless terrain answer,
|
||
// offline.
|
||
globalThis.fetch = async (url) =>
|
||
String(url).startsWith('https://api.cesium.com/')
|
||
? ionAnswers(String(url))
|
||
: bytesResponse([1]);
|
||
|
||
test('Esri goes to its deepest level, its no-imagery picture drawn from the parent', async () => {
|
||
const spec = engine.imagery.esri();
|
||
assert.equal(spec.maxLevel, 23);
|
||
const placeholder = [9, 9, 9];
|
||
await withFetch(
|
||
(url) =>
|
||
url.endsWith('/tile/23/0/0')
|
||
? bytesResponse(placeholder)
|
||
: url.endsWith('/5/1/2')
|
||
? bytesResponse([1, 2, 3, 4])
|
||
: url.endsWith('/22/7/7')
|
||
? bytesResponse(placeholder)
|
||
: bytesResponse([], 503),
|
||
async (asked) => {
|
||
const signal = new AbortController().signal;
|
||
const tile = await spec.fetchTile({ url: `${'x'}/5/1/2`, signal });
|
||
assert.deepEqual([...new Uint8Array(tile.bytes)], [1, 2, 3, 4]);
|
||
assert.equal(tile.contentType, 'image/jpeg');
|
||
assert.deepEqual(
|
||
await spec.fetchTile({ url: 'x/22/7/7', signal }),
|
||
{ missing: true },
|
||
'the no-imagery picture is a missing tile',
|
||
);
|
||
await assert.rejects(
|
||
spec.fetchTile({ url: 'x/1/1/1', signal }),
|
||
(error) => error.statusCode === 503,
|
||
'a refused tile is a failed one',
|
||
);
|
||
assert.equal(
|
||
asked.filter((url) => url.endsWith('/tile/23/0/0')).length,
|
||
1,
|
||
'the no-imagery picture is read once',
|
||
);
|
||
},
|
||
);
|
||
});
|
||
|
||
test('keyless terrain that does not answer is the flat ellipsoid, marked a fallback', async () => {
|
||
await withFetch(
|
||
() => new TypeError('offline'),
|
||
async (asked) => {
|
||
const warn = console.warn;
|
||
console.warn = () => {};
|
||
try {
|
||
assert.deepEqual(await engine.terrain.keyless(), {
|
||
provider: null,
|
||
spec: { kind: 'ellipsoid' },
|
||
fallback: true,
|
||
});
|
||
} finally {
|
||
console.warn = warn;
|
||
}
|
||
assert.deepEqual(asked, [`${KEYLESS_TERRAIN_URL}/layer.json`]);
|
||
},
|
||
);
|
||
await withFetch(
|
||
() => bytesResponse([], 503),
|
||
async () => {
|
||
const warn = console.warn;
|
||
console.warn = () => {};
|
||
try {
|
||
assert.equal((await engine.terrain.keyless()).fallback, true);
|
||
} finally {
|
||
console.warn = warn;
|
||
}
|
||
},
|
||
);
|
||
});
|
||
|
||
test('terrain is the port’s world terrain, or the keyless quantized mesh without a token', async () => {
|
||
const { host, renderer } = scene(['terrain']);
|
||
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 withFetch(
|
||
() => bytesResponse([1]),
|
||
() => engine.terrain.keyless(),
|
||
),
|
||
);
|
||
assert.deepEqual(calls(renderer, 'setTerrain').at(-1).args, [
|
||
{ kind: 'quantizedMesh', url: KEYLESS_TERRAIN_URL },
|
||
]);
|
||
await assert.rejects(engine.imagery.ion(2, ''), /token/);
|
||
assert.deepEqual(await engine.imagery.ion(3, 'token'), {
|
||
kind: 'world',
|
||
worldStyle: 'aerialLabels',
|
||
});
|
||
});
|
||
|
||
test('a token ion refuses refuses the switch with ion’s message, as Cesium’s own route did', async () => {
|
||
await withFetch(
|
||
() =>
|
||
jsonResponse(
|
||
{ code: 'InvalidCredentials', message: 'Invalid access token' },
|
||
401,
|
||
),
|
||
async (asked) => {
|
||
await assert.rejects(
|
||
engine.imagery.ion(2, 'bad'),
|
||
/Invalid access token/,
|
||
);
|
||
await assert.rejects(engine.terrain.world('bad'), /Invalid access token/);
|
||
assert.match(asked[0], /\/v1\/assets\/2\/endpoint\?access_token=bad$/);
|
||
assert.match(asked[1], /\/v1\/assets\/1\/endpoint\?access_token=bad$/);
|
||
},
|
||
);
|
||
await withFetch(
|
||
() => jsonResponse({ type: 'IMAGERY', externalType: 'GOOGLE_2D_MAPS' }),
|
||
async () => {
|
||
await assert.rejects(
|
||
engine.imagery.ion(2, 'token'),
|
||
/Bing imagery endpoint/,
|
||
);
|
||
},
|
||
);
|
||
await withFetch(
|
||
() => new TypeError('offline'),
|
||
async () => {
|
||
await assert.rejects(engine.terrain.world('token'), /offline/);
|
||
},
|
||
);
|
||
});
|
||
|
||
test('where the renderer draws no terrain the ellipsoid stays', async () => {
|
||
const { host, renderer } = scene([]);
|
||
engine.applyTerrain(
|
||
host,
|
||
await withFetch(
|
||
() => bytesResponse([1]),
|
||
() => engine.terrain.keyless(),
|
||
),
|
||
);
|
||
assert.deepEqual(calls(renderer, 'setTerrain').at(-1).args, [null]);
|
||
});
|
||
|
||
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();
|
||
});
|
||
|
||
test('a stack kept after a failed switch and a failed recovery still falls back on tile failures', async () => {
|
||
const { host, renderer } = scene(['photoreal']);
|
||
let osmTries = 0;
|
||
const failing = {
|
||
...engine,
|
||
imagery: {
|
||
...engine.imagery,
|
||
osm() {
|
||
osmTries += 1;
|
||
throw new Error('osm refused');
|
||
},
|
||
},
|
||
};
|
||
const loaded = await failing.loadPhotoreal(host, { googleApiKey: 'key' });
|
||
const controller = new MapSourceController(host, {
|
||
registry: createDefaultMapSources({
|
||
googleTileset: loaded.tileset,
|
||
engine: failing,
|
||
}),
|
||
engine: failing,
|
||
googleTileset: loaded.tileset,
|
||
onError: () => {},
|
||
});
|
||
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 });
|
||
renderer.globe.setPhotoreal = async (spec) => ({
|
||
route: spec ? 'none' : 'google',
|
||
error: { code: 'refused', message: 'refused' },
|
||
});
|
||
const warn = console.warn;
|
||
console.warn = () => {};
|
||
try {
|
||
// OSM fails, and so does its recovery (photoreal): Esri stays.
|
||
await controller.setStack('osm', { silent: true });
|
||
assert.equal(controller.getState().activeId, 'esri-imagery');
|
||
assert.equal(renderer.globe.imagery.list().length, 1, 'its imagery stays');
|
||
const tries = osmTries;
|
||
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.ok(osmTries > tries, 'its tile failures still try its fallback');
|
||
// That fallback failed too: the next failures do not try it again.
|
||
const retried = osmTries;
|
||
for (let n = 0; n < 3; n++) {
|
||
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(osmTries, retried, 'no retry storm');
|
||
} finally {
|
||
console.warn = warn;
|
||
controller.destroy();
|
||
}
|
||
});
|
||
|
||
test('a released imagery spec with a destroy of its own is told, once', () => {
|
||
let destroyed = 0;
|
||
const spec = {
|
||
kind: 'xyz',
|
||
url: 'https://example.com/{z}/{x}/{y}.png',
|
||
destroy() {
|
||
destroyed++;
|
||
},
|
||
isDestroyed: () => destroyed > 0,
|
||
};
|
||
engine.release(spec);
|
||
engine.release(spec);
|
||
assert.equal(destroyed, 1);
|
||
assert.equal(engine.isDestroyed(spec), true);
|
||
// The app's own specs are frozen and have none: released quietly.
|
||
const own = engine.imagery.esri();
|
||
engine.release(own);
|
||
assert.equal(engine.isDestroyed(own), true);
|
||
});
|