Files
gods-eye-view/src/maps/globeEngine.test.mjs
T
Sameh Khamis 8ff9a1fa29 Base map through the globe port
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.
2026-11-16 17:06:35 -08:00

470 lines
16 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 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);
});