mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Street Level: a replacement keeps its own state, and a posted view stands down
- Releasing a held viewer frees the old source's adapter without resetting the panel, so a replacement's error, outcome and armed OPEN survive; a cross-source replacement drops the old photo's details and marker. - The action holds the open photo only for its own switch-off: a source switched by hand during the load stops it and reports cancelled. - A posted view waiting on terrain watches the camera and stands down after a navigation or a globe press; a flat or straight-down camera asks no terrain. - An arming link opens the panel without persisting the layout, and a posted view's street-level step runs as programmatic. - An off-globe street_level point throws TypeError. - zh-Hant uses the file's wording for the new strings; README and CURRENT-STATE count 35 tools.
This commit is contained in:
1 parent
45a33b54df
commit
4fd36c44e0
14 files changed
+391
-84
No files matched your search
@@ -0,0 +1,201 @@
|
||||
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';
|
||||
|
||||
// Replacing a street-level photo, across sources and against the user's own
|
||||
// moves; posted views waiting on terrain. 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');
|
||||
});
|
||||
Reference in new issue
Block a user