mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
A street ribbon that holds neither its ring mean nor the anchor is centred on the street's nearest point when the street runs within 100 m. Nominatim outline selection ranks an exact name, then one holding every asked word, then an overlap, and refuses an overlap whose name lacks the ask's last word unless that word is in the result's address or type, so "Central Park Zoo" is no longer Central Park. The server caches every accepted outline and answers each ask with the one holding its resolved anchor (sent as alat/alon), read across the antimeridian. A duplicate mark that fails to clean up no longer tears down the new outline it duplicates.
1049 lines
29 KiB
JavaScript
1049 lines
29 KiB
JavaScript
// OVERPASS-FREE OUTLINE RUNGS.
|
|
//
|
|
// Streets and pointed-at buildings come from OpenFreeMap tiles before the
|
|
// existing ladder; cities, landmarks, grounds and named buildings fall to the
|
|
// server's guarded Nominatim outline after it. With default settings no
|
|
// request reaches any Overpass endpoint.
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import { Readable } from 'node:stream';
|
|
import {
|
|
containsAnchor,
|
|
createOutlineRungs,
|
|
isNamedAsk,
|
|
nominatimKindFor,
|
|
outlineQueryText,
|
|
} from './outlineRungs.js';
|
|
import { createAnnotationResolver } from './resolver.js';
|
|
import { decodeOpenFreeMapOutlineTile } from '../sources/openFreeMapOutlines.js';
|
|
import { createNominatimOutlineClient } from '../sources/nominatimOutlines.js';
|
|
import { createApplicationRequestServices } from '../services/requests.js';
|
|
import { overpassProxy } from '../../server/providers/overpass.js';
|
|
import { geocodeProxy } from '../../server/providers/regional/place.js';
|
|
import {
|
|
createGateStateStore,
|
|
createNominatimGate,
|
|
} from '../../server/providers/regional/nominatimGate.js';
|
|
|
|
const TILES = [6745, 6746].map((y) =>
|
|
decodeOpenFreeMapOutlineTile(
|
|
readFileSync(
|
|
new URL(
|
|
`../data/fixtures/ofm-outlines-austin-14-3743-${y}.pbf`,
|
|
import.meta.url,
|
|
),
|
|
),
|
|
14,
|
|
3743,
|
|
y,
|
|
),
|
|
);
|
|
const fixtureTiles = () => {
|
|
const asked = [];
|
|
return {
|
|
asked,
|
|
fetchBounds: async (box, options) => {
|
|
asked.push({ box, zoom: options.zoom });
|
|
return { tiles: TILES };
|
|
},
|
|
};
|
|
};
|
|
const CAPITOL = { lat: 30.27472, lon: -97.74035 };
|
|
|
|
const square = (lat, lon, halfDeg) => [
|
|
[lon - halfDeg, lat - halfDeg],
|
|
[lon + halfDeg, lat - halfDeg],
|
|
[lon + halfDeg, lat + halfDeg],
|
|
[lon - halfDeg, lat + halfDeg],
|
|
[lon - halfDeg, lat - halfDeg],
|
|
];
|
|
|
|
function fakeNominatim(answer) {
|
|
const asks = [];
|
|
return {
|
|
asks,
|
|
lookup: async (ask) => {
|
|
asks.push(ask);
|
|
return typeof answer === 'function' ? answer(ask) : answer;
|
|
},
|
|
};
|
|
}
|
|
|
|
/** A ladder whose base answers `baseAnswer` and whose finish passes rings through. */
|
|
function ladder(baseAnswer) {
|
|
const calls = { base: 0, finished: [] };
|
|
return {
|
|
calls,
|
|
base: async () => {
|
|
calls.base += 1;
|
|
return baseAnswer;
|
|
},
|
|
finish: (fp, scope) => {
|
|
calls.finished.push(scope);
|
|
return {
|
|
ring: fp.ring,
|
|
polygons: fp.polygons,
|
|
footprintKind: fp.kind,
|
|
synthesized: false,
|
|
};
|
|
},
|
|
};
|
|
}
|
|
|
|
const UNAVAILABLE = {
|
|
unavailable: true,
|
|
retryable: false,
|
|
code: 'OVERPASS_NOT_CONFIGURED',
|
|
};
|
|
const ctx = (overrides) => ({
|
|
scope: 'auto',
|
|
target: 'X',
|
|
matchName: 'X',
|
|
fromName: true,
|
|
pointLike: false,
|
|
groundsLike: false,
|
|
around: false,
|
|
...CAPITOL,
|
|
view: { lat: CAPITOL.lat, lon: CAPITOL.lon },
|
|
credit() {},
|
|
...overrides,
|
|
});
|
|
|
|
test('ask wording helpers', () => {
|
|
assert.equal(isNamedAsk('this building'), false);
|
|
assert.equal(isNamedAsk('here'), false);
|
|
assert.equal(isNamedAsk('Texas Capitol'), true);
|
|
assert.equal(outlineQueryText('the Texas Capitol grounds'), 'Texas Capitol');
|
|
assert.equal(nominatimKindFor({ scope: 'city' }), 'city');
|
|
assert.equal(nominatimKindFor({ scope: 'state' }), 'admin');
|
|
assert.equal(nominatimKindFor({ scope: 'compound' }), 'landmark');
|
|
assert.equal(
|
|
nominatimKindFor({ scope: 'building', groundsLike: true }),
|
|
'landmark',
|
|
);
|
|
assert.equal(nominatimKindFor({ scope: 'neighborhood' }), null);
|
|
assert.equal(nominatimKindFor({ scope: 'street' }), null);
|
|
assert.equal(nominatimKindFor({ scope: 'compound', pointLike: true }), null);
|
|
});
|
|
|
|
test('a street comes from tiles before the configured ladder, as merged ribbons', async () => {
|
|
const tiles = fixtureTiles();
|
|
const nominatim = fakeNominatim(null);
|
|
const credits = [];
|
|
const run = ladder(UNAVAILABLE);
|
|
const result = await createOutlineRungs({ tiles, nominatim }).resolve(
|
|
ctx({
|
|
scope: 'street',
|
|
target: 'Congress Avenue',
|
|
matchName: 'Congress Avenue',
|
|
credit: (k) => credits.push(k),
|
|
}),
|
|
run,
|
|
);
|
|
assert.ok(result.ring.length > 6);
|
|
assert.equal(result.polygons.length, 1);
|
|
assert.equal('outlineSource' in result, false);
|
|
assert.equal(run.calls.base, 0, 'the ladder is not consulted');
|
|
assert.deepEqual(run.calls.finished, ['street']);
|
|
assert.deepEqual(credits, ['tiles']);
|
|
assert.equal(result.outlineCredit, 'tiles');
|
|
assert.equal(tiles.asked[0].zoom, 14);
|
|
assert.equal(nominatim.asks.length, 0, 'streets never reach Nominatim');
|
|
});
|
|
|
|
test('rungs built without their own tiles share one outline tile cache', async (t) => {
|
|
const tileRequests = [];
|
|
const bytes = (y) =>
|
|
readFileSync(
|
|
new URL(
|
|
`../data/fixtures/ofm-outlines-austin-14-3743-${y}.pbf`,
|
|
import.meta.url,
|
|
),
|
|
);
|
|
t.mock.method(globalThis, 'fetch', async (url) => {
|
|
const href = String(url);
|
|
if (href.endsWith('/planet'))
|
|
return Response.json({
|
|
tiles: [
|
|
'https://tiles.openfreemap.org/planet/shared-test/{z}/{x}/{y}.pbf',
|
|
],
|
|
});
|
|
tileRequests.push(href);
|
|
const y = href.match(/\/(\d+)\.pbf$/)?.[1];
|
|
return new Response(y === '6746' ? bytes(6746) : bytes(6745));
|
|
});
|
|
const ask = () =>
|
|
ctx({
|
|
scope: 'street',
|
|
target: 'Congress Avenue',
|
|
matchName: 'Congress Avenue',
|
|
});
|
|
const first = await createOutlineRungs({
|
|
nominatim: fakeNominatim(null),
|
|
}).resolve(ask(), ladder(UNAVAILABLE));
|
|
assert.ok(first.ring.length > 6);
|
|
const fetched = tileRequests.length;
|
|
assert.ok(fetched > 0);
|
|
const second = await createOutlineRungs({
|
|
nominatim: fakeNominatim(null),
|
|
}).resolve(ask(), ladder(UNAVAILABLE));
|
|
assert.ok(second.ring.length > 6);
|
|
assert.equal(
|
|
tileRequests.length,
|
|
fetched,
|
|
'a second rung set reuses the shared outline tiles',
|
|
);
|
|
const own = fixtureTiles();
|
|
await createOutlineRungs({
|
|
tiles: own,
|
|
nominatim: fakeNominatim(null),
|
|
}).resolve(ask(), ladder(UNAVAILABLE));
|
|
assert.equal(own.asked.length, 1, 'explicit tiles are still used');
|
|
});
|
|
|
|
test('a street the tiles do not name falls through to the ladder', async () => {
|
|
const run = ladder(UNAVAILABLE);
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim: fakeNominatim(null),
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'street',
|
|
target: 'Lombard Street',
|
|
matchName: 'Lombard Street',
|
|
}),
|
|
run,
|
|
);
|
|
assert.equal(result, UNAVAILABLE);
|
|
assert.equal(run.calls.base, 1);
|
|
});
|
|
|
|
test('"circle this building" picks the tile building at the point first', async () => {
|
|
const nominatim = fakeNominatim(null);
|
|
const run = ladder(UNAVAILABLE);
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({ scope: 'building', target: 'this building', fromName: false }),
|
|
run,
|
|
);
|
|
assert.equal(result.footprintKind, 'building');
|
|
assert.equal(result.outlineCredit, 'tiles');
|
|
assert.equal(run.calls.base, 0);
|
|
assert.equal(nominatim.asks.length, 0);
|
|
const primary = [square(CAPITOL.lat, CAPITOL.lon, 0.0002)];
|
|
const other = [square(CAPITOL.lat + 0.001, CAPITOL.lon, 0.0002)];
|
|
const multipart = await createOutlineRungs({
|
|
tiles: {
|
|
fetchBounds: async () => ({
|
|
tiles: [
|
|
{
|
|
buildings: [
|
|
{
|
|
rings: primary,
|
|
featureParts: [primary, other],
|
|
clipped: false,
|
|
heightM: 20,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
}),
|
|
},
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({ scope: 'building', target: 'this building', fromName: false }),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.deepEqual(
|
|
multipart.polygons,
|
|
[primary],
|
|
'the building rung retains the selected component, not unrelated siblings',
|
|
);
|
|
});
|
|
|
|
test('a named building asks Nominatim, then falls back to the tile building', async () => {
|
|
const nominatim = fakeNominatim(null);
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({ scope: 'building', target: 'Texas State Capitol' }),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.deepEqual(
|
|
nominatim.asks.map((a) => a.kind),
|
|
['building'],
|
|
);
|
|
assert.equal(result.footprintKind, 'building');
|
|
});
|
|
|
|
test('named building tile fallbacks require the anchor in filled geometry', async () => {
|
|
const nearby = {
|
|
anchor: { lat: 0, lon: 0.00035 },
|
|
rings: [square(0, 0, 0.0001)],
|
|
};
|
|
for (const { anchor, rings } of [
|
|
nearby,
|
|
{
|
|
anchor: { lat: 0, lon: 0 },
|
|
rings: [square(0, 0, 0.001), square(0, 0, 0.0002)],
|
|
},
|
|
]) {
|
|
const credits = [];
|
|
const run = ladder(UNAVAILABLE);
|
|
const result = await createOutlineRungs({
|
|
tiles: {
|
|
fetchBounds: async () => ({
|
|
tiles: [{ buildings: [{ rings, heightM: null }] }],
|
|
}),
|
|
},
|
|
nominatim: fakeNominatim(null),
|
|
}).resolve(
|
|
ctx({
|
|
...anchor,
|
|
view: anchor,
|
|
scope: 'building',
|
|
target: 'Gateville',
|
|
matchName: 'Gateville',
|
|
credit: (kind) => credits.push(kind),
|
|
}),
|
|
run,
|
|
);
|
|
assert.equal(result, UNAVAILABLE);
|
|
assert.deepEqual(run.calls.finished, []);
|
|
assert.deepEqual(credits, []);
|
|
}
|
|
|
|
const pointed = await createOutlineRungs({
|
|
tiles: {
|
|
fetchBounds: async () => ({
|
|
tiles: [{ buildings: [{ rings: nearby.rings, heightM: null }] }],
|
|
}),
|
|
},
|
|
nominatim: fakeNominatim(null),
|
|
}).resolve(
|
|
ctx({
|
|
...nearby.anchor,
|
|
view: nearby.anchor,
|
|
scope: 'building',
|
|
target: 'this building',
|
|
fromName: false,
|
|
}),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.equal(pointed.footprintKind, 'building');
|
|
assert.equal(pointed.outlineCredit, 'tiles');
|
|
});
|
|
|
|
test('a partial tile load that lost the point tile lets nothing stand in', async () => {
|
|
// The point (z14 tile 8192/8192) is ~28 m from a building in the tile that
|
|
// did load; without the point's own tile, that neighbour must not answer.
|
|
const anchor = { lat: 0, lon: 0.00035 };
|
|
const school = square(CAPITOL.lat, CAPITOL.lon, 0.002);
|
|
const load = (loadedTiles) => ({
|
|
fetchBounds: async () => ({
|
|
tiles: [
|
|
{
|
|
buildings: [{ rings: [square(0, 0, 0.0001)], heightM: null }],
|
|
areas: [
|
|
{ name: null, rings: [school], class: 'school', clipped: false },
|
|
],
|
|
},
|
|
],
|
|
loadedTiles,
|
|
partial: true,
|
|
}),
|
|
});
|
|
const pointAt = (tiles) =>
|
|
createOutlineRungs({ tiles, nominatim: fakeNominatim(null) }).resolve(
|
|
ctx({
|
|
...anchor,
|
|
view: anchor,
|
|
scope: 'building',
|
|
target: 'this building',
|
|
fromName: false,
|
|
}),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.equal(await pointAt(load([{ z: 14, x: 8191, y: 8192 }])), UNAVAILABLE);
|
|
const kept = await pointAt(load([{ z: 14, x: 8192, y: 8192 }]));
|
|
assert.equal(kept.footprintKind, 'building', 'the point tile loaded');
|
|
|
|
const grounds = (loaded) =>
|
|
createOutlineRungs({
|
|
tiles: load(loaded),
|
|
nominatim: fakeNominatim(null),
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'building',
|
|
target: 'Lincoln High School grounds',
|
|
groundsLike: true,
|
|
}),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
// The Capitol fixture point lies in tile 3743/6745.
|
|
assert.equal(await grounds([{ z: 14, x: 3744, y: 6745 }]), UNAVAILABLE);
|
|
assert.equal(
|
|
(await grounds([{ z: 14, x: 3743, y: 6745 }])).footprintKind,
|
|
'area',
|
|
);
|
|
});
|
|
|
|
test('a city with no configured Overpass is outlined by Nominatim', async () => {
|
|
const ring = square(43.6, 1.44, 0.05);
|
|
const nominatim = fakeNominatim({ polygons: [[ring]], class: 'boundary' });
|
|
const credits = [];
|
|
const run = ladder(UNAVAILABLE);
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'city',
|
|
target: 'Toulouse, France',
|
|
matchName: 'Toulouse',
|
|
lat: 43.6,
|
|
lon: 1.44,
|
|
credit: (k) => credits.push(k),
|
|
}),
|
|
run,
|
|
);
|
|
assert.deepEqual(result.ring, ring);
|
|
assert.equal(result.outlineCredit, 'osm');
|
|
assert.deepEqual(nominatim.asks[0], {
|
|
query: 'Toulouse',
|
|
kind: 'city',
|
|
lat: CAPITOL.lat,
|
|
lon: CAPITOL.lon,
|
|
anchorLat: 43.6,
|
|
anchorLon: 1.44,
|
|
});
|
|
assert.deepEqual(
|
|
run.calls.finished,
|
|
['city'],
|
|
'scope caps and drift bound still apply',
|
|
);
|
|
assert.deepEqual(credits, ['osm']);
|
|
});
|
|
|
|
test('a Nominatim outline across the antimeridian still holds its anchor', async () => {
|
|
const ring = [
|
|
[179.9, -16.9],
|
|
[-179.9, -16.9],
|
|
[-179.9, -16.7],
|
|
[179.9, -16.7],
|
|
[179.9, -16.9],
|
|
];
|
|
const hole = [
|
|
[179.99, -16.81],
|
|
[-179.99, -16.81],
|
|
[-179.99, -16.79],
|
|
[179.99, -16.79],
|
|
[179.99, -16.81],
|
|
];
|
|
assert.ok(containsAnchor([[ring]], -16.8, 179.95));
|
|
assert.ok(
|
|
containsAnchor([[ring]], -16.8, -179.95),
|
|
'either side of the line',
|
|
);
|
|
assert.ok(!containsAnchor([[ring, hole]], -16.8, 180), 'holes still exclude');
|
|
assert.ok(!containsAnchor([[ring]], -16.8, 179.5), 'outside stays outside');
|
|
assert.ok(
|
|
!containsAnchor([[ring]], -16.8, 0),
|
|
'far side of the globe is outside',
|
|
);
|
|
const steps = [-170, -130, -90, -50, -10, 20];
|
|
const wide = [
|
|
...steps.map((x) => [x, 10]),
|
|
...steps.toReversed().map((x) => [x, 20]),
|
|
[-170, 10],
|
|
];
|
|
assert.ok(
|
|
containsAnchor([[wide]], 15, 5),
|
|
'a ring wider than 180° is read as stored',
|
|
);
|
|
const polar = [
|
|
[-180, -60],
|
|
[180, -60],
|
|
[180, -90],
|
|
[-180, -90],
|
|
[-180, -60],
|
|
];
|
|
assert.ok(
|
|
containsAnchor([[polar]], -80, 30),
|
|
'a polar ring spanning every longitude',
|
|
);
|
|
const nominatim = fakeNominatim({ polygons: [[ring]], class: 'boundary' });
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'city',
|
|
target: 'Dateline Town',
|
|
matchName: 'Dateline Town',
|
|
lat: -16.8,
|
|
lon: 179.95,
|
|
}),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.deepEqual(result.ring, ring, 'the outline is accepted, not refused');
|
|
assert.equal(result.outlineCredit, 'osm');
|
|
});
|
|
|
|
test('an empty Nominatim polygon list falls back without throwing', async () => {
|
|
const nominatim = fakeNominatim({ polygons: [], class: 'boundary' });
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({ scope: 'city', target: 'Nowhere', matchName: 'Nowhere' }),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.equal(result, UNAVAILABLE);
|
|
});
|
|
|
|
test('named outlines must contain the resolved anchor outside holes', async () => {
|
|
const anchor = { lat: 0, lon: 0 };
|
|
for (const context of [
|
|
{ scope: 'city' },
|
|
{ scope: 'state' },
|
|
{ scope: 'building' },
|
|
{ scope: 'compound' },
|
|
{ scope: 'building', groundsLike: true },
|
|
]) {
|
|
for (const polygons of [
|
|
[[square(0, 0.04, 0.01)]],
|
|
[[square(0, 0, 0.05), square(0, 0, 0.01)]],
|
|
]) {
|
|
const nominatim = fakeNominatim({ polygons, class: 'boundary' });
|
|
const run = ladder(UNAVAILABLE);
|
|
const credits = [];
|
|
const result = await createOutlineRungs({
|
|
tiles: { fetchBounds: async () => ({ tiles: [] }) },
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({
|
|
...anchor,
|
|
...context,
|
|
target: 'Gateville',
|
|
matchName: 'Gateville',
|
|
view: { lat: 0, lon: 0.04, radiusKm: 1 },
|
|
credit: (kind) => credits.push(kind),
|
|
}),
|
|
run,
|
|
);
|
|
assert.equal(
|
|
result,
|
|
UNAVAILABLE,
|
|
`${JSON.stringify(context)}: reject geometry outside the anchor`,
|
|
);
|
|
assert.equal(nominatim.asks.length, 1);
|
|
assert.deepEqual(
|
|
run.calls.finished,
|
|
[],
|
|
'rejected boundary never reaches installation',
|
|
);
|
|
assert.deepEqual(
|
|
credits,
|
|
[],
|
|
'rejected boundary earns no outline credit',
|
|
);
|
|
}
|
|
}
|
|
const ring = square(0, 0, 0.01);
|
|
const valid = await createOutlineRungs({
|
|
tiles: { fetchBounds: async () => ({ tiles: [] }) },
|
|
nominatim: fakeNominatim({ polygons: [[ring]], class: 'building' }),
|
|
}).resolve(
|
|
ctx({ ...anchor, scope: 'building', target: 'Gateville' }),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.deepEqual(
|
|
valid.ring,
|
|
ring,
|
|
'the containing named building remains valid',
|
|
);
|
|
});
|
|
|
|
test('an unnamed school landuse answers a school grounds ask from tiles', async () => {
|
|
const schoolRing = square(CAPITOL.lat, CAPITOL.lon, 0.002);
|
|
const tiles = {
|
|
fetchBounds: async () => ({
|
|
tiles: [
|
|
{
|
|
areas: [
|
|
{
|
|
name: null,
|
|
rings: [schoolRing],
|
|
class: 'school',
|
|
clipped: false,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
const ask = (target) =>
|
|
createOutlineRungs({ tiles, nominatim: fakeNominatim(null) }).resolve(
|
|
ctx({ scope: 'building', target, groundsLike: true }),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
const school = await ask('Lincoln High School grounds');
|
|
assert.equal(school.footprintKind, 'area');
|
|
assert.deepEqual(school.polygons, [[schoolRing]]);
|
|
assert.equal(school.outlineCredit, 'tiles');
|
|
assert.equal(
|
|
await ask('Texas Capitol grounds'),
|
|
UNAVAILABLE,
|
|
'other asks still need a name',
|
|
);
|
|
});
|
|
|
|
test('a multi-part city leads with the part holding the anchor, not the largest', async () => {
|
|
const sea = square(33.5, 139.5, 0.8); // larger, far from the anchor
|
|
const outer = square(CAPITOL.lat, CAPITOL.lon, 0.4);
|
|
const hole = square(CAPITOL.lat, CAPITOL.lon, 0.3);
|
|
const land = square(CAPITOL.lat, CAPITOL.lon, 0.2);
|
|
const nominatim = fakeNominatim({
|
|
polygons: [[sea], [outer, hole], [land]],
|
|
class: 'boundary',
|
|
});
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({ scope: 'city', target: 'Tokyo', matchName: 'Tokyo' }),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.deepEqual(
|
|
result.ring,
|
|
land,
|
|
'the main ring (centroid, scope cap) is the anchored part',
|
|
);
|
|
assert.deepEqual(
|
|
result.polygons,
|
|
[[land], [sea], [outer, hole]],
|
|
'every part and hole is retained',
|
|
);
|
|
});
|
|
|
|
test('a real outline from the ladder (bundled or operator Overpass) is kept', async () => {
|
|
const nominatim = fakeNominatim(null);
|
|
const outline = { ring: square(0, 0, 1), synthesized: false };
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(ctx({ scope: 'city', target: 'Austin' }), ladder(outline));
|
|
assert.equal(result, outline);
|
|
assert.equal(nominatim.asks.length, 0);
|
|
});
|
|
|
|
test('a transient ladder failure stays retryable without spending a lookup', async () => {
|
|
const nominatim = fakeNominatim(null);
|
|
const result = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({ scope: 'compound', target: 'Zilker Park' }),
|
|
ladder(undefined),
|
|
);
|
|
assert.equal(result, undefined);
|
|
assert.equal(nominatim.asks.length, 0);
|
|
});
|
|
|
|
test('no Nominatim outline leaves the honest point; busy stays retryable', async () => {
|
|
const rungs = (answer) =>
|
|
createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim: fakeNominatim(answer),
|
|
});
|
|
assert.equal(
|
|
await rungs(null).resolve(
|
|
ctx({ scope: 'compound', target: 'Nowhere Park' }),
|
|
ladder(UNAVAILABLE),
|
|
),
|
|
UNAVAILABLE,
|
|
);
|
|
const busy = { rateLimited: true, retryAfterMs: 5000 };
|
|
assert.equal(
|
|
await rungs(busy).resolve(
|
|
ctx({ scope: 'compound', target: 'Zilker Park' }),
|
|
ladder(UNAVAILABLE),
|
|
),
|
|
busy,
|
|
);
|
|
// After an operator's definitive miss, a busy Nominatim does not invite retries.
|
|
assert.equal(
|
|
await rungs(busy).resolve(
|
|
ctx({ scope: 'compound', target: 'Zilker Park' }),
|
|
ladder(null),
|
|
),
|
|
null,
|
|
);
|
|
});
|
|
|
|
test('grounds: a building-sized answer is not the grounds; a real enclosure is', async () => {
|
|
const dome = {
|
|
polygons: [[square(30.2747, -97.7403, 0.0003)]],
|
|
class: 'office',
|
|
};
|
|
const grounds = {
|
|
polygons: [[square(30.2747, -97.7403, 0.002)]],
|
|
class: 'leisure',
|
|
};
|
|
// The dome is refused; an unlabeled enclosure cannot stand in as exact grounds.
|
|
const small = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim: fakeNominatim(dome),
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'building',
|
|
target: 'Texas Capitol grounds',
|
|
groundsLike: true,
|
|
}),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.equal(small, UNAVAILABLE);
|
|
const namedRing = square(CAPITOL.lat, CAPITOL.lon, 0.002);
|
|
const named = await createOutlineRungs({
|
|
tiles: {
|
|
fetchBounds: async () => ({
|
|
tiles: [
|
|
{
|
|
areas: [
|
|
{
|
|
name: 'Texas Capitol',
|
|
rings: [namedRing],
|
|
class: 'park',
|
|
clipped: false,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
}),
|
|
},
|
|
nominatim: fakeNominatim(dome),
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'building',
|
|
target: 'Texas Capitol grounds',
|
|
groundsLike: true,
|
|
}),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.equal(
|
|
named.footprintKind,
|
|
'area',
|
|
'genuine matching named tile grounds remain supported',
|
|
);
|
|
assert.deepEqual(named.polygons, [[namedRing]]);
|
|
// Without enclosing tile cover, the honest point remains.
|
|
const bare = await createOutlineRungs({
|
|
tiles: { fetchBounds: async () => ({ tiles: [] }) },
|
|
nominatim: fakeNominatim(dome),
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'building',
|
|
target: 'Texas Capitol grounds',
|
|
groundsLike: true,
|
|
}),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.equal(bare, UNAVAILABLE);
|
|
const nominatim = fakeNominatim(grounds);
|
|
const run = ladder(UNAVAILABLE);
|
|
const big = await createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim,
|
|
}).resolve(
|
|
ctx({
|
|
scope: 'building',
|
|
target: 'the Texas Capitol grounds',
|
|
groundsLike: true,
|
|
}),
|
|
run,
|
|
);
|
|
assert.equal(big.footprintKind, 'area');
|
|
assert.deepEqual(run.calls.finished, ['compound']);
|
|
assert.deepEqual(
|
|
nominatim.asks.map((a) => [a.query, a.kind]),
|
|
[['Texas Capitol', 'landmark']],
|
|
);
|
|
});
|
|
|
|
test('point-like, around and neighbourhood asks never reach Nominatim', async () => {
|
|
for (const extra of [
|
|
{ scope: 'compound', pointLike: true, target: 'Tejano Monument' },
|
|
{ scope: 'compound', around: true, target: 'Zilker Park' },
|
|
{ scope: 'neighborhood', target: 'Mission District' },
|
|
]) {
|
|
const nominatim = fakeNominatim(null);
|
|
await createOutlineRungs({ tiles: fixtureTiles(), nominatim }).resolve(
|
|
ctx(extra),
|
|
ladder(UNAVAILABLE),
|
|
);
|
|
assert.equal(nominatim.asks.length, 0, JSON.stringify(extra));
|
|
}
|
|
});
|
|
|
|
// ------------------------------------------------------------ end to end
|
|
|
|
function routes(...plugins) {
|
|
const found = new Map();
|
|
for (const plugin of plugins)
|
|
plugin.configureServer({
|
|
middlewares: { use: (path, handler) => found.set(path, handler) },
|
|
});
|
|
return found;
|
|
}
|
|
|
|
async function call(handlers, url, init = {}) {
|
|
const parsed = new URL(url, 'http://localhost');
|
|
const mount = [...handlers.keys()]
|
|
.filter(
|
|
(path) =>
|
|
parsed.pathname === path || parsed.pathname.startsWith(`${path}/`),
|
|
)
|
|
.sort((a, b) => b.length - a.length)[0];
|
|
if (!mount) return new Response('{}', { status: 404 });
|
|
const req = Readable.from(init.body ? [Buffer.from(init.body)] : []);
|
|
Object.assign(req, {
|
|
method: init.method || 'GET',
|
|
url: parsed.pathname.slice(mount.length) + parsed.search || '/',
|
|
headers: {},
|
|
socket: { remoteAddress: '127.0.0.1' },
|
|
});
|
|
let status;
|
|
let headers;
|
|
let body;
|
|
await handlers.get(mount)(
|
|
req,
|
|
{
|
|
on() {},
|
|
writeHead(s, h) {
|
|
status = s;
|
|
headers = h;
|
|
},
|
|
end(b) {
|
|
body = b;
|
|
},
|
|
},
|
|
() => {
|
|
status = 404;
|
|
body = '{}';
|
|
},
|
|
);
|
|
return new Response(body, { status, headers });
|
|
}
|
|
|
|
const NOMINATIM_ROWS = {
|
|
Toulouse: [
|
|
{
|
|
category: 'place',
|
|
type: 'city',
|
|
name: 'Toulouse',
|
|
lat: '43.6',
|
|
lon: '1.44',
|
|
geojson: { type: 'Point', coordinates: [1.44, 43.6] },
|
|
},
|
|
{
|
|
category: 'boundary',
|
|
type: 'administrative',
|
|
addresstype: 'city',
|
|
name: 'Toulouse',
|
|
lat: '43.6',
|
|
lon: '1.44',
|
|
osm_type: 'relation',
|
|
osm_id: 35738,
|
|
geojson: { type: 'Polygon', coordinates: [square(43.6, 1.44, 0.05)] },
|
|
},
|
|
],
|
|
'Central Park': [
|
|
{
|
|
category: 'leisure',
|
|
type: 'park',
|
|
name: 'Central Park',
|
|
lat: '40.78',
|
|
lon: '-73.965',
|
|
osm_type: 'relation',
|
|
osm_id: 8,
|
|
geojson: { type: 'Polygon', coordinates: [square(40.78, -73.965, 0.01)] },
|
|
},
|
|
],
|
|
};
|
|
|
|
const PLACES = {
|
|
Toulouse: {
|
|
lat: 43.6,
|
|
lng: 1.44,
|
|
name: 'Toulouse',
|
|
label: 'Toulouse, France',
|
|
types: ['locality', 'political'],
|
|
},
|
|
'Central Park': {
|
|
lat: 40.78,
|
|
lng: -73.965,
|
|
name: 'Central Park',
|
|
label: 'Central Park, New York',
|
|
types: ['park'],
|
|
},
|
|
'Congress Avenue': {
|
|
lat: 30.268,
|
|
lng: -97.7427,
|
|
name: 'Congress Avenue',
|
|
label: 'Congress Ave, Austin',
|
|
types: ['route'],
|
|
},
|
|
};
|
|
|
|
const viewerAt = (lat, lon, height = 4000) => ({
|
|
camera: {
|
|
positionCartographic: {
|
|
latitude: (lat * Math.PI) / 180,
|
|
longitude: (lon * Math.PI) / 180,
|
|
height,
|
|
},
|
|
},
|
|
});
|
|
|
|
test('default settings: outline, street and building asks send nothing to Overpass', async (t) => {
|
|
const prior = process.env.OVERPASS_UPSTREAMS;
|
|
delete process.env.OVERPASS_UPSTREAMS;
|
|
t.after(() => {
|
|
if (prior !== undefined) process.env.OVERPASS_UPSTREAMS = prior;
|
|
});
|
|
// Any request that escapes the injected transports fails the test.
|
|
t.mock.method(globalThis, 'fetch', async (url) =>
|
|
assert.fail(`unexpected network request ${url}`),
|
|
);
|
|
|
|
const upstream = [];
|
|
const stateDir = mkdtempSync(path.join(os.tmpdir(), 'gev-outline-rungs-'));
|
|
t.after(() => rmSync(stateDir, { recursive: true, force: true }));
|
|
const gate = createNominatimGate({
|
|
settings: {
|
|
endpoint: 'https://nominatim.openstreetmap.org/search',
|
|
isPublic: true,
|
|
dailyCap: 50,
|
|
},
|
|
fetchImpl: async (url) => {
|
|
upstream.push(String(url));
|
|
const q = new URL(url).searchParams.get('q');
|
|
return Response.json(NOMINATIM_ROWS[q] || []);
|
|
},
|
|
usage: createGateStateStore({ file: path.join(stateDir, 'state.json') }),
|
|
sleep: async () => {},
|
|
});
|
|
const handlers = routes(overpassProxy(), geocodeProxy({ gate }));
|
|
const local = [];
|
|
const transport = (url, init) => {
|
|
local.push(`${init?.method || 'GET'} ${String(url).split('?')[0]}`);
|
|
return call(handlers, url, init);
|
|
};
|
|
const services = createApplicationRequestServices({ fetchImpl: transport });
|
|
const resolver = createAnnotationResolver({
|
|
featureSource: services.features,
|
|
outlineRungs: createOutlineRungs({
|
|
tiles: fixtureTiles(),
|
|
nominatim: createNominatimOutlineClient({ fetchImpl: transport }),
|
|
}),
|
|
});
|
|
const placeSearch = {
|
|
geocode: async (q) => ({ place: PLACES[q] || null, answered: true }),
|
|
};
|
|
const resolve = async (viewer, args) => {
|
|
const result = await resolver.resolveAnnotationTarget({
|
|
viewer,
|
|
placeSearch,
|
|
footprint: true,
|
|
deferFootprint: true,
|
|
...args,
|
|
});
|
|
return { result, outline: await result.resolveOutline() };
|
|
};
|
|
|
|
const paris = await resolve(viewerAt(43.6, 1.44, 40_000), {
|
|
target: 'Toulouse',
|
|
});
|
|
assert.ok(paris.outline?.ring?.length >= 4, 'city outlined');
|
|
|
|
const park = await resolve(viewerAt(40.78, -73.965), {
|
|
target: 'Central Park',
|
|
});
|
|
|
|
const street = await resolve(viewerAt(30.27, -97.742), {
|
|
target: 'Congress Avenue',
|
|
});
|
|
|
|
const building = await resolve(viewerAt(30.2747, -97.7403, 800), {
|
|
latitude: CAPITOL.lat,
|
|
longitude: CAPITOL.lon,
|
|
entityKind: 'building',
|
|
target: 'this building',
|
|
});
|
|
assert.equal(building.outline?.footprintKind, 'building');
|
|
assert.equal(building.outline.outlineCredit, 'tiles');
|
|
assert.equal(street.outline.outlineCredit, 'tiles');
|
|
assert.equal(paris.outline.outlineCredit, 'osm');
|
|
assert.equal(park.outline.outlineCredit, 'osm');
|
|
|
|
assert.ok(
|
|
upstream.every((url) =>
|
|
url.startsWith('https://nominatim.openstreetmap.org/search?'),
|
|
),
|
|
);
|
|
assert.equal(
|
|
upstream.length,
|
|
2,
|
|
'one upstream request per explicit ask that needed one',
|
|
);
|
|
assert.ok(!upstream.some((url) => /overpass/i.test(url)));
|
|
// The only Overpass traffic is the local capability probe, answered locally.
|
|
assert.ok(
|
|
local
|
|
.filter((line) => line.includes('/api/overpass'))
|
|
.every((line) => line === 'GET /api/overpass/status'),
|
|
local.join('\n'),
|
|
);
|
|
});
|
|
|
|
test('a cancelled ask stops between rungs and never reaches Nominatim', async () => {
|
|
const nominatim = fakeNominatim({
|
|
polygons: [[square(43.6, 1.44, 0.05)]],
|
|
class: 'boundary',
|
|
});
|
|
const rungs = createOutlineRungs({ tiles: fixtureTiles(), nominatim });
|
|
// Cancelled while the configured ladder ran.
|
|
const controller = new AbortController();
|
|
await assert.rejects(
|
|
rungs.resolve(
|
|
ctx({ scope: 'city', target: 'Toulouse', signal: controller.signal }),
|
|
{
|
|
base: async () => {
|
|
controller.abort();
|
|
return UNAVAILABLE;
|
|
},
|
|
finish: (fp) => fp,
|
|
},
|
|
),
|
|
{ name: 'AbortError' },
|
|
);
|
|
// Cancelled before it started: not even the ladder runs.
|
|
const run = ladder(UNAVAILABLE);
|
|
await assert.rejects(
|
|
rungs.resolve(
|
|
ctx({ scope: 'city', target: 'Toulouse', signal: AbortSignal.abort() }),
|
|
run,
|
|
),
|
|
{ name: 'AbortError' },
|
|
);
|
|
assert.equal(run.calls.base, 0);
|
|
assert.equal(nominatim.asks.length, 0);
|
|
});
|