mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-22 03:02:20 +00:00
Main's camera, voice, Cockpit and layer work now runs on the globe contract where this branch draws through it: - The voice tilt to an angle, its pivot about the place under the crosshair and the frame limit from orbit run through the camera rig; src/globeInView.js measures a camera pose with src/geo instead of a Cesium camera. The free-look height limit and the globe-in-view recovery stay Cesium-only for now. - Cockpit takes main's own-layer entry rule. Double-clicking the followed track goes through cockpitHost.routeDoubleClick, so it works on both engines. - Space Missions' failed-entry rollback and GhostMaps' age filter run in the engine-neutral layer code. On Cesium an expired report is dropped in place; on Navara its product is redrawn. - Wildlife Sightings joins the catalog Cesium-only: Navara leaves it out, and the shell builds its card only for the real layer, so a Navara page no longer fails to start on its stand-in. - One instruction sentence is shorter, which keeps the Realtime prompt within its 55,500-character budget with the Sentinel-2 basemap.
566 lines
20 KiB
JavaScript
566 lines
20 KiB
JavaScript
// The W1 voice actions on the globe engine: the same
|
|
// results as on the Cesium viewer, through engine.camera / picker /
|
|
// projector only, and a structured refusal when a required capability
|
|
// is missing from the attached scene.
|
|
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import * as Cesium from 'cesium';
|
|
import * as geo from '../geo/index.js';
|
|
import { createFakeEngine } from '../globe/testing/fakeEngine.js';
|
|
import { GEV_ACTION_SCHEMAS } from './actionSchemas.js';
|
|
import {
|
|
UNAVAILABLE_FEATURES,
|
|
UNAVAILABLE_ON_ENGINE,
|
|
createGevActionRunner,
|
|
} from './gevActions.js';
|
|
import { cameraPoseKey } from './pointerContext.js';
|
|
import { createPointerPicker } from './pointerPick.js';
|
|
import { renderFreshFrame } from './realtimeViewport.js';
|
|
|
|
globalThis.window ||= {
|
|
setTimeout,
|
|
clearTimeout,
|
|
requestIdleCallback: null,
|
|
};
|
|
|
|
const toRad = geo.math.toRadians;
|
|
|
|
/** A fake engine over Austin at `altitude`, looking straight down. */
|
|
function engineOverAustin(options = {}) {
|
|
return createFakeEngine({
|
|
longitude: toRad(-97.74),
|
|
latitude: toRad(30.27),
|
|
altitude: 20_000,
|
|
...options,
|
|
});
|
|
}
|
|
|
|
/** The UI navigation seam, without its policy: runs the move. */
|
|
const navigatingStyleManager = (extra = {}) => ({
|
|
runImmediateNavigation: (noun, navigate) => navigate(),
|
|
...extra,
|
|
});
|
|
|
|
function dataManagerWith(modules, { enabled = Object.keys(modules) } = {}) {
|
|
const on = new Set(enabled);
|
|
const params = [];
|
|
return {
|
|
params,
|
|
layers: new Map(
|
|
Object.entries(modules).map(([id, module]) => [id, { id, module }]),
|
|
),
|
|
isEnabled: (id) => on.has(id),
|
|
getAll: () =>
|
|
Object.keys(modules).map((id) => ({
|
|
id,
|
|
name: id,
|
|
enabled: on.has(id),
|
|
stats: modules[id]?.getStats?.() || {},
|
|
})),
|
|
setLayerParams(id, values) {
|
|
params.push({ id, values });
|
|
return true;
|
|
},
|
|
async setEnabled(id, value) {
|
|
if (value) on.add(id);
|
|
else on.delete(id);
|
|
return true;
|
|
},
|
|
};
|
|
}
|
|
|
|
const runnerOn = (engine, options = {}) =>
|
|
createGevActionRunner({
|
|
viewer: null,
|
|
engine,
|
|
styleManager: navigatingStyleManager(),
|
|
dataManager: dataManagerWith({}),
|
|
...options,
|
|
});
|
|
|
|
const follow = (engine, position) =>
|
|
engine.camera.follow({
|
|
position: () => position,
|
|
viewFrom: { x: 0, y: -2000, z: 800 },
|
|
});
|
|
|
|
test('every capability-gated action is a real offered tool', () => {
|
|
const tools = new Set(GEV_ACTION_SCHEMAS.map((schema) => schema.name));
|
|
for (const name of Object.keys(UNAVAILABLE_FEATURES))
|
|
assert.ok(tools.has(name), `${name} is a voice tool`);
|
|
});
|
|
|
|
for (const kind of ['cesium', 'navara'])
|
|
test(`${kind} enters cockpit on a ready tracked aircraft without starting Contacts`, async () => {
|
|
const engine = engineOverAustin({ kind });
|
|
const runner = runnerOn(engine, {
|
|
styleManager: {
|
|
getCockpitState: () => ({ entryAllowed: true }),
|
|
getAircraftTrackingTarget: () => ({ layerId: 'flights', id: '507c84' }),
|
|
setContextMode: () =>
|
|
assert.fail('the selected flight already owns the camera'),
|
|
controlCockpit: (action, { rollbackTarget }) => {
|
|
assert.equal(action, 'enter');
|
|
assert.equal(rollbackTarget.id, '507c84');
|
|
return { ok: true, state: { active: true } };
|
|
},
|
|
},
|
|
});
|
|
const result = await runner('control_cockpit', { action: 'enter' });
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.state.active, true);
|
|
});
|
|
|
|
test('missing scene capabilities refuse with a structured result', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const touched = [];
|
|
const styleManager = new Proxy(navigatingStyleManager(), {
|
|
get(target, key) {
|
|
if (typeof key === 'string') touched.push(key);
|
|
return target[key];
|
|
},
|
|
});
|
|
delete engine.camera.lookAt;
|
|
const runner = runnerOn(engine, { styleManager });
|
|
// The runner subscribes to camera handoffs when it is made.
|
|
touched.length = 0;
|
|
engine.fake.resetCalls();
|
|
for (const name of [
|
|
'annotate_map',
|
|
'clear_annotations',
|
|
'fly_route',
|
|
'move_camera',
|
|
]) {
|
|
const result = await runner(name, { action: 'status' });
|
|
assert.equal(result.ok, false, name);
|
|
assert.equal(result.action, name);
|
|
assert.equal(result.unavailable, true, name);
|
|
assert.equal(result.code, UNAVAILABLE_ON_ENGINE, name);
|
|
assert.equal(result.engine, 'navara', name);
|
|
assert.equal(result.feature, UNAVAILABLE_FEATURES[name], name);
|
|
assert.equal(result.suggestion, '?engine=cesium', name);
|
|
assert.equal(
|
|
result.error,
|
|
`${UNAVAILABLE_FEATURES[name]} is not available on the Navara engine yet. Switch to the Cesium engine (?engine=cesium) to use it.`,
|
|
name,
|
|
);
|
|
}
|
|
assert.deepEqual(touched, [], 'a refusal reaches no controller');
|
|
assert.deepEqual(engine.fake.calls, [], 'a refusal moves no camera');
|
|
});
|
|
|
|
test('with a viewer radio still reports a missing layer', async () => {
|
|
const runner = createGevActionRunner({
|
|
viewer: {
|
|
clock: { onTick: { addEventListener: () => () => {} } },
|
|
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
|
camera: { moveEnd: { addEventListener() {} } },
|
|
},
|
|
engine: engineOverAustin(),
|
|
styleManager: {},
|
|
dataManager: dataManagerWith({}),
|
|
});
|
|
const radio = await runner('control_radio', { action: 'status' });
|
|
assert.equal(radio.error, 'Radio layer unavailable');
|
|
assert.equal(radio.unavailable, undefined);
|
|
});
|
|
|
|
test('the runner warms the view target on the engine camera, once per engine', () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
runnerOn(engine);
|
|
runnerOn(engine);
|
|
assert.equal(engine.camera.moveEnd.numberOfListeners, 1);
|
|
});
|
|
|
|
test('stop_tracking stops the engine follow', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const target = geo.cartesian3.fromDegrees(-97.7, 30.3, 9000);
|
|
follow(engine, target);
|
|
assert.ok(engine.camera.following());
|
|
const released = [];
|
|
const runner = runnerOn(engine, {
|
|
dataManager: dataManagerWith({
|
|
flights: {
|
|
getTrackedInfo: () => ({ id: 'abc' }),
|
|
stopTracking: () => released.push('flights'),
|
|
},
|
|
}),
|
|
});
|
|
const result = await runner('stop_tracking');
|
|
assert.equal(result.ok, true);
|
|
assert.deepEqual(result.released, ['flights']);
|
|
assert.equal(engine.camera.following(), null);
|
|
});
|
|
|
|
test('zoom_to_globe leaves the follow and flies the engine camera', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
follow(engine, geo.cartesian3.fromDegrees(-97.7, 30.3, 9000));
|
|
const runner = runnerOn(engine);
|
|
const result = await runner('zoom_to_globe');
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.heightKm > 1000, true);
|
|
assert.equal(engine.camera.following(), null);
|
|
assert.equal(engine.fake.callsOf('camera.flyTo').length, 1);
|
|
});
|
|
|
|
test('fly_to_location to coordinates leaves the follow and flies the engine', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
follow(engine, geo.cartesian3.fromDegrees(-97.7, 30.3, 9000));
|
|
const runner = runnerOn(engine);
|
|
const result = await runner('fly_to_location', {
|
|
latitude: 51.5,
|
|
longitude: -0.12,
|
|
});
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.navigationMode, 'close-coordinate');
|
|
assert.equal(engine.camera.following(), null);
|
|
assert.equal(engine.fake.callsOf('camera.flyToSphere').length, 1);
|
|
engine.fake.frames(400, 16);
|
|
const place = engine.camera.pose().cartographic;
|
|
assert.ok(Math.abs(geo.math.toDegrees(place.latitude) - 51.5) < 0.05);
|
|
});
|
|
|
|
test('track_entity flies to a vessel through the engine', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
let selected = null;
|
|
const runner = runnerOn(engine, {
|
|
dataManager: dataManagerWith({
|
|
'ais-live-vessels': {
|
|
findByQuery: () => ({
|
|
mmsi: 366999999,
|
|
name: 'EVER GIVEN',
|
|
latitude: 29.7,
|
|
longitude: -95.0,
|
|
}),
|
|
selectById: (mmsi) => (selected = mmsi),
|
|
},
|
|
}),
|
|
});
|
|
const result = await runner('track_entity', {
|
|
query: 'ever given',
|
|
layerId: 'ais-live-vessels',
|
|
});
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.label, 'EVER GIVEN');
|
|
assert.equal(selected, 366999999);
|
|
assert.equal(engine.fake.callsOf('camera.flyToSphere').length, 1);
|
|
});
|
|
|
|
test('frame_overhead frames the nearby contacts with flyToSphere as on Cesium', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const center = engine.camera.pickEllipsoid({ x: 512, y: 384 });
|
|
const positions = [
|
|
geo.cartesian3.fromDegrees(-97.7, 30.3, 9000),
|
|
geo.cartesian3.fromDegrees(-97.9, 30.1, 11000),
|
|
geo.cartesian3.fromDegrees(-97.5, 30.5, 10000),
|
|
];
|
|
let asked = null;
|
|
const runner = runnerOn(engine, {
|
|
dataManager: dataManagerWith({
|
|
flights: {
|
|
getNearby(at, radiusM, limit) {
|
|
asked = { at, radiusM, limit };
|
|
return positions.map((position, index) => ({
|
|
id: `F${index}`,
|
|
icao24: `a${index}`,
|
|
label: `F${index}`,
|
|
position,
|
|
}));
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
const heading = engine.camera.pose().heading;
|
|
const result = await runner('frame_overhead', { target: 'flights' });
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.count, 3);
|
|
assert.equal(asked.radiusM, 150_000);
|
|
assert.equal(asked.limit, 80);
|
|
assert.ok(geo.cartesian3.distance(asked.at, center) < 1e-6);
|
|
// The same sphere and offset the Cesium path flew.
|
|
const sphere = Cesium.BoundingSphere.fromPoints(positions);
|
|
const radius = Math.max(sphere.radius * 1.25, 8000);
|
|
const [call] = engine.fake.callsOf('camera.flyToSphere');
|
|
const [flown, options] = call.args;
|
|
assert.ok(geo.cartesian3.distance(flown.center, sphere.center) < 1e-6);
|
|
assert.equal(flown.radius, radius);
|
|
assert.equal(options.duration, 2);
|
|
assert.equal(options.heading, heading);
|
|
assert.equal(options.pitch, toRad(-62));
|
|
assert.equal(options.range, radius * 2.4);
|
|
});
|
|
|
|
test('next_iss_pass observes from the engine camera', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
let observer = null;
|
|
const runner = runnerOn(engine, {
|
|
dataManager: dataManagerWith({
|
|
satellites: {
|
|
getNextIssPass(options) {
|
|
observer = options;
|
|
return { status: 'none' };
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
const result = await runner('next_iss_pass');
|
|
assert.equal(result.ok, false);
|
|
assert.ok(Math.abs(observer.latDeg - 30.27) < 1e-6);
|
|
assert.ok(Math.abs(observer.lonDeg + 97.74) < 1e-6);
|
|
});
|
|
|
|
test('get_current_view_state reads the engine camera', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const runner = runnerOn(engine, {
|
|
styleManager: navigatingStyleManager({ activeStyle: 'noir' }),
|
|
});
|
|
const result = await runner('get_current_view_state');
|
|
assert.equal(result.ok, true);
|
|
assert.ok(Math.abs(result.camera.latitude - 30.27) < 1e-6);
|
|
assert.ok(Math.abs(result.camera.longitude + 97.74) < 1e-6);
|
|
assert.ok(Math.abs(result.camera.heightM - 20_000) < 1e-3);
|
|
});
|
|
|
|
test('adjust_camera_zoom moves the engine camera toward the view target', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const runner = runnerOn(engine);
|
|
const result = await runner('adjust_camera_zoom', {
|
|
direction: 'in',
|
|
amount: 'medium',
|
|
});
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.movementRequestedM, 11_000);
|
|
assert.equal(result.movementActualM, 11_000);
|
|
assert.equal(result.afterHeightM, 9000);
|
|
assert.equal(engine.fake.callsOf('camera.cancelFlight').length, 1);
|
|
});
|
|
|
|
test('get_entity_context samples the view through the engine', async () => {
|
|
// Continental: no reverse geocoding, every viewport sample on the globe.
|
|
const engine = engineOverAustin({ kind: 'navara', altitude: 4_000_000 });
|
|
const runner = runnerOn(engine);
|
|
const result = await runner('get_entity_context', { scope: 'in_view' });
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.scene.camera.heightM, 4_000_000);
|
|
assert.equal(result.scene.basemap.viewScale, 'continental');
|
|
assert.equal(result.scene.basemap.viewportSamples.length, 7);
|
|
// The view centre, on the ellipsoid under the camera.
|
|
const [centre] = result.scene.basemap.viewportSamples;
|
|
assert.ok(Math.abs(centre.latitude - 30.27) < 0.1);
|
|
assert.equal(centre.longitude, -97.74);
|
|
});
|
|
|
|
test('select_nearest_aircraft runs on the engine end to end', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
let tracked = null;
|
|
const flights = {
|
|
getStats: () => ({ count: 2, source: 'fixture' }),
|
|
getAnalystRecords: () => [
|
|
{
|
|
id: 'FAR1',
|
|
icao24: 'f1',
|
|
callsign: 'FAR1',
|
|
lat: 30.4,
|
|
lon: -97.7,
|
|
onGround: false,
|
|
},
|
|
{
|
|
id: 'NEAR1',
|
|
icao24: 'n1',
|
|
callsign: 'NEAR1',
|
|
lat: 30.3,
|
|
lon: -97.7,
|
|
onGround: false,
|
|
},
|
|
],
|
|
findByQuery: (query) =>
|
|
query === 'n1'
|
|
? { icao24: 'n1', callsign: 'NEAR1', latitude: 30.3, longitude: -97.7 }
|
|
: null,
|
|
trackById: (id) => (tracked = id),
|
|
};
|
|
const dataManager = dataManagerWith({ flights }, { enabled: [] });
|
|
dataManager.refreshLayer = async () => true;
|
|
const runner = runnerOn(engine, { dataManager });
|
|
const pending = runner('select_nearest_aircraft', {
|
|
latitude: 30.27,
|
|
longitude: -97.74,
|
|
});
|
|
for (let index = 0; index < 50 && !tracked; index++) {
|
|
engine.fake.frames(20, 16);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
const result = await pending;
|
|
assert.equal(result.ok, true, result.error);
|
|
assert.equal(result.aircraft.id, 'n1');
|
|
assert.equal(tracked, 'n1');
|
|
});
|
|
|
|
test('the camera pose key reads the engine pose', () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const { position, heading, pitch, roll } = engine.camera.pose();
|
|
const angle = (value) => Math.round(value * 1000);
|
|
assert.equal(
|
|
cameraPoseKey(engine),
|
|
[
|
|
Math.round(position.x),
|
|
Math.round(position.y),
|
|
Math.round(position.z),
|
|
angle(heading),
|
|
angle(pitch),
|
|
angle(roll),
|
|
].join(','),
|
|
);
|
|
});
|
|
|
|
test('the pointer picker picks through the engine', () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
engine.fake.script('pick', { id: { __gevContextId: 'none' } });
|
|
const pick = createPointerPicker({ engine, dataManager: null });
|
|
const result = pick(512, 384);
|
|
assert.equal(result.entity, null);
|
|
assert.ok(Math.abs(result.ground.lat - 30.27) < 1e-4);
|
|
assert.ok(Math.abs(result.ground.lon + 97.74) < 1e-4);
|
|
assert.equal(result.radiusKm, 15);
|
|
assert.equal(result.cameraKey, cameraPoseKey(engine));
|
|
const [screen] = engine.fake.callsOf('picker.pick')[0].args;
|
|
assert.deepEqual([screen.x, screen.y], [512, 384]);
|
|
});
|
|
|
|
test('a fresh frame for capture comes from the engine render loop', async () => {
|
|
const previous = globalThis.document;
|
|
try {
|
|
globalThis.document = { hidden: false };
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
engine.fake.resetCalls();
|
|
const fresh = renderFreshFrame(engine);
|
|
assert.equal(engine.fake.renderRequests, 1);
|
|
engine.fake.frame();
|
|
assert.equal(await fresh, true);
|
|
globalThis.document = { hidden: true };
|
|
assert.equal(await renderFreshFrame(engine), false);
|
|
assert.equal(engine.fake.renderRequests, 1, 'no render while hidden');
|
|
} finally {
|
|
globalThis.document = previous;
|
|
}
|
|
});
|
|
|
|
test('missing visual style and bloom capabilities refuse and record nothing', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const calls = [];
|
|
const styleManager = navigatingStyleManager({
|
|
setStyle: (...args) => calls.push(['setStyle', ...args]),
|
|
setBloom: (...args) => calls.push(['setBloom', ...args]) && {},
|
|
setSharpen: (...args) => calls.push(['setSharpen', ...args]) && {},
|
|
});
|
|
const runner = runnerOn(engine, { styleManager });
|
|
const style = await runner('set_visual_style', { style: 'thermal' });
|
|
assert.equal(style.ok, false);
|
|
assert.equal(style.code, UNAVAILABLE_ON_ENGINE);
|
|
assert.match(
|
|
style.error,
|
|
/visual style is not available on the Navara engine/,
|
|
);
|
|
const post = await runner('set_post_processing', {
|
|
bloom: { enabled: true },
|
|
});
|
|
assert.equal(post.ok, false);
|
|
assert.equal(post.code, UNAVAILABLE_ON_ENGINE);
|
|
assert.deepEqual(calls, [], 'no style is applied or recorded');
|
|
});
|
|
|
|
test('with a viewer the visual style still applies', async () => {
|
|
const calls = [];
|
|
const runner = createGevActionRunner({
|
|
viewer: {
|
|
clock: { onTick: { addEventListener: () => () => {} } },
|
|
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
|
camera: { moveEnd: { addEventListener() {} } },
|
|
},
|
|
engine: engineOverAustin(),
|
|
styleManager: navigatingStyleManager({
|
|
setStyle: (style) => calls.push(style),
|
|
}),
|
|
dataManager: dataManagerWith({}),
|
|
});
|
|
const result = await runner('set_visual_style', { style: 'thermal' });
|
|
assert.equal(result.ok, true);
|
|
assert.deepEqual(calls, ['thermal']);
|
|
});
|
|
|
|
test('without a viewer a layer the engine lacks refuses instead of throwing', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const runner = runnerOn(engine, {
|
|
dataManager: dataManagerWith({ flights: {} }),
|
|
});
|
|
const result = await runner('set_layer_visibility', {
|
|
layerId: 'cctv',
|
|
enabled: true,
|
|
});
|
|
assert.equal(result.ok, false);
|
|
assert.equal(result.code, UNAVAILABLE_ON_ENGINE);
|
|
assert.equal(result.layerId, 'cctv');
|
|
assert.equal(result.suggestion, '?engine=cesium');
|
|
assert.match(
|
|
result.error,
|
|
/The cctv layer is not available on the Navara engine yet/,
|
|
);
|
|
await assert.rejects(
|
|
runner('set_layer_visibility', { layerId: 'no-such-layer', enabled: true }),
|
|
/Unknown data layer/,
|
|
'a name no engine knows is still an unknown layer',
|
|
);
|
|
});
|
|
|
|
test('without a viewer analyst_query on a layer the engine lacks refuses', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const runner = runnerOn(engine, {
|
|
dataManager: dataManagerWith({ flights: {} }),
|
|
});
|
|
const one = await runner('analyst_query', { layers: ['cctv'] });
|
|
assert.equal(one.ok, false);
|
|
assert.equal(one.code, UNAVAILABLE_ON_ENGINE);
|
|
assert.deepEqual(one.layerIds, ['cctv']);
|
|
assert.match(
|
|
one.error,
|
|
/^The cctv layer is not available on the Navara engine yet/,
|
|
);
|
|
const two = await runner('analyst_query', { layers: ['cctv', 'vessels'] });
|
|
assert.match(
|
|
two.error,
|
|
/^The cctv, ais-live-vessels layers are not available on the Navara engine yet\. Switch to the Cesium engine \(\?engine=cesium\) to use them\.$/,
|
|
);
|
|
});
|
|
|
|
test('stop_tracking with nothing tracked is a no-op success, also without the layers', async () => {
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const dataManager = dataManagerWith({
|
|
flights: { getTrackedInfo: () => null },
|
|
});
|
|
// As the manager answers: a layer it does not hold takes no params.
|
|
dataManager.setLayerParams = (id) => dataManager.layers.has(id);
|
|
const runner = runnerOn(engine, { dataManager });
|
|
const result = await runner('stop_tracking', {});
|
|
assert.equal(result.ok, true);
|
|
assert.deepEqual(result.released, []);
|
|
});
|
|
|
|
test('the spoken refusal of an unavailable layer carries its reason', async () => {
|
|
const { SPEECH_BUILDERS } = await import('./speech.js');
|
|
const engine = engineOverAustin({ kind: 'navara' });
|
|
const runner = runnerOn(engine, {
|
|
dataManager: dataManagerWith({ flights: {} }),
|
|
});
|
|
const result = await runner('set_layer_visibility', {
|
|
layerId: 'cctv',
|
|
enabled: true,
|
|
});
|
|
const speech = SPEECH_BUILDERS.set_layer_visibility(result, {
|
|
layerId: 'cctv',
|
|
enabled: true,
|
|
});
|
|
assert.equal(speech.say, result.error);
|
|
assert.match(speech.say, /Switch to the Cesium engine/);
|
|
});
|