Files
gods-eye-view/src/layers/traffic/navigation.test.mjs
T
f4fcf267c6 fix(osm): stop using public Overpass by default (#648) (#742)
Traffic roads come from OpenFreeMap vector tiles, or TomTom flow tiles with a
key (Hybrid by default). Military areas use OpenFreeMap polygons with a bundled
worldwide name index; wide views show named points. ALPR reads an hourly
OpenStreetMap extract. Cockpit place context and country, state and US county
outlines use bundled Natural Earth and US Census data. Overpass is used only
when an operator configures their own endpoint.

Also: camera arrivals no longer land below ground, keyless terrain retries on
429, bounded relation geometry for configured Overpass, one shared
OpenStreetMap credit, and separate tile and API transports for embedders.

Co-authored-by: theGaryLarson <[email protected]>
Co-authored-by: Milan Khanal <[email protected]>
2026-09-28 19:07:57 -05:00

429 lines
13 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { createTrafficLayer } from './index.js';
function deferred() {
let resolve;
const promise = new Promise((done) => {
resolve = done;
});
return { promise, resolve };
}
function setup(t, requestRoads, getStatus = async () => ({ hasKey: false })) {
t.mock.timers.enable({ apis: ['setTimeout', 'setInterval'] });
const camera = {
positionCartographic: Cesium.Cartographic.fromDegrees(
-97.744,
30.267,
3200,
),
get positionWC() {
return Cesium.Cartesian3.fromRadians(
this.positionCartographic.longitude,
this.positionCartographic.latitude,
this.positionCartographic.height,
);
},
changed: new Cesium.Event(),
moveEnd: new Cesium.Event(),
percentageChanged: 0.5,
computeViewRectangle() {
const { longitude, latitude } = this.positionCartographic;
return new Cesium.Rectangle(
longitude - 0.0002,
latitude - 0.0002,
longitude + 0.0002,
latitude + 0.0002,
);
},
pickEllipsoid: () => null,
};
const viewer = {
camera,
scene: {
canvas: { width: 100, height: 100 },
globe: { show: true, tilesLoaded: true, getHeight: () => 0 },
preRender: new Cesium.Event(),
primitives: { add: (value) => value, remove: () => true },
},
};
const layer = createTrafficLayer({
services: {
credits: {},
render: { holdContinuousRender() {}, releaseContinuousRender() {} },
},
source: {
requestRoads,
getStatus,
fetchFlowForBounds: async () => [],
getFlowSessionStats: () => ({ tilesFetched: 0 }),
resetFlowTileCache() {},
},
});
layer.init(viewer);
t.after(() => layer.destroy(viewer));
const move = (lon, lat, height = 3200) => {
camera.positionCartographic = Cesium.Cartographic.fromDegrees(
lon,
lat,
height,
);
camera.changed.raiseEvent();
camera.moveEnd.raiseEvent();
};
const tick = async (ms) => {
t.mock.timers.tick(ms);
for (let i = 0; i < 30; i++) await Promise.resolve();
};
return { layer, viewer, move, tick };
}
function roads(bounds) {
return {
ok: true,
json: async () => ({
roads: [
{
type: 'primary',
oneway: 0,
coordinates: [
[bounds.west, bounds.south],
[bounds.west + 0.005, bounds.south + 0.005],
],
},
],
}),
};
}
test('traffic recovers a failed destination request after another city has loaded', async (t) => {
let londonCalls = 0;
const { layer, viewer, move, tick } = setup(t, async (bounds) => {
if (bounds.south > 50 && ++londonCalls === 1)
throw new Error('temporary Overpass outage');
return roads(bounds);
});
layer.enable(viewer);
await tick(400);
await tick(2000);
assert.ok(layer.getStats().count > 0);
move(-40, 40, 1000000);
move(-0.1276, 51.5072);
await tick(400);
assert.equal(londonCalls, 1);
for (let i = 0; i < 20; i++) await tick(1500);
assert.ok(
londonCalls >= 2,
'the stationary destination must retry without a toggle',
);
assert.ok(layer.getStats().count > 0);
assert.equal(layer.getStats().loading, false);
});
test('a superseded road response cannot release the current request controller', async (t) => {
const pending = [];
const { layer, viewer, move, tick } = setup(t, (bounds, { signal }) => {
const result = deferred();
pending.push({ ...result, bounds, signal });
return result.promise;
});
layer.enable(viewer);
await tick(400);
move(-0.1276, 51.5072);
await tick(400);
assert.equal(pending.length, 2);
assert.equal(pending[0].signal.aborted, true);
pending[0].resolve(roads(pending[0].bounds));
await tick(0);
layer.disable(viewer);
assert.equal(
pending[1].signal.aborted,
true,
'disable must still cancel the destination request',
);
pending[1].resolve(roads(pending[1].bounds));
await tick(0);
assert.equal(layer.getStats().count, 0);
assert.equal(layer.getStats().loading, false);
});
test('leaving traffic altitude cancels queued and in-flight work', async (t) => {
const pending = [];
const { layer, viewer, move, tick } = setup(t, (bounds, { signal }) => {
const result = deferred();
pending.push({ ...result, bounds, signal });
return result.promise;
});
layer.enable(viewer);
move(-40, 40, 1000000);
await tick(400);
assert.equal(
pending.length,
0,
'a departing city debounce must not fetch above traffic altitude',
);
move(-0.1276, 51.5072);
await tick(400);
assert.equal(pending.length, 1);
move(-40, 40, 1000000);
assert.equal(pending[0].signal.aborted, true);
pending[0].resolve(roads(pending[0].bounds));
await tick(0);
assert.equal(layer.getStats().count, 0);
assert.equal(layer.getStats().loading, false);
});
test('arrival below the camera change threshold loads the final city and unsubscribes on disable', async (t) => {
const seen = [];
const { layer, viewer, tick } = setup(t, async (bounds) => {
seen.push(bounds);
return roads(bounds);
});
layer.enable(viewer);
await tick(400);
viewer.camera.positionCartographic = Cesium.Cartographic.fromDegrees(
-0.1276,
51.5072,
3200,
);
viewer.camera.moveEnd.raiseEvent();
await tick(400);
assert.ok(seen.some((bounds) => bounds.south > 50));
layer.disable(viewer);
assert.equal(viewer.camera.moveEnd.numberOfListeners, 0);
assert.equal(viewer.camera.changed.numberOfListeners, 0);
});
test('parked failures back off and disabling cancels the scheduled retry', async (t) => {
let calls = 0;
const { layer, viewer, tick } = setup(t, async () => {
calls++;
throw new Error('temporary Overpass outage');
});
layer.enable(viewer);
await tick(400);
assert.equal(calls, 1);
assert.equal(layer.getStats().loading, false);
assert.equal(layer.getStats().error, 'OpenFreeMap tiles unavailable');
await tick(1500);
await tick(400);
assert.equal(calls, 2);
await tick(1500);
await tick(400);
assert.equal(calls, 2, 'second failure waits longer than the first');
layer.disable(viewer);
await tick(60000);
assert.equal(calls, 2);
assert.equal(layer.getStats().error, null);
});
test('not-configured roads stop both parked retries and the enable-time kick', async (t) => {
let requests = 0;
const h = setup(t, async () => {
requests++;
return {
ok: false,
status: 503,
headers: new Headers(),
json: async () => ({ code: 'OVERPASS_NOT_CONFIGURED', retryable: false }),
};
});
h.layer.enable(h.viewer);
await h.tick(400);
await h.tick(60_000);
assert.equal(requests, 1);
assert.equal(h.layer.getStats().loading, false);
assert.match(h.layer.getStats().loadingLabel, /UNAVAILABLE/);
});
test('a declined road request reaches the row as the reason, not as a shrug', async (t) => {
let status = 406;
const { layer, viewer, tick } = setup(t, async () => ({ ok: false, status }));
layer.enable(viewer);
await tick(400);
assert.equal(
layer.getStats().error,
'OpenFreeMap tiles unavailable (HTTP 406)',
);
status = 429;
for (let i = 0; i < 20; i++) await tick(1500);
assert.equal(
layer.getStats().error,
'OpenFreeMap tiles rate-limited',
'a rate limit is a different instruction to the reader than a refusal',
);
});
test('an unclassified road failure keeps the general line', async (t) => {
const { layer, viewer, tick } = setup(t, async () => {
throw new Error('socket hang up');
});
layer.enable(viewer);
await tick(400);
assert.equal(layer.getStats().error, 'OpenFreeMap tiles unavailable');
});
test('a stalled TomTom status never blocks road acquisition or first simulated dots', async (t) => {
let calls = 0;
const { layer, viewer, tick } = setup(
t,
async (box) => {
calls++;
return roads(box);
},
() => new Promise(() => {}),
);
// The source contract is exercised independently of status by the production
// load path; the real source status cancellation case is in source.test.
layer.enable(viewer);
await tick(400);
await tick(2000);
assert.ok(calls > 0);
assert.ok(layer.getStats().count > 0);
});
test('explicit enable starts roads without the camera debounce', async (t) => {
let calls = 0;
const { layer, viewer, tick } = setup(t, async (box) => {
calls++;
return roads(box);
});
layer.enable(viewer);
await tick(0);
assert.ok(calls > 0, 'the first load starts before 320 ms');
});
test('moveEnd starts the destination request without another gesture debounce', async (t) => {
let calls = 0;
const { layer, viewer, move, tick } = setup(t, async (bounds) => {
calls++;
return roads(bounds);
});
layer.enable(viewer);
await tick(400);
const before = calls;
move(-0.1276, 51.5072);
await tick(0);
assert.ok(calls > before, 'arrival loads in the next task, before 320 ms');
});
test('traffic surface observers belong to enable and leave no listener after disable or destroy', async (t) => {
const { layer, viewer, tick } = setup(t, async (bounds) => roads(bounds));
viewer.camera.viewMatrix = Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY);
viewer.camera.frustum = {
projectionMatrix: Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY),
};
viewer.scene.camera = viewer.camera;
viewer.scene.postRender = new Cesium.Event();
assert.equal(viewer.scene.postRender.numberOfListeners, 0);
for (let i = 0; i < 3; i++) {
layer.enable(viewer);
layer.enable(viewer);
assert.equal(viewer.scene.postRender.numberOfListeners, 1);
viewer.scene.postRender.raiseEvent();
await tick(1);
layer.disable(viewer);
assert.equal(viewer.scene.postRender.numberOfListeners, 0);
await tick(5000);
assert.equal(
viewer.scene.postRender.numberOfListeners,
0,
'late work cannot resubscribe',
);
}
layer.enable(viewer);
assert.equal(viewer.scene.postRender.numberOfListeners, 1);
layer.destroy(viewer);
assert.equal(viewer.scene.postRender.numberOfListeners, 0);
assert.equal(viewer.scene.preRender.numberOfListeners, 0);
});
test('coverage changes at the same center reload and disabling invalidates coverage without dropping source caches', async (t) => {
const calls = [];
const { layer, viewer, tick } = setup(t, async (bounds) => {
calls.push(bounds);
return roads(bounds);
});
layer.enable(viewer);
await tick(1000);
await tick(2000);
assert.ok(layer.getStats().count > 0);
const before = calls.length;
layer.disable(viewer);
layer.enable(viewer);
await tick(1000);
await tick(2000);
assert.ok(layer.getStats().count > 0, 'enable must repaint the same view');
assert.ok(calls.length >= before);
});
test('a settled footprint loads new tiles even when the camera centre stays put', async (t) => {
const seen = [];
const { layer, viewer, tick } = setup(
t,
async (bounds, { majorOnly, coverage }) => {
if (!majorOnly) seen.push({ ...bounds, coverage });
return roads(bounds);
},
);
layer.setParams({ roadMode: 'osm' });
let reach = 0.005;
const camera = viewer.camera;
camera.getPickRay = () => null;
camera.heading = 0;
camera.pitch = -Math.PI / 2;
camera.pickEllipsoid = (pixel, ellipsoid, result) =>
Cesium.Cartesian3.fromDegrees(
-97.744 + (pixel.x - 50) / 10000,
30.267 + (pixel.y / 100) * reach,
0,
ellipsoid,
result,
);
layer.enable(viewer);
await tick(400);
assert.equal(seen.length, 1);
const firstKey = seen[0].coverage.key;
camera.changed.raiseEvent();
// The final flight step occurs below the changed-event threshold.
reach = 0.08;
camera.pitch = -Math.PI / 12;
await tick(400);
assert.equal(seen.length, 2);
assert.notEqual(seen[1].coverage.key, firstKey);
assert.ok(
seen[1].north > 30.33,
'sample the final view when the debounce fires',
);
camera.moveEnd.raiseEvent();
await tick(400);
assert.equal(
seen.length,
2,
'an identical settled footprint does not reload',
);
});
test('partial coverage retries while coarse roads render, then stops after three retries', async (t) => {
let calls = 0;
const { layer, viewer, tick } = setup(t, async (bounds) => {
calls++;
const response = roads(bounds);
const data = await response.json();
return { ok: true, json: async () => ({ ...data, partial: true }) };
});
layer.enable(viewer);
await tick(400);
await tick(0);
assert.ok(layer.getStats().count > 0);
const initial = calls;
for (let i = 0; i < 12; i++) {
await tick(30000);
await tick(400);
}
assert.equal(calls, initial * 4, 'initial load plus three bounded retries');
assert.ok(layer.getStats().count > 0);
});