Files
gods-eye-view/src/tools/queries/mobility.test.mjs
T
quanticsoul4772andClaude Opus 5.5 ae55963a0e fix(tools): wrap whole-degree headings at 360 to 0
The query tools rounded courses, headings, bearings and azimuths with
Number(value.toFixed(0)) and no wrap, so a direction of 359.5 degrees or
more came back as 360: find_vessel with course 359.7 and heading 359.6
returned course_deg 360 and heading_deg 360.

Round them through the shared roundHeadingDegrees helper the layers and
UI already use (src/data/headingDegrees.js), which wraps into 0 to 359:
course_deg and heading_deg (vessels), course_deg (aircraft), bearing_deg
(transit), heading_deg (cameras), and rise_azimuth_deg and azimuth_deg
(satellites). Other rounding is unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 06:32:07 -08:00

670 lines
19 KiB
JavaScript

import assert from 'node:assert/strict';
import test from 'node:test';
import { composeCatalog, coreTools } from '../index.js';
import { GBFS_CITY_REGISTRY } from '../../layers/bikeshare/registry.js';
const system = (id, city, centerLat, centerLon) => ({
id,
city,
centerLat,
centerLon,
loadRadiusKm: 30,
provider: 'Test Bikes',
stationInformationUrl: `https://gbfs.example/${id}/station_information.json`,
stationStatusUrl: `https://gbfs.example/${id}/station_status.json`,
});
const documents = {
'https://gbfs.example/austin/station_information.json': {
data: {
stations: [
{
station_id: 's1',
name: 'Congress & 2nd',
lat: 30.2645,
lon: -97.7445,
capacity: 12,
},
{
station_id: 's2',
name: 'Far Station',
lat: 30.4,
lon: -97.9,
capacity: 8,
},
{
station_id: 's3',
name: 'Lamar & 5th',
lat: 30.268,
lon: -97.753,
capacity: '10',
},
],
},
},
'https://gbfs.example/austin/station_status.json': {
data: {
stations: [
{
station_id: 's1',
num_bikes_available: 4,
num_docks_available: 8,
is_renting: 1,
last_reported: 1767225600,
},
{
station_id: 's3',
num_bikes_available: 0,
num_docks_available: 10,
is_renting: 0,
},
],
},
},
};
const bikeshare = (systems, failing = new Set()) => ({
systems,
async getStations(url) {
if ([...failing].some((id) => url.includes(`/${id}/`)))
throw new Error('GBFS HTTP 502');
return documents[url];
},
});
const downtown = { lat: 30.2672, lon: -97.7431, radius_km: 2 };
test('bike share joins station information with live status inside the area', async () => {
const catalog = composeCatalog({
tools: coreTools,
services: {
bikeshare: bikeshare([
system('austin', 'Austin, TX', 30.27, -97.74),
system('oslo', 'Oslo', 59.9, 10.7),
]),
},
});
const result = await catalog.call('get_bike_share', { area: downtown });
assert.equal(
result.summary,
'2 bike-share stations in 2 km around 30.267, -97.743 with 4 bikes available.',
);
assert.deepEqual(result.data.systems, ['Austin, TX']);
assert.deepEqual(result.data.rows[0], {
system: 'Austin, TX',
provider: 'Test Bikes',
station_id: 's1',
name: 'Congress & 2nd',
lat: 30.2645,
lon: -97.7445,
bikes_available: 4,
docks_available: 8,
capacity: 12,
renting: true,
returning: true,
last_reported: '2026-01-01T00:00:00.000Z',
distance_km: 0.33,
});
assert.equal(result.data.rows[1].renting, false);
assert.equal(result.data.rows[1].capacity, 10);
});
test('bike share returns localized names without losing stations with malformed names', async () => {
const informationUrl = 'https://gbfs.example/austin/station_information.json';
const information = structuredClone(documents[informationUrl]);
information.version = '3.0';
information.data.stations[0].name = [
{ language: 'hu', text: 'Magyar név' },
{ language: 'en', text: 'Congress & 2nd' },
];
information.data.stations[2].name = [null, { language: 42, text: [] }];
const source = bikeshare([system('austin', 'Austin, TX', 30.27, -97.74)]);
const catalog = composeCatalog({
tools: coreTools,
services: {
bikeshare: {
...source,
getStations: (url) =>
url === informationUrl ? information : source.getStations(url),
},
},
});
const result = await catalog.call('get_bike_share', { area: downtown });
assert.equal(result.data.total, 2);
assert.equal(result.data.rows[0].name, 'Congress & 2nd');
assert.equal(result.data.rows[0].bikes_available, 4);
assert.equal(result.data.rows[1].name, null);
assert.doesNotMatch(result.summary, /unavailable/);
});
test('bike share reports uncovered areas and failed systems honestly', async () => {
const none = composeCatalog({
tools: coreTools,
services: { bikeshare: bikeshare([system('oslo', 'Oslo', 59.9, 10.7)]) },
});
const empty = await none.call('get_bike_share', { area: downtown });
assert.equal(
empty.summary,
'No supported bike-share system covers 2 km around 30.267, -97.743.',
);
assert.equal(empty.data.total, 0);
const both = [
system('austin', 'Austin, TX', 30.27, -97.74),
system('round-rock', 'Round Rock', 30.5, -97.68),
];
const partial = composeCatalog({
tools: coreTools,
services: { bikeshare: bikeshare(both, new Set(['round-rock'])) },
});
assert.match(
(
await partial.call('get_bike_share', {
area: { lat: 30.4, lon: -97.7, radius_km: 20 },
})
).summary,
/\(1 system unavailable\)\.$/,
);
const down = composeCatalog({
tools: coreTools,
services: { bikeshare: bikeshare(both, new Set(['austin', 'round-rock'])) },
});
await assert.rejects(
down.call('get_bike_share', { area: downtown }),
(error) => error.code === 'unavailable',
);
});
test('bike share excludes blank coordinates without losing stations on the prime meridian', async () => {
const stations = [
{ station_id: 'blank', lat: 51.5, lon: ' ' },
{ station_id: 'zero', lat: 51.5, lon: 0 },
];
const catalog = composeCatalog({
tools: coreTools,
services: {
bikeshare: {
systems: [system('fixture', 'Fixture Bikes', 51.5, 0)],
async getStations(url) {
return {
data: {
stations: url.endsWith('station_information.json')
? stations
: stations.map(({ station_id }) => ({
station_id,
num_bikes_available: 4,
})),
},
};
},
},
},
});
const result = await catalog.call('get_bike_share', {
area: { lat: 51.5, lon: 0, radius_km: 2 },
});
assert.deepEqual(
result.data.rows.map((row) => row.station_id),
['zero'],
);
assert.equal(result.data.total, 1);
assert.equal(result.data.rows[0].lon, 0);
assert.equal(
result.summary,
'1 bike-share station in 2 km around 51.500, 0.000 with 4 bikes available.',
);
});
const feed = {
id: 'capmetro',
name: 'CapMetro',
operator: 'Capital Metro',
center: { lat: 30.27, lon: -97.74 },
loadRadiusKm: 50,
attribution: 'Capital Metro',
license: 'Open data',
};
const vehicles = [
{
id: 'v1',
lat: 30.2675,
lon: -97.7425,
bearing: 91.6,
speedMps: 8.23,
timestamp: 1767225600,
routeId: '1',
tripId: 't1',
label: '1 North',
status: 'IN_TRANSIT_TO',
occupancy: 'FEW_SEATS_AVAILABLE',
},
{
id: 'v2',
lat: 30.268,
lon: -97.745,
bearing: null,
speedMps: null,
timestamp: null,
routeId: '801',
label: 'Rapid',
},
{ id: 'v3', lat: 30.5, lon: -97.6, routeId: '1' },
];
// One minute after v1's fix.
const clock = { now: () => Date.UTC(2026, 0, 1, 0, 1) };
const transit = (
snapshot = { ok: true, status: 200, json: async () => ({ vehicles }) },
) => ({
requested: [],
async getFeeds() {
return [
feed,
{ ...feed, id: 'far', name: 'Far Away', center: { lat: 0, lon: 0 } },
];
},
async requestSnapshot(id) {
this.requested.push(id);
return snapshot;
},
});
test('transit vehicles come from nearby feeds and can be limited to a route', async () => {
const source = transit();
const catalog = composeCatalog({
tools: coreTools,
services: { transit: source, clock },
});
const all = await catalog.call('get_transit_vehicles', { area: downtown });
assert.equal(
all.summary,
'2 transit vehicles in 2 km around 30.267, -97.743.',
);
assert.deepEqual(source.requested, ['capmetro']);
assert.deepEqual(all.data.rows[0], {
feed: 'CapMetro',
id: 'v1',
label: '1 North',
route_id: '1',
trip_id: 't1',
lat: 30.2675,
lon: -97.7425,
bearing_deg: 92,
speed_mps: 8.2,
status: 'IN_TRANSIT_TO',
occupancy: 'FEW_SEATS_AVAILABLE',
updated: '2026-01-01T00:00:00.000Z',
distance_km: 0.07,
});
assert.deepEqual(all.data.feeds, [
{
name: 'CapMetro',
status: 'current',
operator: 'Capital Metro',
attribution: 'Capital Metro',
license: 'Open data',
},
]);
const rapid = await catalog.call('get_transit_vehicles', {
area: downtown,
route: 'rapid',
});
assert.equal(
rapid.summary,
'1 transit vehicle on route rapid in 2 km around 30.267, -97.743.',
);
assert.equal(rapid.data.rows[0].id, 'v2');
});
test('a transit bearing that rounds to 360 reads as 0', async () => {
const north = [{ ...vehicles[0], bearing: 359.6 }];
const catalog = composeCatalog({
tools: coreTools,
services: {
transit: transit({
ok: true,
status: 200,
json: async () => ({ vehicles: north }),
}),
clock,
},
});
const result = await catalog.call('get_transit_vehicles', { area: downtown });
assert.equal(result.data.rows[0].bearing_deg, 0);
});
test('transit reports uncovered areas and unavailable feeds', async () => {
const catalog = composeCatalog({
tools: coreTools,
services: { transit: transit() },
});
const oslo = await catalog.call('get_transit_vehicles', {
area: { lat: 59.9, lon: 10.7, radius_km: 5 },
});
assert.equal(
oslo.summary,
'No supported transit feed covers 5 km around 59.900, 10.700.',
);
const down = composeCatalog({
tools: coreTools,
services: { transit: transit({ ok: false, status: 503 }) },
});
await assert.rejects(
down.call('get_transit_vehicles', { area: downtown }),
(error) => error.code === 'unavailable',
);
});
test('traffic flow aggregates speed, congestion and closures by road length', async () => {
// Two 0.01° segments along the equator (about 1.11 km each) and one closure.
const segments = [
{
coords: [
[0, 0],
[0.01, 0],
],
trafficLevel: 1,
roadCategory: 'motorway',
closure: false,
},
{
coords: [
[0, 0.001],
[0.01, 0.001],
],
trafficLevel: 0.25,
roadCategory: 'street',
closure: false,
},
{
coords: [
[0, 0.002],
[0.005, 0.002],
],
trafficLevel: 0,
roadCategory: 'street',
closure: true,
},
{ coords: [[0, 0]], trafficLevel: 1 },
];
const zooms = [];
const traffic = {
getStatus: async () => ({ hasKey: true }),
async fetchFlowForBounds(box, { zoom }) {
zooms.push(zoom);
if (zoom > 10)
throw Object.assign(new Error('Zoom in'), {
code: 'TILE_VIEW_TOO_WIDE',
});
return segments;
},
};
const catalog = composeCatalog({ tools: coreTools, services: { traffic } });
const result = await catalog.call('get_traffic_flow', {
area: { bbox: [-0.1, -0.1, 0.1, 0.1] },
});
assert.deepEqual(zooms, [12, 11, 10]);
assert.equal(
result.summary,
'Traffic in the requested box: 50% of free-flow speed on average; 1.7 km congested of 2.8 km measured; 0.6 km closed.',
);
assert.equal(result.data.speed_pct_of_free_flow, 50);
assert.deepEqual(result.data.by_category, [
{
category: 'street',
road_km: 1.7,
speed_pct_of_free_flow: 17,
congested_km: 1.7,
},
{
category: 'motorway',
road_km: 1.1,
speed_pct_of_free_flow: 100,
congested_km: 0,
},
]);
});
test('traffic reports a missing key, empty areas and areas that are too wide', async () => {
const keyless = {
getStatus: async () => ({ hasKey: false }),
fetchFlowForBounds: async () => [],
};
await assert.rejects(
composeCatalog({ tools: coreTools, services: { traffic: keyless } }).call(
'get_traffic_flow',
{ area: downtown },
),
(error) => error.code === 'unavailable' && /TomTom key/.test(error.message),
);
const quiet = {
getStatus: async () => ({ hasKey: true }),
fetchFlowForBounds: async () => [],
};
assert.equal(
(
await composeCatalog({
tools: coreTools,
services: { traffic: quiet },
}).call('get_traffic_flow', { area: downtown })
).summary,
'No live traffic is reported in 2 km around 30.267, -97.743.',
);
const wide = {
getStatus: async () => ({ hasKey: true }),
fetchFlowForBounds: async () => {
throw Object.assign(new Error('Zoom in'), { code: 'TILE_VIEW_TOO_WIDE' });
},
};
await assert.rejects(
composeCatalog({ tools: coreTools, services: { traffic: wide } }).call(
'get_traffic_flow',
{ area: { bbox: [-100, 30, -95, 35] } },
),
/too large for traffic detail/,
);
});
test('transit marks stale feeds and drops expired positions', async () => {
const headers = new Headers({ 'x-gev-cache': 'STALE-ERROR' });
const snapshot = (extra) => ({
ok: true,
status: 200,
headers,
json: async () => ({
vehicles: [
vehicles[0],
{ ...vehicles[0], id: 'old', timestamp: 1767225600 - 3600 },
],
...extra,
}),
});
const result = await composeCatalog({
tools: coreTools,
services: { transit: transit(snapshot()), clock },
}).call('get_transit_vehicles', { area: downtown });
assert.deepEqual(
result.data.rows.map((row) => row.id),
['v1'],
);
assert.equal(result.data.expired_positions_dropped, 1);
assert.equal(result.data.stale, true);
assert.equal(result.data.feeds[0].status, 'stale');
assert.equal(
result.summary,
'1 transit vehicle in 2 km around 30.267, -97.743 (1 feed stale; positions may be out of date).',
);
});
test('bike share names the systems it did not search', async () => {
const empty = { data: { stations: [] } };
const catalog = composeCatalog({
tools: coreTools,
services: {
bikeshare: {
systems: GBFS_CITY_REGISTRY,
getStations: async () => empty,
},
},
});
// New York, Philadelphia, Washington and Boston.
const result = await catalog.call('get_bike_share', {
area: { bbox: [-77.5, 38.5, -70.5, 42.8] },
});
assert.equal(result.data.systems.length, 3);
assert.ok(result.data.systems_not_searched.length >= 1);
assert.match(
result.summary,
/more not searched: .*; use a smaller area\)\.$/,
);
});
test('bike share over Oslo searches only the nearby Norwegian systems', async () => {
const requested = [];
const result = await composeCatalog({
tools: coreTools,
services: {
bikeshare: {
systems: GBFS_CITY_REGISTRY,
getStations: async (url) => {
requested.push(url);
return { data: { stations: [] } };
},
},
},
}).call('get_bike_share', {
area: { lat: 59.9139, lon: 10.7522, radius_km: 5 },
});
assert.deepEqual(result.data.systems.sort(), [
'Lillestrøm, Norway',
'Oslo, Norway',
]);
assert.deepEqual(result.data.systems_not_searched, []);
assert.ok(
requested.every(
(url) =>
url.startsWith('https://gbfs.urbansharing.com/oslobysykkel.no/') ||
url.startsWith('https://api.cyclocity.fr/contracts/lillestrom/'),
),
);
});
test('bike share over Stavanger searches Kolumbus Bysykkel', async () => {
const result = await composeCatalog({
tools: coreTools,
services: {
bikeshare: {
systems: GBFS_CITY_REGISTRY,
getStations: async () => ({ data: { stations: [] } }),
},
},
}).call('get_bike_share', {
area: { lat: 58.97, lon: 5.7331, radius_km: 5 },
});
assert.deepEqual(result.data.systems, ['Stavanger, Norway']);
});
test('traffic counts only roads inside a radius area and reports missing tiles', async () => {
const flow = (segments, partial = false) => ({
getStatus: async () => ({ hasKey: true }),
fetchFlowDetail: async () => ({ segments, partial }),
});
const call = (traffic, area) =>
composeCatalog({ tools: coreTools, services: { traffic } }).call(
'get_traffic_flow',
{ area },
);
const circle = { lat: 0, lon: 0, radius_km: 10 };
// In the circle's bounding box, but about 12.6 km from its center.
const corner = [
{
coords: [
[0.08, 0.08],
[0.085, 0.085],
],
closure: true,
trafficLevel: 1,
},
];
const outside = await call(flow(corner), circle);
assert.equal(outside.data.closed_km, 0);
assert.equal(outside.data.measured_km, 0);
// A 20 km road through the center keeps the 20 km inside the circle.
const across = [
{
coords: [
[-0.2, 0],
[0.2, 0],
],
trafficLevel: 1,
},
];
const crossing = await call(flow(across), circle);
assert.ok(Math.abs(crossing.data.measured_km - 20) < 0.2);
// A road cutting the circle with both ends outside it.
const chord = [
{
coords: [
[-0.2, 0.05],
[0.2, 0.05],
],
trafficLevel: 1,
},
];
assert.ok((await call(flow(chord), circle)).data.measured_km > 10);
const partial = await call(flow(across, true), circle);
assert.equal(partial.data.partial, true);
assert.match(partial.summary, /Some map tiles did not load/);
});
test('traffic says when the proxy served cached tiles, and how old the oldest is', async () => {
const road = [
{
coords: [
[-0.2, 0],
[0.2, 0],
],
trafficLevel: 0.9,
},
];
const call = (detail) =>
composeCatalog({
tools: coreTools,
services: {
traffic: {
getStatus: async () => ({ hasKey: true }),
fetchFlowDetail: async () => ({
segments: road,
partial: false,
...detail,
}),
},
},
}).call('get_traffic_flow', { area: { lat: 0, lon: 0, radius_km: 10 } });
const oldest = Date.UTC(2026, 9, 16, 8);
const stale = await call({ stale: true, oldestTileAt: oldest });
assert.equal(stale.data.stale, true);
assert.equal(stale.data.oldest_tile_at, '2026-10-16T08:00:00.000Z');
assert.match(
stale.summary,
/cached copies, the oldest from 2026-10-16T08:00:00\.000Z, so traffic may be out of date\./,
);
const live = await call({ stale: false, oldestTileAt: oldest });
assert.equal(live.data.stale, false);
assert.doesNotMatch(live.summary, /out of date/);
// A source that can't tell (no freshness fields) isn't reported as stale.
const unknown = await call({});
assert.equal(unknown.data.stale, false);
assert.equal(unknown.data.oldest_tile_at, null);
});
test('a whole-world bike-share search names every system it skipped', async () => {
const empty = { data: { stations: [] } };
const result = await composeCatalog({
tools: coreTools,
services: {
bikeshare: {
systems: GBFS_CITY_REGISTRY,
getStations: async () => empty,
},
},
}).call('get_bike_share', { area: { bbox: [-180, -90, 180, 90] } });
const named = [...result.data.systems, ...result.data.systems_not_searched];
assert.equal(named.length, GBFS_CITY_REGISTRY.length);
});