Files
gods-eye-view/src/tools/queries/places.test.mjs
T
Kevin Rajan ca58e113c0 test(routes): cover HTML 502 outage in MCP plan_route (#1509)
Preserve quanticsoul4772's routing-outage fix and add a focused voice-facing regression for a non-JSON gateway response.
2026-11-11 09:44:24 -08:00

363 lines
10 KiB
JavaScript

import assert from 'node:assert/strict';
import test from 'node:test';
import { composeCatalog, coreTools } from '../index.js';
import { createMcpServer } from '../mcp/index.js';
import { createPlaceSearchService, createRouteService } from '../places.js';
const place = (id, latitude, longitude, extra = {}) => ({
id,
name: `Place ${id}`,
address: `${id} Main St`,
latitude,
longitude,
distanceM: 120,
primaryType: 'cafe',
types: ['cafe'],
...extra,
});
const placeSearch = (result) => ({
calls: [],
async search(query, near) {
this.calls.push({ query, ...near });
return result;
},
async nearby(near) {
this.calls.push(near);
return result;
},
});
const places = {
resolve: async (name) =>
({
Austin: {
name: 'Austin, Texas',
bounds: { west: -97.94, south: 30.1, east: -97.56, north: 30.52 },
},
Dallas: {
name: 'Dallas, Texas',
bounds: { west: -96.99, south: 32.62, east: -96.46, north: 33.02 },
},
})[name] ?? null,
};
test('place search is centered on the area, kept inside it, and reports a missing key', async () => {
const search = placeSearch({
configured: true,
places: [place('a', 30.27, -97.74), place('far', 40.7, -74)],
});
const catalog = composeCatalog({
tools: coreTools,
services: { placeSearch: search, places },
});
const result = await catalog.call('search_places', {
query: 'coffee',
area: { place: 'Austin' },
});
assert.equal(result.summary, '1 place matching "coffee" in Austin, Texas.');
assert.deepEqual(result.data.rows[0], {
id: 'a',
name: 'Place a',
address: 'a Main St',
type: 'cafe',
lat: 30.27,
lon: -97.74,
distance_m: 120,
});
assert.equal(search.calls[0].query, 'coffee');
assert.ok(Math.abs(search.calls[0].latitude - 30.31) < 1e-9);
assert.equal(search.calls[0].radiusM, 29642);
const unconfigured = composeCatalog({
tools: coreTools,
services: {
placeSearch: placeSearch({ configured: false, places: [] }),
places,
},
});
await assert.rejects(
unconfigured.call('search_places', {
query: 'coffee',
area: { place: 'Austin' },
}),
(error) =>
error.code === 'unavailable' && /Google Places key/.test(error.message),
);
});
test('nearby places use the given radius', async () => {
const search = placeSearch({
configured: true,
places: [place('a', 30.27, -97.74)],
});
const catalog = composeCatalog({
tools: coreTools,
services: { placeSearch: search },
});
const result = await catalog.call('places_nearby', {
location: { lat: 30.27, lon: -97.74 },
radius_m: 400,
});
assert.equal(result.summary, '1 place within 400 m of 30.2700, -97.7400.');
assert.deepEqual(search.calls[0], {
latitude: 30.27,
longitude: -97.74,
radiusM: 400,
});
});
test('routes resolve endpoints, map modes and thin long paths', async () => {
const requests = [];
const geometry = Array.from({ length: 250 }, (_, index) => [
-97.74 + index / 1000,
30.27,
]);
const routing = {
async route(points, profile) {
requests.push({ points, profile });
return {
ok: true,
profile,
distanceM: 312400,
durationS: 11220,
geometry,
};
},
};
const catalog = composeCatalog({
tools: coreTools,
services: { routing, places },
});
const result = await catalog.call('plan_route', {
from: { place: 'Austin' },
to: { lat: 32.78, lon: -96.8 },
mode: 'drive',
});
assert.equal(
result.summary,
'Drive from Austin, Texas to 32.7800, -96.8000: 312.4 km, about 187 minutes.',
);
assert.equal(requests[0].profile, 'car');
assert.deepEqual(requests[0].points[1], {
label: '32.7800, -96.8000',
lat: 32.78,
lon: -96.8,
});
assert.equal(result.data.path_points, 250);
assert.equal(result.data.path_lon_lat.length, 100);
assert.deepEqual(result.data.path_lon_lat.at(-1), [-97.491, 30.27]);
const failing = composeCatalog({
tools: coreTools,
services: {
routing: {
route: async () => ({ ok: false, error: 'route leg too long' }),
},
places,
},
});
await assert.rejects(
failing.call('plan_route', {
from: { place: 'Austin' },
to: { place: 'Dallas' },
}),
/No walk route from Austin, Texas to Dallas, Texas: route leg too long/,
);
await assert.rejects(
catalog.call('plan_route', {
from: { place: 'Austin', lat: 1 },
to: { lat: 1, lon: 2 },
}),
/either place, or lat and lon/,
);
});
test('the place and route services read the app routes and translate failures', async () => {
const requested = [];
const respond = (body, status = 200, headers = {}) =>
new Response(JSON.stringify(body), {
status,
headers: { 'Content-Type': 'application/json', ...headers },
});
const search = createPlaceSearchService({
fetchImpl: async (url) => {
requested.push(url);
return url.includes('nearby')
? respond({ configured: false, error: null, places: [] })
: respond({ places: [place('a', 1, 2)] });
},
});
assert.deepEqual(
await search.search('tea', { latitude: 1, longitude: 2, radiusM: 300 }),
{
configured: true,
places: [place('a', 1, 2)],
},
);
assert.deepEqual(
await search.nearby({ latitude: 1, longitude: 2, radiusM: 50 }),
{ configured: false, places: [] },
);
assert.deepEqual(requested, [
'/api/google/text-search?q=tea&lat=1&lon=2&radiusM=300',
'/api/google/nearby-places?lat=1&lon=2&radiusM=50',
]);
const limited = createPlaceSearchService({
fetchImpl: async () =>
respond({ error: 'Rate limit exceeded', places: [] }, 429, {
'Retry-After': '30',
}),
});
await assert.rejects(
limited.nearby({ latitude: 1, longitude: 2, radiusM: 50 }),
(error) => error.code === 'retry_later' && error.retryAfterSeconds === 30,
);
const routes = [];
const routing = createRouteService({
fetchImpl: async (url) => {
routes.push(url);
if (routes.length === 1)
return respond({
ok: true,
distanceM: 10,
durationS: 5,
geometry: [[2, 1]],
});
if (routes.length === 2)
return respond({ ok: false, error: 'need 2-12 coordinates' }, 400);
return respond({ ok: false, error: 'rate limited' }, 429, {
'Retry-After': '5',
});
},
});
const points = [
{ lat: 1, lon: 2 },
{ lat: 1.5, lon: 2.5 },
];
assert.equal((await routing.route(points, 'foot')).distanceM, 10);
assert.equal(
routes[0],
'/api/route?profile=foot&coords=2.000000%2C1.000000%3B2.500000%2C1.500000',
);
assert.deepEqual(await routing.route(points, 'foot'), {
ok: false,
error: 'need 2-12 coordinates',
});
await assert.rejects(
routing.route(points, 'foot'),
(error) => error.code === 'retry_later' && error.retryAfterSeconds === 5,
);
});
test('a routing outage is reported as unavailable, not as invalid arguments', async () => {
for (const fetchImpl of [
async () =>
Response.json(
{ ok: false, error: 'routing service unavailable' },
{ status: 502 },
),
async () => {
throw new TypeError('fetch failed');
},
]) {
const catalog = composeCatalog({
tools: coreTools,
services: { routing: createRouteService({ fetchImpl }), places },
});
const server = createMcpServer({
catalog,
name: 'test',
version: '1.0.0',
});
const { result } = await server.handle({
jsonrpc: '2.0',
id: 1,
method: 'tools/call',
params: {
name: 'plan_route',
arguments: { from: { place: 'Austin' }, to: { place: 'Dallas' } },
},
});
assert.equal(result.isError, true);
assert.equal(result.structuredContent.error, 'unavailable');
assert.doesNotMatch(result.content[0].text, /No walk route/);
}
// Voice receives only the message, so it must name the outage.
const outage = createRouteService({
fetchImpl: async () =>
Response.json(
{ ok: false, error: 'routing service unavailable' },
{ status: 502 },
),
});
await assert.rejects(
outage.route(
[
{ lat: 30, lon: -97 },
{ lat: 30.01, lon: -97.01 },
],
'foot',
),
{ message: 'Routing service unavailable (HTTP 502)' },
);
});
test('an HTML 502 gateway response tells voice the route service is unavailable', async () => {
const catalog = composeCatalog({
tools: coreTools,
services: {
routing: createRouteService({
fetchImpl: async () =>
new Response('<html>Bad Gateway</html>', {
status: 502,
headers: { 'content-type': 'text/html' },
}),
}),
places,
},
});
const server = createMcpServer({ catalog, name: 'test', version: '1.0.0' });
const { result } = await server.handle({
jsonrpc: '2.0',
id: 1,
method: 'tools/call',
params: {
name: 'plan_route',
arguments: { from: { place: 'Austin' }, to: { place: 'Dallas' } },
},
});
assert.equal(result.isError, true);
assert.equal(result.structuredContent.error, 'unavailable');
assert.equal(
result.content[0].text,
'Routing service unavailable (HTTP 502)',
);
});
test('place answers say when the search limits may have left places out', async () => {
const five = Array.from({ length: 5 }, (_, index) =>
place(`p${index}`, 30.27, -97.74),
);
const catalog = composeCatalog({
tools: coreTools,
services: {
placeSearch: placeSearch({ configured: true, places: five }),
places,
},
});
const capped = await catalog.call('search_places', {
query: 'coffee',
area: { place: 'Austin' },
limit: 100,
});
assert.equal(capped.data.may_have_more, true);
assert.match(capped.summary, /the search returns at most 5 matches\)\.$/);
const wide = await catalog.call('search_places', {
query: 'coffee',
area: { lat: 30.27, lon: -97.74, radius_km: 200 },
});
assert.equal(wide.data.searched_radius_km, 50);
assert.match(wide.summary, /searched within 50 km of the center/);
});