mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
200 lines
6.1 KiB
JavaScript
200 lines
6.1 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createCctvSource, createCctvLayer } from './index.js';
|
|
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
|
|
|
|
const camera = {
|
|
id: 'pack/camera ?x',
|
|
name: 'Camera & road',
|
|
city: 'Austin',
|
|
lat: 30.267,
|
|
lon: -97.744,
|
|
headingDeg: 45,
|
|
fovDeg: 60,
|
|
pitchDeg: -12,
|
|
};
|
|
|
|
test('camera catalog and health use fixed source routes and caller cancellation', async () => {
|
|
const calls = [];
|
|
const source = createCctvSource({
|
|
fetchImpl: async (path, options) => {
|
|
calls.push({ path, options });
|
|
return new Response(
|
|
JSON.stringify(
|
|
path.endsWith('/sources') ? { sources: [] } : { cameras: [] },
|
|
),
|
|
);
|
|
},
|
|
});
|
|
const controller = new AbortController();
|
|
await source.getCatalog({ signal: controller.signal });
|
|
await source.getHealth({ signal: controller.signal });
|
|
assert.deepEqual(
|
|
calls.map((call) => call.path),
|
|
['/api/cctv/sources', '/api/cctv/health'],
|
|
);
|
|
for (const { options } of calls) {
|
|
assert.equal(options.signal, controller.signal);
|
|
assert.equal(options.cache, 'no-store');
|
|
}
|
|
});
|
|
|
|
test('camera sources reject malformed snapshots and failures', async () => {
|
|
for (const method of ['getCatalog', 'getHealth']) {
|
|
const malformed = createCctvSource({
|
|
fetchImpl: async () => new Response('{}'),
|
|
});
|
|
await assert.rejects(malformed[method](), /Malformed camera/);
|
|
const denied = createCctvSource({
|
|
fetchImpl: async () => new Response('', { status: 403 }),
|
|
});
|
|
await assert.rejects(denied[method](), /HTTP 403/);
|
|
}
|
|
});
|
|
|
|
test('cancellation while reading a camera response body prevents publication', async () => {
|
|
const controller = new AbortController();
|
|
const source = createCctvSource({
|
|
fetchImpl: async () => ({
|
|
ok: true,
|
|
json: async () => {
|
|
controller.abort();
|
|
return { sources: [] };
|
|
},
|
|
}),
|
|
});
|
|
await assert.rejects(source.getCatalog({ signal: controller.signal }), {
|
|
name: 'AbortError',
|
|
});
|
|
});
|
|
|
|
test('frame and media URLs preserve registered camera identity and encoded metadata', () => {
|
|
const source = createCctvSource();
|
|
const frame = new URL(source.getFrameUrl(camera), 'https://example.test');
|
|
const media = new URL(source.getMediaUrl(camera), 'https://example.test');
|
|
assert.equal(
|
|
frame.pathname,
|
|
'/api/cctv/frame/' + encodeURIComponent(camera.id),
|
|
);
|
|
assert.equal(
|
|
media.pathname,
|
|
'/api/cctv/media/' + encodeURIComponent(camera.id),
|
|
);
|
|
assert.equal(frame.searchParams.get('label'), camera.name);
|
|
assert.equal(frame.searchParams.get('city'), camera.city);
|
|
assert.equal(frame.searchParams.has('lat'), false);
|
|
assert.equal(frame.searchParams.has('lon'), false);
|
|
assert.equal(frame.searchParams.get('heading'), '45');
|
|
assert.equal(frame.searchParams.get('pitch'), '-12');
|
|
assert.deepEqual([...media.searchParams.keys()], ['ts']);
|
|
});
|
|
|
|
test('camera construction is inert and destruction cancels a pending catalog and its visibility listener', async (t) => {
|
|
const original = globalThis.document;
|
|
const listeners = new Set();
|
|
globalThis.document = {
|
|
addEventListener(type, handler) {
|
|
if (type === 'visibilitychange') listeners.add(handler);
|
|
},
|
|
removeEventListener(type, handler) {
|
|
if (type === 'visibilitychange') listeners.delete(handler);
|
|
},
|
|
};
|
|
t.after(() => {
|
|
globalThis.document = original;
|
|
});
|
|
const noop = () => {};
|
|
const services = {
|
|
overlays: {
|
|
clearOverlaySource: noop,
|
|
hitTestWorldOverlay: noop,
|
|
setOverlayEntries: noop,
|
|
setOverlaySourceVisible: noop,
|
|
},
|
|
sprites: {},
|
|
activation: {},
|
|
locations: {},
|
|
picking: { unregisterPickOwner: noop },
|
|
terrain: {},
|
|
ground: {},
|
|
mesh: {},
|
|
focus: {},
|
|
render: { releaseContinuousRender: noop },
|
|
};
|
|
let resolveCatalog;
|
|
let signal;
|
|
const source = {
|
|
...createCctvSource(),
|
|
getCatalog(options) {
|
|
signal = options.signal;
|
|
return new Promise((resolve) => {
|
|
resolveCatalog = resolve;
|
|
});
|
|
},
|
|
};
|
|
const a = createCctvLayer({ services, source });
|
|
const b = createCctvLayer({ services, source });
|
|
assert.equal(listeners.size, 0);
|
|
const viewer = {};
|
|
const { unbind } = bindFakeDraw(viewer);
|
|
t.after(unbind);
|
|
const initializing = a.init(viewer);
|
|
assert.equal(listeners.size, 1);
|
|
assert.equal(signal.aborted, false);
|
|
a.destroy(viewer);
|
|
assert.equal(listeners.size, 0);
|
|
assert.equal(signal.aborted, true);
|
|
resolveCatalog({ sources: [] });
|
|
await assert.rejects(initializing, { name: 'AbortError' });
|
|
assert.equal(a.getStats().count, 0);
|
|
assert.equal(b.getStats().count, 0);
|
|
});
|
|
|
|
test('frames are read through the registered frame endpoint', async () => {
|
|
const png = Uint8Array.from([0x89, 0x50, 0x4e, 0x47]);
|
|
const requested = [];
|
|
const source = createCctvSource({
|
|
fetchImpl: async (url, init) => {
|
|
requested.push({ url, cache: init.cache });
|
|
return new Response(png, {
|
|
headers: { 'Content-Type': 'Image/PNG; charset=binary' },
|
|
});
|
|
},
|
|
});
|
|
const frame = await source.getFrame(camera);
|
|
assert.equal(frame.contentType, 'image/png');
|
|
assert.deepEqual([...frame.bytes], [...png]);
|
|
assert.equal(
|
|
requested[0].url.split('?')[0],
|
|
'/api/cctv/frame/pack%2Fcamera%20%3Fx',
|
|
);
|
|
assert.equal(requested[0].cache, 'no-store');
|
|
const failing = createCctvSource({
|
|
fetchImpl: async () => new Response(null, { status: 502 }),
|
|
});
|
|
await assert.rejects(failing.getFrame(camera), /Camera frame HTTP 502/);
|
|
});
|
|
|
|
test('frame provenance admits the proxy kinds and leaves missing or unknown headers unknown', async () => {
|
|
for (const kind of [
|
|
'upstream-image',
|
|
'hls-pull',
|
|
'streetview',
|
|
'synthetic',
|
|
'other',
|
|
null,
|
|
]) {
|
|
const source = createCctvSource({
|
|
fetchImpl: async () =>
|
|
new Response(new Uint8Array([1]), {
|
|
headers: {
|
|
'Content-Type': 'image/png',
|
|
...(kind ? { 'X-CCTV-Source': kind } : {}),
|
|
},
|
|
}),
|
|
});
|
|
const frame = await source.getFrame(camera);
|
|
assert.equal(frame.sourceKind, kind === 'other' ? null : kind);
|
|
}
|
|
});
|