mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
A failed flow tile now carries the server's reason. A hosted deployment that limits each account answers USAGE_LIMIT_REACHED or RATE_LIMITED, which the traffic panel labels as the monthly allowance or a rate limit; a 503 with another reason reads as the traffic service being unavailable, not a missing key. The local proxy's no_key and daily budget labels are unchanged.
1079 lines
34 KiB
JavaScript
1079 lines
34 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { readFileSync } from 'node:fs';
|
|
import { getEventListeners } from 'node:events';
|
|
import { createFlowTileSource } from './flowSource.js';
|
|
import { tilesForBounds, tileToBBox } from '../../data/tomtomTiles.js';
|
|
import { decodeFlowTile } from './flowDecode.js';
|
|
import {
|
|
clearSharedOpenFreeMapTiles,
|
|
decodeOpenFreeMapTile,
|
|
} from '../../sources/openFreeMap.js';
|
|
import {
|
|
RoadRequestError,
|
|
roadRequestError,
|
|
trafficDetailBounds,
|
|
createTrafficSource,
|
|
} from './source.js';
|
|
import { clampBoundsAroundCenter } from '../../data/trafficBounds.js';
|
|
const bounds = { south: 30.267, west: -97.744, north: 30.268, east: -97.743 };
|
|
const fixture = readFileSync(
|
|
new URL(
|
|
'../../data/fixtures/tomtom-flow-austin-12-935-1686.pbf',
|
|
import.meta.url,
|
|
),
|
|
);
|
|
test('flow caches and diagnostics belong to their constructed source', async () => {
|
|
let requestsA = 0,
|
|
requestsB = 0;
|
|
const a = createTrafficSource({
|
|
fetchImpl: async () => {
|
|
requestsA++;
|
|
return new Response(fixture);
|
|
},
|
|
});
|
|
const b = createTrafficSource({
|
|
fetchImpl: async () => {
|
|
requestsB++;
|
|
return new Response(fixture);
|
|
},
|
|
});
|
|
const first = await a.fetchFlowForBounds(bounds);
|
|
assert.ok(first.length > 0);
|
|
await a.fetchFlowForBounds(bounds);
|
|
assert.equal(requestsA, 1);
|
|
assert.equal(b.getFlowSessionStats().tilesFetched, 0);
|
|
b.resetFlowTileCache();
|
|
await a.fetchFlowForBounds(bounds);
|
|
assert.equal(requestsA, 1);
|
|
await b.fetchFlowForBounds(bounds);
|
|
assert.equal(requestsB, 1);
|
|
});
|
|
test('a cancelled flow body cannot refill its source cache', async () => {
|
|
const controller = new AbortController();
|
|
let calls = 0;
|
|
const source = createTrafficSource({
|
|
fetchImpl: async () => ({
|
|
ok: true,
|
|
headers: new Headers(),
|
|
arrayBuffer: async () => {
|
|
calls++;
|
|
if (calls === 1) controller.abort();
|
|
return fixture;
|
|
},
|
|
}),
|
|
});
|
|
await assert.rejects(
|
|
source.fetchFlowForBounds(bounds, { signal: controller.signal }),
|
|
{ name: 'AbortError' },
|
|
);
|
|
await source.fetchFlowForBounds(bounds);
|
|
assert.equal(
|
|
calls,
|
|
2,
|
|
'cancelled bytes were not admitted to the decode cache',
|
|
);
|
|
});
|
|
test('road requests validate bounds and select z12/z14 immutable tile passes', async () => {
|
|
const calls = [];
|
|
const source = createTrafficSource({
|
|
mapTiles: {
|
|
async fetchBounds(box, options) {
|
|
calls.push({ box, ...options });
|
|
return { tiles: [{ roads: [] }], partial: false };
|
|
},
|
|
clear() {},
|
|
},
|
|
});
|
|
await assert.rejects(
|
|
source.requestRoads({ ...bounds, north: Infinity }),
|
|
/bounded road viewport/,
|
|
);
|
|
assert.equal(calls.length, 0);
|
|
await source.requestRoads(bounds, { majorOnly: true });
|
|
await source.requestRoads(bounds);
|
|
assert.deepEqual(
|
|
calls.map((c) => c.zoom),
|
|
[12, 14],
|
|
);
|
|
for (const centerLon of [179.99, -179.99]) {
|
|
const clamped = clampBoundsAroundCenter(
|
|
{ south: -0.02, north: 0.02, west: 179.98, east: -179.98 },
|
|
{ lat: 0, lon: centerLon },
|
|
);
|
|
await source.requestRoads(clamped);
|
|
}
|
|
assert.equal(calls.length, 4);
|
|
});
|
|
test('malformed availability is an unavailable source rather than a keyless response', async () => {
|
|
const source = createTrafficSource({
|
|
fetchImpl: async () => new Response('{}'),
|
|
});
|
|
await assert.rejects(source.getStatus(), /Malformed traffic status/);
|
|
});
|
|
|
|
test('traffic construction is inert and parameters belong to each layer', async () => {
|
|
const { createTrafficLayer } = await import('./index.js');
|
|
const source = createTrafficSource({
|
|
fetchImpl: () => assert.fail('construction fetched data'),
|
|
});
|
|
const services = { credits: {}, render: {} };
|
|
const a = createTrafficLayer({ services, source });
|
|
const b = createTrafficLayer({ services, source });
|
|
a.setParams({ densityScale: 2, speedScale: 3, uncoveredRoads: 'hide' });
|
|
assert.equal(a.getParams().densityScale, 2);
|
|
assert.equal(b.getParams().densityScale, 1);
|
|
assert.equal(b.getParams().speedScale, 1);
|
|
assert.equal(b.getParams().uncoveredRoads, 'sim');
|
|
});
|
|
|
|
test('road tile replies respect cancellation even when the tile source ignores it', async () => {
|
|
const abort = new AbortController();
|
|
const source = createTrafficSource({
|
|
mapTiles: {
|
|
async fetchBounds() {
|
|
abort.abort();
|
|
return { tiles: [{ roads: [] }], partial: false };
|
|
},
|
|
},
|
|
});
|
|
await assert.rejects(source.requestRoads(bounds, { signal: abort.signal }), {
|
|
name: 'AbortError',
|
|
});
|
|
});
|
|
|
|
test('keyed and keyless geometry is identical OpenFreeMap data, independent of TomTom failures', async () => {
|
|
const tile = decodeOpenFreeMapTile(
|
|
readFileSync(
|
|
new URL(
|
|
'../../data/fixtures/ofm-austin-14-3743-6745.pbf',
|
|
import.meta.url,
|
|
),
|
|
),
|
|
14,
|
|
3743,
|
|
6745,
|
|
);
|
|
const box = tileToBBox(14, 3743, 6745);
|
|
const calls = [];
|
|
const source = createTrafficSource({
|
|
fetchImpl: async () => {
|
|
throw new Error('HTTP 429');
|
|
},
|
|
mapTiles: {
|
|
fetchBounds: async (_, options) => {
|
|
calls.push(options.zoom);
|
|
return { tiles: [tile], partial: false };
|
|
},
|
|
},
|
|
});
|
|
const keyed = await (await source.requestRoads(box, { live: true })).json();
|
|
const keyless = await (
|
|
await source.requestRoads(box, { live: false })
|
|
).json();
|
|
assert.deepEqual(keyed, keyless);
|
|
assert.equal(keyed.roadSource, 'OpenStreetMap');
|
|
assert.ok(keyed.roads.length > 0);
|
|
assert.ok(keyed.roads.every((road) => !road.flow));
|
|
assert.deepEqual(calls, [14, 14]);
|
|
await assert.rejects(source.fetchFlowForBounds(bounds), /HTTP 429/);
|
|
assert.deepEqual(await (await source.requestRoads(box)).json(), keyless);
|
|
});
|
|
|
|
test('traffic status is session-cached after settlement, but cancelled discovery can restart', async () => {
|
|
const { createFlow } = await import('./flow.js');
|
|
let calls = 0;
|
|
const state = {};
|
|
const flow = createFlow({
|
|
state,
|
|
services: { credits: { registerDynamicCredit() {} } },
|
|
parts: {},
|
|
source: {
|
|
async getStatus({ signal }) {
|
|
calls++;
|
|
signal?.throwIfAborted();
|
|
return { hasKey: false };
|
|
},
|
|
},
|
|
});
|
|
const first = new AbortController();
|
|
await flow.ensureFlowStatus(first.signal);
|
|
first.abort();
|
|
await flow.ensureFlowStatus(new AbortController().signal);
|
|
assert.equal(calls, 1);
|
|
const retryState = {};
|
|
const retryFlow = createFlow({
|
|
state: retryState,
|
|
services: { credits: {} },
|
|
parts: {},
|
|
source: {
|
|
async getStatus({ signal }) {
|
|
calls++;
|
|
signal.throwIfAborted();
|
|
return { hasKey: false };
|
|
},
|
|
},
|
|
});
|
|
await assert.rejects(retryFlow.ensureFlowStatus(first.signal), {
|
|
name: 'AbortError',
|
|
});
|
|
await retryFlow.ensureFlowStatus(new AbortController().signal);
|
|
assert.equal(calls, 3);
|
|
});
|
|
|
|
test('road parsing defers surface reads to the cancellable preparation pass', async () => {
|
|
const { createModel } = await import('./model.js');
|
|
let lookups = 0;
|
|
const model = createModel({
|
|
state: {
|
|
_viewer: {
|
|
scene: {
|
|
sampleHeightSupported: true,
|
|
sampleHeight() {
|
|
assert.fail('offscreen 3D height probe on keyless globe');
|
|
},
|
|
globe: {
|
|
show: true,
|
|
getHeight() {
|
|
lookups++;
|
|
return 0;
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
services: {},
|
|
parts: {},
|
|
source: {},
|
|
});
|
|
const roads = model.parseRoads({
|
|
roads: [
|
|
{
|
|
coordinates: [
|
|
[-97.74, 30.27],
|
|
[-97.741, 30.271],
|
|
],
|
|
type: 'residential',
|
|
oneway: 0,
|
|
},
|
|
],
|
|
});
|
|
assert.equal(roads.length, 2);
|
|
assert.deepEqual(
|
|
roads.map((r) => r.oneway),
|
|
[1, -1],
|
|
);
|
|
assert.equal(roads[0].waypoints.length, 2);
|
|
assert.equal(lookups, 0);
|
|
});
|
|
|
|
test('parsed road cache evicts old views by byte budget and never retains partial snapshots', async () => {
|
|
const { cacheRoadSnapshot } = await import('./ingestion.js');
|
|
const entries = new Map();
|
|
const entry = () => ({
|
|
major: [
|
|
{
|
|
coords: [
|
|
[1, 2],
|
|
[3, 4],
|
|
],
|
|
},
|
|
],
|
|
full: null,
|
|
});
|
|
const first = entry();
|
|
cacheRoadSnapshot(entries, 'old', first);
|
|
cacheRoadSnapshot(entries, 'new', entry(), {
|
|
maxBytes: first.cacheBytes + 1,
|
|
});
|
|
assert.deepEqual([...entries.keys()], ['new']);
|
|
cacheRoadSnapshot(entries, 'new', entry(), { retain: false });
|
|
assert.equal(entries.size, 0);
|
|
cacheRoadSnapshot(entries, 'oversized', entry(), { maxBytes: 1 });
|
|
assert.equal(entries.size, 0);
|
|
});
|
|
|
|
for (const lat of [51.5, 60])
|
|
test(`z14 detail at ${lat} stays centered within the sixteen-tile cap`, async () => {
|
|
const box = {
|
|
south: lat - 0.025,
|
|
north: lat + 0.025,
|
|
west: -0.155,
|
|
east: -0.105,
|
|
};
|
|
assert.ok(tilesForBounds(box, 14).length > 16);
|
|
const detail = trafficDetailBounds(box);
|
|
assert.ok(tilesForBounds(detail, 14).length <= 16);
|
|
assert.ok(Math.abs((detail.south + detail.north) / 2 - lat) < 1e-10);
|
|
const source = createTrafficSource({
|
|
mapTiles: { fetchBounds: async () => ({ tiles: [], partial: false }) },
|
|
});
|
|
const data = await (await source.requestRoads(box)).json();
|
|
assert.equal(data.detailLimited, true);
|
|
assert.deepEqual(data.detailBounds, detail);
|
|
});
|
|
test('TomTom buffers are clipped before caching and preserve direction and flow attributes', async () => {
|
|
const core = tileToBBox(12, 935, 1686);
|
|
const source = createTrafficSource({
|
|
fetchImpl: async () => new Response(fixture),
|
|
});
|
|
const result = await source.fetchFlowForBounds({
|
|
...core,
|
|
east: core.east - 1e-9,
|
|
south: core.south + 1e-9,
|
|
});
|
|
const decoded = decodeFlowTile(fixture, 12, 935, 1686);
|
|
assert.ok(
|
|
decoded.some((r) =>
|
|
r.coords.some(
|
|
([x, y]) =>
|
|
x < core.west || x > core.east || y < core.south || y > core.north,
|
|
),
|
|
),
|
|
);
|
|
assert.ok(
|
|
result.every((r) =>
|
|
r.coords.every(
|
|
([x, y]) =>
|
|
x >= core.west - 1e-10 &&
|
|
x <= core.east + 1e-10 &&
|
|
y >= core.south - 1e-10 &&
|
|
y <= core.north + 1e-10,
|
|
),
|
|
),
|
|
);
|
|
assert.ok(result.some((r) => r.closure));
|
|
});
|
|
|
|
test('a failed detail pass keeps major roads and exposes separate degraded status', async () => {
|
|
const { createIngestion } = await import('./ingestion.js');
|
|
for (const retained of [false, true]) {
|
|
const state = {
|
|
_loadGeneration: 0,
|
|
_tileCache: new Map(),
|
|
_enabled: true,
|
|
_parseRoads: (data) => data.roads,
|
|
};
|
|
let paints = 0;
|
|
const ingestion = createIngestion({
|
|
state,
|
|
services: {},
|
|
parts: {
|
|
viewport: {
|
|
clampBounds: (b) => b,
|
|
getBoundsCenter: (b) => ({
|
|
lat: (b.north + b.south) / 2,
|
|
lon: (b.east + b.west) / 2,
|
|
}),
|
|
},
|
|
flow: {
|
|
warmFlow: async () => {},
|
|
applyFlowThenRender: async () => {
|
|
paints++;
|
|
if (paints === 1) state._retainedPreview = retained;
|
|
return true;
|
|
},
|
|
},
|
|
},
|
|
source: {
|
|
requestRoads: async (_, opts) => {
|
|
if (!opts.majorOnly) throw new Error('tile request failed');
|
|
return {
|
|
ok: true,
|
|
json: async () => ({
|
|
roads: [],
|
|
roadSource: 'OpenStreetMap tiles',
|
|
partial: false,
|
|
}),
|
|
};
|
|
},
|
|
},
|
|
});
|
|
await ingestion.loadRoadsForBounds(bounds, 350);
|
|
assert.equal(
|
|
paints,
|
|
retained ? 2 : 1,
|
|
'only an unpainted retained preview needs fallback work',
|
|
);
|
|
assert.equal(state._roadError, null);
|
|
assert.equal(
|
|
state._detailError,
|
|
'Detailed roads unavailable — OpenFreeMap tiles unavailable',
|
|
);
|
|
assert.equal(state._roadPartial, true);
|
|
assert.equal(state._fetching, false);
|
|
clearTimeout(state._retryTimer);
|
|
}
|
|
});
|
|
|
|
const ofmDetail = decodeOpenFreeMapTile(
|
|
readFileSync(
|
|
new URL('../../data/fixtures/ofm-austin-14-3743-6745.pbf', import.meta.url),
|
|
),
|
|
14,
|
|
3743,
|
|
6745,
|
|
);
|
|
|
|
async function matchingContext(fetchFlowForBounds) {
|
|
const { createState } = await import('./state.js');
|
|
const { createModel } = await import('./model.js');
|
|
const { createFlow } = await import('./flow.js');
|
|
const { createControls } = await import('./controls.js');
|
|
const state = createState({ services: {} });
|
|
Object.assign(state, {
|
|
_liveMode: true,
|
|
_enabled: true,
|
|
_flowStatusPromise: Promise.resolve(),
|
|
});
|
|
const source = {
|
|
fetchFlowForBounds,
|
|
getFlowSessionStats: () => ({ tilesFetched: 1 }),
|
|
};
|
|
const parts = {
|
|
style: {
|
|
presetProfileActive: () => false,
|
|
jamDensityOn: () => false,
|
|
baseDotSize: () => 2,
|
|
activeSizeDelta: () => 0,
|
|
},
|
|
rendering: {
|
|
rebuildHeatLines() {},
|
|
visibleRoadsForAltitude: (roads) => roads,
|
|
},
|
|
};
|
|
const context = { state, source, parts, services: { credits: {} } };
|
|
parts.model = createModel(context);
|
|
return {
|
|
state,
|
|
model: parts.model,
|
|
flow: createFlow(context),
|
|
controls: createControls(context).methods,
|
|
};
|
|
}
|
|
|
|
test('Austin TomTom fixture matches congestion onto OFM detail roads without changing geometry', async () => {
|
|
const source = createTrafficSource({
|
|
fetchImpl: async () => new Response(fixture),
|
|
});
|
|
const context = await matchingContext(source.fetchFlowForBounds);
|
|
const roads = context.model.parseRoads({ roads: ofmDetail.roads });
|
|
const coordinates = structuredClone(roads.map((r) => r.coords));
|
|
await context.flow.applyFlowToRoads(roads, tileToBBox(14, 3743, 6745), 0);
|
|
const matched = roads.filter((r) => r.flow);
|
|
assert.ok(matched.length > 0);
|
|
assert.ok(roads.length >= 94);
|
|
assert.ok(roads.every((r) => [1, -1].includes(r.oneway)));
|
|
assert.ok(matched.some((r) => r.flow.level < 0.8 && r.flow.level > 0));
|
|
assert.deepEqual(
|
|
roads.map((r) => r.coords),
|
|
coordinates,
|
|
'flow never substitutes its own polylines',
|
|
);
|
|
assert.equal(context.state._flowPending, 0);
|
|
|
|
// Inject closure attributes on the same checked-in TomTom geometry: the
|
|
// Austin detail snapshot has no real closures on its matched roads.
|
|
const segments = await source.fetchFlowForBounds(tileToBBox(14, 3743, 6745));
|
|
const closed = await matchingContext(async () =>
|
|
segments.map((s) => ({ ...s, closure: true })),
|
|
);
|
|
await closed.flow.applyFlowToRoads(roads, bounds, 0);
|
|
assert.equal(roads.filter((r) => r.flow?.closure).length, matched.length);
|
|
assert.ok(
|
|
roads
|
|
.filter((r) => r.flow)
|
|
.every((r) => closed.model.computeDotCount(r, 350) === 0),
|
|
);
|
|
});
|
|
|
|
test('late closures hide and stop dots; coverage counts shown matched dots, and reopening restores them', async () => {
|
|
const C = await import('cesium');
|
|
const { state, model, controls } = await matchingContext(async () => []);
|
|
const matched = { flow: { level: 1, closure: false }, type: 'primary' };
|
|
const sim = { flow: null, type: 'residential' };
|
|
const closed = { flow: { level: 0, closure: true }, type: 'primary' };
|
|
state._roads = [matched, sim, closed];
|
|
state._dots = [matched, matched, matched, sim, closed].map((road) => ({
|
|
road,
|
|
baseMps: 10,
|
|
mps: 10,
|
|
point: { show: true, color: C.Color.WHITE },
|
|
}));
|
|
model.recolorDotsInPlace('fixture');
|
|
assert.equal(state._dots[4].point.show, false);
|
|
assert.equal(state._dots[4].mps, 0);
|
|
assert.equal(controls.getStats().count, 4);
|
|
assert.equal(controls.getStats().flowCoveragePct, 75);
|
|
assert.equal(
|
|
state._dots[3].mps,
|
|
10,
|
|
'unmatched roads retain simulated speed',
|
|
);
|
|
assert.equal(state._dots[3].bucket, null);
|
|
closed.flow = { level: 1, closure: false };
|
|
model.recolorDotsInPlace('reopened');
|
|
assert.equal(state._dots[4].point.show, true);
|
|
assert.equal(state._dots[4].mps, 10);
|
|
assert.equal(controls.getStats().count, 5);
|
|
assert.equal(controls.getStats().flowCoveragePct, 80);
|
|
});
|
|
|
|
test('coverage never rounds to "no matches" or full coverage while both kinds of dot are shown', async () => {
|
|
const { state, controls } = await matchingContext(async () => []);
|
|
state._bucketCounts = { free: 1, slow: 0, jam: 0, sim: 300 };
|
|
assert.equal(controls.getStats().flowCoveragePct, 1);
|
|
assert.equal(
|
|
controls.getStats().loadingLabel,
|
|
'LIVE · Roads: OpenStreetMap · Flow: TomTom · 1% cov · Unmatched: simulated',
|
|
);
|
|
state._bucketCounts = { free: 300, slow: 0, jam: 0, sim: 1 };
|
|
assert.equal(controls.getStats().flowCoveragePct, 99);
|
|
assert.equal(
|
|
controls.getStats().loadingLabel,
|
|
'LIVE · Roads: OpenStreetMap · Flow: TomTom · 99% cov · Unmatched: simulated',
|
|
);
|
|
state._bucketCounts = { free: 300, slow: 0, jam: 0, sim: 0 };
|
|
assert.equal(controls.getStats().flowCoveragePct, 100);
|
|
state._bucketCounts = { free: 0, slow: 0, jam: 0, sim: 300 };
|
|
assert.equal(controls.getStats().flowCoveragePct, 0);
|
|
});
|
|
|
|
test('refresh failure removes cached matches and reports simulated flow', async () => {
|
|
const { flow, state, model, controls } = await matchingContext(async () => {
|
|
throw new Error('HTTP 429');
|
|
});
|
|
const roads = model.parseRoads({ roads: ofmDetail.roads });
|
|
roads[0].flow = { level: 0.1, closure: true };
|
|
await flow.applyFlowToRoads(roads, bounds, 0);
|
|
assert.ok(roads.every((r) => r.flow === null));
|
|
assert.equal(controls.getStats().flowCoveragePct, 0);
|
|
assert.match(
|
|
controls.getStats().loadingLabel,
|
|
/SIMULATED — TomTom daily budget reached/,
|
|
);
|
|
assert.equal(state._flowPending, 0);
|
|
});
|
|
|
|
test('superseded flow cannot apply matches after a camera move or disable', async () => {
|
|
let finish;
|
|
const { flow, state, model } = await matchingContext(
|
|
() =>
|
|
new Promise((resolve) => {
|
|
finish = resolve;
|
|
}),
|
|
);
|
|
const roads = model.parseRoads({ roads: ofmDetail.roads });
|
|
const pending = flow.applyFlowToRoads(roads, bounds, 0);
|
|
while (!finish) await new Promise((resolve) => setTimeout(resolve, 0));
|
|
state._loadGeneration++;
|
|
state._flowPending = 0;
|
|
state._enabled = false;
|
|
finish(decodeFlowTile(fixture, 12, 935, 1686));
|
|
await pending;
|
|
assert.ok(roads.every((r) => r.flow === null));
|
|
assert.equal(state._flowPending, 0);
|
|
});
|
|
|
|
test('OSM keyed loads run z12 then z14 and reuse road snapshots while refreshing flow', async () => {
|
|
const { createIngestion } = await import('./ingestion.js');
|
|
const state = {
|
|
_loadGeneration: 0,
|
|
_tileCache: new Map(),
|
|
_enabled: true,
|
|
_liveMode: true,
|
|
_roadMode: 'osm',
|
|
_parseRoads: (data) => data.roads,
|
|
};
|
|
const passes = [],
|
|
paints = [];
|
|
const ingestion = createIngestion({
|
|
state,
|
|
services: {},
|
|
parts: {
|
|
viewport: {
|
|
clampBounds: (b) => b,
|
|
getBoundsCenter: () => ({ lat: 30.267, lon: -97.744 }),
|
|
},
|
|
flow: {
|
|
warmFlow: async () => {},
|
|
applyFlowThenRender: async (roads) => {
|
|
paints.push(roads);
|
|
return true;
|
|
},
|
|
},
|
|
},
|
|
source: {
|
|
requestRoads: async (_, options) => {
|
|
passes.push(options.majorOnly);
|
|
return {
|
|
ok: true,
|
|
json: async () => ({
|
|
roads: ofmDetail.roads,
|
|
roadSource: 'OpenStreetMap',
|
|
roadMode: 'osm',
|
|
}),
|
|
};
|
|
},
|
|
},
|
|
});
|
|
await ingestion.loadRoadsForBounds(bounds, 350);
|
|
assert.deepEqual(passes, [true, false]);
|
|
await ingestion.loadRoadsForBounds(bounds, 350);
|
|
assert.deepEqual(
|
|
passes,
|
|
[true, false],
|
|
'repeat view does not fetch road geometry',
|
|
);
|
|
assert.equal(
|
|
paints.length,
|
|
3,
|
|
'cached roads still pass through flow refresh',
|
|
);
|
|
});
|
|
|
|
test('an OpenFreeMap refusal is named by status, and keeps the status beside the words', () => {
|
|
assert.equal(roadRequestError(429).message, 'OpenFreeMap tiles rate-limited');
|
|
assert.equal(roadRequestError(504).message, 'OpenFreeMap tiles timed out');
|
|
assert.equal(
|
|
roadRequestError(406).message,
|
|
'OpenFreeMap tiles unavailable (HTTP 406)',
|
|
);
|
|
assert.equal(
|
|
roadRequestError(500).message,
|
|
'OpenFreeMap tiles unavailable (HTTP 500)',
|
|
);
|
|
|
|
assert.equal(
|
|
roadRequestError(502).message,
|
|
'OpenFreeMap tiles unavailable (HTTP 502)',
|
|
);
|
|
assert.equal(
|
|
roadRequestError(503).message,
|
|
'OpenFreeMap tiles unavailable (HTTP 503)',
|
|
);
|
|
assert.equal(roadRequestError(503).status, 503);
|
|
|
|
for (const missing of [undefined, null, NaN, 'four-oh-six']) {
|
|
const vague = roadRequestError(missing);
|
|
assert.equal(vague.message, 'OpenFreeMap tiles unavailable');
|
|
assert.equal(vague.status, null, 'an unreadable code is absent, not zero');
|
|
}
|
|
|
|
const refused = roadRequestError(406);
|
|
assert.ok(refused instanceof RoadRequestError);
|
|
assert.ok(refused instanceof Error);
|
|
assert.equal(refused.name, 'RoadRequestError');
|
|
assert.equal(
|
|
refused.status,
|
|
406,
|
|
'a caller must be able to branch on the code without parsing English',
|
|
);
|
|
});
|
|
|
|
for (const phase of ['metadata', 'tile']) {
|
|
for (const failure of [406, 429, 503, 504, 'network', 'timeout']) {
|
|
test(`OpenFreeMap ${phase} ${failure} retains its reason through the road source`, async () => {
|
|
const source = createTrafficSource({
|
|
tileFetchImpl: async (url) => {
|
|
if (phase === 'tile' && url.endsWith('/planet'))
|
|
return Response.json({
|
|
tiles: ['https://tiles.openfreemap.org/test/{z}/{x}/{y}.pbf'],
|
|
});
|
|
if (failure === 'network') throw new TypeError('Failed to fetch');
|
|
if (failure === 'timeout')
|
|
throw new DOMException('deadline', 'TimeoutError');
|
|
return new Response('', { status: failure });
|
|
},
|
|
});
|
|
await assert.rejects(source.requestRoads(bounds), (error) => {
|
|
assert.ok(error instanceof RoadRequestError);
|
|
assert.equal(
|
|
error.status,
|
|
typeof failure === 'number' ? failure : null,
|
|
);
|
|
assert.equal(
|
|
error.message,
|
|
roadRequestError(
|
|
error.status,
|
|
failure === 'timeout' ? { name: 'TimeoutError' } : undefined,
|
|
).message,
|
|
);
|
|
assert.equal(error.retryable, true);
|
|
return true;
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
test('permanent metadata failures remain non-retryable through the road error wrapper', async () => {
|
|
const source = createTrafficSource({
|
|
tileFetchImpl: async () => Response.json({}),
|
|
});
|
|
await assert.rejects(source.requestRoads(bounds), (error) => {
|
|
assert.ok(error instanceof RoadRequestError);
|
|
assert.equal(error.retryable, false);
|
|
assert.equal(error.status, null);
|
|
return true;
|
|
});
|
|
});
|
|
|
|
test('reticle road requests pass exact bounded tiles and retain distant coarse roads', async () => {
|
|
const requests = [];
|
|
const source = createTrafficSource({
|
|
mapTiles: {
|
|
clear() {},
|
|
getMetadata: async () => ({}),
|
|
async fetchBounds(box, options) {
|
|
requests.push(options);
|
|
return { tiles: [{ roads: [] }], partial: false };
|
|
},
|
|
},
|
|
});
|
|
const box = { south: 30.2, west: -97.8, north: 30.4, east: -97.6 };
|
|
const coverage = {
|
|
coarse: [{ z: 12, x: 935, y: 1685 }],
|
|
detail: [{ z: 14, x: 3743, y: 6745 }],
|
|
};
|
|
const result = await source.requestOsmRoads(box, { coverage });
|
|
assert.deepEqual(
|
|
requests.map((r) => r.tiles),
|
|
[coverage.detail, coverage.coarse],
|
|
);
|
|
assert.equal((await result.json()).partial, false);
|
|
});
|
|
|
|
test('footprint requests preserve HTTP failures and cancellation semantics', async () => {
|
|
const coverage = { coarse: [{ z: 12, x: 935, y: 1686 }], detail: [] };
|
|
const source = createTrafficSource({
|
|
mapTiles: {
|
|
clear() {},
|
|
fetchBounds: async () => {
|
|
throw Object.assign(new Error('limited'), { status: 429 });
|
|
},
|
|
},
|
|
});
|
|
await assert.rejects(
|
|
source.requestOsmRoads(bounds, { coverage }),
|
|
(error) => error instanceof RoadRequestError && error.status === 429,
|
|
);
|
|
const controller = new AbortController();
|
|
controller.abort();
|
|
await assert.rejects(
|
|
source.requestOsmRoads(bounds, { coverage, signal: controller.signal }),
|
|
{ name: 'AbortError' },
|
|
);
|
|
});
|
|
|
|
test('near detail starts and streams while distant coarse tiles are still pending', async () => {
|
|
let releaseCoarse;
|
|
const coarse = new Promise((resolve) => {
|
|
releaseCoarse = resolve;
|
|
});
|
|
const order = [],
|
|
painted = [];
|
|
const source = createTrafficSource({
|
|
mapTiles: {
|
|
clear() {},
|
|
fetchBounds: async (box, options) => {
|
|
order.push(options.zoom);
|
|
if (options.zoom === 12) return coarse;
|
|
const tile = {
|
|
roads: [
|
|
{
|
|
coordinates: [
|
|
[-97.744, 30.267],
|
|
[-97.743, 30.268],
|
|
],
|
|
type: 'primary',
|
|
},
|
|
],
|
|
};
|
|
options.onTile?.(tile);
|
|
return { tiles: [tile], partial: false };
|
|
},
|
|
},
|
|
});
|
|
const pending = source.requestOsmRoads(bounds, {
|
|
coverage: {
|
|
detail: [{ z: 14, x: 3743, y: 6745 }],
|
|
coarse: [{ z: 12, x: 935, y: 1686 }],
|
|
},
|
|
onTile: (tile) => painted.push(tile),
|
|
});
|
|
await Promise.resolve();
|
|
assert.deepEqual(order, [14, 12]);
|
|
assert.equal(painted.length, 1);
|
|
assert.equal(painted[0].roads.length, 1);
|
|
releaseCoarse({ tiles: [], partial: false });
|
|
await pending;
|
|
});
|
|
|
|
test('failed detail cores retain real coarse roads while successful cores replace them', async () => {
|
|
const detail = [
|
|
{ z: 14, x: 3743, y: 6745 },
|
|
{ z: 14, x: 3744, y: 6745 },
|
|
];
|
|
const roads = detail.map((tile, i) => {
|
|
const b = tileToBBox(tile.z, tile.x, tile.y);
|
|
return {
|
|
type: 'primary',
|
|
id: i,
|
|
coordinates: [
|
|
[b.west + 0.002, b.south + 0.002],
|
|
[b.east - 0.002, b.north - 0.002],
|
|
],
|
|
};
|
|
});
|
|
for (const allFailed of [false, true]) {
|
|
const source = createTrafficSource({
|
|
mapTiles: {
|
|
async fetchBounds(box, { zoom }) {
|
|
if (zoom === 12) return { tiles: [{ roads }], partial: false };
|
|
if (allFailed) throw new Error('temporary tile failure');
|
|
return {
|
|
tiles: [{ roads: [] }],
|
|
loadedTiles: [detail[0]],
|
|
partial: true,
|
|
};
|
|
},
|
|
},
|
|
});
|
|
const snapshots = [];
|
|
const data = await (
|
|
await source.requestOsmRoads(bounds, {
|
|
coverage: { detail, coarse: [{ z: 12, x: 935, y: 1686 }] },
|
|
onTile: (value) => snapshots.push(value),
|
|
})
|
|
).json();
|
|
assert.equal(data.partial, true);
|
|
assert.equal(data.replace, true);
|
|
assert.deepEqual(data.roads, allFailed ? roads : [roads[1]]);
|
|
assert.deepEqual(snapshots.at(-1).roads, data.roads);
|
|
}
|
|
});
|
|
|
|
test('traffic separates API and public tile transports, including the default tile fetch', async (t) => {
|
|
clearSharedOpenFreeMapTiles();
|
|
t.after(clearSharedOpenFreeMapTiles);
|
|
const publicUrls = [],
|
|
apiUrls = [];
|
|
const publicFetch = async (url) => {
|
|
publicUrls.push(url);
|
|
return url.endsWith('/planet')
|
|
? Response.json({
|
|
tiles: ['https://tiles.openfreemap.org/test/{z}/{x}/{y}.pbf'],
|
|
})
|
|
: new Response(
|
|
readFileSync(
|
|
new URL(
|
|
'../../data/fixtures/ofm-austin-14-3743-6745.pbf',
|
|
import.meta.url,
|
|
),
|
|
),
|
|
);
|
|
};
|
|
t.mock.method(globalThis, 'fetch', publicFetch);
|
|
for (const tileFetchImpl of [undefined, publicFetch]) {
|
|
const source = createTrafficSource({
|
|
tileFetchImpl,
|
|
fetchImpl: async (url) => {
|
|
assert.ok(url.startsWith('/api/'));
|
|
apiUrls.push(url);
|
|
return url.endsWith('/status')
|
|
? Response.json({ hasKey: true })
|
|
: new Response(fixture);
|
|
},
|
|
});
|
|
await source.getStatus();
|
|
await source.fetchFlowForBounds(bounds);
|
|
assert.ok(
|
|
(await (await source.requestOsmRoads(bounds)).json()).roads.length,
|
|
);
|
|
}
|
|
assert.equal(
|
|
publicUrls.filter((url) => url.endsWith('.pbf')).length,
|
|
1,
|
|
'compatible sources reuse the shared decoded public tile',
|
|
);
|
|
assert.equal(publicUrls.filter((url) => url.endsWith('/planet')).length, 2);
|
|
assert.ok(apiUrls.length >= 4);
|
|
});
|
|
|
|
test('flow detail reports stale proxy tiles and the oldest tile time, also from its cache', async () => {
|
|
const fetchedAt = Date.UTC(2026, 9, 16, 8);
|
|
const reply = (status, at) => async () =>
|
|
new Response(fixture, {
|
|
headers: { 'x-tomtom-cache': status, 'x-tomtom-fetched-at': String(at) },
|
|
});
|
|
const stale = createTrafficSource({
|
|
fetchImpl: reply('STALE-BUDGET', fetchedAt),
|
|
});
|
|
const first = await stale.fetchFlowDetail(bounds);
|
|
assert.ok(first.segments.length > 0);
|
|
assert.equal(first.stale, true);
|
|
assert.equal(first.oldestTileAt, fetchedAt);
|
|
// The decoded tile is served from cache now, and keeps its mark.
|
|
const again = await stale.fetchFlowDetail(bounds);
|
|
assert.equal(stale.getFlowSessionStats().tilesFetched, 1);
|
|
assert.equal(again.stale, true);
|
|
assert.equal(again.oldestTileAt, fetchedAt);
|
|
|
|
const fresh = createTrafficSource({ fetchImpl: reply('MISS', fetchedAt) });
|
|
const live = await fresh.fetchFlowDetail(bounds);
|
|
assert.equal(live.stale, false);
|
|
assert.equal(live.oldestTileAt, fetchedAt);
|
|
|
|
const unmarked = createTrafficSource({
|
|
fetchImpl: async () => new Response(fixture),
|
|
});
|
|
const plain = await unmarked.fetchFlowDetail(bounds);
|
|
assert.equal(plain.stale, false);
|
|
assert.equal(plain.oldestTileAt, null);
|
|
});
|
|
|
|
// Capture constructor-owned Maps only while constructing the source, so tests
|
|
// can assert retained metadata without adding a diagnostic API to production.
|
|
function flowSourceWithMaps(fetchImpl) {
|
|
const maps = [];
|
|
const NativeMap = globalThis.Map;
|
|
let source;
|
|
try {
|
|
globalThis.Map = class extends NativeMap {
|
|
constructor(...args) {
|
|
super(...args);
|
|
maps.push(this);
|
|
}
|
|
};
|
|
source = createFlowTileSource({ fetchImpl });
|
|
} finally {
|
|
globalThis.Map = NativeMap;
|
|
}
|
|
return { source, pending: maps[0] };
|
|
}
|
|
|
|
test('flow freshness is released after body failures, size rejection, decode and reset', async () => {
|
|
for (const failure of ['body', 'size', 'decode']) {
|
|
let requestSignal;
|
|
let fail = true;
|
|
const { source, pending } = flowSourceWithMaps(async (url, { signal }) => {
|
|
requestSignal = signal;
|
|
return {
|
|
ok: true,
|
|
headers: new Headers({
|
|
'x-tomtom-cache': fail ? 'STALE-ERROR' : 'MISS',
|
|
'x-tomtom-fetched-at': fail ? '1000' : '2000',
|
|
...(fail && failure === 'size'
|
|
? { 'content-length': '99999999' }
|
|
: {}),
|
|
}),
|
|
async arrayBuffer() {
|
|
if (fail && failure === 'body') throw new Error('body disconnected');
|
|
return fail && failure === 'decode' ? new Uint8Array([255]) : fixture;
|
|
},
|
|
};
|
|
});
|
|
await assert.rejects(source.fetchFlowDetail(bounds));
|
|
assert.equal(pending.size, 0, `${failure} leaves no pending metadata`);
|
|
assert.equal(getEventListeners(requestSignal, 'abort').length, 0);
|
|
assert.equal(source.getFlowSessionStats().cacheEntries, 0);
|
|
fail = false;
|
|
const fresh = await source.fetchFlowDetail(bounds);
|
|
assert.equal(fresh.stale, false);
|
|
assert.equal(fresh.oldestTileAt, 2000);
|
|
assert.equal(pending.size, 0, 'successful decode releases metadata');
|
|
assert.equal(getEventListeners(requestSignal, 'abort').length, 0);
|
|
source.resetFlowTileCache();
|
|
assert.equal(pending.size, 0);
|
|
}
|
|
});
|
|
|
|
test('flow reset and late cancelled headers cannot retain or replace newer freshness', async () => {
|
|
let resolveOld;
|
|
let oldSignal;
|
|
let calls = 0;
|
|
const { source, pending } = flowSourceWithMaps((url, { signal }) => {
|
|
if (++calls === 1) {
|
|
oldSignal = signal;
|
|
return new Promise((resolve) => {
|
|
resolveOld = resolve;
|
|
});
|
|
}
|
|
return Promise.resolve(
|
|
new Response(fixture, {
|
|
headers: { 'x-tomtom-cache': 'MISS', 'x-tomtom-fetched-at': '2000' },
|
|
}),
|
|
);
|
|
});
|
|
const old = source.fetchFlowDetail(bounds);
|
|
const rejected = assert.rejects(old, { name: 'AbortError' });
|
|
while (!resolveOld) await new Promise((resolve) => setImmediate(resolve));
|
|
source.resetFlowTileCache();
|
|
const fresh = await source.fetchFlowDetail(bounds);
|
|
resolveOld(
|
|
new Response(fixture, {
|
|
headers: {
|
|
'x-tomtom-cache': 'STALE-ERROR',
|
|
'x-tomtom-fetched-at': '1000',
|
|
},
|
|
}),
|
|
);
|
|
await rejected;
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(pending.size, 0);
|
|
assert.equal(getEventListeners(oldSignal, 'abort').length, 0);
|
|
assert.equal(fresh.stale, false);
|
|
assert.equal(fresh.oldestTileAt, 2000);
|
|
assert.equal((await source.fetchFlowDetail(bounds)).oldestTileAt, 2000);
|
|
});
|
|
|
|
test('cancelling a flow body releases its freshness before a new request', async () => {
|
|
const controller = new AbortController();
|
|
let requestSignal;
|
|
const { source, pending } = flowSourceWithMaps(async (url, { signal }) => {
|
|
requestSignal = signal;
|
|
return {
|
|
ok: true,
|
|
headers: new Headers({ 'x-tomtom-cache': 'STALE-ERROR' }),
|
|
async arrayBuffer() {
|
|
assert.equal(pending.size, 1);
|
|
controller.abort();
|
|
return fixture;
|
|
},
|
|
};
|
|
});
|
|
await assert.rejects(
|
|
source.fetchFlowDetail(bounds, { signal: controller.signal }),
|
|
{ name: 'AbortError' },
|
|
);
|
|
assert.equal(pending.size, 0);
|
|
assert.equal(getEventListeners(requestSignal, 'abort').length, 0);
|
|
assert.equal(source.getFlowSessionStats().cacheEntries, 0);
|
|
});
|
|
|
|
test('a failed flow tile carries the server reason for its label', async () => {
|
|
for (const [status, body, code] of [
|
|
[
|
|
429,
|
|
{ error: 'Monthly usage limit reached', code: 'USAGE_LIMIT_REACHED' },
|
|
'USAGE_LIMIT_REACHED',
|
|
],
|
|
[
|
|
429,
|
|
{ error: 'Request rate limit reached', code: 'RATE_LIMITED' },
|
|
'RATE_LIMITED',
|
|
],
|
|
[503, { error: 'no_key' }, 'no_key'],
|
|
[503, { error: 'Usage enforcement is temporarily unavailable' }, null],
|
|
]) {
|
|
const source = createFlowTileSource({
|
|
fetchImpl: async () => Response.json(body, { status }),
|
|
});
|
|
await assert.rejects(source.fetchFlowForBounds(bounds), (error) => {
|
|
assert.equal(error.status, status);
|
|
assert.equal(error.code, code);
|
|
return true;
|
|
});
|
|
}
|
|
});
|