mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 00:32:21 +00:00
Merge remote-tracking branch 'upstream/main' into fix/drone-airspace
# Conflicts: # docs/CURRENT-STATE.md # src/app/constructCatalog.test.mjs # src/app/sourceComposition.test.mjs # src/data/layerState.test.mjs # src/data/layerStateTokenLedger.test.mjs # src/i18n/locales/ar.json
This commit is contained in:
195 files changed
+23414
-1578
No files matched your search
@@ -0,0 +1,81 @@
|
||||
// THE BOUNDED ANSWER CACHE — memory and disk bounds for the Nominatim area
|
||||
// and OSM routes. Every memory insertion is bounded (disk hits included), and
|
||||
// the disk keeps to its entry and byte quotas, removing expired files first.
|
||||
//
|
||||
// Run with: npm test
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { promises as fsp } from 'node:fs';
|
||||
import { createBoundedCache } from '../../server/providers/common/boundedCache.js';
|
||||
|
||||
async function tempDir() {
|
||||
return fsp.mkdtemp(path.join(os.tmpdir(), 'gev-bounded-cache-'));
|
||||
}
|
||||
|
||||
test('disk hits are bounded in memory like fresh answers', async () => {
|
||||
const dir = await tempDir();
|
||||
const writer = createBoundedCache({
|
||||
dir,
|
||||
ttlMs: 60_000,
|
||||
maxMemoryEntries: 100,
|
||||
maxDiskEntries: 200,
|
||||
});
|
||||
for (let i = 0; i < 75; i += 1) await writer.set(`k${i}`, `v${i}`);
|
||||
const reader = createBoundedCache({
|
||||
dir,
|
||||
ttlMs: 60_000,
|
||||
maxMemoryEntries: 10,
|
||||
maxDiskEntries: 200,
|
||||
});
|
||||
for (let i = 0; i < 75; i += 1)
|
||||
assert.equal(await reader.get(`k${i}`), `v${i}`);
|
||||
assert.equal(reader.memorySize, 10);
|
||||
await fsp.rm(dir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test('the disk keeps to its entry and byte quotas and drops expired files', async () => {
|
||||
const dir = await tempDir();
|
||||
let clock = 1_000_000;
|
||||
const cache = createBoundedCache({
|
||||
dir,
|
||||
ttlMs: 10_000,
|
||||
maxDiskEntries: 5,
|
||||
maxDiskBytes: 10_000,
|
||||
now: () => clock,
|
||||
});
|
||||
for (let i = 0; i < 12; i += 1) await cache.set(`k${i}`, 'x'.repeat(100));
|
||||
await cache.prune();
|
||||
let files = await fsp.readdir(dir);
|
||||
assert.ok(files.length <= 5, `${files.length} files`);
|
||||
await cache.set('big', 'y'.repeat(20_000));
|
||||
await cache.prune();
|
||||
const sizes = await Promise.all(
|
||||
(await fsp.readdir(dir)).map(
|
||||
async (name) => (await fsp.stat(path.join(dir, name))).size,
|
||||
),
|
||||
);
|
||||
assert.ok(sizes.reduce((a, b) => a + b, 0) <= 10_000, 'byte quota holds');
|
||||
// Age every file past the TTL, then write once more: the old files go.
|
||||
const past = new Date(Date.now() - 3_600_000);
|
||||
for (const name of await fsp.readdir(dir))
|
||||
await fsp.utimes(path.join(dir, name), past, past);
|
||||
clock = Date.now();
|
||||
await cache.set('fresh', 'z');
|
||||
await cache.prune();
|
||||
files = await fsp.readdir(dir);
|
||||
assert.equal(files.length, 1);
|
||||
assert.equal(await cache.get('k0'), undefined);
|
||||
await fsp.rm(dir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test('an expired entry is not served', async () => {
|
||||
let clock = 0;
|
||||
const cache = createBoundedCache({ dir: null, ttlMs: 100, now: () => clock });
|
||||
await cache.set('a', 1);
|
||||
clock = 50;
|
||||
assert.equal(await cache.get('a'), 1);
|
||||
clock = 500;
|
||||
assert.equal(await cache.get('a'), undefined);
|
||||
});
|
||||
@@ -20,7 +20,11 @@ import {
|
||||
import { openAiRealtimeProxy } from 'gods-eye-view/server/providers/openai';
|
||||
import { keySetupEndpoint } from 'gods-eye-view/server/standalone/key-setup';
|
||||
import { realtimeInstructions } from '../../server/providers/openai/instructions.js';
|
||||
import { GEV_REALTIME_TOOLS } from '../../server/providers/openai/tools.js';
|
||||
import {
|
||||
GEV_REALTIME_TOOLS,
|
||||
offeredTools,
|
||||
realtimeTools,
|
||||
} from '../../server/providers/openai/tools.js';
|
||||
import { createDebugLogHandler } from '../../server/providers/openai/debug-log.js';
|
||||
import { attachVoiceResult } from '../voice/speech.js';
|
||||
import { sanitizeDebugValue } from '../voice/realtimeDiagnostics.js';
|
||||
@@ -164,6 +168,7 @@ test('weather-only requests share upstream work and retain fresh and stale respo
|
||||
test('Realtime handler preserves tools and default instructions, isolates supplied annotation guidance, and keeps the upstream key server-side', async (t) => {
|
||||
env(t, 'OPENAI_API_KEY', 'fixture-upstream-secret');
|
||||
env(t, 'GEV_RATELIMIT_OPENAI_PER_MIN', undefined);
|
||||
env(t, 'OVERPASS_UPSTREAMS', undefined);
|
||||
const sent = [];
|
||||
t.mock.method(globalThis, 'fetch', async (url, options) => {
|
||||
assert.equal(url, 'https://api.openai.com/v1/realtime/client_secrets');
|
||||
@@ -194,7 +199,7 @@ test('Realtime handler preserves tools and default instructions, isolates suppli
|
||||
sent.at(-1).session.instructions,
|
||||
realtimeInstructions(guidance),
|
||||
);
|
||||
assert.deepEqual(sent.at(-1).session.tools, GEV_REALTIME_TOOLS);
|
||||
assert.deepEqual(sent.at(-1).session.tools, realtimeTools());
|
||||
}
|
||||
assert.notEqual(sent[0].session.instructions, sent[1].session.instructions);
|
||||
assert.equal(sent[0].session.instructions, sent[2].session.instructions);
|
||||
@@ -580,6 +585,36 @@ test('OAuth login endpoint selects an existing local sign-in without launching C
|
||||
assert.equal(response.body.includes('fixture-existing-secret'), false);
|
||||
});
|
||||
|
||||
test('osm_query is offered only when an operator configured Overpass', async (t) => {
|
||||
env(t, 'OPENAI_API_KEY', 'fixture-upstream-secret');
|
||||
env(t, 'GEV_RATELIMIT_OPENAI_PER_MIN', undefined);
|
||||
const sent = [];
|
||||
t.mock.method(globalThis, 'fetch', async (_url, options) => {
|
||||
sent.push(JSON.parse(options.body).session);
|
||||
return Response.json({ value: 'fixture-ephemeral' });
|
||||
});
|
||||
const mint = () =>
|
||||
request(install(openAiRealtimeProxy({})).get('/api/realtime/token'), {
|
||||
url: '/',
|
||||
});
|
||||
env(t, 'OVERPASS_UPSTREAMS', undefined);
|
||||
await mint();
|
||||
env(t, 'OVERPASS_UPSTREAMS', 'https://overpass.example/api/interpreter');
|
||||
await mint();
|
||||
const [plain, configured] = sent;
|
||||
const names = (session) => session.tools.map((tool) => tool.name);
|
||||
assert.equal(names(plain).includes('osm_query'), false);
|
||||
assert.doesNotMatch(plain.instructions, /osm_query/);
|
||||
assert.ok(names(plain).includes('resolve_area'));
|
||||
assert.ok(names(plain).includes('find_imagery'));
|
||||
assert.deepEqual(configured.tools, GEV_REALTIME_TOOLS);
|
||||
assert.match(configured.instructions, /osm_query/);
|
||||
assert.equal(
|
||||
configured.instructions,
|
||||
realtimeInstructions(undefined, { overpass: true }),
|
||||
);
|
||||
});
|
||||
|
||||
test('caption transcription is on by default, reported to the client meter, and can be turned off', async (t) => {
|
||||
env(t, 'OPENAI_API_KEY', 'fixture-upstream-secret');
|
||||
env(t, 'GEV_RATELIMIT_OPENAI_PER_MIN', undefined);
|
||||
@@ -607,6 +642,7 @@ test('caption transcription is on by default, reported to the client meter, and
|
||||
test('Realtime sessions carry supplied tools, and the standalone voice adds the catalog queries', async (t) => {
|
||||
env(t, 'OPENAI_API_KEY', 'fixture-upstream-secret');
|
||||
env(t, 'GEV_RATELIMIT_OPENAI_PER_MIN', undefined);
|
||||
env(t, 'OVERPASS_UPSTREAMS', undefined);
|
||||
const sent = [];
|
||||
t.mock.method(globalThis, 'fetch', async (url, options) => {
|
||||
sent.push(JSON.parse(options.body));
|
||||
@@ -619,7 +655,11 @@ test('Realtime sessions carry supplied tools, and the standalone voice adds the
|
||||
),
|
||||
);
|
||||
assert.equal(response.status, 200);
|
||||
assert.deepEqual(sent.at(-1).session.tools, tools);
|
||||
// Without an operator Overpass, osm_query is left out of the session.
|
||||
assert.deepEqual(sent.at(-1).session.tools, offeredTools(tools));
|
||||
assert.ok(
|
||||
!sent.at(-1).session.tools.some(({ name }) => name === 'osm_query'),
|
||||
);
|
||||
const names = tools.map((tool) => tool.name);
|
||||
assert.equal(new Set(names).size, names.length);
|
||||
assert.deepEqual(
|
||||
@@ -707,13 +747,18 @@ test('Realtime service configuration selects compatible endpoint/model without f
|
||||
endpoint: 'https://voice.example/client-secrets',
|
||||
models: { standard: 'configured-model' },
|
||||
resolveApiKey: () => 'server-fixture',
|
||||
// Pinned, so the expected tool list never depends on this machine's env.
|
||||
overpassConfigured: () => false,
|
||||
fetchImpl: async (url, options) => {
|
||||
assert.equal(url, 'https://voice.example/client-secrets');
|
||||
assert.equal(options.redirect, 'error');
|
||||
assert.equal(options.headers.Authorization, 'Bearer server-fixture');
|
||||
const payload = JSON.parse(options.body);
|
||||
assert.equal(payload.session.model, 'configured-model');
|
||||
assert.deepEqual(payload.session.tools, GEV_REALTIME_TOOLS);
|
||||
assert.deepEqual(
|
||||
payload.session.tools,
|
||||
realtimeTools({ overpass: false }),
|
||||
);
|
||||
return Response.json({ value: 'short-lived-fixture' });
|
||||
},
|
||||
},
|
||||
|
||||
@@ -785,8 +785,8 @@ test('administrative boundaries must be at the asked level', () => {
|
||||
assert.equal(picked.outline.osm, 'relation/9');
|
||||
});
|
||||
|
||||
test('outline selection does not publish child-owned admin geometry hooks', () => {
|
||||
for (const [name, addresstype] of [
|
||||
test('admin identity comes only from unambiguous evidence on the selected row', () => {
|
||||
for (const [name, addresstype, adminLevel] of [
|
||||
['Nepal', 'country', 'country'],
|
||||
['Bagmati Province', 'province', 'admin1'],
|
||||
['Province of Bagmati', 'province', 'admin1'],
|
||||
@@ -799,8 +799,8 @@ test('outline selection does not publish child-owned admin geometry hooks', () =
|
||||
kind: 'admin',
|
||||
query: name,
|
||||
});
|
||||
assert.equal('adminArea' in outline, false);
|
||||
assert.equal('adminLevel' in outline, false);
|
||||
assert.equal(outline.adminArea, name);
|
||||
assert.equal(outline.adminLevel, adminLevel);
|
||||
}
|
||||
|
||||
for (const row of [
|
||||
@@ -842,25 +842,53 @@ test('outline selection does not publish child-owned admin geometry hooks', () =
|
||||
[boundary({ name: 'Bagmati Zone', addresstype: 'state' })],
|
||||
{ kind: 'admin', query: 'Bagmati Zone' },
|
||||
).outline;
|
||||
assert.equal('adminArea' in retired, false);
|
||||
assert.equal(retired.adminArea, 'Bagmati Zone');
|
||||
assert.equal('adminLevel' in retired, false);
|
||||
|
||||
const retiredPrefix = selectOutlineResult(
|
||||
[boundary({ name: 'Zone of Bagmati', addresstype: 'state' })],
|
||||
{ kind: 'admin', query: 'Zone of Bagmati' },
|
||||
).outline;
|
||||
assert.equal('adminArea' in retiredPrefix, false);
|
||||
assert.equal(retiredPrefix.adminArea, 'Zone of Bagmati');
|
||||
assert.equal('adminLevel' in retiredPrefix, false);
|
||||
});
|
||||
|
||||
test('long admin names do not publish child-owned geometry hooks', () => {
|
||||
test('a Zone is retired only in Nepal, where zones were replaced', () => {
|
||||
const current = selectOutlineResult(
|
||||
[
|
||||
boundary({
|
||||
name: 'Gamo Zone',
|
||||
addresstype: 'county',
|
||||
display_name: 'Gamo Zone, South Ethiopia Regional State, Ethiopia',
|
||||
}),
|
||||
],
|
||||
{ kind: 'admin', query: 'Gamo Zone' },
|
||||
).outline;
|
||||
assert.equal(current.adminArea, 'Gamo Zone');
|
||||
assert.equal(current.adminLevel, 'admin2');
|
||||
|
||||
const retired = selectOutlineResult(
|
||||
[
|
||||
boundary({
|
||||
name: 'Bagmati Zone',
|
||||
addresstype: 'state',
|
||||
display_name: 'Bagmati Zone, Nepal',
|
||||
}),
|
||||
],
|
||||
{ kind: 'admin', query: 'Bagmati Zone' },
|
||||
).outline;
|
||||
assert.equal(retired.adminArea, 'Bagmati Zone');
|
||||
assert.equal('adminLevel' in retired, false);
|
||||
});
|
||||
|
||||
test('admin identity validates the full name before display truncation', () => {
|
||||
const longValidName = `Province of ${'Example '.repeat(24)}`.trim();
|
||||
const valid = selectOutlineResult(
|
||||
[boundary({ name: longValidName, addresstype: 'province' })],
|
||||
{ kind: 'admin', query: longValidName },
|
||||
).outline;
|
||||
assert.equal('adminArea' in valid, false);
|
||||
assert.equal('adminLevel' in valid, false);
|
||||
assert.equal(valid.adminArea, longValidName.slice(0, 160));
|
||||
assert.equal(valid.adminLevel, 'admin1');
|
||||
|
||||
const longContradictoryName = `${'Very Long Administrative Name '.repeat(7)}County`;
|
||||
assert.ok(longContradictoryName.length > 160);
|
||||
|
||||
@@ -1137,7 +1137,7 @@ test('the outline route answers OK with polygons and validates its input', async
|
||||
assert.equal((await request('/elsewhere')).status, 'next');
|
||||
});
|
||||
|
||||
test('the outline route leaves administrative geometry hooks to the annotation layer', async (t) => {
|
||||
test('the outline route serializes only selected-row administrative identity', async (t) => {
|
||||
const { fetchImpl } = stubFetch(async (url) => {
|
||||
const query = new URL(url).searchParams.get('q');
|
||||
const fixtures = {
|
||||
@@ -1195,8 +1195,8 @@ test('the outline route leaves administrative geometry hooks to the annotation l
|
||||
|
||||
const verified = await request('/outline?q=Bagmati%20Province&kind=admin');
|
||||
assert.equal(verified.status, 200);
|
||||
assert.equal('adminArea' in verified.body.outline, false);
|
||||
assert.equal('adminLevel' in verified.body.outline, false);
|
||||
assert.equal(verified.body.outline.adminArea, 'Bagmati Province');
|
||||
assert.equal(verified.body.outline.adminLevel, 'admin1');
|
||||
|
||||
for (const query of [
|
||||
'Northern Region',
|
||||
@@ -1231,7 +1231,7 @@ test('the outline route leaves administrative geometry hooks to the annotation l
|
||||
const retired = await request('/outline?q=Bagmati%20Zone&kind=admin');
|
||||
assert.equal(retired.status, 200);
|
||||
assert.equal(retired.body.status, 'OK');
|
||||
assert.equal('adminArea' in retired.body.outline, false);
|
||||
assert.equal(retired.body.outline.adminArea, 'Bagmati Zone');
|
||||
assert.equal('adminLevel' in retired.body.outline, false);
|
||||
|
||||
const city = await request('/outline?q=Austin&kind=city');
|
||||
|
||||
@@ -0,0 +1,590 @@
|
||||
// THE BOUNDED OSM FEATURE SEARCH — `/api/osm/features`.
|
||||
//
|
||||
// A request names a curated preset, a box, a mode and a limit; the server
|
||||
// writes the Overpass query and sends it only to an operator-configured
|
||||
// Overpass (OVERPASS_UPSTREAMS). These cases pin what can never reach Overpass:
|
||||
// unknown kinds, raw tags, oversized boxes, boundary-area scans, and a second
|
||||
// upstream query while one is running. The generic `/api/overpass` guard is
|
||||
// covered by its own tests and is not loosened here.
|
||||
//
|
||||
// Run with: npm test
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { EventEmitter } from 'node:events';
|
||||
import {
|
||||
compileOsmFeatureQuery,
|
||||
OSM_FEATURE_LIMITS,
|
||||
summarizeOsmFeatures,
|
||||
} from '../../server/providers/overpass/osmFeatures.js';
|
||||
import { installOsmFeaturesRoute } from '../../server/providers/overpass/osmFeaturesRoute.js';
|
||||
import { sanitizeOverpassBody } from '../../server/providers/overpass/query.js';
|
||||
import { OSM_QUERY_LIMITS } from '../voice/osmActions.js';
|
||||
|
||||
test('the server finishes its whole search before the voice answer gives up', () => {
|
||||
// When the browser stops waiting, the route aborts the upstream query, so
|
||||
// an OSM_TIMEOUT retry could never be served from the cache.
|
||||
assert.ok(
|
||||
OSM_FEATURE_LIMITS.timeoutS * 1000 < OSM_FEATURE_LIMITS.upstreamTimeoutMs,
|
||||
'Overpass gives up before the server stops waiting for it',
|
||||
);
|
||||
assert.ok(
|
||||
OSM_FEATURE_LIMITS.upstreamTimeoutMs <= OSM_FEATURE_LIMITS.upstreamBudgetMs,
|
||||
);
|
||||
assert.ok(
|
||||
OSM_FEATURE_LIMITS.upstreamBudgetMs + 2_000 <= OSM_QUERY_LIMITS.budgetMs,
|
||||
`server budget ${OSM_FEATURE_LIMITS.upstreamBudgetMs} ms must end before the client's ${OSM_QUERY_LIMITS.budgetMs} ms`,
|
||||
);
|
||||
});
|
||||
|
||||
test('a preset and a small box compile to a bounded query', () => {
|
||||
const compiled = compileOsmFeatureQuery({
|
||||
preset: 'hospital',
|
||||
bbox: '85.2,27.6,85.4,27.8',
|
||||
limit: '50',
|
||||
});
|
||||
assert.equal(compiled.ok, true);
|
||||
assert.equal(
|
||||
compiled.ql,
|
||||
'[out:json][timeout:20][maxsize:67108864];(nwr["amenity"="hospital"](27.6,85.2,27.8,85.4););out center tags 50;',
|
||||
);
|
||||
assert.doesNotMatch(compiled.ql, /area/, 'no boundary-area scan');
|
||||
const count = compileOsmFeatureQuery({
|
||||
preset: 'bar',
|
||||
bbox: [80, 20, 85, 25],
|
||||
mode: 'count',
|
||||
});
|
||||
assert.match(
|
||||
count.ql,
|
||||
/nwr\["amenity"="bar"\].*nwr\["amenity"="pub"\].*out count;$/,
|
||||
);
|
||||
});
|
||||
|
||||
test('unknown kinds, raw tags, bad and oversized boxes are refused', () => {
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({ preset: 'amenity=hospital', bbox: '0,0,1,1' })
|
||||
.code,
|
||||
'UNKNOWN_PRESET',
|
||||
);
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({ preset: '__proto__', bbox: '0,0,1,1' }).code,
|
||||
'UNKNOWN_PRESET',
|
||||
);
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({ preset: 'hospital', bbox: '0,0,1' }).code,
|
||||
'BAD_BOX',
|
||||
);
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({ preset: 'hospital', bbox: '0,1,1,0' }).code,
|
||||
'BAD_BOX',
|
||||
);
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({ preset: 'hospital', bbox: '0,0,3,3' }).code,
|
||||
'AREA_TOO_LARGE',
|
||||
);
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({
|
||||
preset: 'hospital',
|
||||
bbox: '0,0,3,3',
|
||||
mode: 'count',
|
||||
}).ok,
|
||||
true,
|
||||
);
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({
|
||||
preset: 'hospital',
|
||||
bbox: '0,0,7,7',
|
||||
mode: 'count',
|
||||
}).code,
|
||||
'AREA_TOO_LARGE',
|
||||
);
|
||||
const limited = compileOsmFeatureQuery({
|
||||
preset: 'hospital',
|
||||
bbox: '0,0,1,1',
|
||||
limit: 999999,
|
||||
});
|
||||
assert.match(
|
||||
limited.ql,
|
||||
new RegExp(`out center tags ${OSM_FEATURE_LIMITS.maxLimit};$`),
|
||||
);
|
||||
});
|
||||
|
||||
test('a box across the antimeridian is searched as its two halves', () => {
|
||||
const compiled = compileOsmFeatureQuery({
|
||||
preset: 'hospital',
|
||||
bbox: '179.5,-17,-179.5,-16',
|
||||
});
|
||||
assert.equal(compiled.ok, true);
|
||||
assert.match(compiled.ql, /\(-17,179\.5,-16,180\).*\(-17,-180,-16,-179\.5\)/);
|
||||
});
|
||||
|
||||
test('the generic Overpass guard still refuses boundary-area element scans', () => {
|
||||
const scan =
|
||||
'data=' +
|
||||
encodeURIComponent(
|
||||
'[out:json];area(3600000001)->.a;nwr["amenity"="hospital"](area.a);out;',
|
||||
);
|
||||
assert.equal(sanitizeOverpassBody(scan).ok, false);
|
||||
});
|
||||
|
||||
test('answers are compacted: centres, kept tags, truncation and counts', () => {
|
||||
const compiled = compileOsmFeatureQuery({
|
||||
preset: 'hospital',
|
||||
bbox: '0,0,1,1',
|
||||
limit: 2,
|
||||
});
|
||||
const features = summarizeOsmFeatures(
|
||||
{
|
||||
elements: [
|
||||
{
|
||||
type: 'node',
|
||||
id: 1,
|
||||
lat: 0.5,
|
||||
lon: 0.5,
|
||||
tags: { name: 'A', amenity: 'hospital', 'contact:phone': 'x' },
|
||||
},
|
||||
{
|
||||
type: 'way',
|
||||
id: 2,
|
||||
center: { lat: 0.4, lon: 0.4 },
|
||||
tags: { name: 'B', amenity: 'hospital' },
|
||||
},
|
||||
],
|
||||
},
|
||||
compiled,
|
||||
);
|
||||
assert.equal(features.count, 2);
|
||||
assert.equal(features.truncated, true, 'the limit was reached');
|
||||
assert.deepEqual(features.features[1], {
|
||||
id: 'way/2',
|
||||
lat: 0.4,
|
||||
lon: 0.4,
|
||||
tags: { name: 'B', amenity: 'hospital' },
|
||||
});
|
||||
assert.equal('contact:phone' in features.features[0].tags, false);
|
||||
const count = summarizeOsmFeatures(
|
||||
{
|
||||
elements: [
|
||||
{
|
||||
type: 'count',
|
||||
tags: { nodes: '3', ways: '2', relations: '0', total: '5' },
|
||||
},
|
||||
],
|
||||
},
|
||||
{ ...compiled, mode: 'count' },
|
||||
);
|
||||
assert.equal(count.count, 5);
|
||||
});
|
||||
|
||||
function mount(
|
||||
fetchPayload,
|
||||
{
|
||||
featuresCache,
|
||||
configured = () => true,
|
||||
upstreamTag,
|
||||
upstreamBudgetMs,
|
||||
} = {},
|
||||
) {
|
||||
const routes = new Map();
|
||||
const writes = [];
|
||||
const memoryCache = () => {
|
||||
const held = new Map();
|
||||
return {
|
||||
get: async (key) => held.get(key),
|
||||
set: async (key, value) => {
|
||||
held.set(key, value);
|
||||
writes.push(key);
|
||||
},
|
||||
};
|
||||
};
|
||||
installOsmFeaturesRoute(
|
||||
{ use: (route, handler) => routes.set(route, handler) },
|
||||
{
|
||||
fetchPayload,
|
||||
cacheRoot: null,
|
||||
configured,
|
||||
...(upstreamTag ? { upstreamTag } : {}),
|
||||
...(upstreamBudgetMs ? { upstreamBudgetMs } : {}),
|
||||
featuresCache: featuresCache || memoryCache(),
|
||||
},
|
||||
);
|
||||
let client = 0;
|
||||
const start = (
|
||||
search,
|
||||
route = '/api/osm/features',
|
||||
headers = {},
|
||||
from = null,
|
||||
) => {
|
||||
let req;
|
||||
let res;
|
||||
const promise = new Promise((resolve) => {
|
||||
client += 1;
|
||||
req = Object.assign(new EventEmitter(), {
|
||||
method: 'GET',
|
||||
url: `/?${search}`,
|
||||
headers,
|
||||
socket: { remoteAddress: from || `10.9.0.${client}` },
|
||||
});
|
||||
res = Object.assign(new EventEmitter(), {
|
||||
writableEnded: false,
|
||||
writeHead(status, headers) {
|
||||
res.status = status;
|
||||
res.headers = headers;
|
||||
},
|
||||
setHeader(name, value) {
|
||||
res.headers = { ...(res.headers || {}), [name]: value };
|
||||
},
|
||||
end(body) {
|
||||
res.writableEnded = true;
|
||||
resolve({
|
||||
status: res.status ?? res.statusCode,
|
||||
headers: res.headers,
|
||||
body: JSON.parse(body),
|
||||
});
|
||||
},
|
||||
});
|
||||
routes.get(route)(req, res);
|
||||
});
|
||||
return {
|
||||
promise,
|
||||
disconnect() {
|
||||
res.emit('close');
|
||||
},
|
||||
};
|
||||
};
|
||||
const request = (search, route = '/api/osm/features', headers, from) =>
|
||||
start(search, route, headers, from).promise;
|
||||
return { request, start, writes };
|
||||
}
|
||||
|
||||
test('a search without a limit lists up to 500 features', async () => {
|
||||
const sent = [];
|
||||
const { request } = mount(async (body) => {
|
||||
sent.push(decodeURIComponent(body));
|
||||
return { status: 200, body: JSON.stringify({ elements: [] }) };
|
||||
});
|
||||
for (const search of [
|
||||
'preset=hospital&bbox=0,0,1,1',
|
||||
'preset=school&bbox=0,0,1,1&limit=',
|
||||
]) {
|
||||
const answer = await request(search);
|
||||
assert.equal(answer.status, 200, search);
|
||||
}
|
||||
assert.equal(sent.length, 2);
|
||||
for (const ql of sent) assert.match(ql, /out center tags 500;$/);
|
||||
assert.equal(
|
||||
compileOsmFeatureQuery({ preset: 'hospital', bbox: '0,0,1,1', limit: '7' })
|
||||
.limit,
|
||||
7,
|
||||
);
|
||||
});
|
||||
|
||||
test('one IPv6 /64 is one client for slots and the rate limit', async () => {
|
||||
const release = [];
|
||||
const { request } = mount(async () => {
|
||||
await new Promise((r) => release.push(r));
|
||||
return { status: 200, body: JSON.stringify({ elements: [] }) };
|
||||
});
|
||||
const first = request(
|
||||
'preset=hospital&bbox=0,0,1,1',
|
||||
undefined,
|
||||
{},
|
||||
'2001:db8:1:2::a',
|
||||
);
|
||||
await new Promise((r) => setTimeout(r, 5));
|
||||
// A rotated address that wrongly got its own slot would wait upstream
|
||||
// too: answer every held search before asserting, so a failure never hangs.
|
||||
const rotated = request(
|
||||
'preset=school&bbox=0,0,1,1',
|
||||
undefined,
|
||||
{},
|
||||
'2001:db8:1:2:ffff::b',
|
||||
);
|
||||
await new Promise((r) => setTimeout(r, 5));
|
||||
release.splice(0).forEach((r) => r());
|
||||
assert.equal(
|
||||
(await rotated).status,
|
||||
503,
|
||||
'a rotated address waits for its first search',
|
||||
);
|
||||
assert.equal((await first).status, 200);
|
||||
|
||||
// Twelve a minute per /64, wherever in it the requests come from.
|
||||
const { request: limited } = mount(async () => ({
|
||||
status: 200,
|
||||
body: JSON.stringify({ elements: [] }),
|
||||
}));
|
||||
const statuses = [];
|
||||
for (let i = 0; i < 13; i += 1)
|
||||
statuses.push(
|
||||
(
|
||||
await limited(
|
||||
`preset=hospital&bbox=0,0,1,${(i + 1) / 20}`,
|
||||
undefined,
|
||||
{},
|
||||
`2001:db8:5:6::${(i + 1).toString(16)}`,
|
||||
)
|
||||
).status,
|
||||
);
|
||||
assert.deepEqual(statuses.slice(0, 12), Array(12).fill(200));
|
||||
assert.equal(statuses[12], 429);
|
||||
});
|
||||
|
||||
test('the route answers, caches, and shares upstream slots fairly', async () => {
|
||||
const release = [];
|
||||
let upstream = 0;
|
||||
const { request, writes } = mount(async (body) => {
|
||||
upstream += 1;
|
||||
assert.match(decodeURIComponent(body), /^data=\[out:json\]/);
|
||||
await new Promise((r) => release.push(r));
|
||||
return {
|
||||
status: 200,
|
||||
body: JSON.stringify({
|
||||
elements: [{ type: 'node', id: 7, lat: 1, lon: 1, tags: {} }],
|
||||
}),
|
||||
};
|
||||
});
|
||||
const tick = () => new Promise((r) => setTimeout(r, 5));
|
||||
const first = request(
|
||||
'preset=hospital&bbox=0,0,2,2',
|
||||
undefined,
|
||||
{},
|
||||
'10.1.0.1',
|
||||
);
|
||||
await tick();
|
||||
const sameClient = await request(
|
||||
'preset=school&bbox=0,0,2,2',
|
||||
undefined,
|
||||
{},
|
||||
'10.1.0.1',
|
||||
);
|
||||
assert.equal(
|
||||
sameClient.status,
|
||||
503,
|
||||
"one client's second search waits for its first",
|
||||
);
|
||||
const shared = request(
|
||||
'preset=hospital&bbox=0,0,2,2',
|
||||
undefined,
|
||||
{},
|
||||
'10.1.0.2',
|
||||
);
|
||||
const second = request(
|
||||
'preset=school&bbox=0,0,2,2',
|
||||
undefined,
|
||||
{},
|
||||
'10.1.0.3',
|
||||
);
|
||||
await tick();
|
||||
assert.equal(
|
||||
upstream,
|
||||
2,
|
||||
'another client runs alongside; the same search is shared',
|
||||
);
|
||||
const third = await request(
|
||||
'preset=pharmacy&bbox=0,0,2,2',
|
||||
undefined,
|
||||
{},
|
||||
'10.1.0.4',
|
||||
);
|
||||
assert.equal(third.status, 503, 'the global cap holds');
|
||||
release.forEach((r) => r());
|
||||
const answered = await first;
|
||||
assert.equal(answered.status, 200);
|
||||
assert.equal(answered.body.count, 1);
|
||||
assert.equal((await shared).status, 200);
|
||||
assert.equal((await second).status, 200);
|
||||
const again = await request('preset=hospital&bbox=0,0,2,2');
|
||||
assert.equal(again.headers['X-OSM-Cache'], 'HIT');
|
||||
assert.equal(upstream, 2);
|
||||
assert.equal(writes.length, 2);
|
||||
const refused = await request('preset=hospital&bbox=0,0,9,9');
|
||||
assert.equal(refused.status, 400);
|
||||
assert.equal(refused.body.code, 'AREA_TOO_LARGE');
|
||||
});
|
||||
|
||||
test('a hung Overpass is cut off by the overall budget, across every endpoint', async () => {
|
||||
const { request } = mount(
|
||||
(_body, _max, { signal }) =>
|
||||
new Promise((_, reject) =>
|
||||
signal.addEventListener('abort', () => reject(signal.reason), {
|
||||
once: true,
|
||||
}),
|
||||
),
|
||||
{ upstreamBudgetMs: 30 },
|
||||
);
|
||||
const started = Date.now();
|
||||
const answer = await request('preset=hospital&bbox=0,0,2,2');
|
||||
assert.ok(Date.now() - started < 1000);
|
||||
assert.equal(answer.status, 504);
|
||||
});
|
||||
|
||||
test('a cached answer is served only by the Overpass instance that gave it', async () => {
|
||||
let tag = 'instance-a';
|
||||
let upstream = 0;
|
||||
const { request } = mount(
|
||||
async () => {
|
||||
upstream += 1;
|
||||
return {
|
||||
status: 200,
|
||||
body: JSON.stringify({
|
||||
elements: [{ type: 'node', id: 7, lat: 1, lon: 1, tags: {} }],
|
||||
}),
|
||||
};
|
||||
},
|
||||
{ upstreamTag: () => tag },
|
||||
);
|
||||
assert.equal((await request('preset=hospital&bbox=0,0,2,2')).status, 200);
|
||||
const hit = await request('preset=hospital&bbox=0,0,2,2');
|
||||
assert.equal(hit.headers['X-OSM-Cache'], 'HIT');
|
||||
assert.equal(upstream, 1);
|
||||
tag = 'instance-b';
|
||||
const switched = await request('preset=hospital&bbox=0,0,2,2');
|
||||
assert.equal(switched.headers['X-OSM-Cache'], 'MISS');
|
||||
assert.equal(
|
||||
upstream,
|
||||
2,
|
||||
'the new instance is asked, not the old answer served',
|
||||
);
|
||||
});
|
||||
|
||||
test('a cross-site page cannot spend the operator Overpass', async () => {
|
||||
let upstream = 0;
|
||||
const { request } = mount(async () => {
|
||||
upstream += 1;
|
||||
return { status: 200, body: JSON.stringify({ elements: [] }) };
|
||||
});
|
||||
for (const headers of [
|
||||
{ 'sec-fetch-site': 'cross-site', origin: 'https://evil.example' },
|
||||
{ 'sec-fetch-site': 'cross-site' },
|
||||
{ origin: 'https://evil.example' },
|
||||
]) {
|
||||
const refused = await request('preset=hospital&bbox=0,0,2,2', undefined, {
|
||||
host: 'localhost:5173',
|
||||
...headers,
|
||||
});
|
||||
assert.equal(refused.status, 403, JSON.stringify(headers));
|
||||
}
|
||||
assert.equal(upstream, 0, 'no cross-site request reaches Overpass');
|
||||
const own = await request('preset=hospital&bbox=0,0,2,2', undefined, {
|
||||
host: 'localhost:5173',
|
||||
'sec-fetch-site': 'same-origin',
|
||||
});
|
||||
assert.equal(own.status, 200);
|
||||
// Like /api/overpass, it works behind a reverse proxy: forwarding headers
|
||||
// alone are not a refusal.
|
||||
const proxied = await request('preset=school&bbox=0,0,2,2', undefined, {
|
||||
host: 'localhost:5173',
|
||||
'sec-fetch-site': 'same-origin',
|
||||
'x-forwarded-for': '203.0.113.7',
|
||||
});
|
||||
assert.equal(proxied.status, 200);
|
||||
});
|
||||
|
||||
test('an upstream refusal is not an empty answer', async () => {
|
||||
const { request } = mount(async () => ({
|
||||
status: 429,
|
||||
body: 'rate_limited',
|
||||
rateLimited: true,
|
||||
}));
|
||||
const answer = await request('preset=hospital&bbox=0,0,1,1');
|
||||
assert.equal(answer.status, 429);
|
||||
assert.ok(answer.body.error);
|
||||
});
|
||||
|
||||
test('malformed successful answers are refused and never cached', async () => {
|
||||
const payloads = [
|
||||
{},
|
||||
{ elements: [{ type: 'count', tags: { nodes: '2' } }] },
|
||||
{ elements: [{ type: 'way', id: 9, tags: { amenity: 'hospital' } }] },
|
||||
];
|
||||
const { request, writes } = mount(async () => ({
|
||||
status: 200,
|
||||
body: JSON.stringify(payloads.shift()),
|
||||
}));
|
||||
const missingElements = await request('preset=hospital&bbox=0,0,1,1');
|
||||
const missingTotal = await request('preset=hospital&bbox=0,0,1,1&mode=count');
|
||||
const unusableRows = await request('preset=hospital&bbox=1,1,2,2');
|
||||
for (const answer of [missingElements, missingTotal, unusableRows]) {
|
||||
assert.equal(answer.status, 502);
|
||||
assert.match(answer.body.error, /failed/i);
|
||||
}
|
||||
assert.deepEqual(writes, []);
|
||||
});
|
||||
|
||||
test('the last disconnected waiter aborts upstream work and frees the slot', async () => {
|
||||
let calls = 0;
|
||||
let firstStarted;
|
||||
let firstAborted;
|
||||
const started = new Promise((resolve) => {
|
||||
firstStarted = resolve;
|
||||
});
|
||||
const aborted = new Promise((resolve) => {
|
||||
firstAborted = resolve;
|
||||
});
|
||||
const { request, start } = mount(async (_body, _cap, { signal }) => {
|
||||
calls += 1;
|
||||
if (calls === 1) {
|
||||
firstStarted();
|
||||
return new Promise((resolve, reject) => {
|
||||
signal.addEventListener(
|
||||
'abort',
|
||||
() => {
|
||||
firstAborted();
|
||||
reject(signal.reason);
|
||||
},
|
||||
{ once: true },
|
||||
);
|
||||
});
|
||||
}
|
||||
return { status: 200, body: '{"elements":[]}' };
|
||||
});
|
||||
const abandoned = start('preset=hospital&bbox=0,0,1,1');
|
||||
await started;
|
||||
abandoned.disconnect();
|
||||
await aborted;
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
const next = await request('preset=school&bbox=0,0,1,1');
|
||||
assert.equal(next.status, 200);
|
||||
assert.equal(calls, 2);
|
||||
});
|
||||
|
||||
test('one disconnected coalesced waiter does not cancel a live sibling', async () => {
|
||||
let release;
|
||||
let upstreamSignal;
|
||||
let calls = 0;
|
||||
const { start } = mount(async (_body, _cap, { signal }) => {
|
||||
calls += 1;
|
||||
upstreamSignal = signal;
|
||||
await new Promise((resolve) => {
|
||||
release = resolve;
|
||||
});
|
||||
return { status: 200, body: '{"elements":[]}' };
|
||||
});
|
||||
const first = start('preset=hospital&bbox=0,0,1,1');
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
const second = start('preset=hospital&bbox=0,0,1,1');
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
first.disconnect();
|
||||
assert.equal(upstreamSignal.aborted, false);
|
||||
release();
|
||||
const answer = await second.promise;
|
||||
assert.equal(answer.status, 200);
|
||||
assert.equal(calls, 1);
|
||||
});
|
||||
|
||||
test('without a configured Overpass the route refuses and fetches nothing', async () => {
|
||||
let upstream = 0;
|
||||
const { request } = mount(
|
||||
async () => {
|
||||
upstream += 1;
|
||||
return { status: 200, body: '{"elements":[]}' };
|
||||
},
|
||||
{ configured: () => false },
|
||||
);
|
||||
const answer = await request('preset=hospital&bbox=85.2,27.6,85.4,27.8');
|
||||
assert.equal(answer.status, 503);
|
||||
assert.equal(answer.body.code, 'OVERPASS_NOT_CONFIGURED');
|
||||
assert.equal(answer.body.retryable, false);
|
||||
assert.match(answer.body.error, /configured Overpass/);
|
||||
assert.equal(upstream, 0);
|
||||
});
|
||||
@@ -1,11 +1,27 @@
|
||||
/** A reveal must beat the one-second idle rotation refresh, regardless of FPS. */
|
||||
/**
|
||||
* Wall-clock budget for EACH observed frame, regardless of FPS. Both the settle
|
||||
* frame (measured from the forced moveEnd) and the reveal frame (measured from
|
||||
* the settle frame that hid the contact) must land inside it, so neither can be
|
||||
* repaired by the one-second idle rotation refresh before it is read. The
|
||||
* refresh clock starts at the fleet tick (preRender) of the frame the budget is
|
||||
* measured from, so the budget must leave room for that frame's own render
|
||||
* time: half the refresh interval tolerates frames up to ~500 ms, and a ~300 ms
|
||||
* software-rendered frame (headless SwiftShader) fits with margin.
|
||||
*/
|
||||
export const ARRIVAL_OBSERVATION_MS = 500;
|
||||
|
||||
/** A measured rotation error at or above this fails the arrival check. */
|
||||
export const ARRIVAL_MAX_ERROR_DEG = 10;
|
||||
|
||||
/** Attempts allowed when every earlier one timed out without a wrong angle. */
|
||||
export const ARRIVAL_MAX_ATTEMPTS = 2;
|
||||
|
||||
/**
|
||||
* Observe the first completed moveEnd frame and the first subsequent reveal.
|
||||
* The deadline starts when moveEnd is forced, before its rotation baseline, so
|
||||
* waiting for either frame cannot let the one-second idle refresh mask a bug.
|
||||
* `read` snapshots visibility and rotation error against the current position.
|
||||
* The settle deadline starts when moveEnd is forced, before its rotation
|
||||
* baseline; the reveal deadline restarts at the settle frame, which is where
|
||||
* the contact is hidden. `read` snapshots visibility and rotation error
|
||||
* against the current position.
|
||||
*/
|
||||
export function observeArrivalRotation({
|
||||
scene,
|
||||
@@ -18,6 +34,7 @@ export function observeArrivalRotation({
|
||||
}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const startedAt = now();
|
||||
let phaseStartedAt = startedAt;
|
||||
let moveEnd = null;
|
||||
let moveEndMs = null;
|
||||
let revealFrames = 0;
|
||||
@@ -34,24 +51,42 @@ export function observeArrivalRotation({
|
||||
cleanup();
|
||||
resolve(result);
|
||||
};
|
||||
const expired = () => ({
|
||||
// A timeout keeps every angle it measured: the settle angle before a
|
||||
// reveal timeout, and the angle on a late frame itself (a late frame is
|
||||
// read first; the idle refresh can only repair an angle, so a wrong one
|
||||
// seen late was wrong on time too). `arrivalAngleViolated` then makes the
|
||||
// timeout final instead of retryable.
|
||||
const expired = (late = null) => ({
|
||||
error: `arrival ${moveEnd ? 'reveal' : 'moveEnd'} observation exceeded ${ARRIVAL_OBSERVATION_MS} ms`,
|
||||
elapsedMs: now() - startedAt,
|
||||
moveEndMs,
|
||||
...(moveEnd
|
||||
? { dMoveEnd: moveEnd.rotationError }
|
||||
: late
|
||||
? { dMoveEnd: late.rotationError }
|
||||
: {}),
|
||||
...(moveEnd && late?.shown ? { dReveal: late.rotationError } : {}),
|
||||
flipFrame: -1,
|
||||
});
|
||||
const armDeadline = () => {
|
||||
clearTimer(timer);
|
||||
timer = setTimer(() => finish(expired()), ARRIVAL_OBSERVATION_MS);
|
||||
};
|
||||
remove = scene.postRender.addEventListener(() => {
|
||||
if (done) return;
|
||||
try {
|
||||
const elapsedMs = now() - startedAt;
|
||||
if (elapsedMs >= ARRIVAL_OBSERVATION_MS) {
|
||||
finish(expired());
|
||||
const at = now();
|
||||
const elapsedMs = at - startedAt;
|
||||
const sample = read();
|
||||
if (at - phaseStartedAt >= ARRIVAL_OBSERVATION_MS) {
|
||||
finish(expired(sample));
|
||||
return;
|
||||
}
|
||||
const sample = read();
|
||||
if (moveEnd === null) {
|
||||
moveEnd = sample;
|
||||
moveEndMs = elapsedMs;
|
||||
phaseStartedAt = at;
|
||||
armDeadline();
|
||||
startReveal();
|
||||
} else {
|
||||
revealFrames++;
|
||||
@@ -76,7 +111,7 @@ export function observeArrivalRotation({
|
||||
reject(error);
|
||||
}
|
||||
});
|
||||
timer = setTimer(() => finish(expired()), ARRIVAL_OBSERVATION_MS);
|
||||
armDeadline();
|
||||
try {
|
||||
startMoveEnd();
|
||||
scene.requestRender();
|
||||
@@ -87,14 +122,51 @@ export function observeArrivalRotation({
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether an observation measured a rotation error over the threshold on any
|
||||
* frame it captured, including the settle frame of a reveal that then timed
|
||||
* out. Such an observation is a demonstrated failure, never inconclusive.
|
||||
*/
|
||||
export function arrivalAngleViolated(observation) {
|
||||
const limit = (ARRIVAL_MAX_ERROR_DEG * Math.PI) / 180;
|
||||
return [observation?.dMoveEnd, observation?.dReveal].some(
|
||||
(error) => Number.isFinite(error) && error >= limit,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Observe arrival rotation, retrying only an inconclusive timeout. A wall-clock
|
||||
* timeout means the frame landed where the idle refresh could already have
|
||||
* repaired it, so it earns another attempt; an observation that measured a
|
||||
* wrong angle (or succeeded) is final, so a later clean attempt can never
|
||||
* replace it. `prepare` runs before every attempt; the result carries
|
||||
* `attempts`.
|
||||
*/
|
||||
export async function observeArrivalRotationWithRetry({
|
||||
prepare = async () => {},
|
||||
observe = observeArrivalRotation,
|
||||
maxAttempts = ARRIVAL_MAX_ATTEMPTS,
|
||||
...options
|
||||
}) {
|
||||
let observed;
|
||||
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
|
||||
await prepare();
|
||||
observed = { ...(await observe(options)), attempts: attempt };
|
||||
if (!observed.error || arrivalAngleViolated(observed)) break;
|
||||
}
|
||||
return observed;
|
||||
}
|
||||
|
||||
/** Test the captured frames without retrying a bad first observation. */
|
||||
export function arrivalRotationPassed(observation) {
|
||||
return (
|
||||
!!observation &&
|
||||
!observation.error &&
|
||||
observation.shown === true &&
|
||||
observation.elapsedMs < ARRIVAL_OBSERVATION_MS &&
|
||||
(observation.dMoveEnd * 180) / Math.PI < 10 &&
|
||||
(observation.dReveal * 180) / Math.PI < 10
|
||||
observation.moveEndMs < ARRIVAL_OBSERVATION_MS &&
|
||||
observation.revealMs < ARRIVAL_OBSERVATION_MS &&
|
||||
Number.isFinite(observation.dMoveEnd) &&
|
||||
Number.isFinite(observation.dReveal) &&
|
||||
!arrivalAngleViolated(observation)
|
||||
);
|
||||
}
|
||||
@@ -1,19 +1,23 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import * as arrivalModule from './trackArrivalObservation.mjs';
|
||||
import {
|
||||
ARRIVAL_OBSERVATION_MS,
|
||||
arrivalAngleViolated,
|
||||
arrivalRotationPassed,
|
||||
observeArrivalRotation,
|
||||
observeArrivalRotationWithRetry,
|
||||
} from './trackArrivalObservation.mjs';
|
||||
|
||||
function fixture() {
|
||||
function fixture(start = observeArrivalRotation) {
|
||||
let time = 0;
|
||||
let state = { shown: true, rotationError: 0 };
|
||||
const listeners = new Set();
|
||||
const timers = new Map();
|
||||
let renders = 0;
|
||||
let moveEnds = 0;
|
||||
const observation = observeArrivalRotation({
|
||||
const observation = start({
|
||||
scene: {
|
||||
postRender: {
|
||||
addEventListener(listener) {
|
||||
@@ -110,7 +114,8 @@ test('no reveal fails at a deadline before the one-second idle catch-up', async
|
||||
assert.equal(ARRIVAL_OBSERVATION_MS, 500);
|
||||
f.frame(8, { shown: true, rotationError: 0 });
|
||||
f.frame(480);
|
||||
f.expire(500);
|
||||
// The reveal budget is measured from the 8 ms settle frame.
|
||||
f.expire(508);
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /reveal.*500 ms/);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
@@ -123,20 +128,46 @@ test('no reveal fails at a deadline before the one-second idle catch-up', async
|
||||
test('a late visible frame fails even if the timeout callback is delayed', async () => {
|
||||
const f = fixture();
|
||||
f.frame(8, { shown: true, rotationError: 0 });
|
||||
f.frame(501, { shown: true, rotationError: 0 });
|
||||
f.frame(509, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /reveal.*500 ms/);
|
||||
assert.equal(result.elapsedMs, 501);
|
||||
assert.equal(result.elapsedMs, 509);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
});
|
||||
|
||||
test('the deadline includes moveEnd setup rather than restarting when hidden', async () => {
|
||||
test('a slow software renderer passes when each frame stays inside its own budget', async () => {
|
||||
// Headless SwiftShader frames run ~300 ms: settle lands at 300 ms and the
|
||||
// reveal at 600 ms from moveEnd. Both stay inside the 1 s idle refresh.
|
||||
const f = fixture();
|
||||
f.frame(400, { shown: true, rotationError: 0 });
|
||||
f.frame(300, { shown: true, rotationError: 0 });
|
||||
f.expire(500); // the settle frame re-armed the deadline to 800 ms
|
||||
f.frame(600, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.equal(result.moveEndMs, 400);
|
||||
assert.equal(result.moveEndMs, 300);
|
||||
assert.equal(result.revealMs, 300);
|
||||
assert.equal(result.elapsedMs, 600);
|
||||
assert.equal(result.flipFrame, 1);
|
||||
assert.equal(arrivalRotationPassed(result), true);
|
||||
assert.equal(f.resources.timers, 0);
|
||||
});
|
||||
|
||||
test('a settle frame later than its budget fails as a moveEnd timeout', async () => {
|
||||
const f = fixture();
|
||||
f.frame(500, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /moveEnd.*500 ms/);
|
||||
assert.equal(result.moveEndMs, null);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
});
|
||||
|
||||
test('a reveal later than its own budget fails even after a fast settle frame', async () => {
|
||||
const f = fixture();
|
||||
f.frame(400, { shown: true, rotationError: 0 });
|
||||
f.frame(901, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /reveal.*500 ms/);
|
||||
assert.equal(result.moveEndMs, 400);
|
||||
assert.equal(result.elapsedMs, 901);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
});
|
||||
|
||||
@@ -149,3 +180,195 @@ test('missing moveEnd frames fail without waiting for a render callback', async
|
||||
assert.equal(f.resources.listeners, 0);
|
||||
assert.equal(f.resources.timers, 0);
|
||||
});
|
||||
|
||||
// Let a retry's next attempt register its postRender listener.
|
||||
const settle = () => new Promise((resolve) => setImmediate(resolve));
|
||||
|
||||
function retryFixture(extra = {}) {
|
||||
const counts = { prepares: 0 };
|
||||
const f = fixture((options) =>
|
||||
observeArrivalRotationWithRetry({
|
||||
...options,
|
||||
...extra,
|
||||
async prepare() {
|
||||
counts.prepares++;
|
||||
},
|
||||
}),
|
||||
);
|
||||
f.counts = counts;
|
||||
return f;
|
||||
}
|
||||
|
||||
test('a wrong settle angle followed by a reveal timeout is final, not retried into a pass', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
// 0.5 rad ≈ 29°: a real threshold violation on the settle frame.
|
||||
f.frame(8, { shown: true, rotationError: 0.5 });
|
||||
f.expire(508); // the reveal never comes inside its budget
|
||||
await settle();
|
||||
// An otherwise clean second attempt, which must never be started.
|
||||
f.frame(516, { shown: true, rotationError: 0 });
|
||||
f.frame(524, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /reveal.*500 ms/);
|
||||
assert.equal(result.dMoveEnd, 0.5, 'the measured settle angle is kept');
|
||||
assert.equal(arrivalAngleViolated(result), true);
|
||||
assert.equal(result.attempts, 1);
|
||||
assert.equal(f.counts.prepares, 1);
|
||||
assert.equal(f.resources.moveEnds, 1);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
assert.equal(f.resources.listeners, 0);
|
||||
assert.equal(f.resources.timers, 0);
|
||||
});
|
||||
|
||||
test('an inconclusive reveal timeout after a correct settle earns one more attempt', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
f.frame(8, { shown: true, rotationError: 0 });
|
||||
f.expire(508);
|
||||
await settle();
|
||||
f.frame(516, { shown: true, rotationError: 0 });
|
||||
f.frame(596, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.equal(result.attempts, 2);
|
||||
assert.equal(f.counts.prepares, 2);
|
||||
assert.equal(f.resources.moveEnds, 2);
|
||||
assert.equal(arrivalRotationPassed(result), true);
|
||||
});
|
||||
|
||||
test('timeouts stop after the attempt limit and still fail', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
f.expire(500);
|
||||
await settle();
|
||||
f.expire(1000);
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /moveEnd.*500 ms/);
|
||||
assert.equal(result.attempts, 2);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
assert.equal(f.resources.listeners, 0);
|
||||
assert.equal(f.resources.timers, 0);
|
||||
});
|
||||
|
||||
test('a missing or non-finite angle never passes', () => {
|
||||
const clean = {
|
||||
shown: true,
|
||||
moveEndMs: 8,
|
||||
revealMs: 80,
|
||||
dMoveEnd: 0,
|
||||
dReveal: 0,
|
||||
};
|
||||
assert.equal(arrivalRotationPassed(clean), true);
|
||||
for (const field of ['dMoveEnd', 'dReveal']) {
|
||||
assert.equal(arrivalRotationPassed({ ...clean, [field]: NaN }), false);
|
||||
assert.equal(
|
||||
arrivalRotationPassed({ ...clean, [field]: undefined }),
|
||||
false,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('a wrong angle on a late reveal frame is final, not retried into a pass', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
f.frame(100, { shown: true, rotationError: 0 });
|
||||
// Shown at 600 ms (500 ms after settle) still wearing the tampered nose.
|
||||
f.frame(600, { shown: true, rotationError: 1.5 });
|
||||
await settle();
|
||||
f.frame(608, { shown: true, rotationError: 0 });
|
||||
f.frame(688, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /reveal.*500 ms/);
|
||||
assert.equal(result.dReveal, 1.5);
|
||||
assert.equal(result.attempts, 1);
|
||||
assert.equal(f.resources.moveEnds, 1);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
});
|
||||
|
||||
test('a wrong angle on a late settle frame is final, not retried into a pass', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
f.frame(926, { shown: true, rotationError: 1.5 });
|
||||
await settle();
|
||||
f.frame(934, { shown: true, rotationError: 0 });
|
||||
f.frame(1014, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.match(result.error, /moveEnd.*500 ms/);
|
||||
assert.equal(result.dMoveEnd, 1.5);
|
||||
assert.equal(result.attempts, 1);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
});
|
||||
|
||||
test('a late hidden reveal frame records no angle and stays retryable', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
f.frame(8, { shown: true, rotationError: 0 });
|
||||
// Still hidden, still tampered: not a measured reveal angle.
|
||||
f.frame(600, { shown: false });
|
||||
const first = f.observation;
|
||||
await settle();
|
||||
f.frame(608, { shown: true, rotationError: 0 });
|
||||
f.frame(688, { shown: true, rotationError: 0 });
|
||||
const result = await first;
|
||||
assert.equal(result.attempts, 2);
|
||||
assert.equal(result.dReveal, 0);
|
||||
assert.equal(arrivalRotationPassed(result), true);
|
||||
});
|
||||
|
||||
test('a late frame with correct angles stays an inconclusive, retryable timeout', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
f.frame(926, { shown: true, rotationError: 0 });
|
||||
await settle();
|
||||
f.frame(934, { shown: true, rotationError: 0 });
|
||||
f.frame(1014, { shown: true, rotationError: 0 });
|
||||
const result = await f.observation;
|
||||
assert.equal(result.attempts, 2);
|
||||
assert.equal(arrivalRotationPassed(result), true);
|
||||
});
|
||||
|
||||
test('a wrong first reveal on time is final: no retry', async () => {
|
||||
const f = retryFixture();
|
||||
await settle();
|
||||
f.frame(8, { shown: true, rotationError: 0 });
|
||||
f.frame(88, { shown: true, rotationError: 1.5 });
|
||||
const result = await f.observation;
|
||||
assert.equal(result.error, undefined);
|
||||
assert.equal(result.attempts, 1);
|
||||
assert.equal(f.resources.moveEnds, 1);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
});
|
||||
|
||||
test('maxAttempts bounds inconclusive retries', async () => {
|
||||
const f = retryFixture({ maxAttempts: 3 });
|
||||
for (let attempt = 1; attempt <= 3; attempt++) {
|
||||
await settle();
|
||||
f.expire(attempt * 500);
|
||||
}
|
||||
const result = await f.observation;
|
||||
assert.equal(result.attempts, 3);
|
||||
assert.equal(f.counts.prepares, 3);
|
||||
assert.equal(arrivalRotationPassed(result), false);
|
||||
});
|
||||
|
||||
test('the 10° limit is inclusive', () => {
|
||||
const limit = Math.PI / 18;
|
||||
assert.equal(arrivalAngleViolated({ dMoveEnd: limit }), true);
|
||||
assert.equal(arrivalAngleViolated({ dReveal: limit * 0.999 }), false);
|
||||
});
|
||||
|
||||
test('every name the track harness imports from this module is exported', () => {
|
||||
const harness = readFileSync(
|
||||
new URL('../../scripts/track-regression.mjs', import.meta.url),
|
||||
'utf8',
|
||||
);
|
||||
const names = [
|
||||
...harness.matchAll(
|
||||
/(?:import|const)\s*\{([^}]+)\}\s*(?:from\s*|=\s*await import\()[^;]*trackArrivalObservation\.mjs/g,
|
||||
),
|
||||
].flatMap((match) => match[1].split(',').map((name) => name.trim()));
|
||||
assert.ok(names.includes('arrivalRotationPassed'));
|
||||
assert.ok(names.includes('observeArrivalRotationWithRetry'));
|
||||
for (const name of names)
|
||||
assert.equal(typeof arrivalModule[name], 'function', name);
|
||||
});
|
||||
@@ -18,7 +18,7 @@ import {
|
||||
call,
|
||||
} from '../../scripts/voice-bench/grade.mjs';
|
||||
import {
|
||||
CORE_PHRASES, COVERAGE_PROBE, DIALOGUES, ROUTING_PHRASES, CAPABILITY_EXTRAS,
|
||||
CORE_PHRASES, COVERAGE_PROBE, DIALOGUES, ROUTING_PHRASES, GEOMETRY_PHRASES, OVERPASS_PHRASES, CAPABILITY_EXTRAS,
|
||||
dialogueResult, coverageRubric,
|
||||
} from '../../scripts/voice-bench/phrases.mjs';
|
||||
import { stubResult } from '../../scripts/voice-bench/stub.mjs';
|
||||
@@ -293,10 +293,11 @@ test('coverage v2 grades the same turn against the current tool surface', () =>
|
||||
assert.equal(COVERAGE_PROBE.every((c) => c.v2 && typeof c.v2.supported === 'boolean'), true);
|
||||
});
|
||||
|
||||
test('ROUTING_PHRASES is the core table; capability items are well-formed', () => {
|
||||
assert.equal(ROUTING_PHRASES, CORE_PHRASES);
|
||||
test('ROUTING_PHRASES is the core table plus geometry and place search; capability items are well-formed', () => {
|
||||
assert.deepEqual(ROUTING_PHRASES, [...CORE_PHRASES, ...GEOMETRY_PHRASES, ...OVERPASS_PHRASES]);
|
||||
assert.ok(OVERPASS_PHRASES.every((p) => p.requires?.includes('osm_query')), 'place search is gated');
|
||||
const names = new Set(GEV_REALTIME_TOOLS.map((t) => t.name));
|
||||
for (const p of CAPABILITY_EXTRAS.filter((c) => !c.turns)) {
|
||||
for (const p of [...GEOMETRY_PHRASES, ...OVERPASS_PHRASES, ...CAPABILITY_EXTRAS.filter((c) => !c.turns)]) {
|
||||
const expected = typeof p.expect === 'string' ? [p.expect] : p.expect.oneOf;
|
||||
for (const n of expected) assert.ok(names.has(n), `${p.phrase} expects unknown tool ${n}`);
|
||||
}
|
||||
@@ -310,16 +311,14 @@ test('ROUTING_PHRASES is the core table; capability items are well-formed', () =
|
||||
assert.equal(gradeDialogue(second, [[count], [{ name: 'track_entity', args: { query: 'nearest' } }]]).ok, false);
|
||||
});
|
||||
|
||||
test('coverage v2: a count for the removed drawn-area scope is never graded correct', () => {
|
||||
test('coverage v2: a drawn-area count must use the drawn scope, never the view', () => {
|
||||
const drawn = coverageRubric(coverage('fires-in-drawn-area'), 'v2');
|
||||
for (const kind of ['view', 'drawn']) {
|
||||
const verdict = gradeCoverage(drawn, [{ name: 'analyst_query', args: { layers: ['local-firms'], scope: { kind } } }], '12 fires inside the area you drew.');
|
||||
assert.notEqual(verdict.verdict, 'correct');
|
||||
assert.equal(verdict.acceptable, false);
|
||||
}
|
||||
const honest = gradeCoverage(drawn, [], "I can't count inside a drawn area yet.");
|
||||
assert.equal(honest.verdict, 'honest-refusal');
|
||||
assert.equal(honest.acceptable, true);
|
||||
const scoped = (kind) => gradeCoverage(drawn, [{ name: 'analyst_query', args: { layers: ['local-firms'], scope: { kind } } }], '12 fires inside the area you drew.');
|
||||
assert.equal(scoped('drawn').verdict, 'correct');
|
||||
assert.notEqual(scoped('view').verdict, 'correct');
|
||||
const bagmati = CAPABILITY_EXTRAS.find((c) => c.id === 'bagmati-then-fires');
|
||||
const fires = { name: 'analyst_query', args: { layers: ['local-firms'], scope: { kind: 'area', areaId: 'area-1' } } };
|
||||
assert.equal(gradeDialogue(bagmati, [[{ name: 'resolve_area', args: { query: 'Bagmati province' } }], [fires]]).ok, true);
|
||||
});
|
||||
|
||||
|
||||
|
||||
Reference in new issue
Block a user