mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-22 03:02:20 +00:00
The first formal release. - One-click install via Pinokio; keyless boot lands on a live Esri World Imagery satellite globe with keyless terrain, with automatic OSM fallback and graceful degradation when terrain is unavailable. - Provider Settings (the POWER UP panel): add, replace, or remove API keys inside the app; credential files made owner-only before any secret is written; external keys shown read-only; the panel refuses shared or proxied servers. - Keyless capability responses for the optional HUD summary and place search. - Aircraft-identity voice answers cover operator, type, and route, and say so plainly when enrichment is unavailable. - README rewritten keyless-first; concise 0.1.0 changelog section; CI workflow included. Gates: 2,672 unit tests pass / 0 fail, build clean, tracking regression 108/108, map-source tray QA pass, setup doctor ready.
507 lines
20 KiB
JavaScript
507 lines
20 KiB
JavaScript
// src/data/cctvLod.test.mjs
|
|
// Pure LOD-engine tests, adapted from Manjunath's Part C suite
|
|
// (fix/cctv-part-c-review): zoom-scaled card budgets, nearest-first in-view
|
|
// selection, video exclusion, the eviction-grace planner, and source-aware
|
|
// static-frame pacing.
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
CCTV_CARD_CENTER_WEIGHT,
|
|
CCTV_CARD_INCUMBENT_FACTOR,
|
|
CCTV_LOD_GRACE_MS,
|
|
CCTV_LOD_GRACE_PASSES,
|
|
CCTV_AMBIENT_CARD_MAX,
|
|
CCTV_AMBIENT_CARD_MID,
|
|
CCTV_AMBIENT_CARD_MIN,
|
|
applyEvictionGrace,
|
|
blendCenterRankKm,
|
|
cctvCandidateSpreadKm,
|
|
cctvLodBudgets,
|
|
distributeCctvCards,
|
|
hasFiniteCctvViewport,
|
|
incumbentRankKm,
|
|
screenCenterFraction,
|
|
selectCctvLod,
|
|
staticFrameRefreshMs,
|
|
} from './cctvLod.js';
|
|
|
|
function candidates(count, options = {}) {
|
|
return Array.from({ length: count }, (_, index) => ({
|
|
id: `cam-${String(index).padStart(3, '0')}`,
|
|
distanceKm: index / 10,
|
|
inView: options.hiddenAt !== index,
|
|
isVideo: options.videoAt === index,
|
|
}));
|
|
}
|
|
|
|
test('cctvLodBudgets scales the card budget from 20 to 40 with view height', () => {
|
|
// Owner round 2 (item C): budgets raised 16/24/32 -> 20/28/40.
|
|
assert.equal(CCTV_AMBIENT_CARD_MIN, 20);
|
|
assert.equal(CCTV_AMBIENT_CARD_MID, 28);
|
|
assert.equal(CCTV_AMBIENT_CARD_MAX, 40);
|
|
assert.deepEqual(cctvLodBudgets(500), { cardLimit: CCTV_AMBIENT_CARD_MIN });
|
|
assert.deepEqual(cctvLodBudgets(8_000), { cardLimit: CCTV_AMBIENT_CARD_MID });
|
|
assert.deepEqual(cctvLodBudgets(30_000), { cardLimit: CCTV_AMBIENT_CARD_MAX });
|
|
});
|
|
|
|
test('selectCctvLod caps ambient cards at the 40 hard cap regardless of catalog size', () => {
|
|
const selected = selectCctvLod(candidates(900), { cameraHeightM: 30_000 });
|
|
assert.equal(selected.cardIds.length, CCTV_AMBIENT_CARD_MAX);
|
|
assert.equal(selected.budgets.cardLimit, CCTV_AMBIENT_CARD_MAX);
|
|
});
|
|
|
|
test('selectCctvLod uses only in-view cameras and orders by viewer distance', () => {
|
|
const input = candidates(20, { hiddenAt: 0 }).reverse();
|
|
const selected = selectCctvLod(input, { cameraHeightM: 500 });
|
|
assert.equal(selected.cardIds.includes('cam-000'), false);
|
|
assert.deepEqual(selected.cardIds.slice(0, 3), ['cam-001', 'cam-002', 'cam-003']);
|
|
});
|
|
|
|
test('video cameras never consume ambient card slots', () => {
|
|
const selected = selectCctvLod(candidates(30, { videoAt: 0 }), { cameraHeightM: 500 });
|
|
assert.equal(selected.cardIds.includes('cam-000'), false);
|
|
assert.equal(selected.cardIds.length, CCTV_AMBIENT_CARD_MIN);
|
|
});
|
|
|
|
test('selectCctvLod tolerates malformed candidate rows', () => {
|
|
const selected = selectCctvLod(
|
|
[null, {}, { id: '', inView: true }, { id: 'cam-ok', inView: true, distanceKm: NaN }],
|
|
{ cameraHeightM: 500 }
|
|
);
|
|
assert.deepEqual(selected.cardIds, ['cam-ok']);
|
|
});
|
|
|
|
// ─── Selection-level incumbency (owner field-test finding 4) ────────────────
|
|
|
|
test('incumbentRankKm discounts incumbents by the 20% factor', () => {
|
|
assert.equal(incumbentRankKm(10, false), 10);
|
|
assert.equal(incumbentRankKm(10, true), 10 * CCTV_CARD_INCUMBENT_FACTOR);
|
|
assert.equal(incumbentRankKm(NaN, true), Infinity);
|
|
});
|
|
|
|
test('selectCctvLod: a carded camera outranks a slightly-nearer non-carded one', () => {
|
|
// Street budget filled: budget-1 anchors + one contested slot. The
|
|
// incumbent at 5.0 km holds its card against a newcomer at 4.5 km (only
|
|
// 10% closer).
|
|
const anchors = Array.from({ length: CCTV_AMBIENT_CARD_MIN - 1 }, (_, i) => ({
|
|
id: `anchor-${String(i).padStart(2, '0')}`, distanceKm: i / 100, inView: true,
|
|
}));
|
|
const contested = [
|
|
{ id: 'incumbent', distanceKm: 5.0, inView: true },
|
|
{ id: 'newcomer', distanceKm: 4.5, inView: true },
|
|
];
|
|
const selected = selectCctvLod([...anchors, ...contested], {
|
|
cameraHeightM: 500,
|
|
incumbentIds: new Set(['incumbent']),
|
|
});
|
|
assert.equal(selected.cardIds.length, CCTV_AMBIENT_CARD_MIN);
|
|
assert.ok(selected.cardIds.includes('incumbent'), 'incumbent keeps its card');
|
|
assert.equal(selected.cardIds.includes('newcomer'), false);
|
|
});
|
|
|
|
test('selectCctvLod: a meaningfully (>20%) closer camera still displaces an incumbent', () => {
|
|
const anchors = Array.from({ length: CCTV_AMBIENT_CARD_MIN - 1 }, (_, i) => ({
|
|
id: `anchor-${String(i).padStart(2, '0')}`, distanceKm: i / 100, inView: true,
|
|
}));
|
|
const contested = [
|
|
{ id: 'incumbent', distanceKm: 5.0, inView: true },
|
|
{ id: 'newcomer', distanceKm: 3.9, inView: true }, // beats 5.0 * 0.8 = 4.0
|
|
];
|
|
const selected = selectCctvLod([...anchors, ...contested], {
|
|
cameraHeightM: 500,
|
|
incumbentIds: new Set(['incumbent']),
|
|
});
|
|
assert.ok(selected.cardIds.includes('newcomer'), 'meaningfully closer camera wins');
|
|
assert.equal(selected.cardIds.includes('incumbent'), false);
|
|
});
|
|
|
|
test('selectCctvLod: no incumbents means plain nearest-first (unchanged behavior)', () => {
|
|
const plain = selectCctvLod(candidates(20), { cameraHeightM: 500 });
|
|
const withEmpty = selectCctvLod(candidates(20), { cameraHeightM: 500, incumbentIds: new Set() });
|
|
assert.deepEqual(plain.cardIds, withEmpty.cardIds);
|
|
});
|
|
|
|
// ─── distributeCctvCards — screen distribution (owner round 2, item C) ──────
|
|
// Grid: 5 cols x 4 rows. At viewW 1000 / viewH 800 each cell is 200x200 px.
|
|
|
|
test('distributeCctvCards spreads clustered candidates across cells', () => {
|
|
// Four nearest candidates cluster in the top-left cell; a farther one
|
|
// sits alone bottom-right. Nearest-first would take the whole cluster —
|
|
// distribution gives every occupied cell its best first.
|
|
const clustered = Array.from({ length: 4 }, (_, i) => ({
|
|
id: `center-${i}`, sx: 50 + i * 10, sy: 50, rankKm: i,
|
|
}));
|
|
const lonely = { id: 'periphery', sx: 950, sy: 750, rankKm: 30 };
|
|
assert.deepEqual(
|
|
distributeCctvCards([...clustered, lonely], { budget: 2, viewW: 1000, viewH: 800 }),
|
|
['center-0', 'periphery']
|
|
);
|
|
});
|
|
|
|
test('distributeCctvCards: leftover budget falls back to global rank order', () => {
|
|
const clustered = Array.from({ length: 4 }, (_, i) => ({
|
|
id: `center-${i}`, sx: 50 + i * 10, sy: 50, rankKm: i,
|
|
}));
|
|
const lonely = { id: 'periphery', sx: 950, sy: 750, rankKm: 30 };
|
|
// 2 occupied cells, budget 4: both cell winners, then the cluster's next
|
|
// two by rank.
|
|
assert.deepEqual(
|
|
distributeCctvCards([...clustered, lonely], { budget: 4, viewW: 1000, viewH: 800 }),
|
|
['center-0', 'periphery', 'center-1', 'center-2']
|
|
);
|
|
});
|
|
|
|
test('distributeCctvCards: empty cells are skipped, budget respected', () => {
|
|
// Everything in ONE cell — the 19 empty cells claim nothing; the single
|
|
// occupied cell fills the whole budget in rank order.
|
|
const oneCell = Array.from({ length: 5 }, (_, i) => ({
|
|
id: `c-${i}`, sx: 20 + i * 5, sy: 20, rankKm: i,
|
|
}));
|
|
const ids = distributeCctvCards(oneCell, { budget: 3, viewW: 1000, viewH: 800 });
|
|
assert.deepEqual(ids, ['c-0', 'c-1', 'c-2']);
|
|
});
|
|
|
|
test('distributeCctvCards: an under-budget cut keeps the nearest cell winners', () => {
|
|
const ids = distributeCctvCards([
|
|
{ id: 'far-cell', sx: 900, sy: 700, rankKm: 9 },
|
|
{ id: 'near-cell', sx: 100, sy: 100, rankKm: 1 },
|
|
], { budget: 1, viewW: 1000, viewH: 800 });
|
|
assert.deepEqual(ids, ['near-cell']);
|
|
});
|
|
|
|
test('distributeCctvCards: incumbency (effective distance) is honored inside a cell', () => {
|
|
// Same cell: the incumbent at 5.0 km (discounted to 4.0) beats the
|
|
// non-carded newcomer at 4.5 km for the cell slot.
|
|
const ids = distributeCctvCards([
|
|
{ id: 'newcomer', sx: 100, sy: 100, rankKm: incumbentRankKm(4.5, false) },
|
|
{ id: 'incumbent', sx: 120, sy: 100, rankKm: incumbentRankKm(5.0, true) },
|
|
], { budget: 1, viewW: 1000, viewH: 800 });
|
|
assert.deepEqual(ids, ['incumbent']);
|
|
});
|
|
|
|
test('distributeCctvCards: malformed rows dropped; offscreen anchors clamp to edge cells', () => {
|
|
const ids = distributeCctvCards([
|
|
null,
|
|
{ id: '', sx: 10, sy: 10, rankKm: 0 },
|
|
{ id: 'nan', sx: NaN, sy: 10, rankKm: 0 },
|
|
{ id: 'ok', sx: 10, sy: 10, rankKm: 1 },
|
|
// Margin candidates just outside the viewport land in the edge cells.
|
|
{ id: 'edge', sx: -20, sy: 850, rankKm: 2 },
|
|
], { budget: 5, viewW: 1000, viewH: 800 });
|
|
assert.deepEqual(ids.sort(), ['edge', 'ok']);
|
|
assert.deepEqual(distributeCctvCards([], { budget: 5, viewW: 1000, viewH: 800 }), []);
|
|
});
|
|
|
|
test('selectCctvLod with viewport dims routes the fill through screen distribution', () => {
|
|
// A cluster larger than the street budget sits mid-screen; a periphery
|
|
// camera ranks past the budget. Nearest-first drops it — distribution
|
|
// keeps it because its cell is otherwise empty.
|
|
const clustered = Array.from({ length: CCTV_AMBIENT_CARD_MIN + 2 }, (_, i) => ({
|
|
id: `center-${String(i).padStart(2, '0')}`,
|
|
distanceKm: i / 10,
|
|
inView: true,
|
|
sx: 400 + (i % 5) * 8,
|
|
sy: 300 + Math.floor(i / 5) * 8,
|
|
}));
|
|
const periphery = { id: 'periphery', distanceKm: 9, inView: true, sx: 950, sy: 750 };
|
|
const selected = selectCctvLod([...clustered, periphery], {
|
|
cameraHeightM: 500, viewW: 1000, viewH: 800,
|
|
});
|
|
assert.equal(selected.cardIds.length, CCTV_AMBIENT_CARD_MIN, 'budget respected');
|
|
assert.ok(selected.cardIds.includes('periphery'), 'periphery cell holds a card');
|
|
// Without screen info the original nearest-first cap applies unchanged.
|
|
const plain = selectCctvLod(
|
|
[...clustered, periphery].map(({ sx, sy, ...rest }) => rest),
|
|
{ cameraHeightM: 500 }
|
|
);
|
|
assert.equal(plain.cardIds.includes('periphery'), false);
|
|
});
|
|
|
|
test('center-weight helpers are bounded and robust to invalid anchors and outliers', () => {
|
|
assert.equal(CCTV_CARD_CENTER_WEIGHT, 0.5);
|
|
assert.equal(hasFiniteCctvViewport(1000, 800), true);
|
|
assert.equal(hasFiniteCctvViewport(Infinity, 800), false);
|
|
assert.equal(screenCenterFraction(500, 400, 1000, 800), 0);
|
|
assert.equal(screenCenterFraction(1000, 800, 1000, 800), 1);
|
|
assert.equal(screenCenterFraction(NaN, 400, 1000, 800), 1);
|
|
assert.equal(screenCenterFraction(-200, -200, 1000, 800), 1);
|
|
assert.equal(screenCenterFraction(500, 400, 0, 0), 0);
|
|
const near = Array.from({ length: 20 }, (_, index) => 1 + index / 100);
|
|
assert.equal(cctvCandidateSpreadKm([...near, 900]), 1.18);
|
|
assert.equal(cctvCandidateSpreadKm([Infinity, NaN]), 0);
|
|
assert.equal(blendCenterRankKm(10, 0, 20), 5);
|
|
assert.equal(blendCenterRankKm(10, 1, 20), 15);
|
|
assert.equal(blendCenterRankKm(10, 0.5, 20, 0), 10);
|
|
});
|
|
|
|
test('non-finite positive viewport dimensions retain exact legacy nearest-first selection', () => {
|
|
const near = Array.from({ length: CCTV_AMBIENT_CARD_MIN }, (_, index) => ({
|
|
id: `near-${String(index).padStart(2, '0')}`,
|
|
distanceKm: index,
|
|
inView: true,
|
|
sx: 100,
|
|
sy: 100,
|
|
}));
|
|
const far = {
|
|
id: 'far-other-cell',
|
|
distanceKm: 100,
|
|
inView: true,
|
|
sx: 900,
|
|
sy: 700,
|
|
};
|
|
const input = [...near, far];
|
|
const legacy = selectCctvLod(input, { cameraHeightM: 500 });
|
|
|
|
assert.deepEqual(
|
|
selectCctvLod(input, { cameraHeightM: 500, viewW: Infinity, viewH: 800 }).cardIds,
|
|
legacy.cardIds,
|
|
);
|
|
assert.deepEqual(
|
|
selectCctvLod(input, { cameraHeightM: 500, viewW: 1000, viewH: Infinity }).cardIds,
|
|
legacy.cardIds,
|
|
);
|
|
|
|
const legacyEdgeIds = [
|
|
{ id: ' ', distanceKm: 1, inView: true },
|
|
{ id: 'normal', distanceKm: 2, inView: true },
|
|
];
|
|
assert.deepEqual(
|
|
selectCctvLod(legacyEdgeIds, { cameraHeightM: 500, viewW: 0, viewH: 800 }).cardIds,
|
|
[' ', 'normal'],
|
|
'invalid viewport preserves every non-empty string ID accepted by the legacy path',
|
|
);
|
|
});
|
|
|
|
function edgeVsCenterPool() {
|
|
const edge = Array.from({ length: 30 }, (_, index) => ({
|
|
id: `edge-${String(index).padStart(2, '0')}`,
|
|
distanceKm: 1 + index / 100,
|
|
inView: true,
|
|
sx: 20 + (index % 5) * 2,
|
|
sy: 780 - Math.floor(index / 5) * 2,
|
|
}));
|
|
const center = Array.from({ length: 10 }, (_, index) => ({
|
|
id: `center-${String(index).padStart(2, '0')}`,
|
|
distanceKm: 12 + index / 100,
|
|
inView: true,
|
|
sx: 490 + (index % 5) * 4,
|
|
sy: 390 + (index % 5) * 2,
|
|
}));
|
|
return { edge, center };
|
|
}
|
|
|
|
test('center weighting deterministically favors center without starving peripheral coverage', () => {
|
|
const { edge, center } = edgeVsCenterPool();
|
|
const view = { cameraHeightM: 500, viewW: 1000, viewH: 800 };
|
|
const selected = selectCctvLod([...edge, ...center], view);
|
|
const reordered = selectCctvLod([...center].reverse().concat([...edge].reverse()), view);
|
|
|
|
assert.equal(selected.cardIds.length, CCTV_AMBIENT_CARD_MIN);
|
|
assert.equal(selected.cardIds.filter((id) => id.startsWith('center-')).length, 10);
|
|
assert.equal(selected.cardIds.filter((id) => id.startsWith('edge-')).length, 10);
|
|
assert.deepEqual(reordered.cardIds, selected.cardIds, 'input order cannot affect winners or ordering');
|
|
|
|
const legacy = selectCctvLod(
|
|
[...edge, ...center].map(({ sx, sy, ...candidate }) => candidate),
|
|
{ cameraHeightM: 500 },
|
|
);
|
|
assert.equal(legacy.cardIds.filter((id) => id.startsWith('center-')).length, 0);
|
|
});
|
|
|
|
test('ineligible video, hidden, and malformed-distance rows cannot alter eligible winners', () => {
|
|
const { edge, center } = edgeVsCenterPool();
|
|
const eligible = [...edge, ...center];
|
|
const view = { cameraHeightM: 500, viewW: 1000, viewH: 800 };
|
|
const baseline = selectCctvLod(eligible, view).cardIds;
|
|
const noise = [
|
|
...Array.from({ length: 50 }, (_, index) => ({
|
|
id: `video-${index}`,
|
|
distanceKm: 1_000 + index,
|
|
inView: true,
|
|
isVideo: true,
|
|
sx: 500,
|
|
sy: 400,
|
|
})),
|
|
{ id: 'hidden-outlier', distanceKm: 9_000, inView: false, sx: 900, sy: 700 },
|
|
{ id: 'bad-distance', distanceKm: NaN, inView: true, sx: 900, sy: 700 },
|
|
{ id: '', distanceKm: 0, inView: true, sx: 500, sy: 400 },
|
|
];
|
|
|
|
assert.deepEqual(selectCctvLod([...eligible, ...noise], view).cardIds, baseline);
|
|
assert.deepEqual(selectCctvLod([...noise].reverse().concat([...eligible].reverse()), view).cardIds, baseline);
|
|
});
|
|
|
|
test('malformed-distance rows remain slot-neutral when valid candidates leave spare capacity', () => {
|
|
const view = { cameraHeightM: 500, viewW: 1000, viewH: 800 };
|
|
const candidates = [
|
|
{ id: 'valid', distanceKm: 1, inView: true, sx: 500, sy: 400 },
|
|
{ id: 'bad', distanceKm: NaN, inView: true, sx: 510, sy: 410 },
|
|
];
|
|
|
|
assert.deepEqual(selectCctvLod(candidates, view).cardIds, ['valid']);
|
|
assert.deepEqual(selectCctvLod([...candidates].reverse(), view).cardIds, ['valid']);
|
|
});
|
|
|
|
test('duplicate IDs are slot-neutral and choose a deterministic representative', () => {
|
|
const { edge, center } = edgeVsCenterPool();
|
|
const eligible = [...edge, ...center];
|
|
const view = { cameraHeightM: 500, viewW: 1000, viewH: 800 };
|
|
const baseline = selectCctvLod(eligible, view).cardIds;
|
|
const duplicates = [
|
|
{ ...edge[0], distanceKm: 1_000, sx: 500, sy: 400 },
|
|
{ ...center[0], sx: 20, sy: 780 },
|
|
{ ...center[0], distanceKm: NaN, sx: 500, sy: 400 },
|
|
];
|
|
|
|
assert.deepEqual(selectCctvLod([...eligible, ...duplicates], view).cardIds, baseline);
|
|
assert.deepEqual(
|
|
selectCctvLod([...duplicates, ...eligible].reverse(), view).cardIds,
|
|
baseline,
|
|
'input order cannot choose a different duplicate anchor or affect spread',
|
|
);
|
|
});
|
|
|
|
test('center weighting has deterministic ID ties and preserves invalid-anchor eligibility', () => {
|
|
const anchors = Array.from({ length: CCTV_AMBIENT_CARD_MIN - 1 }, (_, index) => ({
|
|
id: `anchor-${String(index).padStart(2, '0')}`,
|
|
distanceKm: index / 100,
|
|
inView: true,
|
|
sx: 500,
|
|
sy: 400,
|
|
}));
|
|
const tied = [
|
|
{ id: 'tie-b', distanceKm: 10, inView: true, sx: 500, sy: 400 },
|
|
{ id: 'tie-a', distanceKm: 10, inView: true, sx: 500, sy: 400 },
|
|
{ id: 'invalid-anchor', distanceKm: 30, inView: true, sx: NaN, sy: NaN },
|
|
];
|
|
const selected = selectCctvLod([...anchors, ...tied], {
|
|
cameraHeightM: 500,
|
|
viewW: 1000,
|
|
viewH: 800,
|
|
});
|
|
assert.ok(selected.cardIds.includes('tie-a'));
|
|
assert.equal(selected.cardIds.includes('tie-b'), false, 'ID breaks an exact contested tie');
|
|
assert.equal(selected.cardIds.includes('invalid-anchor'), false, 'invalid anchor does not displace valid winners');
|
|
|
|
const onlyInvalid = selectCctvLod([
|
|
{ id: 'invalid-only', distanceKm: 1, inView: true, sx: NaN, sy: NaN },
|
|
], { cameraHeightM: 500, viewW: 1000, viewH: 800 });
|
|
assert.deepEqual(onlyInvalid.cardIds, ['invalid-only'], 'defensive top-up preserves eligibility');
|
|
});
|
|
|
|
test('applyEvictionGrace keeps a fallen-out card and clears grace when it returns', () => {
|
|
// Pass 1: cam-b falls out of the selection but keeps its live card.
|
|
const pass1 = applyEvictionGrace({
|
|
selectedIds: ['cam-a'],
|
|
builtIds: ['cam-a', 'cam-b'],
|
|
graceState: new Map(),
|
|
nowMs: 1_000,
|
|
cardLimit: 16,
|
|
});
|
|
assert.ok(pass1.keepIds.includes('cam-b'), 'graced card stays alive');
|
|
assert.deepEqual(pass1.evictIds, []);
|
|
assert.deepEqual(pass1.graceState.get('cam-b'), { misses: 1, since: 1_000 });
|
|
|
|
// Pass 2: cam-b is selected again — card survived, grace entry cleared.
|
|
const pass2 = applyEvictionGrace({
|
|
selectedIds: ['cam-a', 'cam-b'],
|
|
builtIds: ['cam-a', 'cam-b'],
|
|
graceState: pass1.graceState,
|
|
nowMs: 1_500,
|
|
cardLimit: 16,
|
|
});
|
|
assert.ok(pass2.keepIds.includes('cam-b'));
|
|
assert.deepEqual(pass2.evictIds, []);
|
|
assert.equal(pass2.graceState.size, 0);
|
|
});
|
|
|
|
test('applyEvictionGrace evicts a card that stays unselected past the pass budget', () => {
|
|
let graceState = new Map();
|
|
let result;
|
|
// cam-b stays out: survives CCTV_LOD_GRACE_PASSES consecutive misses...
|
|
for (let pass = 1; pass <= CCTV_LOD_GRACE_PASSES; pass++) {
|
|
result = applyEvictionGrace({
|
|
selectedIds: ['cam-a'],
|
|
builtIds: ['cam-a', 'cam-b'],
|
|
graceState,
|
|
nowMs: 1_000 + pass * 100,
|
|
cardLimit: 16,
|
|
});
|
|
graceState = result.graceState;
|
|
assert.ok(result.keepIds.includes('cam-b'), `still graced at miss ${pass}`);
|
|
}
|
|
// ...and is dropped on the next pass.
|
|
result = applyEvictionGrace({
|
|
selectedIds: ['cam-a'],
|
|
builtIds: ['cam-a', 'cam-b'],
|
|
graceState,
|
|
nowMs: 1_400,
|
|
cardLimit: 16,
|
|
});
|
|
assert.deepEqual(result.evictIds, ['cam-b']);
|
|
assert.equal(result.keepIds.includes('cam-b'), false);
|
|
assert.equal(result.graceState.has('cam-b'), false);
|
|
});
|
|
|
|
test('applyEvictionGrace evicts on wall-time even with few passes', () => {
|
|
const pass1 = applyEvictionGrace({
|
|
selectedIds: ['cam-a'],
|
|
builtIds: ['cam-a', 'cam-b'],
|
|
graceState: new Map(),
|
|
nowMs: 10_000,
|
|
cardLimit: 16,
|
|
});
|
|
assert.ok(pass1.keepIds.includes('cam-b'));
|
|
const pass2 = applyEvictionGrace({
|
|
selectedIds: ['cam-a'],
|
|
builtIds: ['cam-a', 'cam-b'],
|
|
graceState: pass1.graceState,
|
|
nowMs: 10_000 + CCTV_LOD_GRACE_MS,
|
|
cardLimit: 16,
|
|
});
|
|
assert.deepEqual(pass2.evictIds, ['cam-b']);
|
|
});
|
|
|
|
test('applyEvictionGrace never exceeds the hard cap; graced cards go first, oldest first', () => {
|
|
// Two cards in grace, cam-old fell out before cam-new.
|
|
const graceState = new Map([
|
|
['cam-old', { misses: 1, since: 1_000 }],
|
|
['cam-new', { misses: 1, since: 2_000 }],
|
|
]);
|
|
// Selection fills 3 of 4 slots: only one grace slot remains.
|
|
const result = applyEvictionGrace({
|
|
selectedIds: ['cam-a', 'cam-b', 'cam-c'],
|
|
builtIds: ['cam-a', 'cam-b', 'cam-old', 'cam-new'],
|
|
graceState,
|
|
nowMs: 2_100,
|
|
cardLimit: 4,
|
|
});
|
|
assert.equal(result.keepIds.length, 4);
|
|
// cam-c is newly selected and enters immediately despite grace pressure.
|
|
assert.ok(result.keepIds.includes('cam-c'));
|
|
assert.ok(result.keepIds.includes('cam-new'), 'newest grace entry survives');
|
|
assert.deepEqual(result.evictIds, ['cam-old'], 'oldest grace entry evicted for the cap');
|
|
});
|
|
|
|
test('applyEvictionGrace with a full selection keeps no graced cards', () => {
|
|
const selectedIds = Array.from({ length: 4 }, (_, i) => `cam-${i}`);
|
|
const result = applyEvictionGrace({
|
|
selectedIds,
|
|
builtIds: [...selectedIds, 'cam-extra'],
|
|
graceState: new Map(),
|
|
nowMs: 1_000,
|
|
cardLimit: 4,
|
|
});
|
|
assert.deepEqual(result.keepIds.sort(), selectedIds.sort());
|
|
assert.deepEqual(result.evictIds, ['cam-extra']);
|
|
});
|
|
|
|
test('staticFrameRefreshMs follows known pack cadences and bounds explicit values', () => {
|
|
assert.equal(staticFrameRefreshMs({ provider: 'Austin Transportation & Public Works' }), 300_000);
|
|
assert.equal(staticFrameRefreshMs({ provider: 'Transport for London' }), 180_000);
|
|
assert.equal(staticFrameRefreshMs({ provider: 'Caltrans' }), 180_000);
|
|
assert.equal(staticFrameRefreshMs({ frameRefreshMs: 5_000 }), 60_000);
|
|
assert.equal(staticFrameRefreshMs({ frameRefreshMs: 3_000_000 }), 1_200_000);
|
|
assert.equal(staticFrameRefreshMs({ provider: 'Unknown Provider' }), 300_000);
|
|
});
|