mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
MapSourceController (and MapStackController) take the page's globe engine: a globe stack becomes engine.maps.setBaseImagery with the controller's ready provider and credit, then setPhotorealTiles(null), then setTerrain with the cached terrain; a 3D stack becomes setPhotorealTiles with its tileset and credit; owned tilesets are released through maps.releasePhotorealTiles before disposal. The controller keeps its provider/terrain/tileset caches, construction and tile-failure fallbacks, switch generations and error watch. The scene builds its map stack controller with its engine; without an engine the controller applies sources to the viewer as before. The photoreal-to- globe sequence (imagery, credit, globe, tileset) is tested end to end on the Cesium engine.
996 lines
32 KiB
JavaScript
996 lines
32 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { MapSourceController } from './controller.js';
|
|
import { createDefaultMapSources } from './defaultSources.js';
|
|
|
|
function event() {
|
|
const listeners = new Set();
|
|
return {
|
|
addEventListener(fn) {
|
|
listeners.add(fn);
|
|
return () => listeners.delete(fn);
|
|
},
|
|
raise(value = {}) {
|
|
for (const fn of [...listeners]) fn(value);
|
|
},
|
|
get size() {
|
|
return listeners.size;
|
|
},
|
|
};
|
|
}
|
|
function fixture(registry, options = {}) {
|
|
const imagery = [],
|
|
credits = new Set(),
|
|
primitives = [],
|
|
removed = [],
|
|
changes = [];
|
|
const viewer = {
|
|
scene: {
|
|
globe: { show: true },
|
|
requestRender() {},
|
|
frameState: {
|
|
creditDisplay: {
|
|
addStaticCredit(value) {
|
|
credits.add(value);
|
|
},
|
|
removeStaticCredit(value) {
|
|
credits.delete(value);
|
|
},
|
|
},
|
|
},
|
|
primitives: {
|
|
add(value) {
|
|
primitives.push(value);
|
|
},
|
|
remove(value) {
|
|
primitives.splice(primitives.indexOf(value), 1);
|
|
value.destroy?.();
|
|
},
|
|
},
|
|
},
|
|
imageryLayers: {
|
|
add(value) {
|
|
imagery.push(value);
|
|
},
|
|
remove(value, destroy) {
|
|
imagery.splice(imagery.indexOf(value), 1);
|
|
removed.push({ value, destroy });
|
|
},
|
|
},
|
|
};
|
|
const controller = new MapSourceController(viewer, {
|
|
registry,
|
|
createImageryLayer: (provider) => ({ provider }),
|
|
onChange: (state) => changes.push(state),
|
|
...options,
|
|
});
|
|
return { viewer, controller, imagery, credits, primitives, removed, changes };
|
|
}
|
|
const settle = async () => {
|
|
for (let i = 0; i < 20; i++) await Promise.resolve();
|
|
};
|
|
const descriptor = (id) => ({ id, label: id, kind: 'imagery' });
|
|
function publicFixture() {
|
|
const tileset = { show: true };
|
|
const registry = createDefaultMapSources({ googleTileset: tileset });
|
|
const providers = new Map();
|
|
for (const source of registry.sources) {
|
|
if (!source.imagery) continue;
|
|
const provider = { id: source.descriptor.id, errorEvent: event() };
|
|
providers.set(source.descriptor.id, provider);
|
|
source.imagery = async () => provider;
|
|
source.terrain = {
|
|
id: 'keyless',
|
|
create: async () => ({ provider: { id: 'terrain' } }),
|
|
};
|
|
}
|
|
return { ...fixture(registry), registry, providers, tileset };
|
|
}
|
|
|
|
test('an additional imagery source needs no controller branch and owns its cached resources', async () => {
|
|
let reads = 0,
|
|
destroys = 0,
|
|
terrainReads = 0;
|
|
const provider = {
|
|
destroy() {
|
|
destroys++;
|
|
},
|
|
};
|
|
const terrain = {
|
|
id: 'custom-floor',
|
|
create: async () => {
|
|
terrainReads++;
|
|
return { provider: { id: 'terrain' } };
|
|
},
|
|
};
|
|
const registry = {
|
|
defaultId: 'custom',
|
|
sources: [
|
|
{
|
|
descriptor: descriptor('custom'),
|
|
imagery: async () => {
|
|
reads++;
|
|
return provider;
|
|
},
|
|
terrain,
|
|
},
|
|
],
|
|
};
|
|
const env = fixture(registry);
|
|
await env.controller.setStack('custom');
|
|
await env.controller.setStack('custom');
|
|
assert.equal(env.controller.getActiveId(), 'custom');
|
|
assert.equal(env.viewer.terrainProvider.id, 'terrain');
|
|
assert.equal(reads, 1);
|
|
assert.equal(terrainReads, 1);
|
|
assert.equal(env.imagery.length, 1);
|
|
assert.equal(
|
|
env.removed.length,
|
|
0,
|
|
'same provider keeps its loaded imagery layer',
|
|
);
|
|
env.controller.destroy();
|
|
env.controller.destroy();
|
|
await settle();
|
|
assert.equal(env.imagery.length, 0);
|
|
assert.equal(env.removed[0].destroy, true);
|
|
assert.equal(destroys, 1);
|
|
});
|
|
|
|
test('repeated Esri shot handoffs retain imagery and keep tile fallback live', async () => {
|
|
const env = publicFixture();
|
|
await env.controller.setStack('esri-imagery');
|
|
const layer = env.imagery[0];
|
|
const generation = env.controller.getSwitchGeneration();
|
|
const errors = env.providers.get('esri-imagery').errorEvent;
|
|
for (let i = 0; i < 3; i++) await env.controller.setStack('esri-imagery');
|
|
assert.equal(env.imagery[0], layer);
|
|
assert.equal(env.removed.length, 0);
|
|
assert.equal(errors.size, 1);
|
|
assert.equal(env.controller.getSwitchGeneration(), generation + 3);
|
|
errors.raise();
|
|
errors.raise();
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
assert.equal(env.removed.length, 1);
|
|
assert.equal(errors.size, 0);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('returning to the live provider supersedes a pending switch without rebuilding imagery', async () => {
|
|
const env = publicFixture();
|
|
await env.controller.setStack('esri-imagery');
|
|
const layer = env.imagery[0];
|
|
let resolve;
|
|
env.registry.sources.find(
|
|
(source) => source.descriptor.id === 'osm',
|
|
).imagery = () =>
|
|
new Promise((done) => {
|
|
resolve = done;
|
|
});
|
|
const pending = env.controller.setStack('osm');
|
|
await settle();
|
|
await env.controller.setStack('esri-imagery');
|
|
resolve(env.providers.get('osm'));
|
|
await pending;
|
|
assert.equal(env.controller.getActiveId(), 'esri-imagery');
|
|
assert.equal(env.imagery[0], layer);
|
|
assert.equal(env.removed.length, 0);
|
|
await env.controller.setStack('photoreal');
|
|
assert.equal(env.imagery.length, 0);
|
|
assert.equal(env.tileset.show, true);
|
|
await env.controller.setStack('esri-imagery');
|
|
assert.notEqual(env.imagery[0], layer, 'a removed layer must be recreated');
|
|
assert.equal(env.viewer.scene.globe.show, true);
|
|
assert.equal(env.tileset.show, false);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('a destroyed controller aborts creation and disposes a late provider without touching the scene', async () => {
|
|
let resolve,
|
|
signal,
|
|
destroyed = 0;
|
|
const env = fixture({
|
|
defaultId: 'slow',
|
|
sources: [
|
|
{
|
|
descriptor: descriptor('slow'),
|
|
imagery: (request) => {
|
|
signal = request.signal;
|
|
return new Promise((done) => {
|
|
resolve = done;
|
|
});
|
|
},
|
|
},
|
|
],
|
|
});
|
|
const loading = env.controller.setStack('slow');
|
|
await settle();
|
|
env.controller.destroy();
|
|
assert.equal(signal.aborted, true);
|
|
resolve({
|
|
destroy() {
|
|
destroyed++;
|
|
},
|
|
});
|
|
await loading;
|
|
await settle();
|
|
assert.equal(destroyed, 1);
|
|
assert.equal(env.imagery.length, 0);
|
|
assert.deepEqual(
|
|
env.changes.map((state) => state.status),
|
|
['switching'],
|
|
);
|
|
});
|
|
|
|
test('slow terrain cannot overwrite a newer source and a 3D view never starts unused terrain', async () => {
|
|
const env = publicFixture();
|
|
let resolve,
|
|
reads = 0;
|
|
const osm = env.registry.sources.find(
|
|
(source) => source.descriptor.id === 'osm',
|
|
);
|
|
osm.terrain = {
|
|
id: 'slow-floor',
|
|
create: () => {
|
|
reads++;
|
|
return new Promise((done) => {
|
|
resolve = done;
|
|
});
|
|
},
|
|
};
|
|
await env.controller.setStack('photoreal');
|
|
assert.equal(reads, 0);
|
|
const loading = env.controller.setStack('osm');
|
|
await settle();
|
|
await env.controller.setStack('photoreal');
|
|
resolve({ provider: { id: 'late-terrain' } });
|
|
await loading;
|
|
assert.equal(env.viewer.terrainProvider, undefined);
|
|
assert.equal(env.viewer.scene.globe.show, false);
|
|
assert.equal(env.tileset.show, true);
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('Esri construction fallback reports and attributes the source actually rendered', async () => {
|
|
const env = publicFixture();
|
|
env.registry.sources.find(
|
|
(source) => source.descriptor.id === 'esri-imagery',
|
|
).imagery = async () => {
|
|
throw new Error('unreachable');
|
|
};
|
|
await env.controller.setStack('esri-imagery');
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
assert.equal(
|
|
env.controller.getState().lastError,
|
|
'Esri Satellite is unavailable; using OSM',
|
|
);
|
|
assert.equal(env.imagery[0].provider, env.providers.get('osm'));
|
|
assert.equal(env.credits.size, 0);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('one Esri tile failure stays put, two fall back, and stale errors cannot replace a selection', async () => {
|
|
const env = publicFixture();
|
|
await env.controller.setStack('esri-imagery');
|
|
assert.equal(env.credits.size, 1);
|
|
const errorEvent = env.providers.get('esri-imagery').errorEvent;
|
|
errorEvent.raise();
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'esri-imagery');
|
|
errorEvent.raise();
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
assert.equal(env.credits.size, 0);
|
|
assert.equal(
|
|
env.controller.getState().lastError,
|
|
'Esri Satellite tile requests failed; using OSM',
|
|
);
|
|
assert.equal(errorEvent.size, 0);
|
|
await env.controller.setStack('photoreal');
|
|
errorEvent.raise({ timesRetried: 9 });
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('tooltips and rejected selection share the registry reason, including retired map IDs', async () => {
|
|
const errors = [],
|
|
env = publicFixture();
|
|
env.controller._onError = (message) => errors.push(message);
|
|
const reason = env.controller
|
|
.getStacks()
|
|
.find((stack) => stack.id === 'bing-aerial').unavailableReason;
|
|
await env.controller.setStack('bing-aerial');
|
|
assert.deepEqual(errors, [reason]);
|
|
assert.match(reason, /CESIUM_ION_TOKEN/);
|
|
await env.controller.setStack('bing-road');
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('a factory-owned 3D tileset is released after late completion and supplied tilesets stay caller-owned', async () => {
|
|
let resolve,
|
|
destroyed = 0;
|
|
const supplied = {
|
|
show: true,
|
|
destroy() {
|
|
assert.fail('caller-owned tileset');
|
|
},
|
|
};
|
|
const env = fixture({
|
|
defaultId: 'three',
|
|
sources: [
|
|
{
|
|
descriptor: { id: 'three' },
|
|
createTileset: () =>
|
|
new Promise((done) => {
|
|
resolve = done;
|
|
}),
|
|
},
|
|
{ descriptor: { id: 'supplied' }, tileset: supplied },
|
|
],
|
|
});
|
|
const loading = env.controller.setStack('three');
|
|
await settle();
|
|
env.controller.destroy();
|
|
resolve({
|
|
destroy() {
|
|
destroyed++;
|
|
},
|
|
});
|
|
await loading;
|
|
assert.equal(destroyed, 1);
|
|
assert.equal(env.primitives.length, 0);
|
|
});
|
|
|
|
test('invalid source graphs fail before constructing or caching a provider', () => {
|
|
const a = { descriptor: descriptor('a'), constructionFallback: { id: 'b' } };
|
|
const b = { descriptor: descriptor('b'), constructionFallback: { id: 'a' } };
|
|
assert.throws(() => fixture({ sources: [a, b] }), /fallback cycle/);
|
|
assert.throws(() => fixture({ sources: [a, a] }), /unique/);
|
|
assert.throws(() => fixture({ sources: [a] }), /Unknown map fallback/);
|
|
});
|
|
|
|
for (const reactivate of [false, true]) {
|
|
test(`a superseded 3D load stays outside the scene and is released (reactivate: ${reactivate})`, async () => {
|
|
let resolve,
|
|
destroyed = 0,
|
|
reads = 0;
|
|
const tileset = {
|
|
show: true,
|
|
isDestroyed: () => destroyed > 0,
|
|
destroy() {
|
|
destroyed++;
|
|
},
|
|
};
|
|
const supplied = { show: true };
|
|
const env = fixture({
|
|
defaultId: 'slow',
|
|
sources: [
|
|
{
|
|
descriptor: { id: 'slow' },
|
|
createTileset: () => {
|
|
reads++;
|
|
return new Promise((done) => {
|
|
resolve = done;
|
|
});
|
|
},
|
|
},
|
|
{ descriptor: { id: 'supplied' }, tileset: supplied },
|
|
],
|
|
});
|
|
const loading = env.controller.setStack('slow');
|
|
await settle();
|
|
await env.controller.setStack('supplied');
|
|
resolve(tileset);
|
|
await loading;
|
|
assert.equal(env.primitives.length, 0);
|
|
assert.equal(supplied.show, true);
|
|
assert.equal(env.controller.getActiveId(), 'supplied');
|
|
if (reactivate) {
|
|
await env.controller.setStack('slow');
|
|
await env.controller.setStack('slow');
|
|
assert.deepEqual(env.primitives, [tileset]);
|
|
assert.equal(reads, 1);
|
|
assert.equal(tileset.show, true);
|
|
assert.equal(supplied.show, false);
|
|
}
|
|
env.controller.destroy();
|
|
await settle();
|
|
assert.equal(env.primitives.length, 0);
|
|
assert.equal(destroyed, 1);
|
|
});
|
|
}
|
|
|
|
test('a failed recovery reports its error and leaves switching settled', async () => {
|
|
const errors = [];
|
|
const env = fixture(
|
|
{
|
|
defaultId: 'first',
|
|
recoveryId: 'recovery',
|
|
sources: [
|
|
{
|
|
descriptor: descriptor('first'),
|
|
imagery: async () => {
|
|
throw new Error('first offline');
|
|
},
|
|
},
|
|
{
|
|
descriptor: descriptor('recovery'),
|
|
imagery: async () => {
|
|
throw new Error('recovery offline');
|
|
},
|
|
},
|
|
],
|
|
},
|
|
{ onError: (message) => errors.push(message) },
|
|
);
|
|
const result = await env.controller.setStack('first');
|
|
assert.equal(result.status, 'ready');
|
|
assert.equal(result.lastError, 'recovery offline');
|
|
assert.deepEqual(errors, ['first offline', 'recovery offline']);
|
|
assert.equal(env.changes.at(-1).status, 'error');
|
|
assert.equal(env.imagery.length, 0);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('imagery host tileset follows supplied, owned and globe map sources', async () => {
|
|
const supplied = { show: true };
|
|
const owned = { show: false };
|
|
const registry = {
|
|
defaultId: 'supplied',
|
|
sources: [
|
|
{ descriptor: descriptor('supplied'), tileset: supplied },
|
|
{ descriptor: descriptor('owned'), createTileset: async () => owned },
|
|
{ descriptor: descriptor('globe'), imagery: async () => ({}) },
|
|
],
|
|
};
|
|
const { controller } = fixture(registry);
|
|
assert.equal(controller.getImageryHostTileset(), supplied);
|
|
await controller.setStack('owned');
|
|
assert.equal(controller.getImageryHostTileset(), owned);
|
|
await controller.setStack('globe');
|
|
assert.equal(controller.getImageryHostTileset(), null);
|
|
await controller.setStack('supplied');
|
|
assert.equal(controller.getImageryHostTileset(), supplied);
|
|
controller.destroy();
|
|
assert.equal(controller.getImageryHostTileset(), null);
|
|
});
|
|
|
|
function leaseFixture() {
|
|
const env = publicFixture();
|
|
const switches = [];
|
|
const setStack = env.controller.setStack.bind(env.controller);
|
|
env.controller.setStack = (id, options) => {
|
|
switches.push(id);
|
|
return setStack(id, options);
|
|
};
|
|
return { ...env, switches };
|
|
}
|
|
|
|
test('an imagery comparison lease rejects a second owner synchronously until released', async () => {
|
|
const env = leaseFixture();
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'preserve',
|
|
});
|
|
assert.throws(
|
|
() => env.controller.acquireImageryComparison({ owner: 'recent' }),
|
|
/held by nepal/,
|
|
);
|
|
assert.deepEqual(await lease.ready, {
|
|
status: 'ready',
|
|
activeId: 'photoreal',
|
|
});
|
|
await lease.release();
|
|
const next = env.controller.acquireImageryComparison({ owner: 'recent' });
|
|
assert.deepEqual(await next.ready, {
|
|
status: 'ready',
|
|
activeId: 'photoreal',
|
|
});
|
|
await next.release();
|
|
assert.deepEqual(env.switches, []);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test("the 'esri' policy switches from any other stack and release restores it", async () => {
|
|
for (const initial of ['photoreal', 'osm']) {
|
|
const env = leaseFixture();
|
|
if (initial !== env.controller.getActiveId())
|
|
await env.controller.setStack(initial);
|
|
env.switches.length = 0;
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
});
|
|
assert.deepEqual(await lease.ready, {
|
|
status: 'ready',
|
|
activeId: 'esri-imagery',
|
|
});
|
|
assert.equal(env.controller.getActiveId(), 'esri-imagery');
|
|
await lease.release();
|
|
assert.equal(env.controller.getActiveId(), initial);
|
|
assert.deepEqual(env.switches, ['esri-imagery', initial]);
|
|
env.controller.destroy();
|
|
}
|
|
});
|
|
|
|
test("the 'esri-if-photoreal' policy leaves any 2D basemap alone", async () => {
|
|
const photoreal = leaseFixture();
|
|
const fromPhotoreal = photoreal.controller.acquireImageryComparison({
|
|
owner: 'recent',
|
|
switchPolicy: 'esri-if-photoreal',
|
|
});
|
|
assert.equal((await fromPhotoreal.ready).activeId, 'esri-imagery');
|
|
await fromPhotoreal.release();
|
|
assert.deepEqual(photoreal.switches, ['esri-imagery', 'photoreal']);
|
|
photoreal.controller.destroy();
|
|
|
|
const osm = leaseFixture();
|
|
await osm.controller.setStack('osm');
|
|
osm.switches.length = 0;
|
|
const fromOsm = osm.controller.acquireImageryComparison({
|
|
owner: 'recent',
|
|
switchPolicy: 'esri-if-photoreal',
|
|
});
|
|
assert.deepEqual(await fromOsm.ready, { status: 'ready', activeId: 'osm' });
|
|
await fromOsm.release();
|
|
assert.equal(osm.controller.getActiveId(), 'osm');
|
|
assert.deepEqual(osm.switches, []);
|
|
osm.controller.destroy();
|
|
});
|
|
|
|
test("the 'preserve' policy never switches, whatever is active", async () => {
|
|
for (const initial of ['photoreal', 'esri-imagery', 'osm']) {
|
|
const env = leaseFixture();
|
|
if (initial !== env.controller.getActiveId())
|
|
await env.controller.setStack(initial);
|
|
env.switches.length = 0;
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
});
|
|
assert.deepEqual(await lease.ready, { status: 'ready', activeId: initial });
|
|
await lease.release();
|
|
assert.equal(env.controller.getActiveId(), initial);
|
|
assert.deepEqual(env.switches, []);
|
|
env.controller.destroy();
|
|
}
|
|
});
|
|
|
|
test('release keeps an operator choice made while the comparison was open', async () => {
|
|
const env = leaseFixture();
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
});
|
|
await lease.ready;
|
|
await env.controller.setStack('osm');
|
|
await lease.release();
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
assert.deepEqual(env.switches, ['esri-imagery', 'osm']);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('release keeps a fallback that replaced the comparison stack', async () => {
|
|
const env = leaseFixture();
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
});
|
|
await lease.ready;
|
|
const errors = env.providers.get('esri-imagery').errorEvent;
|
|
errors.raise();
|
|
errors.raise();
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
await lease.release();
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
assert.deepEqual(env.switches, ['esri-imagery', 'osm']);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('release during acquisition lets no late activation survive', async () => {
|
|
const env = leaseFixture();
|
|
let resolve;
|
|
env.registry.sources.find(
|
|
(source) => source.descriptor.id === 'esri-imagery',
|
|
).imagery = () =>
|
|
new Promise((done) => {
|
|
resolve = done;
|
|
});
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
});
|
|
await settle();
|
|
const releasing = lease.release();
|
|
resolve(env.providers.get('esri-imagery'));
|
|
assert.deepEqual(await lease.ready, {
|
|
status: 'superseded',
|
|
activeId: 'photoreal',
|
|
});
|
|
await releasing;
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
assert.equal(env.viewer.scene.globe.show, false);
|
|
assert.equal(env.imagery.length, 0);
|
|
assert.equal(env.tileset.show, true);
|
|
assert.deepEqual(env.switches, ['esri-imagery', 'photoreal']);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('release is idempotent and frees the lease for the next owner', async () => {
|
|
const env = leaseFixture();
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
});
|
|
await lease.ready;
|
|
const first = lease.release();
|
|
assert.equal(lease.release(), first);
|
|
await first;
|
|
await lease.release();
|
|
assert.deepEqual(env.switches, ['esri-imagery', 'photoreal']);
|
|
const next = env.controller.acquireImageryComparison({
|
|
owner: 'recent',
|
|
switchPolicy: 'esri',
|
|
});
|
|
assert.equal((await next.ready).status, 'ready');
|
|
await next.release();
|
|
assert.deepEqual(env.switches, [
|
|
'esri-imagery',
|
|
'photoreal',
|
|
'esri-imagery',
|
|
'photoreal',
|
|
]);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('an unavailable comparison stack reports failure and release leaves the map alone', async () => {
|
|
const env = leaseFixture();
|
|
const errors = [];
|
|
env.controller._onError = (message) => errors.push(message);
|
|
const esri = env.controller._sources.get('esri-imagery');
|
|
esri.available = false;
|
|
esri.unavailableReason = 'Esri offline';
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
});
|
|
assert.deepEqual(await lease.ready, {
|
|
status: 'failed',
|
|
activeId: 'photoreal',
|
|
});
|
|
await lease.release();
|
|
assert.deepEqual(env.switches, ['esri-imagery']);
|
|
assert.deepEqual(errors, ['Esri offline']);
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('a lease stays owned until its restoration settles, so a rival cannot read the comparison stack as its own', async () => {
|
|
const env = leaseFixture();
|
|
const lease = env.controller.acquireImageryComparison({
|
|
owner: 'recent',
|
|
switchPolicy: 'esri-if-photoreal',
|
|
});
|
|
assert.equal((await lease.ready).activeId, 'esri-imagery');
|
|
// Hold the restore switch open: the map is still on Esri while it runs.
|
|
const setStack = env.controller.setStack;
|
|
let finishRestore;
|
|
env.controller.setStack = (id, options) =>
|
|
new Promise((resolve) => {
|
|
finishRestore = () => resolve(setStack(id, options));
|
|
});
|
|
const releasing = lease.release();
|
|
assert.equal(typeof finishRestore, 'function', 'the restore was issued');
|
|
assert.throws(
|
|
() =>
|
|
env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
}),
|
|
/held by recent/,
|
|
'the pending restoration still owns the lease',
|
|
);
|
|
finishRestore();
|
|
await releasing;
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
env.controller.setStack = setStack;
|
|
const next = env.controller.acquireImageryComparison({
|
|
owner: 'nepal',
|
|
switchPolicy: 'esri',
|
|
});
|
|
assert.deepEqual(await next.ready, {
|
|
status: 'ready',
|
|
activeId: 'esri-imagery',
|
|
});
|
|
await next.release();
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
assert.deepEqual(env.switches, [
|
|
'esri-imagery',
|
|
'photoreal',
|
|
'esri-imagery',
|
|
'photoreal',
|
|
]);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('subscribe hears every settled activation — silent switches, fallbacks and recoveries — until unsubscribed or destroyed', async () => {
|
|
const env = publicFixture();
|
|
const heard = [];
|
|
const off = env.controller.subscribe((state) =>
|
|
heard.push([state.activeId, state.status]),
|
|
);
|
|
assert.equal(typeof off, 'function');
|
|
assert.equal(typeof env.controller.subscribe(null), 'function');
|
|
await env.controller.setStack('esri-imagery');
|
|
assert.deepEqual(heard, [['esri-imagery', 'ready']]);
|
|
// A silent switch mutes onChange but not the subscription.
|
|
const changesBefore = env.changes.length;
|
|
await env.controller.setStack('photoreal', { silent: true });
|
|
assert.equal(env.changes.length, changesBefore, 'onChange stays silent');
|
|
assert.deepEqual(heard.at(-1), ['photoreal', 'ready']);
|
|
// A subscriber that throws does not stop the others.
|
|
const noisy = env.controller.subscribe(() => {
|
|
throw new Error('listener failed');
|
|
});
|
|
const warn = console.warn;
|
|
const warnings = [];
|
|
console.warn = (...args) => warnings.push(args);
|
|
try {
|
|
await env.controller.setStack('esri-imagery');
|
|
} finally {
|
|
console.warn = warn;
|
|
}
|
|
assert.equal(warnings.length, 1);
|
|
assert.deepEqual(heard.at(-1), ['esri-imagery', 'ready']);
|
|
noisy();
|
|
off();
|
|
await env.controller.setStack('photoreal');
|
|
assert.equal(heard.length, 3, 'unsubscribed listeners hear nothing');
|
|
env.controller.destroy();
|
|
|
|
// A failed activation that recovers still settles once, on the recovery.
|
|
const recovering = fixture(
|
|
{
|
|
defaultId: 'first',
|
|
recoveryId: 'recovery',
|
|
sources: [
|
|
{
|
|
descriptor: descriptor('first'),
|
|
imagery: async () => {
|
|
throw new Error('first offline');
|
|
},
|
|
},
|
|
{ descriptor: descriptor('recovery'), imagery: async () => ({}) },
|
|
],
|
|
},
|
|
{ onError: () => {} },
|
|
);
|
|
const recovered = [];
|
|
recovering.controller.subscribe((state) => recovered.push(state.activeId));
|
|
await recovering.controller.setStack('first');
|
|
assert.deepEqual(recovered, ['recovery']);
|
|
recovering.controller.destroy();
|
|
await recovering.controller.setStack('first');
|
|
assert.deepEqual(recovered, ['recovery'], 'a destroyed controller is mute');
|
|
});
|
|
|
|
test('each switch generation reports its origin: an outside setStack is manual, a fallback or recovery automatic', async () => {
|
|
const env = publicFixture();
|
|
const heard = [];
|
|
env.controller.subscribe((state) =>
|
|
heard.push([state.activeId, state.switchOrigin]),
|
|
);
|
|
await env.controller.setStack('esri-imagery');
|
|
assert.equal(env.controller.getSwitchOrigin(), 'manual');
|
|
const generation = env.controller.getSwitchGeneration();
|
|
// Two tile failures: the controller falls back to OSM on its own.
|
|
const errors = env.providers.get('esri-imagery').errorEvent;
|
|
errors.raise();
|
|
errors.raise();
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
assert.equal(env.controller.getSwitchGeneration(), generation + 1);
|
|
assert.equal(env.controller.getSwitchOrigin(), 'automatic');
|
|
assert.equal(env.controller.getState().switchOrigin, 'automatic');
|
|
// A silent switch from outside is still the caller's choice.
|
|
await env.controller.setStack('photoreal', { silent: true });
|
|
assert.equal(env.controller.getSwitchOrigin(), 'manual');
|
|
assert.deepEqual(heard, [
|
|
['esri-imagery', 'manual'],
|
|
['osm', 'automatic'],
|
|
['photoreal', 'manual'],
|
|
]);
|
|
env.controller.destroy();
|
|
|
|
// A failed activation that recovers settles as automatic.
|
|
const recovering = fixture(
|
|
{
|
|
defaultId: 'first',
|
|
recoveryId: 'recovery',
|
|
sources: [
|
|
{
|
|
descriptor: descriptor('first'),
|
|
imagery: async () => {
|
|
throw new Error('first offline');
|
|
},
|
|
},
|
|
{ descriptor: descriptor('recovery'), imagery: async () => ({}) },
|
|
],
|
|
},
|
|
{ onError: () => {} },
|
|
);
|
|
const recovered = [];
|
|
recovering.controller.subscribe((state) =>
|
|
recovered.push([state.activeId, state.switchOrigin]),
|
|
);
|
|
await recovering.controller.setStack('first');
|
|
assert.equal(recovering.controller.getActiveId(), 'recovery');
|
|
assert.equal(recovering.controller.getSwitchOrigin(), 'automatic');
|
|
await recovering.controller.setStack('recovery');
|
|
assert.equal(recovering.controller.getSwitchOrigin(), 'manual');
|
|
assert.deepEqual(recovered, [
|
|
['recovery', 'automatic'],
|
|
['recovery', 'manual'],
|
|
]);
|
|
recovering.controller.destroy();
|
|
});
|
|
|
|
// --- On a globe engine: scene changes go through engine.maps ----------------
|
|
|
|
async function engineFixture({ googleTileset = { show: true }, engine } = {}) {
|
|
const { createFakeEngine } = await import('../globe/testing/fakeEngine.js');
|
|
engine ??= createFakeEngine();
|
|
const registry = createDefaultMapSources({ googleTileset });
|
|
const providers = new Map();
|
|
for (const source of registry.sources) {
|
|
if (!source.imagery) continue;
|
|
const provider = { id: source.descriptor.id, errorEvent: event() };
|
|
providers.set(source.descriptor.id, provider);
|
|
source.imagery = async () => provider;
|
|
source.terrain = {
|
|
id: 'keyless',
|
|
create: async () => ({ provider: { id: 'terrain' } }),
|
|
};
|
|
}
|
|
const changes = [];
|
|
const controller = new MapSourceController(null, {
|
|
registry,
|
|
engine,
|
|
onChange: (state) => changes.push(state),
|
|
});
|
|
return { engine, registry, providers, controller, changes, googleTileset };
|
|
}
|
|
|
|
test('on an engine a globe stack is base imagery, then no photoreal tiles, then terrain', async () => {
|
|
const env = await engineFixture();
|
|
await env.controller.setStack('esri-imagery');
|
|
const calls = env.engine.fake.calls.filter(({ method }) =>
|
|
method.startsWith('maps.'),
|
|
);
|
|
assert.deepEqual(
|
|
calls.map(({ method }) => method),
|
|
['maps.setBaseImagery', 'maps.setPhotorealTiles', 'maps.setTerrain'],
|
|
);
|
|
const [imagery] = calls[0].args;
|
|
assert.equal(imagery.provider, env.providers.get('esri-imagery'));
|
|
assert.equal(imagery.descriptor.id, 'esri-imagery');
|
|
assert.match(imagery.credit, /Esri/);
|
|
assert.equal(calls[1].args[0], null);
|
|
assert.deepEqual(await calls[2].args[0].create(), {
|
|
provider: { id: 'terrain' },
|
|
});
|
|
assert.equal(env.controller.getActiveId(), 'esri-imagery');
|
|
env.engine.fake.resetCalls();
|
|
await env.controller.setStack('esri-imagery');
|
|
assert.equal(
|
|
env.engine.fake.callsOf('maps.setTerrain').length,
|
|
0,
|
|
'terrain stays applied',
|
|
);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('on an engine a photoreal stack hands the engine its tileset and credit', async () => {
|
|
const env = await engineFixture();
|
|
await env.controller.setStack('osm');
|
|
env.engine.fake.resetCalls();
|
|
await env.controller.setStack('photoreal');
|
|
const [call] = env.engine.fake.callsOf('maps.setPhotorealTiles');
|
|
assert.equal(call.args[0].tileset, env.googleTileset);
|
|
assert.equal(env.engine.fake.callsOf('maps.setBaseImagery').length, 0);
|
|
assert.equal(env.controller.getActiveId(), 'photoreal');
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('on an engine tile failures still fall back through the error watch', async () => {
|
|
const env = await engineFixture();
|
|
await env.controller.setStack('esri-imagery');
|
|
const errors = env.providers.get('esri-imagery').errorEvent;
|
|
assert.equal(errors.size, 1);
|
|
errors.raise();
|
|
errors.raise();
|
|
await settle();
|
|
assert.equal(env.controller.getActiveId(), 'osm');
|
|
assert.equal(errors.size, 0);
|
|
assert.equal(
|
|
env.engine.fake.callsOf('maps.setBaseImagery').at(-1).args[0].provider,
|
|
env.providers.get('osm'),
|
|
);
|
|
env.controller.destroy();
|
|
});
|
|
|
|
test('on an engine owned tilesets are released through engine.maps and disposed', async () => {
|
|
const { createFakeEngine } = await import('../globe/testing/fakeEngine.js');
|
|
const engine = createFakeEngine();
|
|
let destroyed = 0;
|
|
const owned = { show: false, destroy: () => destroyed++ };
|
|
const controller = new MapSourceController(null, {
|
|
engine,
|
|
registry: {
|
|
defaultId: 'owned',
|
|
sources: [
|
|
{ descriptor: descriptor('owned'), createTileset: async () => owned },
|
|
],
|
|
},
|
|
});
|
|
await controller.setStack('owned');
|
|
assert.equal(
|
|
engine.fake.callsOf('maps.setPhotorealTiles')[0].args[0].tileset,
|
|
owned,
|
|
);
|
|
controller.destroy();
|
|
assert.deepEqual(engine.fake.callsOf('maps.releasePhotorealTiles')[0].args, [
|
|
{ tileset: owned },
|
|
]);
|
|
assert.equal(destroyed, 1);
|
|
});
|
|
|
|
test('controller and Cesium engine: photoreal to a globe stack restores imagery and credit and back', async () => {
|
|
const { createCesiumEngine } =
|
|
await import('../globe/cesium/createCesiumEngine.js');
|
|
const { createFakeViewer } =
|
|
await import('../globe/cesium/testing/fakeViewer.mjs');
|
|
const viewer = createFakeViewer();
|
|
const google = { show: true };
|
|
viewer.primitiveList.push(google);
|
|
viewer.scene.globe.show = false;
|
|
const engine = createCesiumEngine(viewer, {
|
|
tilesetRef: () => google,
|
|
requestRender: () => {},
|
|
createImageryLayer: (provider) => ({ provider }),
|
|
});
|
|
const env = await engineFixture({ googleTileset: google, engine });
|
|
const credits = () => viewer.staticCredits.map((credit) => credit.html);
|
|
await env.controller.setStack('photoreal');
|
|
assert.equal(google.show, true);
|
|
assert.equal(viewer.scene.globe.show, false);
|
|
const photorealCredits = credits();
|
|
await env.controller.setStack('esri-imagery');
|
|
assert.equal(google.show, false);
|
|
assert.equal(viewer.scene.globe.show, true);
|
|
assert.deepEqual(viewer.imageryList, [
|
|
{ provider: env.providers.get('esri-imagery') },
|
|
]);
|
|
assert.equal(credits().length, 1);
|
|
assert.match(credits()[0], /Esri/);
|
|
assert.equal(viewer.terrainProvider?.id, 'terrain', 'terrain applied');
|
|
await env.controller.setStack('osm');
|
|
assert.deepEqual(viewer.imageryList, [
|
|
{ provider: env.providers.get('osm') },
|
|
]);
|
|
assert.deepEqual(credits(), [], 'OSM carries no static credit');
|
|
await env.controller.setStack('photoreal');
|
|
assert.deepEqual(viewer.imageryList, []);
|
|
assert.equal(google.show, true);
|
|
assert.equal(viewer.scene.globe.show, false);
|
|
assert.deepEqual(credits(), photorealCredits);
|
|
env.controller.destroy();
|
|
engine.destroy();
|
|
assert.deepEqual(credits(), []);
|
|
});
|