mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
use bundled place boundaries and shared OpenFreeMap tiles before a guarded Nominatim fallback preserve multipart shapes, holes and cancellation, and keep pending annotations visible while ground sampling finishes across frames keep non-Latin name distinctions when selecting provider results, and retain an outline anchor only when it lies in filled geometry
198 lines
6.2 KiB
JavaScript
198 lines
6.2 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import path from 'node:path';
|
|
import { cctvProxy } from '../../server/providers/cctv.js';
|
|
import { radioBrowserProxy } from '../../server/providers/radio.js';
|
|
import { localProviderPlugins } from '../../server/providers/local.js';
|
|
import { makeFixtureRoot } from './fixtureRoot.mjs';
|
|
|
|
const nominatimStorageDir = await makeFixtureRoot('gev-media-composition-');
|
|
test.after(() => rmSync(nominatimStorageDir, { recursive: true, force: true }));
|
|
|
|
function install(plugin, hook = 'configureServer') {
|
|
let handler;
|
|
plugin[hook]({
|
|
middlewares: {
|
|
use(_route, fn) {
|
|
handler = fn;
|
|
},
|
|
},
|
|
});
|
|
return async (url) => {
|
|
const res = {
|
|
writeHead(status, headers) {
|
|
Object.assign(this, { status, headers });
|
|
},
|
|
end(body) {
|
|
this.body = body;
|
|
},
|
|
};
|
|
await handler({ url, method: 'GET' }, res);
|
|
return res;
|
|
};
|
|
}
|
|
|
|
function fixture(t, id) {
|
|
const root = mkdtempSync(path.join(tmpdir(), 'gev-cctv-'));
|
|
t.after(() => rmSync(root, { recursive: true, force: true }));
|
|
mkdirSync(path.join(root, 'config'));
|
|
writeFileSync(
|
|
path.join(root, 'config/cctv_sources.austin.json'),
|
|
JSON.stringify([
|
|
{
|
|
id,
|
|
name: '<Camera & test>',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'video',
|
|
},
|
|
]),
|
|
);
|
|
return root;
|
|
}
|
|
|
|
function isolate(t) {
|
|
for (const name of [
|
|
'CCTV_SOURCES_FILE',
|
|
'CCTV_SOURCES_JSON',
|
|
'CCTV_FORCE_AUSTIN',
|
|
'GOOGLE_MAPS_SERVER_API_KEY',
|
|
'GOOGLE_MAPS_API_KEY',
|
|
]) {
|
|
const previous = process.env[name];
|
|
delete process.env[name];
|
|
t.after(() => {
|
|
if (previous === undefined) delete process.env[name];
|
|
else process.env[name] = previous;
|
|
});
|
|
}
|
|
t.mock.method(globalThis, 'fetch', () => {
|
|
throw Error('fixture must not fetch');
|
|
});
|
|
}
|
|
|
|
test('CCTV instances resolve their own application source root and isolate catalogs and health', async (t) => {
|
|
isolate(t);
|
|
const first = install(cctvProxy({ sourceRoot: fixture(t, 'first') }));
|
|
const second = install(cctvProxy({ sourceRoot: fixture(t, 'second') }));
|
|
const [a, b] = await Promise.all([first('/sources'), second('/sources')]);
|
|
assert.equal(a.status, 200);
|
|
assert.equal(b.status, 200);
|
|
assert.deepEqual(
|
|
JSON.parse(a.body).sources.map((s) => s.id),
|
|
['first'],
|
|
);
|
|
assert.deepEqual(
|
|
JSON.parse(b.body).sources.map((s) => s.id),
|
|
['second'],
|
|
);
|
|
const stream = JSON.parse((await first('/stream/first')).body);
|
|
assert.equal(stream.feedType, 'mp4');
|
|
assert.equal(stream.mediaUrl, '/api/cctv/media/first');
|
|
assert.equal((await first('/media/first')).status, 404);
|
|
const frame = await first('/frame/first');
|
|
assert.equal(frame.headers['X-CCTV-Source'], 'synthetic');
|
|
assert.match(frame.body, /<Camera & test>/);
|
|
assert.equal(JSON.parse((await first('/health')).body).cameras.length, 1);
|
|
assert.deepEqual(JSON.parse((await second('/health')).body).cameras, []);
|
|
});
|
|
|
|
test('composition creates exactly one CCTV and radio provider without acquisition', (t) => {
|
|
isolate(t);
|
|
const plugins = localProviderPlugins({ nominatimStorageDir });
|
|
for (const factory of [cctvProxy, radioBrowserProxy]) {
|
|
assert.equal(plugins.filter((p) => p.name === factory().name).length, 1);
|
|
}
|
|
});
|
|
|
|
for (const hook of ['configureServer', 'configurePreviewServer']) {
|
|
test(`CCTV ${hook} maps header timeouts and cancels upstream error bodies`, async (t) => {
|
|
isolate(t);
|
|
process.env.CCTV_SOURCES_JSON = JSON.stringify([
|
|
{
|
|
id: 'bounded',
|
|
name: 'Test',
|
|
lat: 30,
|
|
lon: -97,
|
|
feedType: 'video',
|
|
url: 'https://camera.example.org/live.mp4',
|
|
},
|
|
]);
|
|
const request = install(
|
|
cctvProxy({ sourceRoot: fixture(t, 'unused') }),
|
|
hook,
|
|
);
|
|
// Resolve the catalog before substituting transport behavior.
|
|
await request('/sources');
|
|
t.mock.method(globalThis, 'fetch', async () => {
|
|
throw new DOMException('timeout', 'AbortError');
|
|
});
|
|
const timeout = await request('/media/bounded');
|
|
assert.equal(timeout.status, 504);
|
|
assert.deepEqual(JSON.parse(timeout.body), {
|
|
error: 'Upstream media timeout',
|
|
});
|
|
let cancelled = false;
|
|
t.mock.method(
|
|
globalThis,
|
|
'fetch',
|
|
async () =>
|
|
new Response(
|
|
new ReadableStream({
|
|
cancel() {
|
|
cancelled = true;
|
|
},
|
|
}),
|
|
{ status: 503 },
|
|
),
|
|
);
|
|
const error = await request('/media/bounded');
|
|
assert.equal(error.status, 503);
|
|
assert.equal(cancelled, true);
|
|
});
|
|
}
|
|
|
|
test('a failed CCTV media fetch reports a fixed health message, not the error text', async (t) => {
|
|
isolate(t);
|
|
const root = mkdtempSync(path.join(tmpdir(), 'gev-cctv-'));
|
|
t.after(() => rmSync(root, { recursive: true, force: true }));
|
|
mkdirSync(path.join(root, 'config'));
|
|
writeFileSync(
|
|
path.join(root, 'config/cctv_sources.austin.json'),
|
|
JSON.stringify([
|
|
{
|
|
id: 'leaky',
|
|
name: 'Leaky camera',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'video',
|
|
url: 'https://cams.fixture.invalid/leaky.m3u8',
|
|
},
|
|
]),
|
|
);
|
|
const leak =
|
|
'connect ETIMEDOUT 203.0.113.9:443 C:\fixture\secret-path\cams.json';
|
|
t.mock.restoreAll();
|
|
t.mock.method(globalThis, 'fetch', () => {
|
|
throw Error(leak);
|
|
});
|
|
|
|
const call = install(cctvProxy({ sourceRoot: root }));
|
|
const media = await call('/media/leaky');
|
|
assert.equal(media.status, 502);
|
|
assert.equal(media.body.includes('203.0.113.9'), false);
|
|
|
|
// GET /health is the second door: src/layers/cctv/frames.js renders each
|
|
// entry's `message` as the camera's status label, so a raw errno stored here
|
|
// reaches the screen even though the response above is sanitized.
|
|
const camera = JSON.parse((await call('/health')).body).cameras.find(
|
|
(entry) => entry.id === 'leaky',
|
|
);
|
|
assert.equal(camera.status, 'degraded');
|
|
assert.equal(camera.message, 'Media fetch failed');
|
|
assert.equal(camera.message.includes('ETIMEDOUT'), false);
|
|
assert.equal(camera.message.includes('secret-path'), false);
|
|
});
|