mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
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.
282 lines
14 KiB
JavaScript
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, []);
|
|
});
|