mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
- The /frame handler reads the client's network key (IPv6 /64) before it awaits the camera, so a client that drops the connection is still charged to its own window instead of the shared fallback key. - The budget is charged only after the Google key and finite catalog coordinates are confirmed, and the key is read once. - Places and the CCTV window share one default (GOOGLE_DEFAULT_PER_MIN). - Tests: the catalog-only test checks heading/fov/pitch from the query at the catalog location; the budget test covers unknown ids, forwarded requests and /64 grouping; a real-socket test covers a dropped connection. The duplicate pose test is removed. - .env.example, SECURITY.md, CURRENT-STATE and the changelog fragment describe the separate per-IP window, the catalog position and the placeholder for seed cameras.
632 lines
21 KiB
JavaScript
632 lines
21 KiB
JavaScript
// /api/cctv/media is the live-feed relay. A still camera used to be relayed
|
|
// through it as well, by an ordinary redirect-following fetch with no content
|
|
// type check and no body cap, which side-stepped everything /api/cctv/frame
|
|
// enforces for the same URL. These pin that a still is refused there and only
|
|
// reachable through /frame, while live feeds keep their relay.
|
|
//
|
|
// Run with: npm test (node --test)
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { Readable } from 'node:stream';
|
|
import { cctvProxy } from '../../server/providers/cctv.js';
|
|
|
|
const STILL = {
|
|
id: 'still-fixture',
|
|
name: 'Still fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'image',
|
|
url: 'https://cams.upstream.invalid/still.jpg',
|
|
};
|
|
// 'jpg' normalizes to 'image'; the alias must not reopen the relay.
|
|
const STILL_ALIAS = {
|
|
...STILL,
|
|
id: 'still-alias',
|
|
feedType: 'jpg',
|
|
url: 'https://cams.upstream.invalid/alias.jpg',
|
|
};
|
|
const VIDEO = {
|
|
id: 'video-fixture',
|
|
name: 'Video fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'video',
|
|
url: 'https://cams.upstream.invalid/live.mp4',
|
|
};
|
|
const WEBM = {
|
|
id: 'webm-fixture',
|
|
name: 'WebM fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'webm',
|
|
url: 'https://cams.upstream.invalid/live.webm',
|
|
};
|
|
const MJPEG = {
|
|
id: 'mjpeg-fixture',
|
|
name: 'MJPEG fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'mjpeg',
|
|
url: 'https://cams.upstream.invalid/live.mjpg',
|
|
};
|
|
|
|
/** A minimal upstream Response with a streaming body. */
|
|
function upstreamResponse({ status = 200, headers = {}, body = 'payload' }) {
|
|
const store = new Map(
|
|
Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]),
|
|
);
|
|
return {
|
|
ok: status >= 200 && status < 300,
|
|
status,
|
|
headers: { get: (name) => store.get(String(name).toLowerCase()) ?? null },
|
|
body: Readable.toWeb(Readable.from([Buffer.from(String(body))])),
|
|
};
|
|
}
|
|
|
|
/** Collects what a handler wrote, the way a Node ServerResponse would. */
|
|
function recordingResponse() {
|
|
const chunks = [];
|
|
let finished;
|
|
const done = new Promise((resolve) => {
|
|
finished = resolve;
|
|
});
|
|
const res = {
|
|
statusCode: 0,
|
|
headers: {},
|
|
writableEnded: false,
|
|
body: '',
|
|
writeHead(status, headers) {
|
|
res.statusCode = status;
|
|
res.headers = { ...res.headers, ...headers };
|
|
},
|
|
setHeader(name, value) {
|
|
res.headers[name] = value;
|
|
},
|
|
write(chunk) {
|
|
chunks.push(Buffer.from(chunk));
|
|
return true;
|
|
},
|
|
end(chunk) {
|
|
if (chunk) chunks.push(Buffer.from(chunk));
|
|
res.writableEnded = true;
|
|
res.body = Buffer.concat(chunks).toString('utf8');
|
|
finished();
|
|
},
|
|
on() {},
|
|
once() {},
|
|
emit() {},
|
|
destroy() {},
|
|
};
|
|
return { res, done };
|
|
}
|
|
|
|
/**
|
|
* Mount the real provider over the fixture cameras and answer every upstream
|
|
* request from the supplied function.
|
|
*/
|
|
function mount(t, respond) {
|
|
const before = {
|
|
json: process.env.CCTV_SOURCES_JSON,
|
|
file: process.env.CCTV_SOURCES_FILE,
|
|
austin: process.env.CCTV_FORCE_AUSTIN,
|
|
serverKey: process.env.GOOGLE_MAPS_SERVER_API_KEY,
|
|
browserKey: process.env.GOOGLE_MAPS_API_KEY,
|
|
rateLimit: process.env.GEV_RATELIMIT_GOOGLE_PER_MIN,
|
|
};
|
|
process.env.CCTV_SOURCES_JSON = JSON.stringify([
|
|
STILL,
|
|
STILL_ALIAS,
|
|
VIDEO,
|
|
WEBM,
|
|
MJPEG,
|
|
]);
|
|
process.env.CCTV_SOURCES_FILE = 'absent-source-file.json';
|
|
process.env.CCTV_FORCE_AUSTIN = '0';
|
|
// No Street View key: a /frame miss lands on the synthetic billboard rather
|
|
// than a network call this file does not model.
|
|
delete process.env.GOOGLE_MAPS_SERVER_API_KEY;
|
|
delete process.env.GOOGLE_MAPS_API_KEY;
|
|
// The default Google budget, whatever the shell sets.
|
|
delete process.env.GEV_RATELIMIT_GOOGLE_PER_MIN;
|
|
const nativeFetch = globalThis.fetch;
|
|
const requests = [];
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
requests.push({ url: String(url), redirect: init.redirect });
|
|
return respond({ url: String(url), init });
|
|
};
|
|
t.after(() => {
|
|
globalThis.fetch = nativeFetch;
|
|
for (const [name, value] of [
|
|
['CCTV_SOURCES_JSON', before.json],
|
|
['CCTV_SOURCES_FILE', before.file],
|
|
['CCTV_FORCE_AUSTIN', before.austin],
|
|
['GOOGLE_MAPS_SERVER_API_KEY', before.serverKey],
|
|
['GOOGLE_MAPS_API_KEY', before.browserKey],
|
|
['GEV_RATELIMIT_GOOGLE_PER_MIN', before.rateLimit],
|
|
]) {
|
|
if (value === undefined) delete process.env[name];
|
|
else process.env[name] = value;
|
|
}
|
|
});
|
|
|
|
let handler = null;
|
|
cctvProxy().configureServer({
|
|
middlewares: {
|
|
use: (_route, fn) => {
|
|
handler = fn;
|
|
},
|
|
},
|
|
});
|
|
assert.ok(handler, 'the CCTV provider must mount a middleware');
|
|
|
|
const call = async (path, headers = {}, socket) => {
|
|
const { res, done } = recordingResponse();
|
|
await handler({ url: path, headers, method: 'GET', on() {}, socket }, res);
|
|
await done;
|
|
return res;
|
|
};
|
|
const health = async (id) => {
|
|
const res = await call('/health');
|
|
return JSON.parse(res.body).cameras.find((entry) => entry.id === id);
|
|
};
|
|
return { call, health, requests };
|
|
}
|
|
|
|
test('a still camera is refused by /media without any upstream request', async (t) => {
|
|
// Everything the old relay would have done with this camera: redirect to a
|
|
// private address, then answer with HTML.
|
|
const app = mount(t, ({ url }) =>
|
|
url.includes('169.254.169.254')
|
|
? upstreamResponse({
|
|
headers: { 'content-type': 'text/html' },
|
|
body: '<html>metadata</html>',
|
|
})
|
|
: upstreamResponse({
|
|
status: 302,
|
|
headers: { location: 'http://169.254.169.254/latest/meta-data/' },
|
|
body: '',
|
|
}),
|
|
);
|
|
for (const camera of [STILL, STILL_ALIAS]) {
|
|
const res = await app.call(`/media/${camera.id}`);
|
|
assert.equal(res.statusCode, 404, camera.id);
|
|
assert.equal(res.headers['Content-Type'], 'application/json');
|
|
assert.deepEqual(JSON.parse(res.body), {
|
|
error: 'No live media for this camera; use the frame endpoint',
|
|
});
|
|
assert.doesNotMatch(res.body, /metadata/);
|
|
// Being asked on the wrong route is not a camera fault.
|
|
assert.equal(await app.health(camera.id), undefined);
|
|
}
|
|
assert.deepEqual(app.requests, [], 'a still camera reached its upstream');
|
|
});
|
|
|
|
test('an unregistered camera id is refused by /media the same way', async (t) => {
|
|
const app = mount(t, () => {
|
|
throw new Error('an unknown camera must not fetch');
|
|
});
|
|
const res = await app.call('/media/not-a-camera');
|
|
assert.equal(res.statusCode, 404);
|
|
assert.equal(app.requests.length, 0);
|
|
});
|
|
|
|
test('a video camera is still relayed by /media', async (t) => {
|
|
const app = mount(t, () =>
|
|
upstreamResponse({
|
|
headers: { 'content-type': 'video/mp4', 'content-length': '5' },
|
|
body: 'video',
|
|
}),
|
|
);
|
|
const res = await app.call(`/media/${VIDEO.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['Content-Type'], 'video/mp4');
|
|
assert.equal(res.headers['X-CCTV-Source'], 'live-media');
|
|
assert.equal(res.body, 'video');
|
|
assert.deepEqual(
|
|
app.requests.map(({ url }) => url),
|
|
[VIDEO.url],
|
|
);
|
|
assert.equal((await app.health(VIDEO.id)).status, 'ok');
|
|
});
|
|
|
|
test('an MJPEG camera is still relayed by /media', async (t) => {
|
|
const app = mount(t, () =>
|
|
upstreamResponse({
|
|
headers: { 'content-type': 'multipart/x-mixed-replace; boundary=frame' },
|
|
body: '--frame',
|
|
}),
|
|
);
|
|
const res = await app.call(`/media/${MJPEG.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.match(res.headers['Content-Type'], /^multipart\/x-mixed-replace/);
|
|
assert.equal(res.body, '--frame');
|
|
assert.deepEqual(
|
|
app.requests.map(({ url }) => url),
|
|
[MJPEG.url],
|
|
);
|
|
});
|
|
|
|
test('a still camera is still served through /frame with its bounded fetch', async (t) => {
|
|
const app = mount(t, () =>
|
|
upstreamResponse({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'jpeg-bytes',
|
|
}),
|
|
);
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['Content-Type'], 'image/jpeg');
|
|
assert.equal(res.headers['X-CCTV-Source'], 'upstream-image');
|
|
assert.equal(res.body, 'jpeg-bytes');
|
|
assert.deepEqual(app.requests, [{ url: STILL.url, redirect: 'manual' }]);
|
|
});
|
|
|
|
test('/frame does not follow a still camera off its origin', async (t) => {
|
|
// The protection /media used to bypass, shown on the route that keeps it.
|
|
const app = mount(t, ({ url }) =>
|
|
url === STILL.url
|
|
? upstreamResponse({
|
|
status: 302,
|
|
headers: { location: 'http://169.254.169.254/latest/meta-data/' },
|
|
body: '',
|
|
})
|
|
: upstreamResponse({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'private',
|
|
}),
|
|
);
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['X-CCTV-Source'], 'synthetic');
|
|
assert.doesNotMatch(res.body, /private/);
|
|
assert.deepEqual(
|
|
app.requests.map(({ url }) => url),
|
|
[STILL.url],
|
|
);
|
|
});
|
|
|
|
/** An upstream Response whose body records whether it was cancelled. */
|
|
function trackedUpstream({ status = 200, headers = {}, body = 'payload' }) {
|
|
const state = { cancelled: false };
|
|
const response = new Response(
|
|
new ReadableStream(
|
|
{
|
|
pull(controller) {
|
|
controller.enqueue(new TextEncoder().encode(body));
|
|
controller.close();
|
|
},
|
|
cancel() {
|
|
state.cancelled = true;
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
),
|
|
{ status, headers },
|
|
);
|
|
return { response, state };
|
|
}
|
|
|
|
test('/media refuses an upstream type that does not match the feed kind', async (t) => {
|
|
let current;
|
|
const app = mount(t, () => current.response);
|
|
for (const [camera, contentType, body] of [
|
|
[VIDEO, 'text/html', '<!doctype html><p>x</p>'],
|
|
[VIDEO, 'image/svg+xml', '<svg xmlns="http://www.w3.org/2000/svg"/>'],
|
|
[VIDEO, 'application/vnd.apple.mpegurl', '#EXTM3U'],
|
|
[VIDEO, 'video/webm', 'video'],
|
|
[VIDEO, undefined, 'video'],
|
|
[WEBM, 'video/mp4', 'video'],
|
|
[MJPEG, 'multipart/x-mixed-replace', '--frame'],
|
|
[MJPEG, 'multipart/x-mixed-replace; boundary=', '--frame'],
|
|
[MJPEG, 'image/jpeg', 'jpeg'],
|
|
[MJPEG, 'text/html; boundary=frame', '<!doctype html><p>x</p>'],
|
|
]) {
|
|
current = trackedUpstream({
|
|
headers: contentType === undefined ? {} : { 'content-type': contentType },
|
|
body,
|
|
});
|
|
const label = `${camera.id}: ${contentType}`;
|
|
const res = await app.call(`/media/${camera.id}`);
|
|
assert.equal(res.statusCode, 502, label);
|
|
assert.equal(res.headers['Content-Type'], 'application/json', label);
|
|
assert.deepEqual(JSON.parse(res.body), { error: 'Media proxy failed' });
|
|
assert.equal(current.state.cancelled, true, `${label}: upstream cancelled`);
|
|
const health = await app.health(camera.id);
|
|
assert.equal(health.status, 'degraded', label);
|
|
assert.equal(health.message, 'Unexpected media type', label);
|
|
}
|
|
});
|
|
|
|
test('/media relays each feed kind under its canonical type, including a partial response', async (t) => {
|
|
let current;
|
|
const app = mount(t, () => current);
|
|
for (const [camera, upstream, expected] of [
|
|
[VIDEO, { 'content-type': 'Video/MP4; codecs="avc1.42E01E"' }, 'video/mp4'],
|
|
[
|
|
VIDEO,
|
|
{
|
|
'content-type': 'video/mp4',
|
|
'content-range': 'bytes 0-4/100',
|
|
'content-length': '5',
|
|
'accept-ranges': 'bytes',
|
|
},
|
|
'video/mp4',
|
|
],
|
|
[WEBM, { 'content-type': 'video/webm' }, 'video/webm'],
|
|
[
|
|
MJPEG,
|
|
{ 'content-type': 'multipart/x-mixed-replace;boundary="frame"' },
|
|
'multipart/x-mixed-replace; boundary=frame',
|
|
],
|
|
[
|
|
MJPEG,
|
|
{ 'content-type': 'multipart/x-mixed-replace; boundary="a b"' },
|
|
'multipart/x-mixed-replace; boundary="a b"',
|
|
],
|
|
]) {
|
|
const status = upstream['content-range'] ? 206 : 200;
|
|
current = upstreamResponse({ status, headers: upstream, body: 'bytes' });
|
|
const res = await app.call(`/media/${camera.id}`);
|
|
assert.equal(res.statusCode, status, camera.id);
|
|
assert.equal(res.headers['Content-Type'], expected);
|
|
assert.equal(res.body, 'bytes');
|
|
if (status === 206)
|
|
assert.equal(res.headers['Content-Range'], 'bytes 0-4/100');
|
|
assert.equal((await app.health(camera.id)).status, 'ok');
|
|
}
|
|
});
|
|
|
|
test('/media does not follow a live camera off its origin', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
url === VIDEO.url
|
|
? upstreamResponse({
|
|
status: 302,
|
|
headers: { location: 'https://elsewhere.invalid/live.mp4' },
|
|
body: '',
|
|
})
|
|
: upstreamResponse({
|
|
headers: { 'content-type': 'video/mp4' },
|
|
body: 'elsewhere',
|
|
}),
|
|
);
|
|
const res = await app.call(`/media/${VIDEO.id}`);
|
|
assert.equal(res.statusCode, 502);
|
|
assert.doesNotMatch(res.body, /elsewhere/);
|
|
assert.deepEqual(app.requests, [{ url: VIDEO.url, redirect: 'manual' }]);
|
|
});
|
|
|
|
test('every CCTV route refuses cross-site requests and admits the app itself', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
upstreamResponse({
|
|
headers: {
|
|
'content-type': url === VIDEO.url ? 'video/mp4' : 'image/jpeg',
|
|
},
|
|
body: 'bytes',
|
|
}),
|
|
);
|
|
const host = 'localhost:5173';
|
|
const paths = [
|
|
'/sources',
|
|
'/health',
|
|
`/stream/${STILL.id}`,
|
|
`/frame/${STILL.id}`,
|
|
`/media/${VIDEO.id}`,
|
|
];
|
|
for (const headers of [
|
|
{ host, 'sec-fetch-site': 'cross-site' },
|
|
{ host, 'sec-fetch-site': 'same-site' },
|
|
{ host, origin: 'https://elsewhere.example' },
|
|
{ host, origin: 'null' },
|
|
])
|
|
for (const path of paths) {
|
|
const res = await app.call(path, headers);
|
|
assert.equal(res.statusCode, 403, `${path} ${JSON.stringify(headers)}`);
|
|
}
|
|
assert.deepEqual(app.requests, [], 'a refused request reached an upstream');
|
|
for (const headers of [
|
|
{ host, 'sec-fetch-site': 'same-origin' },
|
|
{ host, origin: `http://${host}` },
|
|
{},
|
|
]) {
|
|
const frame = await app.call(`/frame/${STILL.id}`, headers);
|
|
assert.equal(frame.statusCode, 200);
|
|
assert.equal(frame.headers['X-CCTV-Source'], 'upstream-image');
|
|
const media = await app.call(`/media/${VIDEO.id}`, headers);
|
|
assert.equal(media.statusCode, 200);
|
|
assert.equal(media.headers['Content-Type'], 'video/mp4');
|
|
}
|
|
});
|
|
|
|
test('/frame falls back past a non-raster upstream and Street View frame', async (t) => {
|
|
let streetViewType;
|
|
const app = mount(t, ({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/')
|
|
? trackedUpstream({
|
|
headers:
|
|
streetViewType === undefined
|
|
? {}
|
|
: { 'content-type': streetViewType },
|
|
body: 'street-view',
|
|
}).response
|
|
: upstreamResponse({
|
|
headers: { 'content-type': 'image/svg+xml' },
|
|
body: '<svg xmlns="http://www.w3.org/2000/svg"/>',
|
|
}),
|
|
);
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
for (const type of [
|
|
'image/svg+xml',
|
|
'text/html',
|
|
'application/xml',
|
|
undefined,
|
|
]) {
|
|
streetViewType = type;
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['X-CCTV-Source'], 'synthetic', String(type));
|
|
assert.doesNotMatch(res.body, /street-view/);
|
|
}
|
|
streetViewType = 'image/JPEG; charset=x';
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.headers['X-CCTV-Source'], 'streetview');
|
|
assert.equal(res.headers['Content-Type'], 'image/jpeg');
|
|
assert.equal(res.body, 'street-view');
|
|
});
|
|
|
|
test('a forwarded same-origin request reaches every CCTV route but not the Street View fallback', async (t) => {
|
|
const app = mount(t, ({ url }) => {
|
|
if (url.startsWith('https://maps.googleapis.com/'))
|
|
return trackedUpstream({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'street-view',
|
|
}).response;
|
|
return url === VIDEO.url
|
|
? upstreamResponse({ headers: { 'content-type': 'video/mp4' } })
|
|
: upstreamResponse({ status: 503, body: '' });
|
|
});
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
const host = 'localhost:5173';
|
|
const streetViewCalls = () =>
|
|
app.requests.filter(({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/'),
|
|
).length;
|
|
for (const forwarded of [
|
|
{ 'x-forwarded-for': '203.0.113.9' },
|
|
{ via: '1.1 proxy' },
|
|
{ forwarded: 'for=203.0.113.9' },
|
|
{ 'x-real-ip': '203.0.113.9' },
|
|
{ 'x-forwarded-for': '' },
|
|
{ 'x-forwarded-for': ' ' },
|
|
{ 'cf-connecting-ip': '' },
|
|
]) {
|
|
const headers = { host, 'sec-fetch-site': 'same-origin', ...forwarded };
|
|
const label = JSON.stringify(forwarded);
|
|
assert.equal((await app.call('/sources', headers)).statusCode, 200, label);
|
|
const media = await app.call(`/media/${VIDEO.id}`, headers);
|
|
assert.equal(media.statusCode, 200, label);
|
|
assert.equal(media.headers['Content-Type'], 'video/mp4', label);
|
|
const frame = await app.call(`/frame/${STILL.id}`, headers);
|
|
assert.equal(frame.statusCode, 200, label);
|
|
assert.equal(frame.headers['X-CCTV-Source'], 'synthetic', label);
|
|
assert.equal(frame.headers['Content-Type'], 'image/svg+xml', label);
|
|
// Cross-site stays refused whatever the forwarding headers say.
|
|
for (const path of ['/sources', `/frame/${STILL.id}`, `/media/${VIDEO.id}`])
|
|
assert.equal(
|
|
(
|
|
await app.call(path, {
|
|
...forwarded,
|
|
host,
|
|
'sec-fetch-site': 'cross-site',
|
|
})
|
|
).statusCode,
|
|
403,
|
|
`${label} ${path}`,
|
|
);
|
|
}
|
|
assert.equal(streetViewCalls(), 0, 'a forwarded request spent the key');
|
|
const direct = await app.call(`/frame/${STILL.id}`, {
|
|
host,
|
|
'sec-fetch-site': 'same-origin',
|
|
});
|
|
assert.equal(direct.headers['X-CCTV-Source'], 'streetview');
|
|
assert.equal(direct.body, 'street-view');
|
|
assert.equal(streetViewCalls(), 1);
|
|
});
|
|
|
|
test('the Street View fallback frames catalog cameras only, from the catalog position', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/')
|
|
? trackedUpstream({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'street-view',
|
|
}).response
|
|
: upstreamResponse({ status: 503 }),
|
|
);
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
const streetView = () =>
|
|
app.requests.filter(({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/'),
|
|
);
|
|
|
|
const unknown = await app.call('/frame/not-a-camera?lat=48.85&lon=2.29');
|
|
assert.equal(unknown.headers['X-CCTV-Source'], 'synthetic');
|
|
assert.deepEqual(streetView(), [], 'no Google call for an unknown id');
|
|
|
|
const steered = await app.call(
|
|
`/frame/${STILL.id}?lat=48.85&lon=2.29&heading=90&fov=74&pitch=-17`,
|
|
);
|
|
assert.equal(steered.headers['X-CCTV-Source'], 'streetview');
|
|
const sv = new URL(streetView()[0].url).searchParams;
|
|
assert.equal(sv.get('location'), `${STILL.lat},${STILL.lon}`);
|
|
assert.equal(sv.get('heading'), '90');
|
|
assert.equal(sv.get('fov'), '74');
|
|
assert.equal(sv.get('pitch'), '-17');
|
|
});
|
|
|
|
test('the Street View fallback spends a per-IP Google budget, and only with a key', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/')
|
|
? trackedUpstream({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'street-view',
|
|
}).response
|
|
: upstreamResponse({ status: 503 }),
|
|
);
|
|
// Read when the first keyed fallback builds the limiter, so after mount().
|
|
process.env.GEV_RATELIMIT_GOOGLE_PER_MIN = '2';
|
|
const streetViewCalls = () =>
|
|
app.requests.filter(({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/'),
|
|
).length;
|
|
const first = { remoteAddress: '203.0.113.7' };
|
|
const frameSource = async (socket) =>
|
|
(await app.call(`/frame/${STILL.id}`, {}, socket)).headers['X-CCTV-Source'];
|
|
|
|
// Without a key nothing is spent.
|
|
for (let i = 0; i < 3; i++)
|
|
assert.equal(await frameSource(first), 'synthetic');
|
|
assert.equal(streetViewCalls(), 0);
|
|
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
// Neither an unknown id nor a forwarded request spends the window.
|
|
assert.equal(
|
|
(await app.call('/frame/not-a-camera', {}, first)).headers['X-CCTV-Source'],
|
|
'synthetic',
|
|
);
|
|
assert.equal(
|
|
(
|
|
await app.call(
|
|
`/frame/${STILL.id}`,
|
|
{ 'x-forwarded-for': '203.0.113.9' },
|
|
first,
|
|
)
|
|
).headers['X-CCTV-Source'],
|
|
'synthetic',
|
|
);
|
|
assert.deepEqual(
|
|
[
|
|
await frameSource(first),
|
|
await frameSource(first),
|
|
await frameSource(first),
|
|
],
|
|
['streetview', 'streetview', 'synthetic'],
|
|
);
|
|
assert.equal(streetViewCalls(), 2, 'no Google call over the budget');
|
|
|
|
// Another address has a budget of its own.
|
|
assert.equal(
|
|
await frameSource({ remoteAddress: '203.0.113.8' }),
|
|
'streetview',
|
|
);
|
|
assert.equal(streetViewCalls(), 3);
|
|
|
|
// Addresses within one IPv6 /64 share a budget.
|
|
const v6 = (remoteAddress) => frameSource({ remoteAddress });
|
|
assert.deepEqual(
|
|
[await v6('2001:db8::1'), await v6('2001:db8::2'), await v6('2001:db8::3')],
|
|
['streetview', 'streetview', 'synthetic'],
|
|
);
|
|
assert.equal(await v6('2001:db8:0:1::1'), 'streetview', 'another /64');
|
|
assert.equal(streetViewCalls(), 6);
|
|
});
|