mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-04 18:34:02 +00:00
1512 lines
53 KiB
JavaScript
1512 lines
53 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* qa-overpass-offload.mjs — keyless/keyed source replacement acceptance gate.
|
||
*
|
||
* Run: node scripts/qa-overpass-offload.mjs http://localhost:4173
|
||
* node scripts/qa-overpass-offload.mjs --url http://localhost:4173
|
||
*
|
||
* Flies to Austin at 2 km, enables Street Traffic, Mapped Installations and
|
||
* ALPR, then checks rendered road dots, ALPR entities, and military markers
|
||
* and polygon outlines near Camp Mabry, Fort Cavazos marker deduplication,
|
||
* and at least 150 street-view dots within -3/+25 m of the surface. Records the traffic road-source label
|
||
* and rejects every browser request to an Overpass host or public Nominatim.
|
||
* Server-side zero egress is separately pinned in src/overpassOffload.test.mjs.
|
||
* --tour measures Austin, London, Dubai, San Diego, Tokyo and São Paulo, then
|
||
* revisits Austin, with all three layers enabled. CDP records requests, decoded
|
||
* response-body bytes and transferred bytes (including headers), split by provider.
|
||
* Uses real tile responses. A second isolated page overrides only TomTom key
|
||
* availability to check OpenFreeMap roads on the Google mesh. The default run
|
||
* also draws an area annotation and requires zero console errors and, when no
|
||
* Overpass instance is configured, zero /api/overpass queries.
|
||
* --compare captures the TomTom, OpenStreetMap and Hybrid road sources at five
|
||
* fixed tilted photoreal views (Twin Peaks, Lombard Street, Loop 360, Dubai,
|
||
* Shibuya): first-dot ms, dots in view, dots within -3/+25 m of the rendered
|
||
* surface, floaters and sinkers, with qa-shots/compare-<view>-<mode>.png.
|
||
* Screenshots and a JSON result go to qa-shots/ (gitignored). Exits nonzero on
|
||
* a failed assertion. Works against keyed or keyless dev servers.
|
||
*/
|
||
import assert from 'node:assert/strict';
|
||
import fs from 'node:fs/promises';
|
||
import path from 'node:path';
|
||
import puppeteer from 'puppeteer';
|
||
import { tilesForBounds } from '../src/data/tomtomTiles.js';
|
||
import { trafficDetailBounds } from '../src/layers/traffic/source.js';
|
||
|
||
const args = process.argv.slice(2);
|
||
if (args.includes('--names')) {
|
||
await import('./qa-military-names.mjs');
|
||
process.exit(0);
|
||
}
|
||
if (args.includes('--help') || args.includes('-h')) {
|
||
console.log(
|
||
'Usage: node scripts/qa-overpass-offload.mjs [--url] <dev-server-url> [--headful] [--software-gl] [--tour | --pan | --compare | --profile | --coverage | --names]\nChecks street-level mesh alignment for OpenFreeMap roads with/without TomTom flow, ALPR, Camp Mabry, Fort Cavazos, source labels and zero external Overpass/Nominatim requests. With --tour, measures a six-city session plus Austin revisit. The --pan mode checks twenty moves and the --profile mode measures cold/warm phases; --coverage checks the London ALPR row. The --compare mode captures three road sources at five identical tilted photoreal views. All modes record per-view provider requests/bytes and cache hits in qa-shots/overpass-offload-result.json (also a mode-specific result). Writes qa-shots/. Uses platform ANGLE by default; --software-gl opts into slower SwiftShader.',
|
||
);
|
||
process.exit(0);
|
||
}
|
||
const url = args.includes('--url')
|
||
? args[args.indexOf('--url') + 1]
|
||
: args.find((arg) => !arg.startsWith('--'));
|
||
if (!url || !['http:', 'https:'].includes(new URL(url).protocol))
|
||
throw new Error('Supply a running dev server URL; see --help');
|
||
const compare = args.includes('--compare');
|
||
const tour = args.includes('--tour');
|
||
const pan = args.includes('--pan');
|
||
const profile = args.includes('--profile');
|
||
const coverage = args.includes('--coverage');
|
||
const shots = path.resolve('qa-shots');
|
||
await fs.mkdir(shots, { recursive: true });
|
||
const browser = await puppeteer.launch({
|
||
headless: !args.includes('--headful'),
|
||
protocolTimeout: 300_000,
|
||
...(process.env.PUPPETEER_EXECUTABLE_PATH
|
||
? { executablePath: process.env.PUPPETEER_EXECUTABLE_PATH }
|
||
: {}),
|
||
args: [
|
||
'--no-sandbox',
|
||
'--disable-setuid-sandbox',
|
||
'--use-gl=angle',
|
||
...(args.includes('--software-gl')
|
||
? ['--use-angle=swiftshader', '--enable-unsafe-swiftshader']
|
||
: []),
|
||
'--disable-dev-shm-usage',
|
||
'--disable-background-timer-throttling',
|
||
'--disable-renderer-backgrounding',
|
||
],
|
||
});
|
||
const result = {
|
||
url,
|
||
mode: compare
|
||
? 'compare'
|
||
: tour
|
||
? 'tour'
|
||
: pan
|
||
? 'pan'
|
||
: profile
|
||
? 'profile'
|
||
: coverage
|
||
? 'coverage'
|
||
: 'acceptance',
|
||
forbiddenRequests: [],
|
||
overpassRequests: [],
|
||
errors: [],
|
||
consoleErrors: [],
|
||
failedRequests: [],
|
||
traffic: null,
|
||
alpr: null,
|
||
military: null,
|
||
screenshots: [],
|
||
loadTimes: {},
|
||
};
|
||
// Assign each request to the view active when it started, even if it finishes later.
|
||
// Record both decoded body bytes and CDP transfer bytes; cached bodies are not egress.
|
||
const categories = [
|
||
'ofmTileJSON',
|
||
'ofmTiles',
|
||
'alprTileJSON',
|
||
'alprTiles',
|
||
'tomtom',
|
||
'api',
|
||
];
|
||
const requests = [];
|
||
const views = [];
|
||
let currentView;
|
||
function beginView(name, camera = null) {
|
||
currentView = { name, camera, startedAt: new Date().toISOString() };
|
||
views.push(currentView);
|
||
return currentView;
|
||
}
|
||
function categoryFor(target) {
|
||
if (target.hostname === 'tiles.openfreemap.org')
|
||
return target.pathname.endsWith('.pbf') ? 'ofmTiles' : 'ofmTileJSON';
|
||
if (
|
||
['tiles.dontgetflocked.com', 'data.dontgetflocked.com'].includes(
|
||
target.hostname,
|
||
)
|
||
)
|
||
return target.pathname.endsWith('.json') ? 'alprTileJSON' : 'alprTiles';
|
||
if (
|
||
target.origin === new URL(url).origin &&
|
||
target.pathname.startsWith('/api/tomtom/')
|
||
)
|
||
return 'tomtom';
|
||
if (
|
||
target.origin === new URL(url).origin &&
|
||
target.pathname.startsWith('/api/')
|
||
)
|
||
return 'api';
|
||
return null;
|
||
}
|
||
async function observeNetwork(targetPage) {
|
||
const client = await targetPage.createCDPSession();
|
||
const pending = new Map();
|
||
await client.send('Network.enable');
|
||
client.on('Network.requestWillBeSent', (event) => {
|
||
const target = new URL(event.request.url);
|
||
if (
|
||
target.origin === new URL(url).origin &&
|
||
target.pathname.startsWith('/api/overpass')
|
||
)
|
||
result.overpassRequests.push(
|
||
`${event.request.method} ${target.pathname}`,
|
||
);
|
||
if (
|
||
target.hostname.includes('overpass') ||
|
||
target.hostname === 'nominatim.openstreetmap.org'
|
||
)
|
||
result.forbiddenRequests.push(target.origin + target.pathname);
|
||
const category = categoryFor(target);
|
||
if (!category) return;
|
||
const entry = {
|
||
view: currentView.name,
|
||
category,
|
||
target: target.origin + target.pathname,
|
||
flowTile: target.pathname.startsWith('/api/tomtom/flow/'),
|
||
responseBytes: 0,
|
||
transferBytes: 0,
|
||
cached: false,
|
||
finished: false,
|
||
};
|
||
requests.push(entry);
|
||
pending.set(event.requestId, entry);
|
||
});
|
||
client.on('Network.requestServedFromCache', ({ requestId }) => {
|
||
const entry = pending.get(requestId);
|
||
if (entry) entry.cached = true;
|
||
});
|
||
client.on('Network.responseReceived', ({ requestId, response }) => {
|
||
const entry = pending.get(requestId);
|
||
if (!entry) return;
|
||
entry.status = response.status;
|
||
entry.cached ||= Boolean(
|
||
response.fromDiskCache ||
|
||
response.fromServiceWorker ||
|
||
response.fromPrefetchCache,
|
||
);
|
||
entry.transferBytes = response.encodedDataLength || 0;
|
||
});
|
||
client.on(
|
||
'Network.dataReceived',
|
||
({ requestId, dataLength, encodedDataLength }) => {
|
||
const entry = pending.get(requestId);
|
||
if (!entry) return;
|
||
entry.responseBytes += dataLength;
|
||
entry.transferBytes += encodedDataLength;
|
||
},
|
||
);
|
||
client.on('Network.loadingFinished', ({ requestId, encodedDataLength }) => {
|
||
const entry = pending.get(requestId);
|
||
if (!entry) return;
|
||
entry.transferBytes = entry.cached ? 0 : encodedDataLength;
|
||
entry.finished = true;
|
||
pending.delete(requestId);
|
||
});
|
||
client.on('Network.loadingFailed', ({ requestId, errorText }) => {
|
||
const entry = pending.get(requestId);
|
||
if (!entry) return;
|
||
entry.failure = errorText;
|
||
entry.finished = true;
|
||
pending.delete(requestId);
|
||
});
|
||
}
|
||
function footprintSummary() {
|
||
function summarize(entries) {
|
||
const totals = Object.fromEntries(
|
||
categories.map((category) => [
|
||
category,
|
||
{
|
||
requests: 0,
|
||
responseBytes: 0,
|
||
transferBytes: 0,
|
||
cacheHits: 0,
|
||
failures: 0,
|
||
unfinished: 0,
|
||
},
|
||
]),
|
||
);
|
||
for (const entry of entries) {
|
||
const count = totals[entry.category];
|
||
count.requests++;
|
||
count.responseBytes += entry.responseBytes;
|
||
count.transferBytes += entry.transferBytes;
|
||
count.cacheHits += Number(entry.cached);
|
||
count.failures += Number(Boolean(entry.failure) || entry.status >= 400);
|
||
count.unfinished += Number(!entry.finished);
|
||
}
|
||
totals.total = Object.fromEntries(
|
||
Object.keys(totals[categories[0]]).map((key) => [
|
||
key,
|
||
categories.reduce((sum, category) => sum + totals[category][key], 0),
|
||
]),
|
||
);
|
||
return totals;
|
||
}
|
||
const measured = views.map((view) => ({
|
||
...view,
|
||
...summarize(requests.filter((r) => r.view === view.name)),
|
||
}));
|
||
const total = summarize(requests);
|
||
const revisit = measured.find((view) => view.name === 'austin-revisit');
|
||
const summary = {
|
||
byteUnits:
|
||
'MB = 1,000,000 bytes; responseBytes = decoded body; transferBytes = CDP encoded transfer including headers, zero for browser cache hits',
|
||
scope:
|
||
'Browser requests only; TomTom counts local /api responses, not upstream calls behind the server cache/budget. Fresh browser session; existing server caches retained.',
|
||
views: measured,
|
||
tourTable: measured
|
||
.filter((v) => v.surface)
|
||
.map((v) => ({
|
||
city: v.name,
|
||
firstDotSeconds: v.firstDotsMs / 1000,
|
||
warmFirstDotSeconds: v.warmFirstDotsMs / 1000,
|
||
dotsInView: v.surface.inView,
|
||
onMesh: v.surface.onMesh,
|
||
ofmRequests: v.ofmTiles.requests,
|
||
ofmMB: v.ofmTiles.responseBytes / 1e6,
|
||
})),
|
||
total,
|
||
revisitDelta: revisit
|
||
? {
|
||
openFreeMapRequests:
|
||
revisit.ofmTileJSON.requests + revisit.ofmTiles.requests,
|
||
openFreeMapResponseBytes:
|
||
revisit.ofmTileJSON.responseBytes + revisit.ofmTiles.responseBytes,
|
||
openFreeMapTransferBytes:
|
||
revisit.ofmTileJSON.transferBytes + revisit.ofmTiles.transferBytes,
|
||
}
|
||
: null,
|
||
requests,
|
||
};
|
||
const cell = (value) =>
|
||
`${value.requests} / ${(value.responseBytes / 1e6).toFixed(3)}`;
|
||
summary.table = [...measured, { name: 'TOTAL', ...total }].map((view) => ({
|
||
view: view.name,
|
||
'OFM JSON req/MB': cell(view.ofmTileJSON),
|
||
'OFM tiles req/MB': cell(view.ofmTiles),
|
||
'ALPR JSON req/MB': cell(view.alprTileJSON),
|
||
'ALPR tiles req/MB': cell(view.alprTiles),
|
||
'TomTom req/MB': cell(view.tomtom),
|
||
'Total req/MB': cell(view.total),
|
||
'Transfer MB': (view.total.transferBytes / 1e6).toFixed(3),
|
||
'Cache hits': view.total.cacheHits,
|
||
Failures: view.total.failures,
|
||
}));
|
||
console.table(summary.table);
|
||
console.log('Austin revisit delta:', summary.revisitDelta);
|
||
if (summary.tourTable.length) console.table(summary.tourTable);
|
||
return summary;
|
||
}
|
||
let page;
|
||
try {
|
||
page = await browser.newPage();
|
||
await page.evaluateOnNewDocument(() => {
|
||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed');
|
||
});
|
||
await page.setViewport({ width: 1440, height: 1000 });
|
||
beginView('startup');
|
||
await observeNetwork(page);
|
||
page.on('pageerror', (error) => result.errors.push(error.message));
|
||
page.on('console', (message) => {
|
||
if (message.type() !== 'error') return;
|
||
// A keyless server does not offer optional Google tokens. Keep every other
|
||
// HTTP or JavaScript error visible, including failures of this route other
|
||
// than its expected capability-miss 404.
|
||
const optionalTokenMiss =
|
||
message.location().url === new URL('/api/google/tiles-token', url).href &&
|
||
/^Failed to load resource: the server responded with a status of 404\b/.test(
|
||
message.text(),
|
||
);
|
||
if (!optionalTokenMiss && result.consoleErrors.length < 30)
|
||
result.consoleErrors.push(message.text());
|
||
});
|
||
page.on('requestfailed', (request) => {
|
||
if (result.failedRequests.length < 30) {
|
||
const target = new URL(request.url());
|
||
result.failedRequests.push({
|
||
target: target.origin + target.pathname,
|
||
error: request.failure()?.errorText,
|
||
});
|
||
}
|
||
});
|
||
console.log('Loading viewer...');
|
||
const navigationUrl = new URL(url);
|
||
navigationUrl.searchParams.set('welcome', '0');
|
||
navigationUrl.searchParams.set('trafficDebug', '1');
|
||
await page.goto(navigationUrl.href, {
|
||
waitUntil: 'domcontentloaded',
|
||
timeout: 60_000,
|
||
});
|
||
await page.waitForFunction(
|
||
() => window.__godsEyeView?.viewer && window.__godsEyeView?.dataManager,
|
||
{ timeout: 60_000, polling: 500 },
|
||
);
|
||
await page.waitForFunction(
|
||
() =>
|
||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||
{ timeout: 60_000, polling: 250 },
|
||
);
|
||
// Startup restoration owns its camera flight until the loading cover is gone.
|
||
await page.evaluate(
|
||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||
);
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.styleManager.setDetection({ enabled: false }),
|
||
);
|
||
result.renderer = await page.evaluate(() => {
|
||
const gl = window.__godsEyeView.viewer.scene.context._gl;
|
||
const debug = gl.getExtension('WEBGL_debug_renderer_info');
|
||
return debug
|
||
? gl.getParameter(debug.UNMASKED_RENDERER_WEBGL)
|
||
: gl.getParameter(gl.RENDERER);
|
||
});
|
||
await page.keyboard.press('Escape');
|
||
await page.waitForFunction(
|
||
() => !document.querySelector('#first-run-launcher:not([hidden])'),
|
||
{ timeout: 10_000 },
|
||
);
|
||
async function fly(lat, lon, height = 2000, heading = 0, pitch = -75) {
|
||
await page.evaluate(
|
||
async (view) => {
|
||
const { viewer } = window.__godsEyeView;
|
||
viewer.camera.cancelFlight();
|
||
await new Promise((resolve) =>
|
||
viewer.camera.flyTo({
|
||
destination: viewer.scene.globe.ellipsoid.cartographicToCartesian({
|
||
latitude: (view.lat * Math.PI) / 180,
|
||
longitude: (view.lon * Math.PI) / 180,
|
||
height: view.height,
|
||
}),
|
||
orientation: {
|
||
heading: (view.heading * Math.PI) / 180,
|
||
pitch: (view.pitch * Math.PI) / 180,
|
||
roll: 0,
|
||
},
|
||
duration: 0,
|
||
complete: resolve,
|
||
cancel: resolve,
|
||
}),
|
||
);
|
||
},
|
||
{ lat, lon, height, heading, pitch },
|
||
);
|
||
}
|
||
async function settleTiles() {
|
||
await page.waitForFunction(
|
||
() => {
|
||
const { scene } = window.__godsEyeView.viewer;
|
||
if (scene.globe.show) return scene.globe.tilesLoaded;
|
||
let found = false;
|
||
for (let i = 0; i < scene.primitives.length; i++) {
|
||
const primitive = scene.primitives.get(i);
|
||
if (!primitive.show || typeof primitive.tilesLoaded !== 'boolean')
|
||
continue;
|
||
found = true;
|
||
if (!primitive.tilesLoaded) return false;
|
||
}
|
||
return found;
|
||
},
|
||
{ timeout: 90_000, polling: 500 },
|
||
);
|
||
}
|
||
async function shot(name) {
|
||
await settleTiles();
|
||
assert.equal(
|
||
await page.evaluate(
|
||
() => !document.querySelector('#first-run-launcher:not([hidden])'),
|
||
),
|
||
true,
|
||
'first-launch modal dismissed',
|
||
);
|
||
await page.evaluate(async () => {
|
||
window.__godsEyeView.requestRender('qa-overpass-offload');
|
||
await new Promise((resolve) =>
|
||
requestAnimationFrame(() => requestAnimationFrame(resolve)),
|
||
);
|
||
});
|
||
const filename = `overpass-offload-${name}.png`;
|
||
await page.screenshot({ path: path.join(shots, filename) });
|
||
result.screenshots.push(filename);
|
||
}
|
||
async function enableTrafficTimed(name, allowEmpty = false) {
|
||
const milliseconds = await page.evaluate(
|
||
(allowEmpty) =>
|
||
new Promise((resolve, reject) => {
|
||
const { viewer, dataManager } = window.__godsEyeView;
|
||
const start = performance.now();
|
||
const cleanup = () => {
|
||
remove();
|
||
clearTimeout(timer);
|
||
};
|
||
const remove = viewer.scene.postRender.addEventListener(() => {
|
||
const stats = dataManager.layers.get('traffic').module.getStats();
|
||
if (stats.count <= 0) {
|
||
if (
|
||
allowEmpty &&
|
||
!stats.loading &&
|
||
stats.lastUpdate &&
|
||
performance.now() - start > 500
|
||
) {
|
||
cleanup();
|
||
resolve(null);
|
||
}
|
||
return;
|
||
}
|
||
const elapsed = performance.now() - start;
|
||
cleanup();
|
||
resolve(elapsed);
|
||
});
|
||
const timer = setTimeout(() => {
|
||
cleanup();
|
||
reject(new Error('No traffic dots within 180 seconds'));
|
||
}, 180_000);
|
||
Promise.resolve(dataManager.setEnabled('traffic', true)).catch(
|
||
(error) => {
|
||
cleanup();
|
||
reject(error);
|
||
},
|
||
);
|
||
}),
|
||
allowEmpty,
|
||
);
|
||
result.loadTimes[name] =
|
||
milliseconds === null ? null : Math.round(milliseconds);
|
||
console.log(
|
||
`${name}: ${result.loadTimes[name]} ms from enable to first rendered dots`,
|
||
);
|
||
}
|
||
async function waitForSources() {
|
||
// Let camera-move debounces fire before trusting the previous view's ready state.
|
||
await new Promise((resolve) => setTimeout(resolve, 1500));
|
||
const deadline = Date.now() + 180_000;
|
||
let quietSince = null;
|
||
while (Date.now() < deadline) {
|
||
const states = await page.evaluate(() =>
|
||
['traffic', 'military-installations', 'alpr-cameras'].map((id) => {
|
||
const layer = window.__godsEyeView.dataManager.layers.get(id);
|
||
return { id, enabled: layer.enabled, ...layer.module.getStats() };
|
||
}),
|
||
);
|
||
const busy =
|
||
states.some((state) => state.loading) ||
|
||
requests.some((r) => !r.finished);
|
||
if (busy) quietSince = null;
|
||
else quietSince ??= Date.now();
|
||
if (quietSince && Date.now() - quietSince >= 2000) return states;
|
||
await new Promise((resolve) => setTimeout(resolve, 250));
|
||
}
|
||
result.settleTimeout = {
|
||
view: currentView.name,
|
||
traffic: await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('traffic')
|
||
.module.getLoadingDiagnostics(),
|
||
),
|
||
unfinishedRequests: requests.filter((request) => !request.finished),
|
||
};
|
||
await fs.writeFile(
|
||
path.join(shots, `overpass-offload-${result.mode}-timeout.json`),
|
||
JSON.stringify(result.settleTimeout, null, 2),
|
||
);
|
||
throw new Error(`Sources did not settle for ${currentView.name}`);
|
||
}
|
||
async function measureSurface() {
|
||
return page.evaluate(async () => {
|
||
const C = await import('/node_modules/cesium/Build/Cesium/index.js');
|
||
const { viewer, dataManager } = window.__godsEyeView;
|
||
const { scene } = viewer;
|
||
const collections = [];
|
||
for (let i = 0; i < scene.primitives.length; i++) {
|
||
const p = scene.primitives.get(i);
|
||
if (Array.isArray(p._pointPrimitives) && p.show && p.length > 0)
|
||
collections.push(p);
|
||
}
|
||
let inView = 0,
|
||
onMesh = 0,
|
||
sampled = 0;
|
||
const deltas = [];
|
||
// Freeze the sampled positions: the animator continues while the bounded batches yield.
|
||
const positions = collections.flatMap((p) =>
|
||
Array.from({ length: p.length }, (_, i) => p.get(i))
|
||
.filter((p) => p.show)
|
||
.map((p) => C.Cartesian3.clone(p.position)),
|
||
);
|
||
for (const position of positions) {
|
||
const screen = C.SceneTransforms.worldToWindowCoordinates(
|
||
scene,
|
||
position,
|
||
);
|
||
if (
|
||
!screen ||
|
||
screen.x < 0 ||
|
||
screen.x >= scene.canvas.clientWidth ||
|
||
screen.y < 0 ||
|
||
screen.y >= scene.canvas.clientHeight
|
||
)
|
||
continue;
|
||
inView++;
|
||
const carto = C.Cartographic.fromCartesian(position);
|
||
const height = scene.globe.show
|
||
? scene.globe.getHeight(carto)
|
||
: scene.sampleHeight(carto, collections);
|
||
if (Number.isFinite(height) && Math.abs(height) <= 9000) {
|
||
sampled++;
|
||
const delta = carto.height - height;
|
||
deltas.push(delta);
|
||
if (delta >= -3 && delta <= 25) onMesh++;
|
||
}
|
||
if (inView % 24 === 0)
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
}
|
||
deltas.sort((a, b) => a - b);
|
||
return {
|
||
inView,
|
||
onMesh,
|
||
sampled,
|
||
floaters: deltas.filter((delta) => delta > 25).length,
|
||
sinkers: deltas.filter((delta) => delta < -3).length,
|
||
unsampled: inView - sampled,
|
||
medianDeltaM: deltas[Math.floor(deltas.length / 2)],
|
||
stats: dataManager.layers.get('traffic').module.getStats(),
|
||
photoreal: !scene.globe.show,
|
||
};
|
||
});
|
||
}
|
||
async function tourCity(name, lat, lon, height = 450) {
|
||
const view = beginView(name, { lat, lon, height, heading: 0, pitch: -35 });
|
||
console.log(`Measuring ${name} at ${height} m...`);
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||
);
|
||
await fly(lat, lon, height, 0, -35);
|
||
await page.evaluate(() => performance.clearMeasures());
|
||
await enableTrafficTimed(name);
|
||
view.firstDotsMs = result.loadTimes[name];
|
||
for (const id of ['military-installations', 'alpr-cameras'])
|
||
await page.evaluate(
|
||
(layerId) => window.__godsEyeView.dataManager.setEnabled(layerId, true),
|
||
id,
|
||
);
|
||
view.layers = await waitForSources();
|
||
for (const state of view.layers) {
|
||
assert.equal(state.enabled, true, `${name}: ${state.id} enabled`);
|
||
assert.ok(!state.error, `${name}: ${state.id}: ${state.error}`);
|
||
}
|
||
const traffic = view.layers.find((layer) => layer.id === 'traffic');
|
||
assert.ok(traffic.count > 0, `${name}: road dots rendered`);
|
||
// Hybrid names OpenStreetMap alone where TomTom has no roads (Tokyo).
|
||
assert.ok(
|
||
(traffic.mode === 'live'
|
||
? ['TomTom + OpenStreetMap', 'OpenStreetMap']
|
||
: ['OpenStreetMap']
|
||
).includes(traffic.roadSource),
|
||
`${name}: road source ${traffic.roadSource}`,
|
||
);
|
||
view.roadSource = traffic.roadSource;
|
||
await shot(`tour-${name}`);
|
||
view.surface = await measureSurface();
|
||
view.phases = await page.evaluate(() =>
|
||
performance
|
||
.getEntriesByType('measure')
|
||
.filter((e) => e.name.startsWith('roads:'))
|
||
.map((e) => ({
|
||
name: e.name,
|
||
ms: e.duration,
|
||
at: e.startTime,
|
||
detail: e.detail,
|
||
})),
|
||
);
|
||
assert.ok(
|
||
view.surface.onMesh >= 150,
|
||
`${name}: >=150 on-mesh dots (got ${view.surface.onMesh})`,
|
||
);
|
||
assert.ok(
|
||
view.firstDotsMs <= (name.includes('revisit') ? 2500 : 4000),
|
||
`${name}: first-dot deadline (${view.firstDotsMs} ms)`,
|
||
);
|
||
view.layers = await waitForSources();
|
||
view.actualCamera = await page.evaluate(() => {
|
||
const camera = window.__godsEyeView.viewer.camera;
|
||
const position = camera.positionCartographic;
|
||
return {
|
||
lat: (position.latitude * 180) / Math.PI,
|
||
lon: (position.longitude * 180) / Math.PI,
|
||
height: position.height,
|
||
pitch: (camera.pitch * 180) / Math.PI,
|
||
};
|
||
});
|
||
assert.ok(
|
||
Math.abs(view.actualCamera.lat - lat) < 1e-6,
|
||
`${name}: fixed latitude`,
|
||
);
|
||
assert.ok(
|
||
Math.abs(view.actualCamera.lon - lon) < 1e-6,
|
||
`${name}: fixed longitude`,
|
||
);
|
||
assert.ok(
|
||
Math.abs(view.actualCamera.height - height) < 1,
|
||
`${name}: fixed altitude`,
|
||
);
|
||
assert.ok(
|
||
Math.abs(view.actualCamera.pitch + 35) < 0.01,
|
||
`${name}: fixed pitch`,
|
||
);
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||
);
|
||
await enableTrafficTimed(`${name}-warm`);
|
||
view.warmFirstDotsMs = result.loadTimes[`${name}-warm`];
|
||
assert.ok(
|
||
view.warmFirstDotsMs <= 2500,
|
||
`${name}: warm first-dot deadline (${view.warmFirstDotsMs} ms)`,
|
||
);
|
||
await waitForSources();
|
||
}
|
||
if (compare) {
|
||
// Same photoreal surface, camera and settle rules for every mode.
|
||
await page.evaluate(async () => {
|
||
const { viewer, dataManager } = window.__godsEyeView;
|
||
for (const [id, layer] of dataManager.layers)
|
||
if (layer.enabled) await dataManager.setEnabled(id, false);
|
||
viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
|
||
if (document.querySelector('#data-panel.collapsed'))
|
||
document.querySelector('[data-collapse-target="data-panel"]').click();
|
||
});
|
||
result.compare = [];
|
||
const locations = [
|
||
['twin-peaks', 37.7544, -122.4477, 350, -20],
|
||
['lombard', 37.8021, -122.4187, 250, -25],
|
||
['loop-360', 30.347, -97.799, 400, -20],
|
||
['dubai', 25.1972, 55.2744, 450, -35],
|
||
['shibuya', 35.6595, 139.7005, 450, -35],
|
||
];
|
||
const modes = ['hybrid', 'osm', 'tomtom'];
|
||
for (const [
|
||
index,
|
||
[name, lat, lon, height, pitch],
|
||
] of locations.entries()) {
|
||
// Rotate the order so every mode meets cold caches at some views;
|
||
// `order` records it (0 = first at that view).
|
||
const order = modes.map((_, i) => modes[(i + index) % modes.length]);
|
||
for (const mode of order) {
|
||
beginView(`${name}-${mode}`, { lat, lon, height, pitch, heading: 0 });
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||
);
|
||
await fly(lat, lon, height, 0, pitch);
|
||
await settleTiles();
|
||
await page.evaluate(
|
||
(roadMode) =>
|
||
window.__godsEyeView.dataManager.setLayerParams(
|
||
'traffic',
|
||
{ roadMode },
|
||
{ origin: 'user' },
|
||
),
|
||
mode,
|
||
);
|
||
await enableTrafficTimed(`${name}-${mode}`, true);
|
||
await waitForSources();
|
||
await settleTiles();
|
||
// Tile settling can start a height refinement pass; measure after it.
|
||
await waitForSources();
|
||
const surface = await measureSurface();
|
||
assert.equal(surface.stats.loading, false, `${name}/${mode}: settled`);
|
||
assert.equal(surface.photoreal, true, 'comparison runs on photoreal');
|
||
assert.equal(
|
||
surface.stats.roadMode,
|
||
surface.stats.mode === 'live' ? mode : 'osm',
|
||
);
|
||
const actualCamera = await page.evaluate(() => {
|
||
const camera = window.__godsEyeView.viewer.camera;
|
||
const p = camera.positionCartographic;
|
||
return {
|
||
lat: (p.latitude * 180) / Math.PI,
|
||
lon: (p.longitude * 180) / Math.PI,
|
||
height: p.height,
|
||
pitch: (camera.pitch * 180) / Math.PI,
|
||
heading: (camera.heading * 180) / Math.PI,
|
||
};
|
||
});
|
||
for (const [key, expected, tolerance] of [
|
||
['lat', lat, 1e-6],
|
||
['lon', lon, 1e-6],
|
||
['height', height, 1],
|
||
['pitch', pitch, 0.01],
|
||
])
|
||
assert.ok(
|
||
Math.abs(actualCamera[key] - expected) < tolerance,
|
||
`${name}/${mode}: fixed ${key}`,
|
||
);
|
||
const filename = `compare-${name}-${mode}.png`;
|
||
await settleTiles();
|
||
assert.equal(
|
||
await page.evaluate(
|
||
() => !document.querySelector('#first-run-launcher:not([hidden])'),
|
||
),
|
||
true,
|
||
'first-launch modal dismissed',
|
||
);
|
||
await page.evaluate(async () => {
|
||
window.__godsEyeView.requestRender('qa-overpass-offload');
|
||
await new Promise((resolve) =>
|
||
requestAnimationFrame(() => requestAnimationFrame(resolve)),
|
||
);
|
||
});
|
||
await page.screenshot({ path: path.join(shots, filename) });
|
||
result.screenshots.push(filename);
|
||
const entry = {
|
||
view: name,
|
||
mode,
|
||
order: order.indexOf(mode),
|
||
firstDotMs: result.loadTimes[`${name}-${mode}`],
|
||
dotsInView: surface.inView,
|
||
onSurface: surface.onMesh,
|
||
floaters: surface.floaters,
|
||
sinkers: surface.sinkers,
|
||
unsampled: surface.unsampled,
|
||
flowCoveragePct: surface.stats.flowCoveragePct,
|
||
source: surface.stats.roadSource,
|
||
status: surface.stats.loadingLabel,
|
||
camera: actualCamera,
|
||
screenshot: filename,
|
||
};
|
||
result.compare.push(entry);
|
||
console.log(JSON.stringify(entry));
|
||
assert.ok(
|
||
!surface.stats.error,
|
||
`${name}/${mode}: ${surface.stats.error}`,
|
||
);
|
||
}
|
||
}
|
||
// Drive the real row control and read durable state after the user action.
|
||
await page.waitForSelector(
|
||
'[data-layer-id="traffic"] [data-chip-id="roads-osm"]',
|
||
);
|
||
await page.click('[data-layer-id="traffic"] [data-chip-id="roads-osm"]');
|
||
await page.waitForFunction(
|
||
() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('traffic')
|
||
.module.getParams().roadMode === 'osm',
|
||
);
|
||
await page.waitForFunction(
|
||
() =>
|
||
JSON.parse(localStorage.getItem('gev:layer-state:v2'))?.o?.traffic
|
||
?.roadMode === 'osm',
|
||
);
|
||
result.rowControl = { clicked: 'osm', persisted: true };
|
||
await waitForSources();
|
||
console.table(
|
||
result.compare.map(
|
||
({
|
||
view,
|
||
mode,
|
||
order,
|
||
firstDotMs,
|
||
dotsInView,
|
||
onSurface,
|
||
floaters,
|
||
sinkers,
|
||
unsampled,
|
||
}) => ({
|
||
view,
|
||
mode,
|
||
order,
|
||
firstDotMs,
|
||
dotsInView,
|
||
onSurface,
|
||
floaters,
|
||
sinkers,
|
||
unsampled,
|
||
}),
|
||
),
|
||
);
|
||
} else if (coverage) {
|
||
// The shared London presentation gate below is also independently runnable.
|
||
} else if (profile) {
|
||
await fly(30.2672, -97.7431, 450, 0, -35);
|
||
await settleTiles();
|
||
for (const name of ['cold', 'warm']) {
|
||
beginView(name);
|
||
await page.evaluate(() => {
|
||
performance.clearMeasures();
|
||
window.__godsEyeView.dataManager.setEnabled('traffic', false);
|
||
});
|
||
await enableTrafficTimed(name);
|
||
await waitForSources();
|
||
result[name] = await page.evaluate(() =>
|
||
performance
|
||
.getEntriesByType('measure')
|
||
.filter((e) => e.name.startsWith('roads:'))
|
||
.map((e) => ({
|
||
name: e.name,
|
||
ms: e.duration,
|
||
at: e.startTime,
|
||
detail: e.detail,
|
||
})),
|
||
);
|
||
console.log(name, JSON.stringify(result[name]));
|
||
}
|
||
} else if (pan) {
|
||
const sessionBudget = 32; // <= 0.54% of the default 6,000/day upstream budget.
|
||
await page.evaluate(() => {
|
||
window.__godsEyeView.viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
|
||
});
|
||
beginView('pan-start');
|
||
await fly(30.2672, -97.7431, 450, 0, -35);
|
||
await enableTrafficTimed('pan-start');
|
||
assert.ok(
|
||
result.loadTimes['pan-start'] <= 4000,
|
||
`Austin cold first dots <= 4 s (${result.loadTimes['pan-start']} ms)`,
|
||
);
|
||
await waitForSources();
|
||
const positions = [[0, 0]];
|
||
// Metres east/north: 10 small steps, 5 larger steps, then 5 exact returns.
|
||
const offsets = [
|
||
[200, 0],
|
||
[400, 0],
|
||
[400, 200],
|
||
[200, 200],
|
||
[0, 200],
|
||
[-200, 200],
|
||
[-200, 0],
|
||
[-200, -200],
|
||
[0, -200],
|
||
[200, -200],
|
||
[1700, -200],
|
||
[1700, 1300],
|
||
[200, 1300],
|
||
[-1300, 1300],
|
||
[-1300, -200],
|
||
];
|
||
const moves = offsets.map((p, i) => ({
|
||
p,
|
||
kind: i < 10 ? 'small' : 'large',
|
||
}));
|
||
for (const index of [0, 3, 8, 11, 15])
|
||
moves.push({
|
||
p: index === 0 ? [0, 0] : offsets[index - 1],
|
||
kind: 'return',
|
||
});
|
||
for (const [i, move] of moves.entries()) {
|
||
const [east, north] = move.p;
|
||
const lat = 30.2672 + north / 111320;
|
||
const lon =
|
||
-97.7431 + east / (111320 * Math.cos((30.2672 * Math.PI) / 180));
|
||
const view = beginView(`pan-${i + 1}-${move.kind}`, {
|
||
lat,
|
||
lon,
|
||
height: 450,
|
||
pitch: -35,
|
||
});
|
||
const before = new Set(
|
||
requests.filter((r) => r.category === 'ofmTiles').map((r) => r.target),
|
||
);
|
||
await fly(lat, lon, 450, 0, -35);
|
||
await settleTiles();
|
||
view.layers = await waitForSources();
|
||
const state = view.layers.find((r) => r.id === 'traffic');
|
||
const batch = requests.filter((r) => r.view === view.name);
|
||
const roadRequests = batch.filter((r) => r.category === 'ofmTiles');
|
||
if (move.kind === 'return')
|
||
assert.equal(
|
||
roadRequests.length,
|
||
0,
|
||
`${view.name}: cached return makes no OFM requests`,
|
||
);
|
||
for (const request of roadRequests)
|
||
assert.ok(
|
||
!before.has(request.target),
|
||
`${view.name}: no duplicate XYZ`,
|
||
);
|
||
if (move.kind === 'small' && roadRequests.length) {
|
||
const bounds = state.roadBounds;
|
||
assert.ok(bounds, 'admitted road bounds exposed');
|
||
const allowed = new Set(
|
||
[
|
||
...tilesForBounds(bounds, 12),
|
||
...tilesForBounds(trafficDetailBounds(bounds), 14),
|
||
].map((t) => `${t.z}/${t.x}/${t.y}.pbf`),
|
||
);
|
||
for (const request of roadRequests)
|
||
assert.ok(
|
||
[...allowed].some((x) => request.target.endsWith('/' + x)),
|
||
`${view.name}: newly exposed tile belongs to admitted viewport`,
|
||
);
|
||
}
|
||
assert.ok(
|
||
state.count > 0 && !state.error,
|
||
`${view.name}: healthy traffic`,
|
||
);
|
||
view.pan = {
|
||
move: i + 1,
|
||
kind: move.kind,
|
||
ofmRequests: roadRequests.length,
|
||
ofmBytes: roadRequests.reduce((n, r) => n + r.responseBytes, 0),
|
||
flowRequests: batch.filter((r) => r.flowTile).length,
|
||
apiCalls: batch.filter((r) => ['api', 'tomtom'].includes(r.category))
|
||
.length,
|
||
dots: state.count,
|
||
};
|
||
positions.push(move.p);
|
||
console.log(JSON.stringify(view.pan));
|
||
}
|
||
const ofm = requests.filter((r) => r.category === 'ofmTiles');
|
||
assert.equal(
|
||
new Set(ofm.map((r) => r.target)).size,
|
||
ofm.length,
|
||
'no identical OpenFreeMap XYZ requested twice in session',
|
||
);
|
||
const flow = requests.filter((r) => r.flowTile).length;
|
||
assert.ok(
|
||
flow <= sessionBudget,
|
||
`TomTom ${flow} requests <= ${sessionBudget} session budget`,
|
||
);
|
||
result.pan = {
|
||
sessionBudget,
|
||
defaultDailyBudget: 6000,
|
||
flowRequests: flow,
|
||
table: views.filter((v) => v.pan).map((v) => v.pan),
|
||
};
|
||
console.table(result.pan.table);
|
||
} else if (tour) {
|
||
// A continent jump can temporarily use the previous city's terrain height
|
||
// for collision avoidance (São Paulo -> Austin raises a 450 m target).
|
||
// Pin the prescribed camera fixtures so the revisit covers identical tiles.
|
||
await page.evaluate(() => {
|
||
window.__godsEyeView.viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
|
||
});
|
||
for (const city of [
|
||
['austin', 30.2672, -97.7431],
|
||
['london', 51.5074, -0.1278],
|
||
['dubai', 25.2048, 55.2708],
|
||
['san-diego', 32.7157, -117.1611],
|
||
['tokyo', 35.6762, 139.6503],
|
||
['sao-paulo', -23.5505, -46.6333, 1250],
|
||
])
|
||
await tourCity(...city);
|
||
await tourCity('austin-revisit', 30.2672, -97.7431);
|
||
} else {
|
||
beginView('austin', {
|
||
lat: 30.2672,
|
||
lon: -97.7431,
|
||
height: 2000,
|
||
heading: 0,
|
||
pitch: -75,
|
||
});
|
||
console.log('Checking Austin traffic and ALPR...');
|
||
await fly(30.2672, -97.7431);
|
||
await enableTrafficTimed('initialFirstDotsMs');
|
||
for (const id of ['military-installations', 'alpr-cameras']) {
|
||
console.log(`Enabling ${id}...`);
|
||
await page.evaluate(
|
||
(layerId) =>
|
||
Promise.race([
|
||
window.__godsEyeView.dataManager.setEnabled(layerId, true),
|
||
new Promise((_, reject) =>
|
||
setTimeout(
|
||
() => reject(new Error('Layer enable timed out')),
|
||
30_000,
|
||
),
|
||
),
|
||
]),
|
||
id,
|
||
);
|
||
}
|
||
await page.waitForFunction(
|
||
() => {
|
||
const layers = window.__godsEyeView.dataManager.layers;
|
||
return ['traffic', 'alpr-cameras'].every((id) => {
|
||
const s = layers.get(id).module.getStats();
|
||
return s.count > 0 && !s.loading && !s.error;
|
||
});
|
||
},
|
||
{ timeout: 120_000, polling: 500 },
|
||
);
|
||
const austin = await page.evaluate(() => {
|
||
const { viewer, dataManager } = window.__godsEyeView;
|
||
const traffic = dataManager.layers.get('traffic').module.getStats();
|
||
const alpr = dataManager.layers.get('alpr-cameras').module.getStats();
|
||
let cameraEntities = 0;
|
||
for (let i = 0; i < viewer.dataSources.length; i++)
|
||
for (const entity of viewer.dataSources.get(i).entities.values) {
|
||
if (
|
||
String(entity.id).startsWith('alpr:') &&
|
||
entity.billboard &&
|
||
entity.show
|
||
)
|
||
cameraEntities++;
|
||
}
|
||
return {
|
||
traffic,
|
||
alpr,
|
||
cameraEntities,
|
||
sourceLabel: traffic.loadingLabel,
|
||
cameraHeight: viewer.camera.positionCartographic.height,
|
||
};
|
||
});
|
||
result.traffic = austin.traffic;
|
||
result.loadTimes[
|
||
`${austin.traffic.mode === 'live' ? 'keyed' : 'keyless'}FirstDotsMs`
|
||
] = result.loadTimes.initialFirstDotsMs;
|
||
result.alpr = austin.alpr;
|
||
result.sourceLabel = austin.sourceLabel;
|
||
result.cameraHeight = austin.cameraHeight;
|
||
assert.ok(
|
||
austin.cameraHeight > 1500 && austin.cameraHeight < 2500,
|
||
'Austin assertions run at approximately 2 km',
|
||
);
|
||
assert.ok(austin.traffic.count > 0, 'road dots rendered');
|
||
assert.ok(austin.cameraEntities > 0, 'ALPR camera entities rendered');
|
||
assert.equal(
|
||
austin.traffic.roadSource,
|
||
austin.traffic.mode === 'live'
|
||
? 'TomTom + OpenStreetMap'
|
||
: 'OpenStreetMap',
|
||
);
|
||
assert.match(austin.sourceLabel, /Roads: (TomTom \+ )?OpenStreetMap/);
|
||
await shot('austin');
|
||
async function checkStreetSurface(name) {
|
||
await waitForSources();
|
||
beginView(name, {
|
||
lat: 30.2672,
|
||
lon: -97.7431,
|
||
height: 450,
|
||
heading: 0,
|
||
pitch: -35,
|
||
});
|
||
await page.evaluate(async () =>
|
||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||
);
|
||
await fly(30.2672, -97.7431, 450, 0, -35);
|
||
await settleTiles();
|
||
await enableTrafficTimed(`${name}WarmFirstDotsMs`);
|
||
await page.waitForFunction(
|
||
() => {
|
||
const s = window.__godsEyeView.dataManager.layers
|
||
.get('traffic')
|
||
.module.getStats();
|
||
return s.count > 0 && !s.loading && !s.error;
|
||
},
|
||
{ timeout: 180_000, polling: 500 },
|
||
);
|
||
await settleTiles();
|
||
const measured = await measureSurface();
|
||
result[name] = measured;
|
||
assert.equal(
|
||
measured.stats.roadSource,
|
||
measured.stats.mode === 'live'
|
||
? 'TomTom + OpenStreetMap'
|
||
: 'OpenStreetMap',
|
||
);
|
||
if (measured.stats.mode === 'live') {
|
||
assert.ok(
|
||
measured.stats.flowCoveragePct > 0,
|
||
'Austin has matched TomTom flow',
|
||
);
|
||
assert.match(
|
||
measured.stats.loadingLabel,
|
||
/LIVE · Roads: TomTom \+ OpenStreetMap · Flow/,
|
||
);
|
||
} else {
|
||
assert.equal(measured.stats.flowCoveragePct, 0);
|
||
assert.match(measured.stats.loadingLabel, /SIMULATED/);
|
||
}
|
||
const { free, slow, jam, sim } = measured.stats.flowBuckets;
|
||
assert.equal(
|
||
measured.stats.flowCoveragePct,
|
||
Math.round((100 * (free + slow + jam)) / (free + slow + jam + sim)),
|
||
);
|
||
|
||
console.log(
|
||
`${name}: ${measured.onMesh}/${measured.inView} projected dots on the surface; ${measured.stats.flowCoveragePct}% flow coverage`,
|
||
);
|
||
await shot(name);
|
||
await waitForSources();
|
||
// Preserve the earlier 350 m acceptance fixture and the 450 m view.
|
||
beginView(`${name}-350m`, {
|
||
lat: 30.2685,
|
||
lon: -97.7425,
|
||
height: 350,
|
||
heading: 10,
|
||
pitch: -30,
|
||
});
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||
);
|
||
await fly(30.2685, -97.7425, 350, 10, -30);
|
||
await settleTiles();
|
||
await enableTrafficTimed(`${name}-350m`);
|
||
await waitForSources();
|
||
const closeSurface = await measureSurface();
|
||
result[`${name}-350m`] = closeSurface;
|
||
assert.ok(
|
||
closeSurface.onMesh >= 150,
|
||
`${name}: preserved 350 m on-mesh gate (${closeSurface.onMesh})`,
|
||
);
|
||
await shot(`${name}-350m`);
|
||
beginView(`${name}-orbit`, {
|
||
lat: 30.2685,
|
||
lon: -97.7425,
|
||
height: 350,
|
||
heading: 65,
|
||
pitch: -40,
|
||
});
|
||
await fly(30.2685, -97.7425, 350, 65, -40);
|
||
await settleTiles();
|
||
await page.waitForFunction(
|
||
() => {
|
||
const s = window.__godsEyeView.dataManager.layers
|
||
.get('traffic')
|
||
.module.getStats();
|
||
return s.count > 0 && !s.loading && !s.error;
|
||
},
|
||
{ timeout: 180_000, polling: 500 },
|
||
);
|
||
await shot(`${name}-orbit`);
|
||
assert.ok(
|
||
measured.onMesh >= 150,
|
||
`${name}: at least 150 projected dots within -3/+25 m of the surface (got ${measured.onMesh})`,
|
||
);
|
||
}
|
||
console.log(
|
||
'Checking street-level traffic against the rendered surface...',
|
||
);
|
||
await checkStreetSurface('traffic-street');
|
||
if (result.traffic.mode === 'live') {
|
||
// A second isolated page models Google configured / TomTom absent. Geometry and mesh are real responses.
|
||
await waitForSources();
|
||
const keyedPage = page;
|
||
beginView('keyless-startup');
|
||
page = await browser.newPage();
|
||
await page.setViewport({ width: 1440, height: 1000 });
|
||
await page.evaluateOnNewDocument(() => {
|
||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed');
|
||
const original = window.fetch;
|
||
window.fetch = (input, init) =>
|
||
new URL(typeof input === 'string' ? input : input.url, location.href)
|
||
.pathname === '/api/tomtom/status'
|
||
? Promise.resolve(
|
||
new Response(JSON.stringify({ hasKey: false }), {
|
||
headers: { 'content-type': 'application/json' },
|
||
}),
|
||
)
|
||
: original(input, init);
|
||
});
|
||
page.on('pageerror', (error) => result.errors.push(error.message));
|
||
await observeNetwork(page);
|
||
const fallbackUrl = new URL(navigationUrl);
|
||
fallbackUrl.searchParams.set('trafficRoads', 'tomtom');
|
||
await page.goto(fallbackUrl.href, {
|
||
waitUntil: 'domcontentloaded',
|
||
timeout: 60_000,
|
||
});
|
||
await page.waitForFunction(
|
||
() =>
|
||
window.__godsEyeView?.dataManager &&
|
||
document
|
||
.getElementById('loading-screen')
|
||
?.classList.contains('hidden'),
|
||
{ timeout: 90_000 },
|
||
);
|
||
await page.evaluate(
|
||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||
);
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.styleManager.setDetection({ enabled: false }),
|
||
);
|
||
beginView('austin-keyless', {
|
||
lat: 30.2672,
|
||
lon: -97.7431,
|
||
height: 2000,
|
||
heading: 0,
|
||
pitch: -75,
|
||
});
|
||
console.log('Checking OpenFreeMap roads without TomTom flow...');
|
||
await fly(30.2672, -97.7431);
|
||
await enableTrafficTimed('keylessFirstDotsMs');
|
||
await checkStreetSurface('traffic-street-ofm');
|
||
assert.equal(
|
||
result['traffic-street-ofm'].stats.roadSource,
|
||
'OpenStreetMap',
|
||
);
|
||
assert.match(
|
||
result['traffic-street-ofm'].stats.loadingLabel,
|
||
/TomTom roads need a TomTom key/,
|
||
);
|
||
await waitForSources();
|
||
await page.close();
|
||
page = keyedPage;
|
||
}
|
||
await waitForSources();
|
||
beginView('camp-mabry', {
|
||
lat: 30.3125,
|
||
lon: -97.765,
|
||
height: 3500,
|
||
heading: 25,
|
||
pitch: -80,
|
||
});
|
||
console.log('Checking Camp Mabry...');
|
||
const before = await page.evaluate(
|
||
() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('military-installations')
|
||
.module.getStats().lastUpdate,
|
||
);
|
||
await fly(30.3125, -97.765, 3500, 25, -80);
|
||
await page.waitForFunction(
|
||
(prior) => {
|
||
const s = window.__godsEyeView.dataManager.layers
|
||
.get('military-installations')
|
||
.module.getStats();
|
||
return s.count > 0 && !s.loading && !s.error && s.lastUpdate !== prior;
|
||
},
|
||
{ timeout: 120_000, polling: 500 },
|
||
before,
|
||
);
|
||
result.military = await page.evaluate(() => {
|
||
const { viewer, dataManager } = window.__godsEyeView;
|
||
const center = viewer.scene.globe.ellipsoid.cartographicToCartesian({
|
||
latitude: (30.314 * Math.PI) / 180,
|
||
longitude: (-97.763 * Math.PI) / 180,
|
||
height: 0,
|
||
});
|
||
const records = dataManager.layers
|
||
.get('military-installations')
|
||
.module.getNearby(center, 4000);
|
||
const ids = new Set(records.map((r) => r.id));
|
||
let markers = 0,
|
||
outlines = 0;
|
||
for (let i = 0; i < viewer.dataSources.length; i++)
|
||
for (const entity of viewer.dataSources.get(i).entities.values) {
|
||
if (!ids.has(entity.installationId || entity.id) || !entity.show)
|
||
continue;
|
||
if (entity.billboard || entity.point) markers++;
|
||
if (entity.polyline) outlines++;
|
||
}
|
||
return {
|
||
markers,
|
||
outlines,
|
||
names: records.map((r) => r.name),
|
||
stats: dataManager.layers
|
||
.get('military-installations')
|
||
.module.getStats(),
|
||
};
|
||
});
|
||
assert.ok(result.military.markers > 0, 'military markers near Camp Mabry');
|
||
assert.ok(
|
||
result.military.outlines > 0,
|
||
'military polygon outlines near Camp Mabry',
|
||
);
|
||
await shot('camp-mabry');
|
||
await waitForSources();
|
||
beginView('camp-mabry-close', {
|
||
lat: 30.314,
|
||
lon: -97.763,
|
||
height: 650,
|
||
heading: 125,
|
||
pitch: -45,
|
||
});
|
||
await fly(30.314, -97.763, 650, 125, -45);
|
||
await shot('camp-mabry-close');
|
||
await waitForSources();
|
||
beginView('fort-cavazos', {
|
||
lat: 31.135,
|
||
lon: -97.78,
|
||
height: 30000,
|
||
heading: 0,
|
||
pitch: -90,
|
||
});
|
||
console.log('Checking Fort Cavazos...');
|
||
const priorFort = await page.evaluate(
|
||
() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('military-installations')
|
||
.module.getStats().lastUpdate,
|
||
);
|
||
await fly(31.135, -97.78, 30000, 0, -90);
|
||
await settleTiles();
|
||
await page.waitForFunction(
|
||
(prior) => {
|
||
const s = window.__godsEyeView.dataManager.layers
|
||
.get('military-installations')
|
||
.module.getStats();
|
||
return !s.loading && !s.error && s.count > 0 && s.lastUpdate !== prior;
|
||
},
|
||
{ timeout: 120_000, polling: 500 },
|
||
priorFort,
|
||
);
|
||
result.fortCavazos = await page.evaluate(() => {
|
||
const { viewer, dataManager } = window.__godsEyeView;
|
||
let markers = 0,
|
||
outlines = 0;
|
||
for (let i = 0; i < viewer.dataSources.length; i++)
|
||
for (const e of viewer.dataSources.get(i).entities.values) {
|
||
if (
|
||
!e.show ||
|
||
!/^(ofm:installation:|osm:military:)/.test(String(e.id))
|
||
)
|
||
continue;
|
||
if (
|
||
(e.point &&
|
||
e.point.show?.getValue(viewer.clock.currentTime) !== false) ||
|
||
e.billboard
|
||
)
|
||
markers++;
|
||
if (e.polyline) outlines++;
|
||
}
|
||
const stats = dataManager.layers
|
||
.get('military-installations')
|
||
.module.getStats();
|
||
return {
|
||
markers: markers + (stats.namedMarkers || 0),
|
||
outlines,
|
||
stats,
|
||
};
|
||
});
|
||
await shot('fort-cavazos');
|
||
assert.ok(
|
||
result.fortCavazos.markers > 0 && result.fortCavazos.markers <= 12,
|
||
`Fort Cavazos has 1–12 installation markers (got ${result.fortCavazos.markers})`,
|
||
);
|
||
await waitForSources();
|
||
beginView('austin-revisit', {
|
||
lat: 30.2672,
|
||
lon: -97.7431,
|
||
height: 2000,
|
||
heading: 0,
|
||
pitch: -75,
|
||
});
|
||
await fly(30.2672, -97.7431);
|
||
await waitForSources();
|
||
await shot('austin-revisit');
|
||
await waitForSources();
|
||
}
|
||
if (!pan && !profile && !compare && !tour && !coverage) {
|
||
// Area annotation outlines: without a configured Overpass instance the
|
||
// app learns that once and never sends the query (so no 503 is logged);
|
||
// the pin stays and bundled outlines still resolve.
|
||
beginView('annotation-area');
|
||
await page.evaluate(() =>
|
||
['traffic', 'military-installations', 'alpr-cameras'].forEach((id) =>
|
||
window.__godsEyeView.dataManager.setEnabled(id, false),
|
||
),
|
||
);
|
||
await fly(37.7989, -122.4662, 4000, 0, -45);
|
||
const errorsBefore = result.consoleErrors.length;
|
||
const postsBefore = result.overpassRequests.filter((r) =>
|
||
r.startsWith('POST'),
|
||
).length;
|
||
result.annotation = await page.evaluate(async () => {
|
||
const configured = await fetch('/api/overpass/status')
|
||
.then((response) => response.json())
|
||
.then((body) => body.configured);
|
||
const annotation = await window.__godsEyeView.annotations.annotate([
|
||
{ type: 'area', target: 'Presidio of San Francisco', footprint: true },
|
||
]);
|
||
return { configured, drawn: annotation.drawn };
|
||
});
|
||
// Let any deferred outline upgrade settle before counting.
|
||
await new Promise((resolve) => setTimeout(resolve, 8000));
|
||
result.annotation.consoleErrors = result.consoleErrors.slice(errorsBefore);
|
||
result.annotation.overpassPosts =
|
||
result.overpassRequests.filter((r) => r.startsWith('POST')).length -
|
||
postsBefore;
|
||
console.log('Area annotation:', result.annotation);
|
||
assert.ok(result.annotation.drawn >= 1, 'area annotation drawn');
|
||
assert.deepEqual(
|
||
result.annotation.consoleErrors,
|
||
[],
|
||
'area annotation logs no console errors',
|
||
);
|
||
if (result.annotation.configured === false)
|
||
assert.equal(
|
||
result.annotation.overpassPosts,
|
||
0,
|
||
'unconfigured Overpass is never queried',
|
||
);
|
||
await shot('annotation-area');
|
||
await page.evaluate(() => window.__godsEyeView.annotations.clear?.());
|
||
}
|
||
if (!pan && !profile && !compare) {
|
||
beginView('alpr-london');
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||
);
|
||
await fly(51.5074, -0.1278, 450, 0, -35);
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.setEnabled('alpr-cameras', true),
|
||
);
|
||
await waitForSources();
|
||
result.alprLondon = await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('alpr-cameras')
|
||
.module.getStats(),
|
||
);
|
||
assert.equal(result.alprLondon.noCoverage, true);
|
||
assert.equal(result.alprLondon.countLabel, '');
|
||
assert.equal(
|
||
result.alprLondon.loadingLabel,
|
||
'No ALPR data for this area — US and Canada only',
|
||
);
|
||
await page.evaluate(() => {
|
||
if (document.querySelector('#data-panel.collapsed'))
|
||
document.querySelector('[data-collapse-target="data-panel"]').click();
|
||
document
|
||
.querySelector('[data-layer-id="alpr-cameras"]')
|
||
.scrollIntoView({ block: 'center' });
|
||
});
|
||
await page.waitForFunction(
|
||
() =>
|
||
document
|
||
.querySelector('[data-layer-id="alpr-cameras"] .data-toggle-meta')
|
||
?.textContent.includes('US and Canada only'),
|
||
{ timeout: 10000 },
|
||
);
|
||
const row = await page.$('[data-layer-id="alpr-cameras"]');
|
||
assert.doesNotMatch(
|
||
await row.evaluate((node) => node.innerText),
|
||
/0 nearby/,
|
||
);
|
||
await shot('alpr-london');
|
||
}
|
||
assert.deepEqual(result.consoleErrors, [], 'zero unexpected console errors');
|
||
assert.deepEqual(
|
||
result.forbiddenRequests,
|
||
[],
|
||
'zero Overpass/Nominatim browser requests',
|
||
);
|
||
assert.deepEqual(result.errors, [], 'no browser JavaScript errors');
|
||
result.passed = true;
|
||
console.log(`${result.mode} checks passed`);
|
||
} catch (error) {
|
||
result.passed = false;
|
||
result.failure = error.message;
|
||
if (page) {
|
||
await page
|
||
.screenshot({ path: path.join(shots, 'overpass-offload-failure.png') })
|
||
.catch(() => {});
|
||
result.diagnostic = await page
|
||
.evaluate(() => ({
|
||
text: document.body.innerText.slice(0, 3000),
|
||
layers: [...(window.__godsEyeView?.dataManager?.layers || [])]
|
||
.filter(([id]) =>
|
||
['traffic', 'military-installations', 'alpr-cameras'].includes(id),
|
||
)
|
||
.map(([id, entry]) => [id, entry.module.getStats()]),
|
||
}))
|
||
.catch(() => null);
|
||
}
|
||
console.error(error);
|
||
process.exitCode = 1;
|
||
} finally {
|
||
result.footprint = footprintSummary();
|
||
await fs.writeFile(
|
||
path.join(shots, `overpass-offload-${result.mode}-result.json`),
|
||
JSON.stringify(result, null, 2),
|
||
);
|
||
await fs.writeFile(
|
||
path.join(shots, 'overpass-offload-result.json'),
|
||
JSON.stringify(result, null, 2),
|
||
);
|
||
await browser.close();
|
||
}
|