Files
gods-eye-view/src/streetLevelReplacement.test.mjs
T
German Khokhlov 71797427d6 Street Level: a posted view whose camera was taken stands down whole again
Applying the rest of a posted view after the camera was taken during its
terrain wait still let it change the camera: stop_tracking dropped a follow
the user had just started, and annotate_map framed the view's marks. A
camera taken during the wait now ends the view again, as before. The 2 s
terrain timeout and the per-view catch on the queue stay.
2026-11-11 19:01:58 +04:00

282 lines
14 KiB
JavaScript

import './testSupport/registerDom.mjs';
import test from 'node:test';
import assert from 'node:assert/strict';
import { createStreetLevelLayer } from './layers/streetLevel/index.js';
import { fakeStreetLevelProvider, fakeCesiumViewer } from './testSupport/streetLevelFakes.mjs';
import { showStreetLevel } from './voice/gevActions.js';
import { installViews } from './app/embed.js';
import { groundedLookAt } from './view/index.js';
import { composeCatalog, coreTools } from './tools/index.js';
// Replacing a street-level photo, across sources and against the user's own
// moves; posted views waiting on terrain, and their look-at near a pole.
// Offline: providers, lookups, terrain and flights are fixtures.
globalThis.fetch = async () => { throw new Error('Unexpected network use in offline test'); };
const settle = () => new Promise(resolve => setTimeout(resolve, 0));
function deferred() {
let resolve;
const promise = new Promise(done => { resolve = done; });
return { promise, resolve };
}
function provider(id, { nearest = async () => 'B', load = async () => {}, billed = false } = {}) {
const def = fakeStreetLevelProvider({ id, pickPrefix: id + ':', nearestImage: nearest });
def.name = id;
def.label = id.toUpperCase();
def.billedPerImage = billed;
const create = def.create;
def.create = context => {
const instance = create(context);
let pose;
instance.viewer.onPose = listener => { pose = listener; return () => { pose = null; }; };
instance.viewer.open = async imageId => {
def.calls.open.push(imageId);
await load(imageId);
pose?.({ imageId, position: { lat: 48, lon: 2 }, creator: 'fixture photographer',
externalUrl: 'https://www.mapillary.com/app/?pKey=' + imageId });
};
return instance;
};
return def;
}
async function harness(t, defs) {
document.body.className = '';
document.body.replaceChildren();
const viewer = fakeCesiumViewer();
viewer.canvas = viewer.scene.canvas;
viewer.canvas.setPointerCapture = () => {};
const layer = createStreetLevelLayer({ providers: defs });
layer.init(viewer);
layer.enable(viewer);
layer.attachViewerHost(document.body.appendChild(document.createElement('div')));
t.after(() => { layer.destroy(); document.body.className = ''; document.body.replaceChildren(); });
await settle();
const dataManager = {
layers: new Map([['street-level', { module: layer }]]),
getAll: () => [{ id: 'street-level', enabled: true }],
isEnabled: () => true,
getLayerParams: () => ({ mapillary: true }),
setLayerParams: (_id, params) => layer.setParams(params),
};
const shell = { _navigationGeneration: 1, initialRestorePromise: Promise.resolve(), setCleanView() {} };
const flights = [];
const context = { viewer, dataManager, styleManager: shell,
runOptions: { signal: new AbortController().signal },
runGevAction: async (name, args) => {
assert.equal(name, 'fly_to_location');
flights.push(args);
return { ok: true, latitude: args.latitude, longitude: args.longitude, label: 'fixture point' };
},
};
const run = (name, args) => name === 'show_street_level' ? showStreetLevel(args, context) : Promise.resolve({ ok: true });
return { layer, viewer, dataManager, shell, context, run, flights };
}
async function embed(t, h, terrain) {
const replies = [];
const peer = { postMessage: message => replies.push(message) };
const windowRef = new EventTarget();
windowRef.parent = peer;
windowRef.document = document;
const remove = installViews({ ...h, terrain, windowRef, location: { search: '?embed=1', hash: '' } });
t.after(remove);
await settle();
const post = (id, view) => {
const event = new Event('message');
Object.assign(event, { source: peer, origin: 'https://host.example', data: { type: 'gev:view', id, view } });
windowRef.dispatchEvent(event);
};
return { post, replies };
}
const args = provider => ({ provider, latitude: 48, longitude: 2, fly: false });
const view = pitch => ({ camera: { lat: 48, lon: 2, altitude_m: 1000, pitch_deg: pitch }, street_level: { provider: 'mapillary' } });
for (const outcome of ['empty', 'error']) {
test('a replacement from another source that opens nothing keeps its explanation (' + outcome + ')', async t => {
const a = provider('mapillary');
const b = provider('panoramax', { nearest: async () => {
if (outcome === 'error') throw new Error('Fixture lookup failure');
return null;
} });
const h = await harness(t, [a, b]);
assert.equal(await h.layer.openImage('mapillary', 'A', { frame: false }), true);
const result = await showStreetLevel(args('panoramax'), h.context);
const street = h.layer.getUIState().street;
t.diagnostic(JSON.stringify({ result, error: street.error, nearestOutcome: street.nearestOutcome }));
assert.equal(result.ok, false);
assert.equal(street.open, false);
assert.ok(street.error, 'replacement explanation must survive release');
if (outcome === 'empty') assert.equal(street.nearestOutcome, 'empty');
});
}
test('an arming link from another source keeps its armed point', async t => {
const h = await harness(t, [provider('mapillary'), provider('google', { billed: true })]);
assert.equal(await h.layer.openImage('mapillary', 'A', { frame: false }), true);
const result = await showStreetLevel({ ...args('google'), autoOpen: false }, h.context);
const street = h.layer.getUIState().street;
t.diagnostic(JSON.stringify({ result, armed: street.armed }));
assert.equal(result.armed, true);
assert.deepEqual(street.armed?.point, { lat: 48, lon: 2 });
});
test('a same-source lookup that finds nothing keeps its explanation', async t => {
const h = await harness(t, [provider('mapillary', { nearest: async () => null })]);
await h.layer.openImage('mapillary', 'A', { frame: false });
const result = await showStreetLevel(args('mapillary'), h.context);
assert.equal(result.noImagery, true);
assert.ok(h.layer.getUIState().street.error);
assert.equal(h.layer.getUIState().street.nearestOutcome, 'empty');
});
for (const takeover of ['navigation', 'gesture', 'none']) {
test('a posted view waiting on terrain yields to the user (' + takeover + ')', async t => {
const a = provider('mapillary');
const h = await harness(t, [a]);
const entered = deferred();
const terrain = deferred();
const e = await embed(t, h, { getHeights: async () => { entered.resolve(); return terrain.promise; } });
e.post(1, view(-45));
await entered.promise;
if (takeover === 'navigation') h.shell._navigationGeneration++;
if (takeover === 'gesture') h.viewer.canvas.dispatchEvent(new Event('pointerdown'));
terrain.resolve([{ ellipsoid: 200 }]);
for (let n = 0; n < 8 && !e.replies.some(r => r.id === 1); n++) await settle();
const reply = e.replies.find(r => r.id === 1);
t.diagnostic(JSON.stringify({ takeover, flights: h.flights, opened: a.calls.open, reply }));
assert.ok(reply, 'host receives completion');
assert.equal(h.flights.length, takeover === 'none' ? 1 : 0, 'superseded view must not reclaim the camera');
assert.equal(a.calls.open.length, takeover === 'none' ? 1 : 0);
assert.equal(reply.ok, takeover === 'none');
});
}
test('a posted view looking at the horizon does not wait on terrain or hold the queue', async t => {
const h = await harness(t, [provider('mapillary')]);
const terrain = deferred();
let terrainCalls = 0;
const e = await embed(t, h, { getHeights: () => { terrainCalls++; return terrain.promise; } });
e.post(1, view(0));
e.post(2, { ...view(-90), street_level: { provider: 'mapillary', lat: 49, lon: 3 } });
for (let n = 0; n < 8; n++) await settle();
const before = e.replies.filter(r => r.id).map(r => r.id);
terrain.resolve([{ ellipsoid: 200 }]);
for (let n = 0; n < 8 && !e.replies.some(r => r.id === 2); n++) await settle();
const after = e.replies.filter(r => r.id).map(r => r.id);
t.diagnostic(JSON.stringify({ terrainCalls, before, after, flights: h.flights }));
assert.deepEqual(after, [1, 2], 'both complete after irrelevant terrain is released');
assert.deepEqual(before, [1, 2], 'both should complete without any terrain response');
assert.equal(terrainCalls, 0);
});
for (const initial of [true, false]) {
test('a source switched by hand during the load stops the request (photo open before: ' + initial + ')', async t => {
const entered = deferred();
const load = deferred();
const a = provider('mapillary', { load: async id => { if (id === 'B') { entered.resolve(); await load.promise; } } });
const h = await harness(t, [a, provider('panoramax')]);
if (initial) await h.layer.openImage('mapillary', 'A', { frame: false });
const request = showStreetLevel(args('mapillary'), h.context);
await entered.promise;
h.layer.setProviderEnabled('panoramax', true);
load.resolve();
const result = await request;
const street = h.layer.getUIState().street;
t.diagnostic(JSON.stringify({ initial, result, open: street.open, sourceOn: h.layer.providerStatus('mapillary').on }));
assert.equal(h.layer.providerStatus('mapillary').on, false);
assert.equal(street.open, false);
assert.equal(result.ok, false, 'request for the disabled source must not report success');
assert.equal(result.cancelled, true);
});
}
test('a failed replacement from another source does not keep the old photo\'s details', async t => {
const h = await harness(t, [provider('mapillary'), provider('panoramax', { load: async () => { throw new Error('Fixture image load failure'); } })]);
await h.layer.openImage('mapillary', 'A', { frame: false });
const before = h.layer.getUIState().street;
assert.equal(before.imageId, 'A');
assert.ok(before.externalUrl);
const result = await showStreetLevel(args('panoramax'), h.context);
const street = h.layer.getUIState().street;
t.diagnostic(JSON.stringify({ result, street }));
assert.equal(result.ok, false);
assert.equal(street.providerId, 'panoramax');
assert.match(street.error, /Fixture image load failure/);
assert.deepEqual({ imageId: street.imageId, position: street.position, creator: street.creator, externalUrl: street.externalUrl },
{ imageId: null, position: null, creator: null, externalUrl: null }, 'destroyed provider photo must not be attributed to replacement');
});
const rejections = [];
process.on('unhandledRejection', reason => { rejections.push(String(reason?.message || reason)); });
// 111 m from the North Pole, looking east and down: 1 km ahead is more than a
// full turn of that parallel.
const north = { camera: { lat: 89.999, lon: 170, altitude_m: 1000, pitch_deg: -45, heading_deg: 90 }, street_level: { provider: 'mapillary' } };
const placed = { camera: { lat: 48, lon: 2, altitude_m: 1000, pitch_deg: -45 }, street_level: { provider: 'mapillary', lat: 48, lon: 2 } };
test('a grounded look-at near a pole stays on the globe', async () => {
const point = await groundedLookAt(north.camera, { getHeights: async () => [{ ellipsoid: 0 }] });
assert.ok(Math.abs(point.lat) <= 90 && Math.abs(point.lon) <= 180, JSON.stringify(point));
});
test('show_in_gods_eye_view frames the South Pole with a tilted camera', async () => {
const catalog = composeCatalog({
tools: coreTools,
services: { app: { baseUrl: 'http://localhost:4173/' }, terrain: { getHeights: async () => [{ ellipsoid: 2835 }] } },
});
const result = await catalog.call('show_in_gods_eye_view', {
camera: { lat: -90, lon: 0, altitude_m: 3500, pitch_deg: -30, heading_deg: 45 },
street_level: { provider: 'mapillary' },
});
const street = result.data?.view?.street_level;
assert.ok(street && Math.abs(street.lat) <= 90 && Math.abs(street.lon) <= 180, JSON.stringify(result));
});
test('a posted polar view is answered and the next view still applies', async t => {
rejections.length = 0;
const h = await harness(t, [provider('mapillary')]);
const e = await embed(t, h, { getHeights: async () => [{ ellipsoid: 0 }] });
e.post(1, north);
e.post(2, placed);
for (let n = 0; n < 20 && !e.replies.some(r => r.id === 2); n++) await settle();
t.diagnostic(JSON.stringify({ replies: e.replies.filter(r => r.id), rejections }));
assert.ok(e.replies.some(r => r.id === 1), 'the polar view gets an answer');
assert.ok(e.replies.some(r => r.id === 2 && r.ok === true), 'the next view still applies');
assert.deepEqual(rejections, [], 'no rejection escapes the views queue');
});
test('a stalled terrain answer does not hold posted views', { timeout: 15000 }, async t => {
const h = await harness(t, [provider('mapillary')]);
let asked = 0;
// Hangs like a stalled upstream; gives up only when its signal aborts.
const terrain = {
getHeights: (_points, { signal } = {}) => {
asked++;
return new Promise((_, reject) => signal?.addEventListener('abort', () => reject(signal.reason), { once: true }));
},
};
const e = await embed(t, h, terrain);
e.post(1, view(-45));
e.post(2, placed);
const started = Date.now();
while (Date.now() - started < 5000 && !e.replies.some(r => r.id === 2)) await new Promise(resolve => setTimeout(resolve, 100));
t.diagnostic(JSON.stringify({ asked, waitedMs: Date.now() - started, replies: e.replies.filter(r => r.id).map(r => r.id) }));
assert.equal(asked, 1);
assert.ok(e.replies.some(r => r.id === 1), 'the view falls back to its own estimate within 5 s');
assert.ok(e.replies.some(r => r.id === 2), 'the next view is not held behind it');
});
test('a posted view that throws is answered and does not hold the views behind it', async t => {
rejections.length = 0;
const h = await harness(t, [provider('mapillary')]);
const getAll = h.dataManager.getAll;
let calls = 0;
h.dataManager.getAll = () => {
if (calls++ === 0) throw new Error('Fixture layer list failure');
return getAll();
};
const e = await embed(t, h, null);
e.post(1, placed);
e.post(2, placed);
for (let n = 0; n < 20 && !e.replies.some(r => r.id === 2); n++) await settle();
t.diagnostic(JSON.stringify({ replies: e.replies.filter(r => r.id), rejections }));
assert.deepEqual(e.replies.find(r => r.id === 1), { type: 'gev:view-applied', id: 1, ok: false, error: 'Fixture layer list failure' });
assert.ok(e.replies.some(r => r.id === 2 && r.ok === true), 'the next view still applies');
assert.deepEqual(rejections, []);
});