mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Riding an aircraft now adopts its layer the way a direct selection does, and Contacts gives up a dependency the user adopts, so ending Contacts mid-session (one of its layers off, or Contacts itself) no longer turns off the ridden layer and ends the Cockpit. When Contacts goes off, Live Signals drops the rows built from its snapshot instead of leaving stale distances marked CURRENT, and the feed-off warning is no longer duplicated.
4196 lines
127 KiB
JavaScript
4196 lines
127 KiB
JavaScript
import { readFileSync } from 'node:fs';
|
|
import { readLayerSource } from '../testSupport/readLayerSource.mjs';
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import * as Cesium from 'cesium';
|
|
import militaryAwarenessLayer, {
|
|
_getAwarenessNavigationStateForTest,
|
|
_getAwarenessPanelRendersForTest,
|
|
awarenessClearMatchesSubject,
|
|
awarenessNeedsContinuousRender,
|
|
awarenessRefreshDecision,
|
|
awarenessRefreshIntervalMs,
|
|
awarenessRefreshRequired,
|
|
awarenessResultsAreLive,
|
|
buildAwarenessContextSnapshot,
|
|
canNavigateAwarenessNext,
|
|
contactsWindowFromSnapshot,
|
|
contextTargetFlyToAllowed,
|
|
summarizeInstallationViewport,
|
|
findCompatibleHistoryIndex,
|
|
AWARENESS_QUERY_LIMIT,
|
|
historySubjectSnapshot,
|
|
} from './militaryAwareness.js';
|
|
import flightsLayer, {
|
|
_setTrackedFlightRefreshStateForTest,
|
|
} from './flights.js';
|
|
import militaryFlightsLayer, {
|
|
_setTrackedMilitaryRefreshStateForTest,
|
|
} from './militaryFlights.js';
|
|
import aisLiveVesselsLayer, {
|
|
_setVesselStateForTest,
|
|
} from './aisLiveVessels.js';
|
|
import militaryInstallationsLayer from './militaryInstallations.js';
|
|
import {
|
|
_resetRenderGovernorForTest,
|
|
getRenderGovernorDiagnostics,
|
|
installRenderGovernor,
|
|
} from '../renderGovernor.js';
|
|
import {
|
|
AWARENESS_RADIUS_M,
|
|
formatAwarenessLabel,
|
|
getAwarenessNavigationTargets,
|
|
} from './militaryAwarenessEngine.js';
|
|
import {
|
|
formatAwarenessCount,
|
|
presentAwarenessDistance,
|
|
} from '../layers/awareness/panel.js';
|
|
import { NAVIGATION_AUTHORITY_EVENT } from '../navigationPolicy.js';
|
|
|
|
const militaryAwarenessSource = readLayerSource(
|
|
new URL('./militaryAwareness.js', import.meta.url),
|
|
'utf8',
|
|
);
|
|
const awarenessPanelSource = readFileSync(
|
|
new URL('../ui/views/panels/AwarenessPanel.vue', import.meta.url),
|
|
'utf8',
|
|
);
|
|
|
|
const AWARENESS_DEPENDENCIES = [
|
|
'flights',
|
|
'military',
|
|
'ais-live-vessels',
|
|
'military-installations',
|
|
];
|
|
|
|
test('Contacts labels a capped cohort as a lower bound', () => {
|
|
assert.equal(
|
|
formatAwarenessCount({ count: 20_000, complete: false, truncated: true }),
|
|
'At least 20,000',
|
|
);
|
|
assert.equal(
|
|
formatAwarenessCount({ count: 19_999, complete: true, truncated: false }),
|
|
'19,999',
|
|
);
|
|
assert.equal(formatAwarenessCount({ count: null }), '?');
|
|
});
|
|
|
|
test('Contacts moves a distance that rounds to 1,000 m into kilometres', () => {
|
|
assert.equal(presentAwarenessDistance(999.4), '999\u00a0m');
|
|
assert.equal(presentAwarenessDistance(999.6), '1.0\u00a0km');
|
|
assert.equal(presentAwarenessDistance(4600), '4.6\u00a0km');
|
|
assert.equal(presentAwarenessDistance(9949), '9.9\u00a0km');
|
|
assert.equal(presentAwarenessDistance(9950), '10\u00a0km');
|
|
assert.equal(presentAwarenessDistance(9960), '10\u00a0km');
|
|
});
|
|
|
|
function installAwarenessRuntime({
|
|
isEnabled = () => true,
|
|
isEffectivelyEnabled = isEnabled,
|
|
setEnabled = async () => true,
|
|
getLayerLifecycleState = (layerId) => ({
|
|
enabled: isEnabled(layerId),
|
|
lifecycleState: isEnabled(layerId) ? 'enabled' : 'disabled',
|
|
uncertain: false,
|
|
}),
|
|
// Per-layer getStats override, keyed by layer id. Whatever a caller puts here
|
|
// must be a shape the REAL module actually returns — a fixture that invents a
|
|
// status its module never emits guards nothing. See the settled-but-fetching
|
|
// tests below, which use militaryInstallations' genuine first-fetch readout.
|
|
layerStats = {},
|
|
subscribe = undefined,
|
|
} = {}) {
|
|
const originalWindow = globalThis.window;
|
|
const originalDocument = globalThis.document;
|
|
const listeners = new Map();
|
|
let nextTimer = 1;
|
|
let preRenderListener = null;
|
|
|
|
class FakeElement {
|
|
constructor() {
|
|
this.classList = { contains: () => false };
|
|
this.style = { setProperty() {} };
|
|
this.hidden = false;
|
|
}
|
|
|
|
setAttribute() {}
|
|
addEventListener() {}
|
|
removeEventListener() {}
|
|
appendChild() {}
|
|
append() {}
|
|
remove() {}
|
|
replaceChildren() {}
|
|
}
|
|
|
|
const fakeWindow = {
|
|
addEventListener(type, listener) {
|
|
if (!listeners.has(type)) listeners.set(type, new Set());
|
|
listeners.get(type).add(listener);
|
|
},
|
|
removeEventListener(type, listener) {
|
|
listeners.get(type)?.delete(listener);
|
|
},
|
|
setInterval() {
|
|
return nextTimer++;
|
|
},
|
|
clearInterval() {},
|
|
requestAnimationFrame() {
|
|
return nextTimer++;
|
|
},
|
|
cancelAnimationFrame() {},
|
|
dispatch(type, detail) {
|
|
for (const listener of listeners.get(type) || []) listener({ detail });
|
|
},
|
|
// Real dispatch surface: the layer announces navigation authority through
|
|
// it before any camera flight that does not assign a tracked entity.
|
|
dispatchEvent(event) {
|
|
for (const listener of listeners.get(event?.type) || []) listener(event);
|
|
return true;
|
|
},
|
|
};
|
|
const fakeBody = new FakeElement();
|
|
const renderRequests = [];
|
|
const cameraFlights = [];
|
|
const viewer = {
|
|
camera: {
|
|
flyToBoundingSphere(sphere, options) {
|
|
cameraFlights.push({ sphere, options });
|
|
},
|
|
cancelFlight() {},
|
|
},
|
|
scene: {
|
|
// Enough surface for the real render governor to drive this viewer.
|
|
requestRenderMode: false,
|
|
maximumRenderTimeChange: 0,
|
|
requestRender() {
|
|
renderRequests.push(Date.now());
|
|
},
|
|
preRender: {
|
|
addEventListener(listener) {
|
|
preRenderListener = listener;
|
|
return () => {
|
|
preRenderListener = null;
|
|
};
|
|
},
|
|
},
|
|
},
|
|
entities: {
|
|
add(entity) {
|
|
return entity;
|
|
},
|
|
remove() {},
|
|
},
|
|
container: new FakeElement(),
|
|
};
|
|
const layers = new Map(
|
|
AWARENESS_DEPENDENCIES.map((layerId) => [
|
|
layerId,
|
|
{
|
|
module: {
|
|
getStats() {
|
|
const override = layerStats[layerId];
|
|
if (override)
|
|
return typeof override === 'function' ? override() : override;
|
|
return { count: 4, status: 'ready', stale: false, error: null };
|
|
},
|
|
},
|
|
},
|
|
]),
|
|
);
|
|
|
|
globalThis.window = fakeWindow;
|
|
globalThis.document = {
|
|
body: fakeBody,
|
|
getElementById() {
|
|
return null;
|
|
},
|
|
createElement() {
|
|
return new FakeElement();
|
|
},
|
|
addEventListener() {},
|
|
removeEventListener() {},
|
|
};
|
|
militaryAwarenessLayer.attachDataManager({
|
|
isEnabled,
|
|
isEffectivelyEnabled,
|
|
setEnabled,
|
|
getLayerLifecycleState,
|
|
layers,
|
|
...(subscribe ? { subscribe } : {}),
|
|
});
|
|
militaryAwarenessLayer.setParams({ passive: true });
|
|
militaryAwarenessLayer.init(viewer);
|
|
const panelViews = [];
|
|
const unsubscribePanel = militaryAwarenessLayer.subscribePanel((view) =>
|
|
panelViews.push(view),
|
|
);
|
|
militaryAwarenessLayer.enable();
|
|
|
|
return {
|
|
dispatch: fakeWindow.dispatch.bind(fakeWindow),
|
|
tick() {
|
|
preRenderListener?.();
|
|
},
|
|
viewer,
|
|
renderRequests,
|
|
cameraFlights,
|
|
window: fakeWindow,
|
|
/** Record every navigation-authority announcement, in order. */
|
|
captureAuthority() {
|
|
const taken = [];
|
|
fakeWindow.addEventListener(NAVIGATION_AUTHORITY_EVENT, (event) =>
|
|
taken.push(event?.detail?.reason || 'unknown'),
|
|
);
|
|
return taken;
|
|
},
|
|
/** The Contacts panel as the layer publishes it to the view. */
|
|
panel() {
|
|
return {
|
|
view: panelViews.at(-1) ?? null,
|
|
publishes: panelViews.length,
|
|
renders: _getAwarenessPanelRendersForTest(),
|
|
};
|
|
},
|
|
restore() {
|
|
unsubscribePanel();
|
|
militaryAwarenessLayer.destroy();
|
|
globalThis.window = originalWindow;
|
|
globalThis.document = originalDocument;
|
|
},
|
|
};
|
|
}
|
|
|
|
/** The count a published Contacts panel shows for one cohort row. */
|
|
function panelCount(runtime, label) {
|
|
return runtime.panel().view?.rows?.find((row) => row.label === label)?.count;
|
|
}
|
|
|
|
test('Contacts continuation target is the visible explanatory note', () => {
|
|
assert.match(
|
|
awarenessPanelSource,
|
|
/<p class="military-awareness-note" tabindex="-1" data-awareness-focus-continuation>\{\{ view\.note \}\}<\/p>/,
|
|
);
|
|
assert.doesNotMatch(
|
|
awarenessPanelSource,
|
|
/<span[^>]*data-awareness-focus-continuation/,
|
|
);
|
|
assert.match(
|
|
militaryAwarenessSource,
|
|
/'Open-source mapped\/observed context\./,
|
|
);
|
|
});
|
|
|
|
test('awareness disable settles every owned dependency release before resolving', async () => {
|
|
let releasing = false;
|
|
let releaseDependencies;
|
|
const releaseGate = new Promise((resolve) => {
|
|
releaseDependencies = resolve;
|
|
});
|
|
const calls = [];
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => false,
|
|
setEnabled: async (layerId, enabled) => {
|
|
calls.push({ layerId, enabled });
|
|
if (!enabled) await releaseGate;
|
|
return true;
|
|
},
|
|
});
|
|
|
|
try {
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
militaryAwarenessLayer.enable();
|
|
await nextTurn();
|
|
const disabling = militaryAwarenessLayer.disable().then(() => {
|
|
releasing = true;
|
|
});
|
|
await nextTurn();
|
|
assert.equal(
|
|
releasing,
|
|
false,
|
|
'coordinator OFF waits for owned dependency releases',
|
|
);
|
|
assert.deepEqual(
|
|
calls
|
|
.filter(({ enabled }) => !enabled)
|
|
.map(({ layerId }) => layerId)
|
|
.sort(),
|
|
[...AWARENESS_DEPENDENCIES].sort(),
|
|
);
|
|
releaseDependencies();
|
|
await disabling;
|
|
assert.equal(releasing, true);
|
|
} finally {
|
|
releaseDependencies();
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('same-turn Contacts OFF registers after every owned dependency ON', async () => {
|
|
const calls = [];
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => false,
|
|
isEffectivelyEnabled: () => false,
|
|
setEnabled: (layerId, enabled) => {
|
|
calls.push({ layerId, enabled });
|
|
return Promise.resolve(true);
|
|
},
|
|
});
|
|
|
|
try {
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
const disabling = militaryAwarenessLayer.disable();
|
|
assert.deepEqual(
|
|
calls.map(
|
|
({ layerId, enabled }) => `${layerId}:${enabled ? 'on' : 'off'}`,
|
|
),
|
|
[
|
|
...AWARENESS_DEPENDENCIES.map((layerId) => `${layerId}:on`),
|
|
...AWARENESS_DEPENDENCIES.map((layerId) => `${layerId}:off`),
|
|
],
|
|
'OFF must be the newest manager intent before this JavaScript turn yields',
|
|
);
|
|
await disabling;
|
|
await nextTurn();
|
|
assert.equal(
|
|
calls.slice(AWARENESS_DEPENDENCIES.length).some(({ enabled }) => enabled),
|
|
false,
|
|
'no deferred ON may run after release',
|
|
);
|
|
} finally {
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('Contacts does not claim a dependency already enabling for the user', async () => {
|
|
const calls = [];
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => false,
|
|
isEffectivelyEnabled: (layerId) => layerId === 'flights',
|
|
setEnabled: (layerId, enabled) => {
|
|
calls.push({ layerId, enabled });
|
|
return Promise.resolve(true);
|
|
},
|
|
});
|
|
|
|
try {
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await militaryAwarenessLayer.disable();
|
|
assert.equal(
|
|
calls.some(({ layerId }) => layerId === 'flights'),
|
|
false,
|
|
'an in-flight user enable stays outside Contacts ownership',
|
|
);
|
|
} finally {
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a dependency the user adopts stays on when Contacts turns off', async () => {
|
|
// A direct selection, or the Cockpit riding one of its aircraft, promotes a
|
|
// layer Contacts turned on into the user's own (adoptLayerVisibility). The
|
|
// coordinator must give it up, or its OFF release tears the layer down —
|
|
// and the track or the Cockpit with it — before Context restores it.
|
|
const calls = [];
|
|
const subscribers = new Set();
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => false,
|
|
isEffectivelyEnabled: () => false,
|
|
setEnabled: (layerId, enabled) => {
|
|
calls.push({ layerId, enabled });
|
|
return Promise.resolve(true);
|
|
},
|
|
subscribe: (listener) => {
|
|
subscribers.add(listener);
|
|
return () => subscribers.delete(listener);
|
|
},
|
|
});
|
|
|
|
try {
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
for (const listener of subscribers)
|
|
listener({
|
|
type: 'visibility',
|
|
layerId: 'flights',
|
|
enabled: true,
|
|
origin: 'user',
|
|
adopted: true,
|
|
adoptedFromSelection: true,
|
|
});
|
|
await militaryAwarenessLayer.disable();
|
|
const released = calls
|
|
.filter(({ enabled }) => !enabled)
|
|
.map(({ layerId }) => layerId)
|
|
.sort();
|
|
assert.deepEqual(
|
|
released,
|
|
AWARENESS_DEPENDENCIES.filter((layerId) => layerId !== 'flights').sort(),
|
|
'the adopted layer is the user\'s now; the rest are still released',
|
|
);
|
|
} finally {
|
|
runtime.restore();
|
|
}
|
|
assert.equal(subscribers.size, 0, 'destroy drops the manager subscription');
|
|
});
|
|
|
|
test('operational awareness becomes ready after aircraft while deferred sources keep loading', async () => {
|
|
let enabled = false;
|
|
let releaseAircraft;
|
|
let releaseDeferred;
|
|
const aircraftGate = new Promise((resolve) => {
|
|
releaseAircraft = resolve;
|
|
});
|
|
const deferredGate = new Promise((resolve) => {
|
|
releaseDeferred = resolve;
|
|
});
|
|
const calls = [];
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => false,
|
|
setEnabled: async (layerId, nextEnabled) => {
|
|
calls.push({ layerId, enabled: nextEnabled });
|
|
if (nextEnabled) {
|
|
await (['flights', 'military'].includes(layerId)
|
|
? aircraftGate
|
|
: deferredGate);
|
|
}
|
|
return true;
|
|
},
|
|
});
|
|
|
|
try {
|
|
await militaryAwarenessLayer.disable();
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
const enabling = militaryAwarenessLayer.enable().then(() => {
|
|
enabled = true;
|
|
});
|
|
await nextTurn();
|
|
assert.equal(enabled, false, 'coordinator ON waits for aircraft readiness');
|
|
assert.deepEqual(
|
|
calls
|
|
.filter(({ enabled: nextEnabled }) => nextEnabled)
|
|
.map(({ layerId }) => layerId)
|
|
.sort(),
|
|
[...AWARENESS_DEPENDENCIES].sort(),
|
|
);
|
|
releaseAircraft();
|
|
await enabling;
|
|
assert.equal(
|
|
enabled,
|
|
true,
|
|
'deferred vessels/installations do not block Contacts',
|
|
);
|
|
assert.equal(
|
|
calls.filter(({ layerId }) =>
|
|
['ais-live-vessels', 'military-installations'].includes(layerId),
|
|
).length,
|
|
2,
|
|
'deferred requests were started in the same activation',
|
|
);
|
|
} finally {
|
|
releaseAircraft();
|
|
releaseDeferred();
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('pending mapped installations render as unknown instead of a false zero', async () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1_000);
|
|
const restoreCollections = stubAwarenessCollections({});
|
|
const runtime = installAwarenessRuntime({
|
|
// Deliberately inconsistent visibility intent exercises the defensive
|
|
// lifecycle guard: `enabling` must win over a stale true response.
|
|
isEnabled: () => true,
|
|
getLayerLifecycleState: (layerId) =>
|
|
layerId === 'military-installations'
|
|
? { enabled: false, lifecycleState: 'enabling', uncertain: false }
|
|
: { enabled: true, lifecycleState: 'enabled', uncertain: false },
|
|
});
|
|
|
|
try {
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'pending-site', position),
|
|
);
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
const installations = snapshot?.cohorts.find(
|
|
({ id }) => id === 'military-installations',
|
|
);
|
|
assert.equal(
|
|
installations?.count,
|
|
null,
|
|
'loading is not an observed empty cohort',
|
|
);
|
|
assert.match(installations?.reason || '', /unavailable/i);
|
|
assert.equal(
|
|
panelCount(runtime, 'Mapped installations'),
|
|
'?',
|
|
'the operator sees ? rather than an all-clear 0 while installations load',
|
|
);
|
|
} finally {
|
|
restoreCollections();
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
// ── The `loading === true && !lastUpdate` predicate in sourceState ────────────
|
|
//
|
|
// It is a CONTRACT over the whole dependency list, not a fix for one layer, and
|
|
// the dependencies reach it by different routes:
|
|
//
|
|
// - ais-live-vessels is its REACHABLE producer. enable()/update() both resolve
|
|
// as soon as the first /api/vessels poll answers, so the manager's
|
|
// lifecycle settles to `enabled` — but until the server-side socket delivers
|
|
// a position, firstConnectPhase stays 'loading' and the module reports busy,
|
|
// no lastUpdate, count 0, and an UNDEFINED status, so the status list alone
|
|
// never catches it either.
|
|
// - military-installations never reaches this window, and these pins are not
|
|
// about it. Its enable() is synchronous and the manager awaits update(),
|
|
// which owns the first Overpass fetch, so the lifecycle stays `enabling`
|
|
// throughout and the sibling `enabling` test above is what covers it.
|
|
// Confirmed live on :4272 across a held 17 s first fetch (34 samples,
|
|
// `enabling` the whole way) and across a failing one.
|
|
//
|
|
// The readouts below are taken FROM the real module rather than hand-written. A
|
|
// fixture that invents a shape its module never emits guards nothing — that is
|
|
// exactly how a hole in this gate survived a passing suite once already.
|
|
|
|
/** Drive aisLiveVessels into a state and return the readout IT produces. */
|
|
function aisStatsFor(options) {
|
|
_setVesselStateForTest(options);
|
|
return Object.freeze(aisLiveVesselsLayer.getStats());
|
|
}
|
|
|
|
/** Socket connecting: busy, never answered, undefined status. */
|
|
const AIS_FIRST_CONNECT_STATS = aisStatsFor({
|
|
enabled: true,
|
|
transportStatus: 'connecting',
|
|
firstConnectPhase: 'loading',
|
|
lastUpdate: null,
|
|
});
|
|
|
|
/** The same module once the socket answers with an honestly empty viewport. */
|
|
const AIS_SETTLED_EMPTY_STATS = aisStatsFor({
|
|
enabled: true,
|
|
transportStatus: 'open',
|
|
firstConnectPhase: 'ready',
|
|
lastUpdate: 1_700_000_000_000,
|
|
});
|
|
|
|
/** Answered once, and busy again on a later refresh poll. */
|
|
const AIS_REFRESHING_ANSWERED_STATS = aisStatsFor({
|
|
enabled: true,
|
|
loading: true,
|
|
transportStatus: 'open',
|
|
firstConnectPhase: 'ready',
|
|
lastUpdate: 1_700_000_000_000,
|
|
records: [{ mmsi: '1' }, { mmsi: '2' }, { mmsi: '3' }],
|
|
});
|
|
|
|
// Leave the shared module neutral for every test below.
|
|
_setVesselStateForTest({ enabled: false });
|
|
|
|
test('the first-connect readout is the real one, and is exactly what the predicate keys on', () => {
|
|
assert.equal(
|
|
AIS_FIRST_CONNECT_STATS.loading,
|
|
true,
|
|
'the module reports itself busy while connecting',
|
|
);
|
|
assert.equal(
|
|
AIS_FIRST_CONNECT_STATS.lastUpdate,
|
|
null,
|
|
'and has never answered',
|
|
);
|
|
assert.equal(
|
|
AIS_FIRST_CONNECT_STATS.count,
|
|
0,
|
|
'with a zero that means nothing yet',
|
|
);
|
|
assert.equal(
|
|
AIS_FIRST_CONNECT_STATS.status,
|
|
undefined,
|
|
'and no status at all — the status list cannot be what catches this',
|
|
);
|
|
assert.equal(
|
|
AIS_SETTLED_EMPTY_STATS.loading,
|
|
false,
|
|
'an answered socket is not busy',
|
|
);
|
|
assert.ok(
|
|
AIS_SETTLED_EMPTY_STATS.lastUpdate,
|
|
'and carries the moment it answered',
|
|
);
|
|
assert.equal(
|
|
AIS_REFRESHING_ANSWERED_STATS.loading,
|
|
true,
|
|
'a refresh poll is busy again',
|
|
);
|
|
assert.ok(
|
|
AIS_REFRESHING_ANSWERED_STATS.lastUpdate,
|
|
'without erasing the answer already given',
|
|
);
|
|
});
|
|
|
|
test('a vessel feed still connecting after the lifecycle settles reads as unknown, not an all-clear', async () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1_000);
|
|
const restoreCollections = stubAwarenessCollections({});
|
|
// The window this pins: enable() and the first poll have RESOLVED, so the
|
|
// manager reports a fully settled `enabled` lifecycle, while the socket has
|
|
// still never delivered a position.
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => true,
|
|
getLayerLifecycleState: () => ({
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
uncertain: false,
|
|
}),
|
|
layerStats: { 'ais-live-vessels': AIS_FIRST_CONNECT_STATS },
|
|
});
|
|
|
|
try {
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'connecting-site', position),
|
|
);
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
const vessels = snapshot?.cohorts.find(
|
|
({ id }) => id === 'ais-live-vessels',
|
|
);
|
|
assert.equal(
|
|
vessels?.count,
|
|
null,
|
|
'a source that has never answered has told us nothing — 0 would be a fabricated all-clear',
|
|
);
|
|
assert.match(vessels?.reason || '', /unavailable/i);
|
|
assert.equal(
|
|
panelCount(runtime, 'AIS vessels'),
|
|
'?',
|
|
'the panel prints ? for the whole settled-but-connecting window, never an all-clear 0',
|
|
);
|
|
} finally {
|
|
restoreCollections();
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a settled vessel feed reporting a real empty viewport recovers to 0', async () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1_000);
|
|
const restoreCollections = stubAwarenessCollections({});
|
|
// Same lifecycle, but the socket answered: `lastUpdate` is set and the module
|
|
// is no longer busy, so this zero is an OBSERVATION and must be shown as one.
|
|
// Without this pin the fix above could degenerate into a permanent `?`.
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => true,
|
|
getLayerLifecycleState: () => ({
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
uncertain: false,
|
|
}),
|
|
layerStats: { 'ais-live-vessels': AIS_SETTLED_EMPTY_STATS },
|
|
});
|
|
|
|
try {
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'settled-site', position),
|
|
);
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
const vessels = snapshot?.cohorts.find(
|
|
({ id }) => id === 'ais-live-vessels',
|
|
);
|
|
assert.equal(
|
|
vessels?.count,
|
|
0,
|
|
'an answered empty viewport is a real observation',
|
|
);
|
|
assert.equal(
|
|
panelCount(runtime, 'AIS vessels'),
|
|
'0',
|
|
'the operator sees the real count once the feed answers',
|
|
);
|
|
} finally {
|
|
restoreCollections();
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a still-answered feed keeps its count through later polls that set loading again', async () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1_000);
|
|
const restoreCollections = stubAwarenessCollections({});
|
|
// A refresh poll sets `loading` true again while `lastUpdate` stays set. The
|
|
// guard is deliberately "never answered", not "busy": blanking to ? on every
|
|
// refresh would be its own dishonesty, and a flickering panel besides.
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => true,
|
|
getLayerLifecycleState: () => ({
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
uncertain: false,
|
|
}),
|
|
layerStats: { 'ais-live-vessels': AIS_REFRESHING_ANSWERED_STATS },
|
|
});
|
|
|
|
try {
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'refreshing-site', position),
|
|
);
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
const vessels = snapshot?.cohorts.find(
|
|
({ id }) => id === 'ais-live-vessels',
|
|
);
|
|
assert.notEqual(
|
|
vessels?.count,
|
|
null,
|
|
'a refresh poll does not erase an answer already given',
|
|
);
|
|
} finally {
|
|
restoreCollections();
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('voice reports a still-connecting vessel feed as unknown rather than zero', async () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1_000);
|
|
const restoreCollections = stubAwarenessCollections({});
|
|
// The same real first-connect readout the panel pins above. The voice surface
|
|
// reads the same cohort the panel does, so it inherited the same fabricated
|
|
// zero and needs its own pin.
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => true,
|
|
getLayerLifecycleState: () => ({
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
uncertain: false,
|
|
}),
|
|
layerStats: { 'ais-live-vessels': AIS_FIRST_CONNECT_STATS },
|
|
});
|
|
|
|
try {
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'voice-site', position),
|
|
);
|
|
await nextTurn();
|
|
|
|
const spoken = contactsWindowFromSnapshot(
|
|
militaryAwarenessLayer.getContextSnapshot(),
|
|
);
|
|
assert.equal(
|
|
spoken?.vessels,
|
|
'unknown',
|
|
'voice must not speak a zero the feed never reported',
|
|
);
|
|
} finally {
|
|
restoreCollections();
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
function nextTurn() {
|
|
return new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
|
|
function replaceMethod(target, name, replacement, restores) {
|
|
const original = target[name];
|
|
target[name] = replacement;
|
|
restores.push(() => {
|
|
target[name] = original;
|
|
});
|
|
}
|
|
|
|
function stubAwarenessCollections({
|
|
flights = [],
|
|
military = [],
|
|
vessels = [],
|
|
installations = [],
|
|
}) {
|
|
const restores = [];
|
|
replaceMethod(flightsLayer, 'getNearby', () => flights, restores);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'getAllPositions',
|
|
() => flights.map((item) => ({ ...item, id: item.icao24 })),
|
|
restores,
|
|
);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => military, restores);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'getAllPositions',
|
|
() => military.map((item) => ({ ...item, id: item.icao24 })),
|
|
restores,
|
|
);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => vessels, restores);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'getAllPositions',
|
|
() => vessels.map((item) => ({ ...item, id: item.mmsi })),
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryInstallationsLayer,
|
|
'getNearby',
|
|
() => installations,
|
|
restores,
|
|
);
|
|
return () => restores.reverse().forEach((restore) => restore());
|
|
}
|
|
|
|
function awarenessSubject(layerId, id, position) {
|
|
return { layerId, id, label: id, position };
|
|
}
|
|
|
|
for (const fixture of [
|
|
{
|
|
name: 'civilian',
|
|
layerId: 'flights',
|
|
layer: flightsLayer,
|
|
other: militaryFlightsLayer,
|
|
},
|
|
{
|
|
name: 'military',
|
|
layerId: 'military',
|
|
layer: militaryFlightsLayer,
|
|
other: flightsLayer,
|
|
},
|
|
]) {
|
|
test(`Contacts activation adopts an already tracked ${fixture.name} flight`, async () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const subject = awarenessSubject(
|
|
fixture.layerId,
|
|
`${fixture.name}-tracked`,
|
|
position,
|
|
);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
let retrackCalls = 0;
|
|
|
|
try {
|
|
const trackedEntity = {
|
|
gevTrackedId: `${subject.layerId}:${subject.id}`,
|
|
};
|
|
runtime.viewer.trackedEntity = trackedEntity;
|
|
replaceMethod(
|
|
fixture.layer,
|
|
'getTrackedSubject',
|
|
() => subject,
|
|
restores,
|
|
);
|
|
replaceMethod(fixture.other, 'getTrackedSubject', () => null, restores);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
() => {
|
|
retrackCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
() => {
|
|
retrackCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.equal(snapshot?.subject.layerId, subject.layerId);
|
|
assert.equal(snapshot?.subject.id, subject.id);
|
|
assert.equal(snapshot?.navigation.canPrevious, false);
|
|
assert.equal(snapshot?.navigation.canNext, false);
|
|
assert.equal(
|
|
retrackCalls,
|
|
0,
|
|
'adoption must not recreate the existing track',
|
|
);
|
|
assert.equal(
|
|
runtime.viewer.trackedEntity,
|
|
trackedEntity,
|
|
'adoption must not replace the source-owned tracked entity',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
}
|
|
|
|
test('Contacts activation adopts the production military tracked-subject descriptor', async () => {
|
|
const id = 'ae01ce';
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.03, 31.05, 8_534.4);
|
|
const sourceViewer = { scene: { primitives: { remove() {} } } };
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
let retrackCalls = 0;
|
|
|
|
try {
|
|
_setTrackedMilitaryRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, show: true },
|
|
billboardCollection: { show: true, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta: {
|
|
callsign: 'RCH451 ',
|
|
altitudeFt: 28_000,
|
|
renderAltitudeM: 8_534.4,
|
|
speedMps: 231.5,
|
|
track: 92.1,
|
|
onGround: false,
|
|
},
|
|
});
|
|
const accessorSubject = militaryFlightsLayer.getTrackedSubject();
|
|
assert.equal(accessorSubject?.layerId, 'military');
|
|
assert.equal(accessorSubject?.id, id);
|
|
assert.equal(accessorSubject?.label, 'RCH451');
|
|
assert.notEqual(
|
|
accessorSubject?.position,
|
|
position,
|
|
'the production accessor must detach its Cartesian position',
|
|
);
|
|
assert.ok(
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
accessorSubject?.position,
|
|
position,
|
|
Cesium.Math.EPSILON7,
|
|
),
|
|
);
|
|
accessorSubject.position.x += 100;
|
|
assert.ok(
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
militaryFlightsLayer.getTrackedSubject()?.position,
|
|
position,
|
|
Cesium.Math.EPSILON7,
|
|
),
|
|
'mutating one accessor result must not alter the tracked source position',
|
|
);
|
|
runtime.viewer.trackedEntity = { gevTrackedId: `military:${id}` };
|
|
replaceMethod(flightsLayer, 'getTrackedSubject', () => null, restores);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
() => {
|
|
retrackCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
() => {
|
|
retrackCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.equal(snapshot?.subject.layerId, 'military');
|
|
assert.equal(snapshot?.subject.id, id);
|
|
assert.equal(snapshot?.subject.label, 'RCH451');
|
|
assert.ok(
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
snapshot?.subject.position,
|
|
position,
|
|
Cesium.Math.EPSILON7,
|
|
),
|
|
);
|
|
assert.equal(
|
|
retrackCalls,
|
|
0,
|
|
'production military adoption must preserve tracker ownership',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
_setTrackedMilitaryRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, show: true },
|
|
billboardCollection: { show: true, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta: {},
|
|
tracked: false,
|
|
});
|
|
militaryFlightsLayer.destroy(sourceViewer);
|
|
assert.deepEqual(
|
|
militaryFlightsLayer.getAllPositions(),
|
|
[],
|
|
'production military test state must be fully cleared',
|
|
);
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('production military tracked-subject label falls back to registration before the ICAO hex', async () => {
|
|
const id = 'ae02df';
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.03, 31.05, 6_400);
|
|
const sourceViewer = { scene: { primitives: { remove() {} } } };
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
|
|
try {
|
|
_setTrackedMilitaryRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, show: true },
|
|
billboardCollection: { show: true, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta: {
|
|
callsign: ' ',
|
|
registration: 'N123AB ',
|
|
altitudeFt: 21_000,
|
|
renderAltitudeM: 6_400,
|
|
speedMps: 180.2,
|
|
track: 271.4,
|
|
onGround: false,
|
|
},
|
|
});
|
|
// The proximity list already labels a callsign-less contact by registration;
|
|
// the tracked-subject descriptor must use the same chain instead of the hex.
|
|
assert.equal(
|
|
militaryFlightsLayer.getNearby(position, 5_000)[0]?.id,
|
|
'N123AB',
|
|
);
|
|
assert.equal(militaryFlightsLayer.getTrackedSubject()?.label, 'N123AB');
|
|
// getAllPositions was the last military surface still reading as raw hex.
|
|
const snapshotRow = militaryFlightsLayer.getAllPositions(10)[0];
|
|
assert.equal(
|
|
snapshotRow?.label,
|
|
'N123AB',
|
|
'getAllPositions label must use the same chain',
|
|
);
|
|
assert.equal(
|
|
snapshotRow?.id,
|
|
id,
|
|
'getAllPositions id stays the identity hex',
|
|
);
|
|
|
|
runtime.viewer.trackedEntity = { gevTrackedId: `military:${id}` };
|
|
replaceMethod(flightsLayer, 'getTrackedSubject', () => null, restores);
|
|
replaceMethod(flightsLayer, 'trackById', () => true, restores);
|
|
replaceMethod(militaryFlightsLayer, 'trackById', () => true, restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.equal(snapshot?.subject.id, id);
|
|
assert.equal(
|
|
snapshot?.subject.label,
|
|
'N123AB',
|
|
'an adopted callsign-less contact must not surface its raw ICAO hex',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
_setTrackedMilitaryRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, show: true },
|
|
billboardCollection: { show: true, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta: {},
|
|
tracked: false,
|
|
});
|
|
militaryFlightsLayer.destroy(sourceViewer);
|
|
assert.deepEqual(
|
|
militaryFlightsLayer.getAllPositions(),
|
|
[],
|
|
'production military test state must be fully cleared',
|
|
);
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a cached Context subject re-reads its label when enrichment lands after selection', async () => {
|
|
// The subject snapshot is captured once at selection. Selecting a
|
|
// callsign-less aircraft BEFORE adsbdb enrichment answers used to freeze the
|
|
// ICAO hex into Context while every other surface later swapped to the
|
|
// registration. The refresh path must re-resolve the label, never the id.
|
|
const id = 'ae1fa4';
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668);
|
|
const sourceViewer = { camera: { positionCartographic: null }, scene: {} };
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
// Held by reference so the enrichment step can mutate it in place, exactly
|
|
// as _requestTypeEnrichment's callback does (`meta.registration = …`).
|
|
const meta = {
|
|
callsign: ' ',
|
|
altitude: 10_668,
|
|
renderAltitudeM: 10_700,
|
|
velocity: 250,
|
|
true_track: 95,
|
|
klass: 'airliner',
|
|
onGround: false,
|
|
wasAirborne: true,
|
|
turnRateDps: 0,
|
|
rawLat: 30.21,
|
|
rawLon: -97.71,
|
|
};
|
|
|
|
try {
|
|
_setTrackedFlightRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, color: Cesium.Color.WHITE, show: true },
|
|
billboardCollection: { show: true, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta,
|
|
});
|
|
|
|
runtime.viewer.trackedEntity = { gevTrackedId: `flights:${id}` };
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'getTrackedSubject',
|
|
() => null,
|
|
restores,
|
|
);
|
|
replaceMethod(flightsLayer, 'trackById', () => true, restores);
|
|
replaceMethod(militaryFlightsLayer, 'trackById', () => true, restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
|
|
// Pre-enrichment: nothing but the hex is known, so the hex is correct here.
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subject.label,
|
|
id,
|
|
);
|
|
const panel = runtime.panel();
|
|
assert.equal(panel.view?.kind, 'results', 'the Context panel must exist');
|
|
assert.match(panel.view.subject, /ae1fa4/, 'panel starts on the hex');
|
|
|
|
// A refresh that changes NOTHING must not repaint (no per-refresh storm).
|
|
const settledRenders = runtime.panel().renders;
|
|
const settledPublishes = runtime.panel().publishes;
|
|
await militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
runtime.panel().renders,
|
|
settledRenders,
|
|
'an unchanged label must not trigger a panel repaint',
|
|
);
|
|
assert.equal(
|
|
runtime.panel().publishes,
|
|
settledPublishes,
|
|
'an unchanged refresh publishes no new panel, results or standby',
|
|
);
|
|
|
|
// Enrichment answers. The contact has NOT moved and no source revision
|
|
// changed, so the label is the only thing making this render-worthy.
|
|
meta.registration = 'N123AB ';
|
|
await militaryAwarenessLayer.update();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.equal(
|
|
snapshot?.subject.label,
|
|
'N123AB',
|
|
'Context must adopt the registration once enrichment supplies it',
|
|
);
|
|
assert.equal(
|
|
snapshot?.subject.id,
|
|
id,
|
|
'subject identity must stay the ICAO hex',
|
|
);
|
|
// The RENDERED panel is the surface the operator actually reads.
|
|
const repainted = runtime.panel();
|
|
assert.ok(
|
|
repainted.publishes > settledPublishes,
|
|
'a changed label must repaint the standalone Context panel',
|
|
);
|
|
assert.match(
|
|
repainted.view.subject,
|
|
/N123AB/,
|
|
'the rendered Context panel must show the registration without a position change',
|
|
);
|
|
assert.doesNotMatch(
|
|
JSON.stringify(repainted.view),
|
|
/ae1fa4/,
|
|
'the hex must be gone from the panel',
|
|
);
|
|
|
|
// The Cockpit signal list builds its nearby-contact titles with this exact
|
|
// helper over the cohort rows, so the same fixture pins that surface too.
|
|
assert.equal(
|
|
formatAwarenessLabel(flightsLayer.getNearby(position, 250_000, 5)[0]),
|
|
'N123AB',
|
|
'cockpit signal titles must resolve to the registration, not the hex',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
_setTrackedFlightRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, show: true },
|
|
billboardCollection: { show: false, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta: {},
|
|
tracked: false,
|
|
});
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('Contacts activation adopts the production civilian tracked-subject descriptor', async () => {
|
|
const id = 'a1b2c3';
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.67, 30.19, 10_668);
|
|
const sourceViewer = { scene: { primitives: { remove() {} } } };
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
let retrackCalls = 0;
|
|
|
|
try {
|
|
_setTrackedFlightRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, show: true },
|
|
billboardCollection: { show: true, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta: {
|
|
callsign: 'DAL123 ',
|
|
altitude: 10_668,
|
|
renderAltitudeM: 10_700,
|
|
velocity: 250,
|
|
true_track: 95,
|
|
onGround: false,
|
|
rawLat: 30.19,
|
|
rawLon: -97.67,
|
|
},
|
|
});
|
|
const accessorSubject = flightsLayer.getTrackedSubject();
|
|
assert.equal(accessorSubject?.layerId, 'flights');
|
|
assert.equal(accessorSubject?.id, id);
|
|
assert.equal(accessorSubject?.label, 'DAL123');
|
|
assert.notEqual(
|
|
accessorSubject?.position,
|
|
position,
|
|
'the production accessor must detach its Cartesian position',
|
|
);
|
|
assert.ok(
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
accessorSubject?.position,
|
|
position,
|
|
Cesium.Math.EPSILON7,
|
|
),
|
|
);
|
|
accessorSubject.position.x += 100;
|
|
assert.ok(
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
flightsLayer.getTrackedSubject()?.position,
|
|
position,
|
|
Cesium.Math.EPSILON7,
|
|
),
|
|
'mutating one accessor result must not alter the tracked source position',
|
|
);
|
|
runtime.viewer.trackedEntity = { gevTrackedId: `flights:${id}` };
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'getTrackedSubject',
|
|
() => null,
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
() => {
|
|
retrackCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
() => {
|
|
retrackCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.equal(snapshot?.subject.layerId, 'flights');
|
|
assert.equal(snapshot?.subject.id, id);
|
|
assert.equal(snapshot?.subject.label, 'DAL123');
|
|
assert.ok(
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
snapshot?.subject.position,
|
|
position,
|
|
Cesium.Math.EPSILON7,
|
|
),
|
|
);
|
|
assert.equal(
|
|
retrackCalls,
|
|
0,
|
|
'production civilian adoption must preserve tracker ownership',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
_setTrackedFlightRefreshStateForTest({
|
|
icao24: id,
|
|
entity: null,
|
|
billboard: { position, show: true },
|
|
billboardCollection: { show: true, remove() {} },
|
|
viewer: sourceViewer,
|
|
meta: {},
|
|
tracked: false,
|
|
});
|
|
flightsLayer.destroy(sourceViewer);
|
|
assert.deepEqual(
|
|
flightsLayer.getAllPositions(),
|
|
[],
|
|
'production civilian test state must be fully cleared',
|
|
);
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('Contacts activation reconciles to a newer cross-layer tracked flight after dependencies settle', async () => {
|
|
let releaseDependencies;
|
|
const dependencyGate = new Promise((resolve) => {
|
|
releaseDependencies = resolve;
|
|
});
|
|
const positions = {
|
|
first: Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000),
|
|
latest: Cesium.Cartesian3.fromDegrees(-97.7, 30.3, 1200),
|
|
};
|
|
let civilianTracked = awarenessSubject('flights', 'first', positions.first);
|
|
let militaryTracked = null;
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => false,
|
|
setEnabled: async (_layerId, enabled) => {
|
|
if (enabled) await dependencyGate;
|
|
return true;
|
|
},
|
|
});
|
|
const restores = [];
|
|
|
|
try {
|
|
runtime.viewer.trackedEntity = { gevTrackedId: 'flights:first' };
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'getTrackedSubject',
|
|
() => civilianTracked,
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'getTrackedSubject',
|
|
() => militaryTracked,
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subject.id,
|
|
'first',
|
|
);
|
|
|
|
civilianTracked = null;
|
|
militaryTracked = awarenessSubject('military', 'latest', positions.latest);
|
|
runtime.viewer.trackedEntity = { gevTrackedId: 'military:latest' };
|
|
releaseDependencies();
|
|
await nextTurn();
|
|
await nextTurn();
|
|
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subject.layerId,
|
|
'military',
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subject.id,
|
|
'latest',
|
|
);
|
|
} finally {
|
|
releaseDependencies();
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('tracked flight cleared during Contacts activation suppresses fallback autofocus', async () => {
|
|
let releaseDependencies;
|
|
const dependencyGate = new Promise((resolve) => {
|
|
releaseDependencies = resolve;
|
|
});
|
|
const selectedPosition = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const fallbackPosition = Cesium.Cartesian3.fromDegrees(-97.7, 30.3, 1200);
|
|
let tracked = awarenessSubject('flights', 'selected', selectedPosition);
|
|
const restoreCollections = stubAwarenessCollections({
|
|
flights: [
|
|
{ icao24: 'fallback', position: fallbackPosition, distanceM: 1000 },
|
|
],
|
|
});
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: () => false,
|
|
setEnabled: async (_layerId, enabled) => {
|
|
if (enabled) await dependencyGate;
|
|
return true;
|
|
},
|
|
});
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
runtime.viewer.trackedEntity = { gevTrackedId: 'flights:selected' };
|
|
replaceMethod(flightsLayer, 'getTrackedSubject', () => tracked, restores);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'getTrackedSubject',
|
|
() => null,
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => focused.push(id) > 0,
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subject.id,
|
|
'selected',
|
|
);
|
|
|
|
tracked = null;
|
|
runtime.viewer.trackedEntity = undefined;
|
|
// Deliberately untagged: this is the DESELECT case, and an untagged clear
|
|
// must default to deliberate. An eviction (`reason: 'evicted'`) instead
|
|
// keeps the subject as CONTACT LOST — see the eviction tests below — but
|
|
// must not weaken this one: a real deselect during settlement still has to
|
|
// clear AND suppress the fallback autofocus.
|
|
runtime.dispatch('gev:awareness-subject-cleared', {
|
|
layerId: 'flights',
|
|
id: 'selected',
|
|
});
|
|
releaseDependencies();
|
|
await nextTurn();
|
|
await nextTurn();
|
|
|
|
assert.equal(militaryAwarenessLayer.getContextSnapshot(), null);
|
|
assert.deepEqual(focused, []);
|
|
} finally {
|
|
releaseDependencies();
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('awareness clears are scoped to the selected source layer', () => {
|
|
const subject = { layerId: 'ais-live-vessels', id: '123' };
|
|
assert.equal(
|
|
awarenessClearMatchesSubject(subject, {
|
|
layerId: 'military-installations',
|
|
}),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
awarenessClearMatchesSubject(subject, { layerId: 'ais-live-vessels' }),
|
|
true,
|
|
);
|
|
assert.equal(awarenessClearMatchesSubject(subject, null), false);
|
|
});
|
|
|
|
// ===========================================================================
|
|
// BEGIN Contact-readout presence block — fix/context-panel-next-subjects.
|
|
// Integrators: this whole delimited block belongs to the Contact-panel
|
|
// CONTACT LOST work. Keep it intact and keep any concurrent branch's own
|
|
// additions at the END of the file, so the two never collide.
|
|
// ===========================================================================
|
|
|
|
/** Live/absent/unknown presence stub matching the layer `hasContact` contract. */
|
|
function stubPresence(layer, verdict, restores) {
|
|
replaceMethod(layer, 'hasContact', () => verdict, restores);
|
|
}
|
|
|
|
test('a fast-culled subject is reported absent so the readout can hold last-known', () => {
|
|
// The Contact panel keeps a culled subject on screen as CONTACT LOST rather
|
|
// than collapsing, so it needs the snapshot to say whether the subject is
|
|
// still carried by its source.
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
let present = true;
|
|
|
|
try {
|
|
replaceMethod(aisLiveVesselsLayer, 'hasContact', () => present, restores);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'getAllPositions',
|
|
() => [{ id: '353136000', position }],
|
|
restores,
|
|
);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'ais-live-vessels',
|
|
id: '353136000',
|
|
label: 'MAERSK DETROIT',
|
|
position,
|
|
});
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
true,
|
|
);
|
|
|
|
present = false;
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
false,
|
|
'a subject its layer no longer carries is absent',
|
|
);
|
|
|
|
present = null; // layer disabled or not yet loaded: it cannot answer
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
false,
|
|
'an unanswerable tick never revives a subject already known absent',
|
|
);
|
|
|
|
present = true;
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
true,
|
|
'a returning subject clears the absent state',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a layer that cannot answer is never read as a cull', () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
|
|
try {
|
|
// `hasContact` returns null while the layer is disabled or unloaded.
|
|
stubPresence(aisLiveVesselsLayer, null, restores);
|
|
replaceMethod(aisLiveVesselsLayer, 'getAllPositions', () => [], restores);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'ais-live-vessels',
|
|
id: '353136000',
|
|
label: 'MAERSK DETROIT',
|
|
position,
|
|
});
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
true,
|
|
'a silent layer must not fabricate a CONTACT LOST cue',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('presence never comes from the capped position rows', () => {
|
|
// getAllPositions(limit) breaks at its cap and the live flights layer runs
|
|
// ~11k contacts against a 1,000 cap, so "not in the rows" is not "gone".
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const saturated = Array.from({ length: 1000 }, (unused, index) => ({
|
|
id: `filler-${index}`,
|
|
position,
|
|
}));
|
|
|
|
try {
|
|
stubPresence(flightsLayer, true, restores);
|
|
replaceMethod(flightsLayer, 'getAllPositions', () => saturated, restores);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'flights',
|
|
id: 'ab4991',
|
|
label: 'N627CT',
|
|
position,
|
|
});
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
true,
|
|
'a contact past the row cap is still present',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a mapped installation subject is always present — static data is never culled', () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.78, 31.13, 0);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
|
|
try {
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'military-installations',
|
|
id: 'fort-cavazos',
|
|
label: 'FORT CAVAZOS',
|
|
position,
|
|
});
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
true,
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('layer hasContact answers presence in O(1) and declines when unloaded', () => {
|
|
for (const layer of [
|
|
flightsLayer,
|
|
militaryFlightsLayer,
|
|
aisLiveVesselsLayer,
|
|
]) {
|
|
assert.equal(
|
|
typeof layer.hasContact,
|
|
'function',
|
|
'every presence-bearing source layer must expose hasContact',
|
|
);
|
|
// Unloaded layers cannot answer, and must say so rather than guessing.
|
|
assert.equal(layer.hasContact('definitely-not-here'), null);
|
|
}
|
|
});
|
|
|
|
test('hasContact declines while a layer is disabled, whatever its maps still hold', () => {
|
|
// disable() hides the collection but keeps the records, so a map lookup
|
|
// alone would report a preserved subject as FRESH from hidden stale data.
|
|
for (const [name, source, guard] of [
|
|
[
|
|
'flights',
|
|
readLayerSource(new URL('./flights.js', import.meta.url)),
|
|
/hasContact\(\s*icao24,?\s*\)\s*\{\s*\n\s*if\s*\(\s*!(?:flightState\.)?_billboardCollection\s*\|\|\s*!(?:flightState\.)?_billboardCollection\.show\s*\|\|\s*(?:flightState\.)?_billboards\.size\s*===\s*0,?\s*\)\s*return\s*null;/,
|
|
],
|
|
[
|
|
'militaryFlights',
|
|
readLayerSource(new URL('./militaryFlights.js', import.meta.url)),
|
|
/hasContact\(\s*icao24,?\s*\)\s*\{\s*\n\s*if\s*\(\s*!(?:flightState\.)?_billboardCollection\s*\|\|\s*!(?:flightState\.)?_billboardCollection\.show\s*\|\|\s*(?:flightState\.)?_billboards\.size\s*===\s*0,?\s*\)\s*return\s*null;/,
|
|
],
|
|
[
|
|
'aisLiveVessels',
|
|
readLayerSource(new URL('./aisLiveVessels.js', import.meta.url)),
|
|
/hasContact\(\s*mmsi,?\s*\)\s*\{\s*\n\s*if\s*\(\s*!state\.feed\.enabled\s*\|\|\s*!state\.records\.byMmsi\s*\|\|\s*state\.records\.byMmsi\.size\s*===\s*0,?\s*\)\s*return\s*null;/,
|
|
],
|
|
]) {
|
|
assert.match(
|
|
source,
|
|
guard,
|
|
`${name}.hasContact must decline while the layer is disabled`,
|
|
);
|
|
}
|
|
});
|
|
|
|
test('a disabled layer leaves the presence verdict untouched', () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
let verdict = true;
|
|
|
|
try {
|
|
replaceMethod(aisLiveVesselsLayer, 'hasContact', () => verdict, restores);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'getAllPositions',
|
|
() => [{ id: '353136000', position }],
|
|
restores,
|
|
);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'ais-live-vessels',
|
|
id: '353136000',
|
|
label: 'MAERSK DETROIT',
|
|
position,
|
|
});
|
|
|
|
verdict = false;
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
false,
|
|
);
|
|
|
|
// Layer switched off: null must hold the last verdict, not revive it.
|
|
verdict = null;
|
|
militaryAwarenessLayer.update();
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subjectPresent,
|
|
false,
|
|
'a disabled layer cannot resurrect a contact already known absent',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
// --- the real eviction path (Finding 1) ------------------------------------
|
|
// An aged-out contact does not merely vanish from its collection: the owning
|
|
// layer dispatches a selection-clear. Routed as a deliberate clear that nulls
|
|
// the snapshot, the panel collapses before the lost-state resolver ever runs.
|
|
|
|
function selectFlightSubject(runtime, restores, id = 'ab4991') {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 5000);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'flights',
|
|
id,
|
|
label: 'N627CT',
|
|
position,
|
|
});
|
|
return position;
|
|
}
|
|
|
|
test('an evicted aircraft becomes CONTACT LOST instead of collapsing the panel', () => {
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
try {
|
|
stubPresence(flightsLayer, true, restores);
|
|
selectFlightSubject(runtime, restores);
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subject.id,
|
|
'ab4991',
|
|
);
|
|
|
|
// Exactly what flights.js emits when the poll ages a tracked plane out.
|
|
stubPresence(flightsLayer, false, restores);
|
|
runtime.dispatch('gev:awareness-subject-cleared', {
|
|
layerId: 'flights',
|
|
id: 'ab4991',
|
|
reason: 'evicted',
|
|
});
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.ok(
|
|
snapshot,
|
|
'an eviction must not null the snapshot — that hides the panel',
|
|
);
|
|
assert.equal(
|
|
snapshot.subject.id,
|
|
'ab4991',
|
|
'the lost contact keeps its identity',
|
|
);
|
|
assert.equal(snapshot.subjectPresent, false);
|
|
assert.equal(
|
|
typeof snapshot.navigation?.canNext,
|
|
'boolean',
|
|
'navigation stays resolvable so PREVIOUS/NEXT remain operable',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('an evicted vessel becomes CONTACT LOST instead of collapsing the panel', () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
try {
|
|
replaceMethod(aisLiveVesselsLayer, 'hasContact', () => true, restores);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'getAllPositions',
|
|
() => [{ id: '353136000', position }],
|
|
restores,
|
|
);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'ais-live-vessels',
|
|
id: '353136000',
|
|
label: 'MAERSK DETROIT',
|
|
position,
|
|
});
|
|
|
|
// What aisLiveVessels.js emits once a selected vessel exhausts its pin.
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'ais-live-vessels',
|
|
reason: 'evicted',
|
|
});
|
|
|
|
const snapshot = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.ok(
|
|
snapshot,
|
|
'an eviction must not null the snapshot — that hides the panel',
|
|
);
|
|
assert.equal(snapshot.subject.id, '353136000');
|
|
assert.equal(snapshot.subjectPresent, false);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a deliberate clear still fully clears the subject', () => {
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
try {
|
|
stubPresence(flightsLayer, true, restores);
|
|
selectFlightSubject(runtime, restores);
|
|
assert.ok(militaryAwarenessLayer.getContextSnapshot());
|
|
|
|
// No eviction origin: click-empty-space, Escape, voice stop, layer disable.
|
|
runtime.dispatch('gev:awareness-subject-cleared', {
|
|
layerId: 'flights',
|
|
id: 'ab4991',
|
|
});
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot(),
|
|
null,
|
|
'a deliberate clear must still take the panel down',
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('a deliberate source clear still fully clears the subject', () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
try {
|
|
replaceMethod(aisLiveVesselsLayer, 'hasContact', () => true, restores);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'getAllPositions',
|
|
() => [{ id: '353136000', position }],
|
|
restores,
|
|
);
|
|
replaceMethod(aisLiveVesselsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryInstallationsLayer, 'getNearby', () => [], restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:awareness-subject-selected', {
|
|
layerId: 'ais-live-vessels',
|
|
id: '353136000',
|
|
label: 'MAERSK DETROIT',
|
|
position,
|
|
});
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'ais-live-vessels',
|
|
});
|
|
assert.equal(militaryAwarenessLayer.getContextSnapshot(), null);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('production eviction sites actually tag their clears', () => {
|
|
// The event contract above is worthless if the real cull paths never set the
|
|
// origin, so pin the three production call sites.
|
|
const flightsSource = readLayerSource(
|
|
new URL('./flights.js', import.meta.url),
|
|
);
|
|
const militarySource = readLayerSource(
|
|
new URL('./militaryFlights.js', import.meta.url),
|
|
);
|
|
const vesselsSource = readLayerSource(
|
|
new URL('./aisLiveVessels.js', import.meta.url),
|
|
);
|
|
|
|
for (const [name, source] of [
|
|
['flights', flightsSource],
|
|
['militaryFlights', militarySource],
|
|
]) {
|
|
assert.match(
|
|
source,
|
|
/if\s*\(\s*icao24\s*===\s*(?:flightState\.)?_trackedIcao,?\s*\)\s*\{\s*\n\s*(?:(?:parts\.)?tracking\.)?_clearTracking\(\s*false,\s*\{\s*evicted:\s*true\s*\},?\s*\);/,
|
|
`${name} must mark its aged-out cull as an eviction`,
|
|
);
|
|
assert.match(
|
|
source,
|
|
/reason: evicted \? 'evicted' : 'deliberate'/,
|
|
`${name} must carry the clear origin on the dispatched event`,
|
|
);
|
|
}
|
|
assert.match(
|
|
vesselsSource,
|
|
/clearVesselInspection\(\{ evicted: true \}\)/,
|
|
'aisLiveVessels must mark its aged-out selected vessel as an eviction',
|
|
);
|
|
// Fourth cull site: a FIRMS refresh whose new payload no longer carries the
|
|
// selected fire. The fire did not get deselected — it left the feed.
|
|
// The tag alone is not enough — see the behavioral test in
|
|
// firmsInteraction.test.mjs. The clear must also run BEFORE renderCurrentLod,
|
|
// whose registration sweep deletes the record the clear needs to see.
|
|
const firmsSource = readLayerSource(
|
|
new URL('./firmsHeatmap.js', import.meta.url),
|
|
);
|
|
const evictedClear = firmsSource.indexOf(
|
|
'clearSelectedEntityContextForLayer(id, { evicted: true });',
|
|
);
|
|
const lodRebuild = firmsSource.indexOf(
|
|
'components.rendering.renderCurrentLod(true);\n if (reselected) components.selection.selectFire(reselected, false);',
|
|
);
|
|
assert.ok(
|
|
evictedClear > 0,
|
|
'FIRMS must mark a refresh-vanished selection as an eviction',
|
|
);
|
|
assert.ok(
|
|
lodRebuild > 0,
|
|
'the FIRMS refresh must settle its selection before rebuilding',
|
|
);
|
|
assert.ok(
|
|
evictedClear < lodRebuild,
|
|
'the eviction clear must precede the LOD rebuild or it emits nothing at all',
|
|
);
|
|
// …and the deliberate FIRMS paths (layer disable, destroy, deselect) stay untagged.
|
|
assert.equal(
|
|
(firmsSource.match(/clearSelectedEntityContextForLayer\(id\);/g) || [])
|
|
.length,
|
|
3,
|
|
'only the refresh-vanish site is an eviction; disable/destroy/deselect stay deliberate',
|
|
);
|
|
assert.match(
|
|
militaryAwarenessSource,
|
|
/awarenessClearIsEviction/,
|
|
'awareness must branch on the clear origin rather than always clearing',
|
|
);
|
|
});
|
|
|
|
// ===========================================================================
|
|
// END Contact-readout presence block — fix/context-panel-next-subjects.
|
|
// ===========================================================================
|
|
|
|
test('cockpit blocks only non-aircraft Context camera flights', () => {
|
|
const cockpitBody = {
|
|
classList: { contains: (name) => name === 'cockpit-mode' },
|
|
};
|
|
assert.equal(
|
|
contextTargetFlyToAllowed('ais-live-vessels', cockpitBody),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
contextTargetFlyToAllowed('military-installations', cockpitBody),
|
|
false,
|
|
);
|
|
assert.equal(contextTargetFlyToAllowed('flights', cockpitBody), true);
|
|
assert.equal(
|
|
contextTargetFlyToAllowed('ais-live-vessels', {
|
|
classList: { contains: () => false },
|
|
}),
|
|
true,
|
|
);
|
|
});
|
|
|
|
test('vessel entry and selection framing both use the 3 km focus radius', () => {
|
|
assert.match(
|
|
militaryAwarenessSource,
|
|
/const\s*VESSEL_FOCUS_RADIUS_M\s*=\s*3000;/,
|
|
);
|
|
const focusRadiusUses =
|
|
militaryAwarenessSource.match(
|
|
/new\s*Cesium\.BoundingSphere\(\s*vessel\.position,\s*VESSEL_FOCUS_RADIUS_M,?\s*\)/g,
|
|
) || [];
|
|
assert.equal(focusRadiusUses.length, 2);
|
|
});
|
|
|
|
test('awareness rescans only for invalidation, source change, or meaningful movement', () => {
|
|
assert.equal(
|
|
awarenessRefreshRequired({
|
|
force: false,
|
|
hasResults: true,
|
|
movementM: 10,
|
|
sourceRevisionChanged: false,
|
|
}),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
awarenessRefreshRequired({
|
|
force: false,
|
|
hasResults: true,
|
|
movementM: 250,
|
|
sourceRevisionChanged: false,
|
|
}),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
awarenessRefreshRequired({
|
|
force: false,
|
|
hasResults: true,
|
|
movementM: 0,
|
|
sourceRevisionChanged: true,
|
|
}),
|
|
true,
|
|
);
|
|
});
|
|
|
|
test('installation summaries disclose viewport-scoped coverage', () => {
|
|
const empty = summarizeInstallationViewport([], {
|
|
available: true,
|
|
stale: false,
|
|
});
|
|
assert.match(empty.reason, /viewport feed/i);
|
|
assert.match(empty.reason, /not a complete 250 km survey/i);
|
|
|
|
const unavailable = summarizeInstallationViewport([], {
|
|
available: false,
|
|
stale: false,
|
|
});
|
|
assert.equal(unavailable.reason, 'feed unavailable');
|
|
const retrying = summarizeInstallationViewport([], {
|
|
available: false,
|
|
stats: {
|
|
statusMessage: 'Overpass temporarily unavailable — retrying in 30s',
|
|
},
|
|
});
|
|
assert.equal(
|
|
retrying.count,
|
|
null,
|
|
'retrying is not a claim of zero mapped sites',
|
|
);
|
|
assert.equal(
|
|
retrying.reason,
|
|
'Overpass temporarily unavailable — retrying in 30s',
|
|
);
|
|
});
|
|
|
|
test('installation summaries name a subject window instead of the viewport', () => {
|
|
const stats = { coverage: { kind: 'subject', radiusM: 100_000 } };
|
|
const empty = summarizeInstallationViewport([], {
|
|
available: true,
|
|
stale: false,
|
|
stats,
|
|
});
|
|
assert.equal(empty.count, 0);
|
|
assert.match(empty.reason, /none mapped within 100 km/);
|
|
assert.match(empty.reason, /not a complete 250 km survey/);
|
|
const found = summarizeInstallationViewport(
|
|
[{ id: 'ofm:installation:1', label: 'Military area', distanceM: 1200 }],
|
|
{ available: true, stale: false, stats },
|
|
);
|
|
assert.equal(found.count, 1);
|
|
assert.equal(found.reason, 'mapped matches within 100 km of the subject');
|
|
});
|
|
|
|
test('compact Context snapshots retain installation coverage', () => {
|
|
const snapshot = buildAwarenessContextSnapshot(
|
|
{
|
|
subject: { layerId: 'flights', id: 'abc' },
|
|
evaluatedAt: 123,
|
|
radiusM: 250000,
|
|
cohorts: [
|
|
{
|
|
id: 'military-installations',
|
|
label: 'Mapped installations',
|
|
source: 'OpenStreetMap',
|
|
coverage: 'CURRENT VIEWPORT ONLY',
|
|
summary: {
|
|
relationship: 'NEARBY',
|
|
count: 2,
|
|
reason: 'mapped matches',
|
|
nearest: [],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
{ canNext: true },
|
|
);
|
|
|
|
assert.equal(snapshot.cohorts[0].coverage, 'CURRENT VIEWPORT ONLY');
|
|
assert.deepEqual(snapshot.navigation, { canNext: true });
|
|
});
|
|
|
|
test('expanded Context results omit the redundant status heading', () => {
|
|
assert.doesNotMatch(militaryAwarenessSource, /military-awareness-heading/);
|
|
assert.doesNotMatch(
|
|
militaryAwarenessSource,
|
|
/GLOBAL CONTEXT <span>CONTEXT ONLY<\/span>/,
|
|
);
|
|
assert.doesNotMatch(awarenessPanelSource, /military-awareness-heading/);
|
|
assert.match(awarenessPanelSource, /military-awareness-subject/);
|
|
assert.match(militaryAwarenessSource, /FLIGHT \/ VESSEL WINDOW/);
|
|
assert.match(awarenessPanelSource, /military-awareness-controls/);
|
|
});
|
|
|
|
test('Context entry tracks a nearer civilian aircraft over a farther military aircraft', async () => {
|
|
const camera = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const civilianPosition = Cesium.Cartesian3.fromDegrees(-97.73, 30.27, 1000);
|
|
const militaryPosition = Cesium.Cartesian3.fromDegrees(-98.5, 30.27, 1000);
|
|
const restoreCollections = stubAwarenessCollections({
|
|
flights: [
|
|
{ icao24: 'civilian', position: civilianPosition, distanceM: 1000 },
|
|
],
|
|
military: [
|
|
{ icao24: 'military', position: militaryPosition, distanceM: 70000 },
|
|
],
|
|
});
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
runtime.viewer.camera = { positionWC: camera };
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => focused.push(`flights:${id}`) > 0,
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
(id) => focused.push(`military:${id}`) > 0,
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
|
|
assert.deepEqual(focused, ['flights:civilian']);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('Context entry prefers military aircraft on an exact nearest-distance tie', async () => {
|
|
const camera = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const tiedPosition = Cesium.Cartesian3.fromDegrees(-97.73, 30.27, 1000);
|
|
const restoreCollections = stubAwarenessCollections({
|
|
flights: [{ icao24: 'civilian', position: tiedPosition, distanceM: 1000 }],
|
|
military: [{ icao24: 'military', position: tiedPosition, distanceM: 1000 }],
|
|
});
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
runtime.viewer.camera = { positionWC: camera };
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => focused.push(`flights:${id}`) > 0,
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
(id) => focused.push(`military:${id}`) > 0,
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
|
|
assert.deepEqual(focused, ['military:military']);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('Context entry retries once on the next refresh after initially empty feeds', async () => {
|
|
const flights = [];
|
|
const camera = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.73, 30.27, 1000);
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
runtime.viewer.camera = { positionWC: camera };
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => focused.push(id) > 0,
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
assert.deepEqual(focused, []);
|
|
|
|
flights.push({ icao24: 'recovered', position, distanceM: 1000 });
|
|
runtime.tick();
|
|
assert.deepEqual(focused, ['recovered']);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('user deselect cancels a pending Context entry auto-focus retry', async () => {
|
|
const flights = [];
|
|
const camera = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const selectedPosition = Cesium.Cartesian3.fromDegrees(-97.72, 30.27, 1000);
|
|
const replacementPosition = Cesium.Cartesian3.fromDegrees(
|
|
-97.73,
|
|
30.27,
|
|
1000,
|
|
);
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
runtime.viewer.camera = { positionWC: camera };
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => focused.push(id) > 0,
|
|
restores,
|
|
);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
await nextTurn();
|
|
assert.deepEqual(focused, []);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'user-selected', selectedPosition),
|
|
);
|
|
runtime.dispatch('gev:entity-selection-cleared', { layerId: 'flights' });
|
|
flights.push({
|
|
icao24: 'replacement',
|
|
position: replacementPosition,
|
|
distanceM: 1000,
|
|
});
|
|
runtime.tick();
|
|
|
|
assert.deepEqual(focused, []);
|
|
assert.equal(militaryAwarenessLayer.getContextSnapshot(), null);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('reset camera release preserves the selected Contact for explicit refocus', () => {
|
|
const selectedPosition = Cesium.Cartesian3.fromDegrees(-97.72, 30.27, 1000);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const released = [];
|
|
const releaseOptions = [];
|
|
|
|
try {
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'selected-flight', selectedPosition),
|
|
);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'stopTracking',
|
|
(options) => {
|
|
released.push('flights');
|
|
releaseOptions.push(['flights', options]);
|
|
runtime.dispatch('gev:awareness-subject-cleared', {
|
|
layerId: 'flights',
|
|
id: 'selected-flight',
|
|
});
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'stopTracking',
|
|
(options) => {
|
|
released.push('military');
|
|
releaseOptions.push(['military', options]);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'clearSelection',
|
|
() => released.push('ais') > 0,
|
|
restores,
|
|
);
|
|
|
|
assert.equal(
|
|
militaryAwarenessLayer.releaseCameraOwnership({ origin: 'tool' }),
|
|
true,
|
|
);
|
|
|
|
assert.deepEqual(released, ['flights', 'military', 'ais']);
|
|
assert.deepEqual(releaseOptions, [
|
|
['flights', { origin: 'tool' }],
|
|
['military', { origin: 'tool' }],
|
|
]);
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.subject.id,
|
|
'selected-flight',
|
|
);
|
|
assert.equal(
|
|
_getAwarenessNavigationStateForTest().pendingSelectionKey,
|
|
null,
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('same-layer selection clear is suppressed during a synchronous navigation reselect', () => {
|
|
const positions = {
|
|
a: Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000),
|
|
b: Cesium.Cartesian3.fromDegrees(-97.73, 30.28, 1000),
|
|
};
|
|
const flights = Object.entries(positions).map(([id, position], index) => ({
|
|
icao24: id,
|
|
callsign: id.toUpperCase(),
|
|
position,
|
|
distanceM: (index + 1) * 1000,
|
|
}));
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
|
|
try {
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
() => {
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'flights',
|
|
});
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', positions.a),
|
|
);
|
|
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.getContextSnapshot()?.subject.id, 'a');
|
|
assert.deepEqual(_getAwarenessNavigationStateForTest(), {
|
|
historyKeys: ['flights:a'],
|
|
navigationVisitedKeys: ['flights:a'],
|
|
historyLength: 1,
|
|
navigationIndex: 0,
|
|
suppressedHistoryKey: null,
|
|
pendingSelectionKey: null,
|
|
});
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('FOCUS on an already-tracked subject clears its suppression keys before a later deselect', () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const flights = [
|
|
{
|
|
icao24: 'a',
|
|
callsign: 'A',
|
|
position,
|
|
distanceM: 0,
|
|
},
|
|
];
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
|
|
try {
|
|
let refocusCalls = 0;
|
|
let trackCalls = 0;
|
|
let refocusOptions = null;
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'refocusTrackedById',
|
|
(_id, options) => {
|
|
refocusCalls += 1;
|
|
refocusOptions = options;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
() => {
|
|
trackCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', position),
|
|
);
|
|
|
|
assert.equal(
|
|
militaryAwarenessLayer.focusCurrent({ origin: 'voice' }),
|
|
true,
|
|
);
|
|
assert.equal(refocusCalls, 1);
|
|
assert.deepEqual(refocusOptions, { origin: 'voice' });
|
|
assert.equal(
|
|
trackCalls,
|
|
0,
|
|
'an owned Contact follow should reframe without recreating selection',
|
|
);
|
|
assert.deepEqual(_getAwarenessNavigationStateForTest(), {
|
|
historyKeys: ['flights:a'],
|
|
navigationVisitedKeys: ['flights:a'],
|
|
historyLength: 1,
|
|
navigationIndex: 0,
|
|
suppressedHistoryKey: null,
|
|
pendingSelectionKey: null,
|
|
});
|
|
|
|
runtime.dispatch('gev:entity-selection-cleared', { layerId: 'flights' });
|
|
assert.equal(militaryAwarenessLayer.getContextSnapshot(), null);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('NEXT wraps through a fresh visited cycle instead of ping-ponging after exhaustion', () => {
|
|
const positions = Object.fromEntries(
|
|
['a', 'b', 'c', 'd'].map((id, index) => [
|
|
id,
|
|
Cesium.Cartesian3.fromDegrees(-97.74 + index * 0.01, 30.27, 1000),
|
|
]),
|
|
);
|
|
const flights = Object.entries(positions).map(([id, position], index) => ({
|
|
icao24: id,
|
|
callsign: id.toUpperCase(),
|
|
position,
|
|
distanceM: (index + 1) * 1000,
|
|
}));
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
focused.push(id);
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'flights',
|
|
});
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', id, positions[id]),
|
|
);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', positions.a),
|
|
);
|
|
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.deepEqual(_getAwarenessNavigationStateForTest(), {
|
|
historyKeys: ['flights:a', 'flights:b'],
|
|
navigationVisitedKeys: ['flights:a', 'flights:b'],
|
|
historyLength: 2,
|
|
navigationIndex: 1,
|
|
suppressedHistoryKey: null,
|
|
pendingSelectionKey: null,
|
|
});
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.deepEqual(focused, ['b', 'c', 'd']);
|
|
assert.deepEqual(
|
|
_getAwarenessNavigationStateForTest().navigationVisitedKeys,
|
|
['flights:a', 'flights:b', 'flights:c', 'flights:d'],
|
|
);
|
|
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.deepEqual(focused, ['b', 'c', 'd', 'a']);
|
|
assert.deepEqual(
|
|
_getAwarenessNavigationStateForTest().navigationVisitedKeys,
|
|
['flights:d', 'flights:a'],
|
|
);
|
|
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.deepEqual(focused, ['b', 'c', 'd', 'a', 'b', 'c']);
|
|
assert.notDeepEqual(focused.slice(-4), ['a', 'b', 'a', 'b']);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('NEXT reaches beyond the panel cap when more nearby targets exist', () => {
|
|
const ids = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l'];
|
|
const positions = Object.fromEntries(
|
|
ids.map((id, index) => [
|
|
id,
|
|
Cesium.Cartesian3.fromDegrees(-97.74 + index * 0.001, 30.27, 1000),
|
|
]),
|
|
);
|
|
const flights = Object.entries(positions).map(([id, position], index) => ({
|
|
icao24: id,
|
|
callsign: id.toUpperCase(),
|
|
position,
|
|
distanceM: (index + 1) * 1000,
|
|
}));
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
focused.push(id);
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'flights',
|
|
});
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', id, positions[id]),
|
|
);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', positions.a),
|
|
);
|
|
|
|
for (let index = 0; index < 11; index += 1) {
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
}
|
|
|
|
assert.deepEqual(focused[focused.length - 1], 'l');
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('NEXT jumps to expanded flight search after fully cycling nearby flight candidates', () => {
|
|
const subjectPosition = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const nearby = {
|
|
b: Cesium.Cartesian3.fromDegrees(-97.739, 30.2702, 1000),
|
|
c: Cesium.Cartesian3.fromDegrees(-97.738, 30.2704, 1000),
|
|
};
|
|
const expanded = {
|
|
d: Cesium.Cartesian3.fromDegrees(-97.0, 30.8, 1000),
|
|
};
|
|
const nearbyFlights = Object.entries(nearby).map(([id, position], index) => ({
|
|
icao24: id,
|
|
callsign: id.toUpperCase(),
|
|
position,
|
|
distanceM: (index + 2) * 1000,
|
|
}));
|
|
const farFlight = {
|
|
icao24: 'd',
|
|
callsign: 'D',
|
|
position: expanded.d,
|
|
distanceM: AWARENESS_RADIUS_M + 1000,
|
|
};
|
|
|
|
const restoreCollections = stubAwarenessCollections({
|
|
flights: nearbyFlights,
|
|
});
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
let getNearbyCalls = 0;
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'getNearby',
|
|
(position, radius) => {
|
|
getNearbyCalls += 1;
|
|
if (radius <= AWARENESS_RADIUS_M) {
|
|
return nearbyFlights;
|
|
}
|
|
return [...nearbyFlights, farFlight];
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
focused.push(id);
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'flights',
|
|
});
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject(
|
|
'flights',
|
|
id,
|
|
id === 'a'
|
|
? subjectPosition
|
|
: { b: nearby.b, c: nearby.c, d: expanded.d }[id],
|
|
),
|
|
);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', subjectPosition),
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
|
|
assert.deepEqual(focused, ['b', 'c', 'd']);
|
|
assert.equal(getNearbyCalls >= 3, true);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('NEXT can restrict navigation to a requested layer', () => {
|
|
const flights = [
|
|
{ icao24: 'f1', callsign: 'F1', distanceM: 1000 },
|
|
{ icao24: 'f2', callsign: 'F2', distanceM: 1500 },
|
|
];
|
|
const military = [{ icao24: 'm1', callsign: 'M1', distanceM: 700 }];
|
|
const restoreCollections = stubAwarenessCollections({ flights, military });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
focused.push(`flights:${id}`);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
(id, options) => {
|
|
focused.push({ target: `military:${id}`, options });
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'f1', Cesium.Cartesian3.ZERO),
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.navigateNext({
|
|
targetLayer: 'military',
|
|
origin: 'voice',
|
|
}),
|
|
true,
|
|
);
|
|
assert.deepEqual(focused, [
|
|
{
|
|
target: 'military:m1',
|
|
options: { origin: 'voice' },
|
|
},
|
|
]);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('NEXT can restrict navigation to an aircraftClass', () => {
|
|
const flights = [
|
|
{
|
|
icao24: 'f1',
|
|
callsign: 'F1',
|
|
distanceM: 1000,
|
|
aircraftClass: 'airliner',
|
|
},
|
|
{
|
|
icao24: 'f2',
|
|
callsign: 'F2',
|
|
distanceM: 1500,
|
|
aircraftClass: 'helicopter',
|
|
},
|
|
{
|
|
icao24: 'f3',
|
|
callsign: 'F3',
|
|
distanceM: 2000,
|
|
aircraftClass: 'airliner',
|
|
},
|
|
];
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
focused.push(id);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'f1', Cesium.Cartesian3.ZERO),
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.navigateNext({ aircraftClass: 'helicopter' }),
|
|
true,
|
|
);
|
|
assert.deepEqual(focused, ['f2']);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('Cockpit NEXT ignores a nearer vessel and selects the next aircraft', () => {
|
|
const subjectPosition = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const nextPosition = Cesium.Cartesian3.fromDegrees(-97.73, 30.28, 1200);
|
|
const vesselPosition = Cesium.Cartesian3.fromDegrees(-97.739, 30.271, 0);
|
|
const flights = [
|
|
{
|
|
icao24: 'f2',
|
|
callsign: 'F2',
|
|
distanceM: 1500,
|
|
position: nextPosition,
|
|
},
|
|
];
|
|
const vessels = [
|
|
{
|
|
mmsi: 'v1',
|
|
id: 'v1',
|
|
name: 'VESSEL',
|
|
distanceM: 100,
|
|
position: vesselPosition,
|
|
},
|
|
];
|
|
const restoreCollections = stubAwarenessCollections({ flights, vessels });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
|
|
try {
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
focused.push(`flights:${id}`);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'selectById',
|
|
(id) => {
|
|
focused.push(`vessel:${id}`);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'f1', subjectPosition),
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.navigateNext({ aircraftOnly: true }),
|
|
true,
|
|
);
|
|
assert.deepEqual(focused, ['flights:f2']);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('history navigation applies layer and aircraft-class filters in both directions', () => {
|
|
const history = [
|
|
{ layerId: 'flights', id: 'airliner', aircraftClass: 'airliner' },
|
|
{ layerId: 'military', id: 'fighter', aircraftClass: 'fighter' },
|
|
{ layerId: 'military', id: 'helo', aircraftClass: 'helicopter' },
|
|
];
|
|
assert.equal(
|
|
findCompatibleHistoryIndex(history, 0, 1, {
|
|
targetLayer: 'military',
|
|
aircraftClass: 'helicopter',
|
|
}),
|
|
2,
|
|
);
|
|
assert.equal(
|
|
findCompatibleHistoryIndex(history, 2, -1, {
|
|
targetLayer: 'flights',
|
|
aircraftClass: 'airliner',
|
|
}),
|
|
0,
|
|
);
|
|
assert.equal(
|
|
findCompatibleHistoryIndex(history, 2, -1, {
|
|
targetLayer: 'military',
|
|
aircraftClass: 'helicopter',
|
|
}),
|
|
-1,
|
|
);
|
|
});
|
|
|
|
test('Cockpit history navigation skips vessels and installations in both directions', () => {
|
|
const history = [
|
|
{ layerId: 'flights', id: 'airliner' },
|
|
{ layerId: 'ais-live-vessels', id: 'vessel' },
|
|
{ layerId: 'military-installations', id: 'base' },
|
|
{ layerId: 'military', id: 'fighter' },
|
|
];
|
|
assert.equal(
|
|
findCompatibleHistoryIndex(history, 0, 1, { aircraftOnly: true }),
|
|
3,
|
|
);
|
|
assert.equal(
|
|
findCompatibleHistoryIndex(history, 3, -1, { aircraftOnly: true }),
|
|
0,
|
|
);
|
|
});
|
|
|
|
test('production-shaped history snapshots retain aircraft class from the selected source record', () => {
|
|
const subject = {
|
|
layerId: 'military',
|
|
id: 'helo-1',
|
|
label: 'HELO1',
|
|
position: {},
|
|
};
|
|
const snapshot = historySubjectSnapshot(subject, {
|
|
icao24: 'helo-1',
|
|
aircraftClass: 'helicopter',
|
|
});
|
|
assert.equal(snapshot.aircraftClass, 'helicopter');
|
|
assert.equal(subject.aircraftClass, undefined);
|
|
});
|
|
|
|
test('NEXT steps over a history contact whose layer has since evicted it', () => {
|
|
const positions = Object.fromEntries(
|
|
['a', 'b', 'c'].map((id, index) => [
|
|
id,
|
|
Cesium.Cartesian3.fromDegrees(-97.74 + index * 0.01, 30.27, 1000),
|
|
]),
|
|
);
|
|
const flights = Object.entries(positions).map(([id, position], index) => ({
|
|
icao24: id,
|
|
callsign: id.toUpperCase(),
|
|
position,
|
|
distanceM: (index + 1) * 1000,
|
|
}));
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
const evicted = new Set();
|
|
|
|
try {
|
|
replaceMethod(flightsLayer, 'refocusTrackedById', () => false, restores);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
// An evicted contact is gone from the layer: it cannot be tracked, and
|
|
// it announces no selection.
|
|
if (evicted.has(id)) return false;
|
|
focused.push(id);
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'flights',
|
|
});
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', id, positions[id]),
|
|
);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', positions.a),
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigatePrevious(), true);
|
|
assert.equal(militaryAwarenessLayer.navigatePrevious(), true);
|
|
assert.deepEqual(_getAwarenessNavigationStateForTest().historyKeys, [
|
|
'flights:a',
|
|
'flights:b',
|
|
'flights:c',
|
|
]);
|
|
assert.equal(_getAwarenessNavigationStateForTest().navigationIndex, 0);
|
|
|
|
// CONTACT LOST: the cull evicts b while it still sits in navigation history.
|
|
evicted.add('b');
|
|
focused.length = 0;
|
|
|
|
// NEXT must step over the lost entry and reach c, not dead-end on b and
|
|
// report "no further target" for the rest of the session.
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.deepEqual(focused, ['c']);
|
|
assert.equal(_getAwarenessNavigationStateForTest().navigationIndex, 2);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('a fully evicted forward history falls through to the live cohort', () => {
|
|
const positions = Object.fromEntries(
|
|
['a', 'b', 'c'].map((id, index) => [
|
|
id,
|
|
Cesium.Cartesian3.fromDegrees(-97.74 + index * 0.01, 30.27, 1000),
|
|
]),
|
|
);
|
|
const flights = Object.entries(positions).map(([id, position], index) => ({
|
|
icao24: id,
|
|
callsign: id.toUpperCase(),
|
|
position,
|
|
distanceM: (index + 1) * 1000,
|
|
}));
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const focused = [];
|
|
const evicted = new Set();
|
|
|
|
try {
|
|
replaceMethod(flightsLayer, 'refocusTrackedById', () => false, restores);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
if (evicted.has(id)) return false;
|
|
focused.push(id);
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'flights',
|
|
});
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', id, positions[id]),
|
|
);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', positions.a),
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigatePrevious(), true);
|
|
assert.equal(_getAwarenessNavigationStateForTest().navigationIndex, 0);
|
|
|
|
// Every remaining forward history entry is lost.
|
|
evicted.add('b');
|
|
focused.length = 0;
|
|
|
|
// With no reachable history left, NEXT resumes the live cohort search
|
|
// rather than reporting exhaustion.
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.deepEqual(focused, ['c']);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('every Context camera flight without a tracked entity takes navigation authority', () => {
|
|
// Aircraft focus stamps for free (it assigns viewer.trackedEntity, and the UI
|
|
// stamps on trackedEntityChanged). Vessels and installations fly WITHOUT ever
|
|
// setting one, so an earlier deferred geocode would still match the
|
|
// generation it captured and could resolve on top of the new Context focus.
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const vessels = [
|
|
{ mmsi: '111', id: '111', name: 'VESSEL', position, distanceM: 900 },
|
|
];
|
|
const installations = [
|
|
{ id: 'inst-1', name: 'BASE', position, distanceM: 1200 },
|
|
];
|
|
const restoreCollections = stubAwarenessCollections({
|
|
vessels,
|
|
installations,
|
|
});
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const taken = runtime.captureAuthority();
|
|
|
|
try {
|
|
replaceMethod(aisLiveVesselsLayer, 'selectById', () => true, restores);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'getAllPositions',
|
|
() => [{ id: '111', position }],
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
militaryInstallationsLayer,
|
|
'focusById',
|
|
() => true,
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject-a', position),
|
|
);
|
|
|
|
militaryAwarenessLayer.focusTarget('ais-live-vessels', '111');
|
|
assert.deepEqual(taken, ['context-vessel-focus']);
|
|
// The announcement precedes the flight, never trails it.
|
|
assert.equal(runtime.cameraFlights.length, 1);
|
|
|
|
militaryAwarenessLayer.focusTarget('military-installations', 'inst-1');
|
|
assert.deepEqual(taken, [
|
|
'context-vessel-focus',
|
|
'context-installation-focus',
|
|
]);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('Contacts vessel autofocus takes navigation authority before it frames', async () => {
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const restoreCollections = stubAwarenessCollections({});
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
const taken = [];
|
|
runtime.window.addEventListener(NAVIGATION_AUTHORITY_EVENT, (event) =>
|
|
taken.push(event?.detail),
|
|
);
|
|
|
|
try {
|
|
replaceMethod(militaryFlightsLayer, 'getAllPositions', () => [], restores);
|
|
replaceMethod(flightsLayer, 'getAllPositions', () => [], restores);
|
|
replaceMethod(
|
|
aisLiveVesselsLayer,
|
|
'getAllPositions',
|
|
() => [{ id: '222', position }],
|
|
restores,
|
|
);
|
|
replaceMethod(aisLiveVesselsLayer, 'selectById', () => true, restores);
|
|
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
// Activation enables dependencies before it auto-focuses.
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
assert.equal(runtime.cameraFlights.length, 1, 'autofocus framed a vessel');
|
|
assert.deepEqual(taken, [
|
|
{
|
|
reason: 'context-vessel-autofocus',
|
|
cancelPendingSelection: false,
|
|
},
|
|
]);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('NEXT reaches every layer before repeating any contact', () => {
|
|
// The comparator used to rank subject-layer affinity above visited state, so
|
|
// an already-visited same-layer contact outranked every unvisited contact in
|
|
// the other three layers and NEXT ping-ponged inside one layer forever.
|
|
const cohorts = [
|
|
{
|
|
id: 'flights',
|
|
summary: {
|
|
nearest: [
|
|
{ icao24: 'f1', distanceM: 100 },
|
|
{ icao24: 'f2', distanceM: 200 },
|
|
],
|
|
},
|
|
},
|
|
{
|
|
id: 'military',
|
|
summary: { nearest: [{ icao24: 'm1', distanceM: 300 }] },
|
|
},
|
|
{
|
|
id: 'ais-live-vessels',
|
|
summary: { nearest: [{ mmsi: 'v1', distanceM: 400 }] },
|
|
},
|
|
{
|
|
id: 'military-installations',
|
|
summary: { nearest: [{ id: 'i1', distanceM: 500 }] },
|
|
},
|
|
];
|
|
const subject = { layerId: 'flights', id: 'f0' };
|
|
const visited = new Set(['flights:f0']);
|
|
const reached = [];
|
|
|
|
// Walk the whole cohort. Under the old comparator step 3 handed back the
|
|
// already-visited f1, because subject-layer affinity outranked visited state.
|
|
for (let step = 0; step < 5; step += 1) {
|
|
const [next] = getAwarenessNavigationTargets(cohorts, subject, [
|
|
...visited,
|
|
]);
|
|
assert.ok(next, `step ${step} produced no target`);
|
|
const key = `${next.layerId}:${next.id}`;
|
|
assert.equal(visited.has(key), false, `step ${step} repeated ${key}`);
|
|
visited.add(key);
|
|
reached.push(next.layerId);
|
|
}
|
|
|
|
assert.deepEqual(
|
|
[...new Set(reached)].sort(),
|
|
['ais-live-vessels', 'flights', 'military', 'military-installations'],
|
|
'a full cohort walk must reach all four layers, not loop inside one',
|
|
);
|
|
});
|
|
|
|
test('the navigable cohort is generous but finite, and the count stays exact', () => {
|
|
// Caps guard materialization only. A cohort larger than the navigable window
|
|
// must still report its true size — a capped COUNT would be a lie.
|
|
const items = Array.from({ length: 12000 }, (_, index) => ({
|
|
id: `installation-${index}`,
|
|
distanceM: index,
|
|
}));
|
|
const summary = summarizeInstallationViewport(items, {
|
|
available: true,
|
|
stale: false,
|
|
});
|
|
assert.equal(summary.count, 12000, 'the count reflects every in-range item');
|
|
assert.equal(summary.nearest.length, 10, 'the panel still shows ten');
|
|
assert.ok(
|
|
Number.isFinite(AWARENESS_QUERY_LIMIT),
|
|
'the fetch limit is finite',
|
|
);
|
|
assert.ok(
|
|
summary.navigationNearest.length < 12000,
|
|
'the navigable window is bounded',
|
|
);
|
|
assert.ok(
|
|
summary.navigationNearest.length >= 5001,
|
|
'and still far beyond the former 5,000 cap',
|
|
);
|
|
});
|
|
|
|
test('walking a cohort does not rescan the source layer per selection', () => {
|
|
// Each selection used to pay a fresh full-layer proximity scan just to recover
|
|
// the aircraft class for its history snapshot. The sweep already holds that
|
|
// record, so a NEXT burst must not grow the scan count.
|
|
const positions = Object.fromEntries(
|
|
['a', 'b', 'c', 'd'].map((id, index) => [
|
|
id,
|
|
Cesium.Cartesian3.fromDegrees(-97.74 + index * 0.01, 30.27, 1000),
|
|
]),
|
|
);
|
|
const flights = Object.entries(positions).map(([id, position], index) => ({
|
|
icao24: id,
|
|
callsign: id.toUpperCase(),
|
|
position,
|
|
distanceM: (index + 1) * 1000,
|
|
aircraftClass: 'airliner',
|
|
}));
|
|
const restoreCollections = stubAwarenessCollections({ flights });
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
let historyScans = 0;
|
|
|
|
try {
|
|
const scanning = flightsLayer.getNearby;
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'getNearby',
|
|
(...args) => {
|
|
// The history-snapshot lookup has a signature all its own: a tight 1 km
|
|
// radius with a 25-row cap. Cohort sweeps use the awareness radius.
|
|
const [, range, maxCount] = args;
|
|
if (range === 1000 && maxCount === 25) historyScans += 1;
|
|
return scanning.apply(flightsLayer, args);
|
|
},
|
|
restores,
|
|
);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'trackById',
|
|
(id) => {
|
|
runtime.dispatch('gev:entity-selection-cleared', {
|
|
layerId: 'flights',
|
|
});
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', id, positions[id]),
|
|
);
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'a', positions.a),
|
|
);
|
|
historyScans = 0;
|
|
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
|
|
// Every contact in this burst is already in the sweep, so the snapshot
|
|
// reads it from there and the extra scans are zero.
|
|
assert.equal(
|
|
historyScans,
|
|
0,
|
|
`a three-step NEXT burst paid ${historyScans} extra layer scans (want 0)`,
|
|
);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('the contacts window reports exactly the counts the panel renders', () => {
|
|
// Field case: the panel showed 42 while analyst_query reported 8 for the same
|
|
// 250 km question — the panel counts the awareness cohort, analyst counts
|
|
// CURRENTLY-LOADED records, and the flights layer reloads by viewport. Both
|
|
// honest. The window block exists so the panel's numbers travel with the
|
|
// answer, so it must be derived from the panel's own snapshot, not recomputed.
|
|
const results = {
|
|
subject: {
|
|
layerId: 'flights',
|
|
id: 'a52e54',
|
|
label: 'ASA635',
|
|
position: Cesium.Cartesian3.ZERO,
|
|
},
|
|
evaluatedAt: Date.now(),
|
|
radiusM: AWARENESS_RADIUS_M,
|
|
cohorts: [
|
|
{
|
|
id: 'flights',
|
|
label: 'Flights',
|
|
source: 'OpenSky',
|
|
summary: {
|
|
relationship: 'nearby',
|
|
count: 42,
|
|
reason: 'observed',
|
|
nearest: [],
|
|
},
|
|
},
|
|
{
|
|
id: 'military',
|
|
label: 'Military flights',
|
|
source: 'adsb.lol',
|
|
summary: {
|
|
relationship: 'nearby',
|
|
count: 13,
|
|
reason: 'observed',
|
|
nearest: [],
|
|
},
|
|
},
|
|
{
|
|
id: 'ais-live-vessels',
|
|
label: 'AIS vessels',
|
|
source: 'AISStream',
|
|
summary: {
|
|
relationship: 'unknown',
|
|
count: null,
|
|
reason: 'feed unavailable',
|
|
nearest: [],
|
|
},
|
|
},
|
|
],
|
|
};
|
|
const snapshot = buildAwarenessContextSnapshot(results, {});
|
|
const window = contactsWindowFromSnapshot(snapshot);
|
|
|
|
// Same fixture, both derivations: the window equals the rendered cohort counts.
|
|
const rendered = Object.fromEntries(
|
|
snapshot.cohorts.map((cohort) => [cohort.id, cohort.count]),
|
|
);
|
|
assert.equal(window.flights, rendered.flights);
|
|
assert.equal(window.military, rendered.military);
|
|
assert.equal(window.flights, 42);
|
|
assert.equal(window.military, 13);
|
|
assert.equal(window.aircraft, 55);
|
|
assert.equal(window.complete, true);
|
|
assert.equal(window.centeredOn, 'ASA635');
|
|
assert.equal(window.radiusKm, Math.round(AWARENESS_RADIUS_M / 1000));
|
|
// A feed that cannot answer says so rather than reporting a confident zero.
|
|
assert.equal(rendered['ais-live-vessels'], null);
|
|
assert.equal(window.vessels, 'unknown');
|
|
});
|
|
|
|
test('the voice query snapshot is a detached copy of the rendered aircraft cohort', async () => {
|
|
const subjectPosition = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1_000);
|
|
const nearbyPosition = Cesium.Cartesian3.fromDegrees(-97.7, 30.3, 1_500);
|
|
const restoreCollections = stubAwarenessCollections({
|
|
flights: [
|
|
{
|
|
icao24: 'subject',
|
|
id: 'SUBJECT',
|
|
position: subjectPosition,
|
|
distance: 0,
|
|
},
|
|
{
|
|
icao24: 'nearby',
|
|
id: 'NEARBY',
|
|
position: nearbyPosition,
|
|
distance: 5_000,
|
|
},
|
|
],
|
|
});
|
|
const runtime = installAwarenessRuntime();
|
|
try {
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject', subjectPosition),
|
|
);
|
|
await nextTurn();
|
|
const first = militaryAwarenessLayer.getAircraftQuerySnapshot();
|
|
assert.equal(first.cohorts.flights.count, 1);
|
|
assert.equal(first.cohorts.flights.complete, true);
|
|
assert.equal(first.cohorts.flights.provenance.id, 'flights');
|
|
assert.equal(first.cohorts.flights.provenance.enabled, true);
|
|
assert.equal(first.cohorts.flights.items[0].icao24, 'nearby');
|
|
first.cohorts.flights.items[0].icao24 = 'mutated';
|
|
first.cohorts.flights.items[0].position.x = 99;
|
|
first.cohorts.flights.provenance.source = 'mutated';
|
|
first.cohorts.flights.provenance.stats.coverage = { radiusM: 1 };
|
|
first.subject.position.x = 77;
|
|
const second = militaryAwarenessLayer.getAircraftQuerySnapshot();
|
|
assert.equal(second.cohorts.flights.items[0].icao24, 'nearby');
|
|
assert.equal(second.cohorts.flights.items[0].position.x, nearbyPosition.x);
|
|
assert.notEqual(second.cohorts.flights.provenance.source, 'mutated');
|
|
assert.notDeepEqual(second.cohorts.flights.provenance.stats.coverage, {
|
|
radiusM: 1,
|
|
});
|
|
assert.equal(second.subject.position.x, subjectPosition.x);
|
|
} finally {
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('there is no contacts window without a subject', () => {
|
|
assert.equal(contactsWindowFromSnapshot(null), null);
|
|
assert.equal(contactsWindowFromSnapshot({ cohorts: [] }), null);
|
|
});
|
|
|
|
test('installation summaries keep the full navigation cohort beyond the former 5,000 cap', () => {
|
|
const items = Array.from({ length: 5001 }, (_, index) => ({
|
|
id: `installation-${index}`,
|
|
distanceM: index * 1000,
|
|
}));
|
|
const summary = summarizeInstallationViewport(items, {
|
|
available: true,
|
|
stale: false,
|
|
});
|
|
assert.equal(summary.nearest.length, 10);
|
|
assert.equal(summary.navigationNearest.length, 5001);
|
|
assert.equal(AWARENESS_QUERY_LIMIT >= 5001, true);
|
|
});
|
|
|
|
test('unknown subject cohort blocks cross-layer NEXT navigation and availability', () => {
|
|
const vesselPosition = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const militaryPosition = Cesium.Cartesian3.fromDegrees(-97.7, 30.3, 1000);
|
|
const restoreCollections = stubAwarenessCollections({
|
|
military: [
|
|
{
|
|
icao24: 'm1',
|
|
callsign: 'M1',
|
|
position: militaryPosition,
|
|
distanceM: 5000,
|
|
},
|
|
],
|
|
});
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: (layerId) => layerId !== 'ais-live-vessels',
|
|
});
|
|
const restores = [];
|
|
let focusCalls = 0;
|
|
|
|
try {
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
() => {
|
|
focusCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('ais-live-vessels', 'v1', vesselPosition),
|
|
);
|
|
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.navigation.canNext,
|
|
false,
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), false);
|
|
assert.equal(focusCalls, 0);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('NEXT availability helper gates only new-target branches on an unknown cohort', () => {
|
|
assert.equal(
|
|
canNavigateAwarenessNext({
|
|
hasForwardHistory: true,
|
|
hasExpandedFlightTarget: true,
|
|
hasNearbyTarget: true,
|
|
subjectCohortUnknown: true,
|
|
}),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
canNavigateAwarenessNext({
|
|
hasExpandedFlightTarget: true,
|
|
subjectCohortUnknown: true,
|
|
}),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
canNavigateAwarenessNext({
|
|
hasNearbyTarget: true,
|
|
subjectCohortUnknown: true,
|
|
}),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
canNavigateAwarenessNext({
|
|
hasExpandedFlightTarget: true,
|
|
subjectCohortUnknown: false,
|
|
}),
|
|
true,
|
|
);
|
|
});
|
|
|
|
test('canNext agrees with NEXT for unknown, healthy-empty, and recovered flight feeds', () => {
|
|
const positions = {
|
|
subject: Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000),
|
|
contact: Cesium.Cartesian3.fromDegrees(-97.7, 30.3, 1000),
|
|
};
|
|
const military = [
|
|
{
|
|
icao24: 'm1',
|
|
callsign: 'M1',
|
|
position: positions.contact,
|
|
distanceM: 5000,
|
|
},
|
|
];
|
|
let flightsEnabled = false;
|
|
const restoreCollections = stubAwarenessCollections({ military });
|
|
const runtime = installAwarenessRuntime({
|
|
isEnabled: (layerId) => layerId !== 'flights' || flightsEnabled,
|
|
});
|
|
const restores = [];
|
|
let focusCalls = 0;
|
|
|
|
try {
|
|
replaceMethod(
|
|
militaryFlightsLayer,
|
|
'trackById',
|
|
() => {
|
|
focusCalls += 1;
|
|
return true;
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject', positions.subject),
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.navigation.canNext,
|
|
false,
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), false);
|
|
assert.equal(focusCalls, 0);
|
|
|
|
flightsEnabled = true;
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject', positions.subject),
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.navigation.canNext,
|
|
true,
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(focusCalls, 1);
|
|
|
|
flightsEnabled = false;
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject', positions.subject),
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.navigation.canNext,
|
|
false,
|
|
);
|
|
|
|
flightsEnabled = true;
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject', positions.subject),
|
|
);
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.navigation.canNext,
|
|
true,
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), true);
|
|
assert.equal(focusCalls, 2);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('far-side hidden aircraft cannot enable NEXT when navigation cannot see them', () => {
|
|
const subjectPosition = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const hiddenPosition = Cesium.Cartesian3.fromDegrees(82.26, -30.27, 1000);
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
|
|
try {
|
|
replaceMethod(flightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(militaryFlightsLayer, 'getNearby', () => [], restores);
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'getAllPositions',
|
|
() => [
|
|
{
|
|
id: 'hidden',
|
|
position: hiddenPosition,
|
|
},
|
|
],
|
|
restores,
|
|
);
|
|
replaceMethod(militaryFlightsLayer, 'getAllPositions', () => [], restores);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject', subjectPosition),
|
|
);
|
|
|
|
assert.equal(
|
|
militaryAwarenessLayer.getContextSnapshot()?.navigation.canNext,
|
|
false,
|
|
);
|
|
assert.equal(militaryAwarenessLayer.navigateNext(), false);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|
|
|
|
test('runtime listeners exist only while the awareness layer is enabled', () => {
|
|
const originalWindow = globalThis.window;
|
|
const originalDocument = globalThis.document;
|
|
const listeners = new Map();
|
|
let preRenderListeners = 0;
|
|
let nextTimer = 1;
|
|
|
|
class FakeElement {
|
|
constructor() {
|
|
this.classList = { contains: () => false };
|
|
this.style = { setProperty() {} };
|
|
this.hidden = false;
|
|
this.innerHTML = '';
|
|
}
|
|
|
|
setAttribute() {}
|
|
addEventListener() {}
|
|
removeEventListener() {}
|
|
appendChild() {}
|
|
append() {}
|
|
remove() {}
|
|
replaceChildren() {}
|
|
}
|
|
|
|
const fakeWindow = {
|
|
addEventListener(type, listener) {
|
|
if (!listeners.has(type)) listeners.set(type, new Set());
|
|
listeners.get(type).add(listener);
|
|
},
|
|
removeEventListener(type, listener) {
|
|
listeners.get(type)?.delete(listener);
|
|
},
|
|
setInterval() {
|
|
return nextTimer++;
|
|
},
|
|
clearInterval() {},
|
|
requestAnimationFrame(callback) {
|
|
return nextTimer++;
|
|
},
|
|
cancelAnimationFrame() {},
|
|
};
|
|
const fakeBody = new FakeElement();
|
|
const viewer = {
|
|
scene: {
|
|
preRender: {
|
|
addEventListener() {
|
|
preRenderListeners += 1;
|
|
return () => {
|
|
preRenderListeners -= 1;
|
|
};
|
|
},
|
|
},
|
|
},
|
|
entities: { remove() {} },
|
|
container: new FakeElement(),
|
|
};
|
|
|
|
globalThis.window = fakeWindow;
|
|
globalThis.document = {
|
|
body: fakeBody,
|
|
getElementById() {
|
|
return null;
|
|
},
|
|
createElement() {
|
|
return new FakeElement();
|
|
},
|
|
};
|
|
|
|
try {
|
|
militaryAwarenessLayer.setParams({ passive: true });
|
|
militaryAwarenessLayer.init(viewer);
|
|
assert.equal(
|
|
[...listeners.values()].reduce((count, set) => count + set.size, 0),
|
|
0,
|
|
);
|
|
assert.equal(preRenderListeners, 0);
|
|
|
|
militaryAwarenessLayer.enable();
|
|
assert.equal(
|
|
[...listeners.values()].reduce((count, set) => count + set.size, 0),
|
|
4,
|
|
);
|
|
assert.equal(preRenderListeners, 1);
|
|
|
|
militaryAwarenessLayer.disable();
|
|
assert.equal(
|
|
[...listeners.values()].reduce((count, set) => count + set.size, 0),
|
|
0,
|
|
);
|
|
assert.equal(preRenderListeners, 0);
|
|
|
|
militaryAwarenessLayer.enable();
|
|
militaryAwarenessLayer.destroy();
|
|
assert.equal(
|
|
[...listeners.values()].reduce((count, set) => count + set.size, 0),
|
|
0,
|
|
);
|
|
assert.equal(preRenderListeners, 0);
|
|
} finally {
|
|
globalThis.window = originalWindow;
|
|
globalThis.document = originalDocument;
|
|
}
|
|
});
|
|
|
|
test('awareness runtime parameters return a detached snapshot', () => {
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
const snapshot = militaryAwarenessLayer.getParams();
|
|
militaryAwarenessLayer.setParams({ passive: true });
|
|
assert.deepEqual(snapshot, { passive: false });
|
|
});
|
|
|
|
test('Contacts refresh cadence is snappy while the camera moves and parked otherwise', () => {
|
|
assert.equal(awarenessRefreshIntervalMs(false), 750);
|
|
assert.ok(
|
|
awarenessRefreshIntervalMs(true) >= 100 &&
|
|
awarenessRefreshIntervalMs(true) <= 200,
|
|
'a moving camera earns a ~150-200 ms cadence',
|
|
);
|
|
});
|
|
|
|
test('intermittent pose-bin crossings cannot refresh faster than the motion floor', () => {
|
|
// The adversarial pattern: a SLOW continuous drag. The pose signature is
|
|
// quantized, so it crosses a bin only every fourth frame — which a per-frame
|
|
// "unchanged means parked" test reads as a motion-end four times a frame-quad,
|
|
// refreshing at nearly display rate.
|
|
let lastRefreshMs = 0;
|
|
let lastPoseChangeMs = 0;
|
|
let wasMoving = false;
|
|
let refreshes = 0;
|
|
const frames = 60;
|
|
const frameMs = 16;
|
|
for (let frame = 0; frame < frames; frame += 1) {
|
|
const nowMs = 1_000 + frame * frameMs;
|
|
if (frame % 4 === 0) lastPoseChangeMs = nowMs;
|
|
const decision = awarenessRefreshDecision({
|
|
nowMs,
|
|
lastRefreshMs,
|
|
lastPoseChangeMs,
|
|
wasMoving,
|
|
});
|
|
wasMoving = decision.moving;
|
|
if (decision.refresh) {
|
|
refreshes += 1;
|
|
lastRefreshMs = nowMs;
|
|
}
|
|
}
|
|
// 960 ms of motion against a 175 ms floor tops out at six refreshes.
|
|
const ceiling = Math.ceil(
|
|
(frames * frameMs) / awarenessRefreshIntervalMs(true),
|
|
);
|
|
assert.ok(
|
|
refreshes <= ceiling,
|
|
`intermittent bin crossings must respect the ${awarenessRefreshIntervalMs(true)} ms floor: ` +
|
|
`expected at most ${ceiling} refreshes in ${frames} frames, got ${refreshes}`,
|
|
);
|
|
assert.ok(refreshes >= 4, `motion must still be snappy, got ${refreshes}`);
|
|
});
|
|
|
|
test('motion ends only after the pose has been unchanged through the settle window', () => {
|
|
const parked = (nowMs, lastPoseChangeMs, wasMoving = true) =>
|
|
awarenessRefreshDecision({
|
|
nowMs,
|
|
lastRefreshMs: nowMs - 10_000,
|
|
lastPoseChangeMs,
|
|
wasMoving,
|
|
}).moving;
|
|
assert.equal(
|
|
parked(1_000, 1_000),
|
|
true,
|
|
'the frame the pose changed is moving',
|
|
);
|
|
assert.equal(
|
|
parked(1_200, 1_000),
|
|
true,
|
|
'a 200 ms gap between bin crossings is still moving',
|
|
);
|
|
assert.equal(
|
|
parked(1_249, 1_000),
|
|
true,
|
|
'just inside the settle window is still moving',
|
|
);
|
|
assert.equal(
|
|
parked(1_250, 1_000),
|
|
false,
|
|
'the settle window expiring ends motion',
|
|
);
|
|
});
|
|
|
|
test('the motion-end settle refresh still respects the motion floor', () => {
|
|
// Motion ends 20 ms after a refresh: the settle must NOT jump the floor.
|
|
const tooSoon = awarenessRefreshDecision({
|
|
nowMs: 2_000,
|
|
lastRefreshMs: 1_980,
|
|
lastPoseChangeMs: 1_700,
|
|
wasMoving: true,
|
|
});
|
|
assert.deepEqual(tooSoon, { moving: false, refresh: false });
|
|
const allowed = awarenessRefreshDecision({
|
|
nowMs: 2_000,
|
|
lastRefreshMs: 1_800,
|
|
lastPoseChangeMs: 1_700,
|
|
wasMoving: true,
|
|
});
|
|
assert.deepEqual(allowed, { moving: false, refresh: true });
|
|
});
|
|
|
|
test('parked Contacts takes no continuous-render hold and requests at most the parked cadence', () => {
|
|
const realNow = Date.now;
|
|
let clockMs = 1_700_000_000_000;
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const neighbour = Cesium.Cartesian3.fromDegrees(-97.7, 30.27, 1000);
|
|
const restoreCollections = stubAwarenessCollections({
|
|
// A real neighbouring contact, so the cohort is genuinely LIVE — an empty
|
|
// or failed cohort must not take the hold (see the failed-feed test below).
|
|
flights: [
|
|
{ icao24: 'subject-flight', position, distanceM: 0 },
|
|
{ icao24: 'neighbour-flight', position: neighbour, distanceM: 4000 },
|
|
],
|
|
});
|
|
_resetRenderGovernorForTest();
|
|
const runtime = installAwarenessRuntime();
|
|
const holds = () => getRenderGovernorDiagnostics().holds;
|
|
|
|
try {
|
|
Date.now = () => clockMs;
|
|
installRenderGovernor(runtime.viewer);
|
|
runtime.viewer.camera = {
|
|
positionWC: new Cesium.Cartesian3(1_000_000, 200_000, 300_000),
|
|
heading: 0,
|
|
pitch: -0.4,
|
|
roll: 0,
|
|
};
|
|
|
|
// 1. Enabled, nothing selected, camera parked — Contacts must not be a
|
|
// reason the whole scene keeps repainting.
|
|
assert.ok(
|
|
!holds().includes('military-awareness'),
|
|
'enable() must not hold outright',
|
|
);
|
|
for (let frame = 0; frame < 60; frame += 1) {
|
|
clockMs += 16;
|
|
runtime.tick();
|
|
}
|
|
assert.ok(
|
|
!holds().includes('military-awareness'),
|
|
'a parked empty panel holds nothing',
|
|
);
|
|
|
|
// 2. A live subject, still parked: one ring paints, then quiet.
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject-flight', position),
|
|
);
|
|
const requestsAfterSelect = runtime.renderRequests.length;
|
|
for (let frame = 0; frame < 60; frame += 1) {
|
|
clockMs += 16;
|
|
runtime.tick();
|
|
}
|
|
assert.ok(
|
|
!holds().includes('military-awareness'),
|
|
'a parked panel holds nothing even with a subject',
|
|
);
|
|
const parkedRequests = runtime.renderRequests.length - requestsAfterSelect;
|
|
// 960 ms parked = at most two 750 ms-cadence frames' worth of requests.
|
|
assert.ok(
|
|
parkedRequests <= 2,
|
|
`parked Contacts requested ${parkedRequests} renders in 960 ms`,
|
|
);
|
|
|
|
// 3. Moving: the arrows are screen-projected, so per-frame work is real.
|
|
clockMs += 16;
|
|
runtime.viewer.camera.heading += 0.5;
|
|
runtime.tick();
|
|
assert.ok(
|
|
holds().includes('military-awareness'),
|
|
'a moving view earns the hold',
|
|
);
|
|
|
|
// 4. Parked again: the hold is dropped on a frame the hold itself bought.
|
|
clockMs += 300;
|
|
runtime.tick();
|
|
assert.ok(
|
|
!holds().includes('military-awareness'),
|
|
'settling releases the hold',
|
|
);
|
|
|
|
// 5. Teardown releases even without another frame.
|
|
runtime.viewer.camera.heading += 0.5;
|
|
clockMs += 16;
|
|
runtime.tick();
|
|
assert.ok(holds().includes('military-awareness'));
|
|
militaryAwarenessLayer.disable();
|
|
assert.ok(
|
|
!holds().includes('military-awareness'),
|
|
'disable() drops the hold',
|
|
);
|
|
} finally {
|
|
Date.now = realNow;
|
|
runtime.restore();
|
|
restoreCollections();
|
|
_resetRenderGovernorForTest();
|
|
}
|
|
});
|
|
|
|
test('Contacts needs continuous render only for a live cohort under a moving view', () => {
|
|
const need = (input) => awarenessNeedsContinuousRender(input);
|
|
assert.equal(
|
|
need({ cameraMoving: true, hasSubject: true, hasLiveResults: true }),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
need({ cameraMoving: false, hasSubject: true, hasLiveResults: true }),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
need({ cameraMoving: true, hasSubject: false, hasLiveResults: false }),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
need({ cameraMoving: true, hasSubject: true, hasLiveResults: false }),
|
|
false,
|
|
);
|
|
});
|
|
|
|
test('empty and failed cohorts are not "live" — there is no arrow to animate', () => {
|
|
const cohorts = (...counts) => ({
|
|
cohorts: counts.map((count) => ({ summary: { count } })),
|
|
});
|
|
assert.equal(
|
|
awarenessResultsAreLive(cohorts(3, 0, null)),
|
|
true,
|
|
'one populated cohort is enough',
|
|
);
|
|
assert.equal(
|
|
awarenessResultsAreLive(cohorts(0, 0, 0)),
|
|
false,
|
|
'healthy but empty feeds animate nothing',
|
|
);
|
|
assert.equal(
|
|
awarenessResultsAreLive(cohorts(null, null)),
|
|
false,
|
|
'unavailable/stale feeds animate nothing',
|
|
);
|
|
assert.equal(awarenessResultsAreLive(cohorts(0, null)), false);
|
|
assert.equal(awarenessResultsAreLive({ cohorts: [] }), false);
|
|
assert.equal(awarenessResultsAreLive(null), false);
|
|
});
|
|
|
|
test('a moving view over failed feeds takes no continuous-render hold', () => {
|
|
const realNow = Date.now;
|
|
let clockMs = 1_700_000_000_000;
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
// Every dependency reports unavailable, so every cohort summarizes to count
|
|
// null — the exact state the old Boolean(state.results) gate still held for.
|
|
const restoreCollections = stubAwarenessCollections({});
|
|
_resetRenderGovernorForTest();
|
|
const runtime = installAwarenessRuntime({ isEnabled: () => false });
|
|
const holds = () => getRenderGovernorDiagnostics().holds;
|
|
|
|
try {
|
|
Date.now = () => clockMs;
|
|
installRenderGovernor(runtime.viewer);
|
|
runtime.viewer.camera = {
|
|
positionWC: new Cesium.Cartesian3(1_000_000, 200_000, 300_000),
|
|
heading: 0,
|
|
pitch: -0.4,
|
|
roll: 0,
|
|
};
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject-flight', position),
|
|
);
|
|
const results = militaryAwarenessLayer.getContextSnapshot();
|
|
assert.ok(results, 'a subject is selected, so an evaluation exists');
|
|
assert.equal(
|
|
awarenessResultsAreLive(results),
|
|
false,
|
|
'but every cohort is empty/failed',
|
|
);
|
|
|
|
for (let frame = 0; frame < 10; frame += 1) {
|
|
clockMs += 16;
|
|
runtime.viewer.camera.heading += 0.5; // unmistakably moving
|
|
runtime.tick();
|
|
}
|
|
assert.ok(
|
|
!holds().includes('military-awareness'),
|
|
'a moving view with nothing to point at must not pin the governor',
|
|
);
|
|
} finally {
|
|
Date.now = realNow;
|
|
runtime.restore();
|
|
restoreCollections();
|
|
_resetRenderGovernorForTest();
|
|
}
|
|
});
|
|
|
|
test('a moving camera refreshes Contacts more than once inside one parked interval', () => {
|
|
const realNow = Date.now;
|
|
let clockMs = 1_700_000_000_000;
|
|
const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 1000);
|
|
const restoreCollections = stubAwarenessCollections({
|
|
flights: [{ icao24: 'subject-flight', position, distanceM: 0 }],
|
|
});
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
let refreshes = 0;
|
|
|
|
try {
|
|
Date.now = () => clockMs;
|
|
runtime.viewer.camera = {
|
|
positionWC: new Cesium.Cartesian3(1_000_000, 200_000, 300_000),
|
|
heading: 0,
|
|
pitch: -0.4,
|
|
roll: 0,
|
|
};
|
|
replaceMethod(
|
|
flightsLayer,
|
|
'getAllPositions',
|
|
() => {
|
|
refreshes += 1;
|
|
return [{ id: 'subject-flight', position }];
|
|
},
|
|
restores,
|
|
);
|
|
|
|
runtime.dispatch(
|
|
'gev:awareness-subject-selected',
|
|
awarenessSubject('flights', 'subject-flight', position),
|
|
);
|
|
|
|
// 720 ms of MOVING frames at ~60 Hz — one parked interval's worth of time.
|
|
refreshes = 0;
|
|
for (let frame = 0; frame < 45; frame += 1) {
|
|
clockMs += 16;
|
|
runtime.viewer.camera.heading += 0.02; // "looking around"
|
|
runtime.tick();
|
|
}
|
|
assert.ok(
|
|
refreshes > 1,
|
|
`expected more than one refresh inside a 750 ms motion window, got ${refreshes}`,
|
|
);
|
|
assert.ok(
|
|
refreshes <= Math.ceil(720 / awarenessRefreshIntervalMs(true)),
|
|
`motion must stay under the ${awarenessRefreshIntervalMs(true)} ms floor, got ${refreshes}`,
|
|
);
|
|
|
|
// Motion stops. Hysteresis keeps the view "moving" for one settle window,
|
|
// which ends in a single settle refresh; after that the cheap parked
|
|
// cadence resumes at exactly one refresh per 750 ms.
|
|
clockMs += 300;
|
|
runtime.tick();
|
|
refreshes = 0;
|
|
for (let frame = 0; frame < 60; frame += 1) {
|
|
clockMs += 16;
|
|
runtime.tick();
|
|
}
|
|
assert.equal(
|
|
refreshes,
|
|
1,
|
|
'a parked camera keeps the single-refresh-per-750 ms cadence',
|
|
);
|
|
} finally {
|
|
Date.now = realNow;
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
restoreCollections();
|
|
}
|
|
});
|
|
|
|
test('a selected installation card keeps every member name as text', () => {
|
|
const runtime = installAwarenessRuntime();
|
|
const restores = [];
|
|
try {
|
|
for (const layer of [
|
|
aisLiveVesselsLayer,
|
|
flightsLayer,
|
|
militaryFlightsLayer,
|
|
militaryInstallationsLayer,
|
|
])
|
|
replaceMethod(layer, 'getNearby', () => [], restores);
|
|
militaryAwarenessLayer.setParams({ passive: false });
|
|
runtime.dispatch('gev:entity-selected', {
|
|
layerId: 'military-installations',
|
|
id: 'osm:military:w1',
|
|
label: 'Parent base',
|
|
latitude: 31.13,
|
|
longitude: -97.78,
|
|
properties: {
|
|
memberNames: ['Area one', 'Area two', 'Area three', '<Area four>'],
|
|
},
|
|
});
|
|
militaryAwarenessLayer.update();
|
|
// The view renders names as text; ui/awarenessPanel.test.mjs covers it.
|
|
const names = runtime.panel().view?.subjectNames;
|
|
assert.equal(names?.summary, 'Named areas (4)');
|
|
assert.deepEqual(names?.names, [
|
|
'Area one',
|
|
'Area two',
|
|
'Area three',
|
|
'<Area four>',
|
|
]);
|
|
} finally {
|
|
restores.reverse().forEach((restore) => restore());
|
|
runtime.restore();
|
|
}
|
|
});
|