mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
Each sprite layer's icon or dot set is now made at a draw order taken from SPRITE_LAYER_ORDER through the renderer's per-set drawOrder: flights over military, vessels, directions, transit, bikeshare, FIRMS and CCTV, whichever layer was turned on first. Picks name the topmost first. The orders are negative, so selection highlights, route endpoints, the tracked plane and every other set at the default order still draw over all sprite layers, as they did before. The raise-to-top restorer, the sprite registry and the primitive-name lookups are gone, which takes spriteOrder.js off the viewer-access list. Before, the restorer raised the layers to the bottom of the scene in the order they were enabled, so flights usually ended up under the others.
454 lines
15 KiB
JavaScript
454 lines
15 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createVesselLayer } from './index.js';
|
|
import { createVesselState } from './state.js';
|
|
import * as Cesium from 'cesium';
|
|
import { createVesselIconBook } from './iconBook.js';
|
|
import { liftedForHorizon } from '../../geo/horizon.js';
|
|
import { bindFakeCesiumCamera } from '../../testSupport/fakeCameraPort.mjs';
|
|
import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs';
|
|
|
|
/** A query port with nothing on screen: the viewer doubles have no scene. */
|
|
const offscreen = {
|
|
project: () => null,
|
|
projectMany: (source, out) => out.fill(NaN),
|
|
};
|
|
|
|
const noop = () => {};
|
|
function services() {
|
|
return {
|
|
context: {
|
|
clearSelectedEntityContextForLayer: noop,
|
|
registerEntityContext: () => null,
|
|
},
|
|
trails: {
|
|
createTrail: () => ({ setPositions: noop, clear: noop, destroy: noop }),
|
|
},
|
|
labels: { formatKnots: (knots) => `${knots} kt` },
|
|
picking: { unregisterPickOwner: noop },
|
|
overlay: {
|
|
setOverlayEntries: noop,
|
|
setOverlaySourceVisible: noop,
|
|
clearOverlaySource: noop,
|
|
},
|
|
geoid: {},
|
|
sprites: {},
|
|
focus: {
|
|
focusNowMs: (now) => now,
|
|
getFocusTarget: () => null,
|
|
focusPassIsNeeded: () => false,
|
|
forgetSpriteFocus: noop,
|
|
},
|
|
worldFocus: {},
|
|
render: {
|
|
holdContinuousRender: noop,
|
|
releaseContinuousRender: noop,
|
|
governorRequestRender: noop,
|
|
},
|
|
};
|
|
}
|
|
function setup(source, options = {}, viewer = {}) {
|
|
const layer = createVesselLayer({ source, services: services(), options });
|
|
const icons = createVesselIconBook();
|
|
if (viewer.camera)
|
|
bindFakeCesiumCamera(viewer, { query: offscreen, draw: fakeDrawPort() });
|
|
layer.testing._setVesselStateForTest({ viewer, icons });
|
|
let now = 1000;
|
|
layer.testing._setAisRuntimeForTest({
|
|
now: () => now,
|
|
setTimeout,
|
|
clearTimeout,
|
|
});
|
|
return {
|
|
layer,
|
|
icons,
|
|
advance: (ms) => {
|
|
now += ms;
|
|
},
|
|
};
|
|
}
|
|
const observation = (id, reference = id) => ({
|
|
id,
|
|
reference,
|
|
latitude: 51.93,
|
|
longitude: 4.05,
|
|
name: id,
|
|
observedAtMs: 500,
|
|
speedMps: 4,
|
|
headingDeg: 180,
|
|
courseDeg: 170,
|
|
});
|
|
const snapshot = (records, extra = {}) => ({
|
|
records,
|
|
source: 'Fixture vessels',
|
|
complete: true,
|
|
stale: false,
|
|
freshness: 'current',
|
|
observedAtMs: 500,
|
|
transportStatus: 'live',
|
|
rawRowCount: records.length,
|
|
...extra,
|
|
});
|
|
|
|
test('vessel construction is inert and each instance owns its records, icon cache and clock', () => {
|
|
let requested = 0;
|
|
const source = {
|
|
getSnapshot() {
|
|
requested++;
|
|
},
|
|
};
|
|
const one = createVesselState({ source, services: services() });
|
|
const two = createVesselState({ source, services: services() });
|
|
for (const key of ['state', 'shipIconCache'])
|
|
assert.notEqual(one[key], two[key]);
|
|
assert.notEqual(one.state.records.byMmsi, two.state.records.byMmsi);
|
|
assert.notEqual(one.state.feed, two.state.feed);
|
|
assert.notEqual(one.state.records.all, two.state.records.all);
|
|
assert.notEqual(one.state.records.unkeyed, two.state.records.unkeyed);
|
|
assert.notEqual(one.state.trailPositions, two.state.trailPositions);
|
|
const { layer } = setup(source);
|
|
const other = createVesselLayer({ source, services: services() });
|
|
layer.testing._beginAisSessionForTest();
|
|
assert.equal(other.getStats().loading, false);
|
|
assert.equal(requested, 0);
|
|
layer.testing._setVesselStateForTest({ enabled: false });
|
|
});
|
|
|
|
test('missing vessel source fails before mutating the viewer', () => {
|
|
const layer = createVesselLayer({ services: services() });
|
|
assert.throws(() => layer.init({}), /snapshot source/);
|
|
layer.setSource({ getSnapshot: noop });
|
|
});
|
|
|
|
test('partial observations retain missing contacts only until their receipt deadline', async () => {
|
|
let current = snapshot([observation('111'), observation('222')]);
|
|
const { layer, advance } = setup({
|
|
async getSnapshot() {
|
|
return current;
|
|
},
|
|
});
|
|
await layer.update();
|
|
current = snapshot([observation('111')], { complete: false, rawRowCount: 2 });
|
|
await layer.update();
|
|
assert.equal(layer.hasContact('222'), true);
|
|
assert.equal(layer.getStats().stale, false);
|
|
assert.equal(layer.getStats().partial, true);
|
|
assert.equal(layer.getStats().rawRowCount, 2);
|
|
assert.equal(layer.getStats().acceptedRowCount, 1);
|
|
assert.equal(layer.getStats().lastUpdate, 500);
|
|
advance(5 * 60 * 1000);
|
|
await layer.update();
|
|
assert.equal(layer.hasContact('222'), false);
|
|
});
|
|
|
|
test('a complete feed still removes an absent unselected vessel immediately', async () => {
|
|
let current = snapshot([observation('111'), observation('222')]);
|
|
const { layer } = setup({
|
|
async getSnapshot() {
|
|
return current;
|
|
},
|
|
});
|
|
await layer.update();
|
|
current = snapshot([observation('111')]);
|
|
await layer.update();
|
|
assert.equal(layer.hasContact('222'), false);
|
|
});
|
|
|
|
test('an incomplete feed bounds its retained union to the configured row budget', async () => {
|
|
let current = snapshot(
|
|
Array.from({ length: 500 }, (_, i) => observation(String(i + 1000))),
|
|
);
|
|
const { layer } = setup(
|
|
{
|
|
async getSnapshot() {
|
|
return current;
|
|
},
|
|
},
|
|
{ maxRows: 500 },
|
|
);
|
|
await layer.update();
|
|
current = snapshot(
|
|
Array.from({ length: 500 }, (_, i) => observation(String(i + 2000))),
|
|
{ complete: false },
|
|
);
|
|
await layer.update();
|
|
assert.equal(layer.getStats().count, 500);
|
|
assert.equal(layer.hasContact('1000'), false);
|
|
assert.equal(layer.hasContact('2000'), true);
|
|
});
|
|
|
|
test('unknown source time does not become fresh at the time of receipt', async () => {
|
|
const { layer } = setup({
|
|
async getSnapshot() {
|
|
return snapshot([observation('111')], {
|
|
observedAtMs: null,
|
|
freshness: 'unknown',
|
|
});
|
|
},
|
|
});
|
|
await layer.update();
|
|
assert.equal(layer.getStats().lastUpdate, null);
|
|
assert.equal(layer.getStats().stale, true);
|
|
});
|
|
|
|
test('refresh replaces the history reference and clearing selection cancels late history', async (t) => {
|
|
const originalDocument = globalThis.document;
|
|
globalThis.document = { getElementById: () => null };
|
|
t.after(() => {
|
|
if (originalDocument === undefined) delete globalThis.document;
|
|
else globalThis.document = originalDocument;
|
|
});
|
|
let current = snapshot([observation('111', 'old-reference')]);
|
|
let request;
|
|
let resolveTrack;
|
|
const { layer } = setup({
|
|
async getSnapshot() {
|
|
return current;
|
|
},
|
|
getTrack(reference, { signal }) {
|
|
request = { reference, signal };
|
|
return new Promise((resolve) => {
|
|
resolveTrack = resolve;
|
|
});
|
|
},
|
|
});
|
|
await layer.update();
|
|
current = snapshot([observation('111', 'new-reference')]);
|
|
await layer.update();
|
|
assert.equal(layer.selectById('111'), true);
|
|
assert.equal(request.reference, 'new-reference');
|
|
layer.clearSelection();
|
|
assert.equal(request.signal.aborted, true);
|
|
resolveTrack({ records: [{ latitude: 51.94, longitude: 4.04 }] });
|
|
await new Promise(setImmediate);
|
|
assert.equal(layer.testing._getVesselStateForTest().trailPositionCount, 0);
|
|
});
|
|
|
|
test('destroy cancels pending observations and ignores their later completion', async (t) => {
|
|
const originalDocument = globalThis.document;
|
|
globalThis.document = { getElementById: () => null };
|
|
t.after(() => {
|
|
if (originalDocument === undefined) delete globalThis.document;
|
|
else globalThis.document = originalDocument;
|
|
});
|
|
let requestSignal;
|
|
let resolve;
|
|
const { layer } = setup({
|
|
getSnapshot(_query, { signal }) {
|
|
requestSignal = signal;
|
|
return new Promise((done) => {
|
|
resolve = done;
|
|
});
|
|
},
|
|
});
|
|
const pending = layer.update();
|
|
layer.destroy();
|
|
assert.equal(requestSignal.aborted, true);
|
|
resolve(snapshot([observation('111')]));
|
|
await pending;
|
|
assert.equal(layer.getStats().count, 0);
|
|
assert.equal(layer.hasContact('111'), null);
|
|
});
|
|
|
|
test('partial-feed expiry releases a selected vessel and its pending trail', async (t) => {
|
|
const originalDocument = globalThis.document;
|
|
globalThis.document = { getElementById: () => null };
|
|
t.after(() => {
|
|
if (originalDocument === undefined) delete globalThis.document;
|
|
else globalThis.document = originalDocument;
|
|
});
|
|
let current = snapshot([observation('111'), observation('222')]);
|
|
let signal;
|
|
let finish;
|
|
const { layer, advance } = setup({
|
|
async getSnapshot() {
|
|
return current;
|
|
},
|
|
getTrack(_reference, options) {
|
|
signal = options.signal;
|
|
return new Promise((resolve) => {
|
|
finish = resolve;
|
|
});
|
|
},
|
|
});
|
|
await layer.update();
|
|
layer.selectById('222');
|
|
current = snapshot([observation('111')], { complete: false });
|
|
await layer.update();
|
|
assert.equal(layer.getSelectedInfo().mmsi, '222');
|
|
assert.equal(signal.aborted, false);
|
|
advance(5 * 60 * 1000);
|
|
await layer.update();
|
|
assert.equal(layer.getSelectedInfo(), null);
|
|
assert.equal(signal.aborted, true);
|
|
finish({ records: [] });
|
|
await new Promise(setImmediate);
|
|
assert.equal(layer.testing._getVesselStateForTest().trailPositionCount, 0);
|
|
});
|
|
|
|
test('refresh keeps the icon row and its pick identity, and eviction releases the row', async () => {
|
|
let current = snapshot([observation('111')]);
|
|
const { layer, icons } = setup({ getSnapshot: async () => current });
|
|
await layer.update();
|
|
assert.deepEqual(icons.ids(), ['111']);
|
|
const meta = icons.item('111').meta;
|
|
const drawn = () => icons.item('111').pos;
|
|
const near = (a, b) => Cesium.Cartesian3.distance(a, b) < 0.01;
|
|
assert.ok(near(layer.findByQuery('111').position, drawn()));
|
|
const oldPosition = drawn();
|
|
current = snapshot([{ ...observation('111'), longitude: 4.06 }]);
|
|
await layer.update();
|
|
assert.equal(icons.size, 1);
|
|
assert.equal(
|
|
icons.item('111').meta,
|
|
meta,
|
|
'focus identity survives a refresh',
|
|
);
|
|
assert.ok(!near(drawn(), oldPosition));
|
|
assert.ok(near(layer.findByQuery('111').position, drawn()));
|
|
current = snapshot([observation('222')]);
|
|
await layer.update();
|
|
assert.equal(icons.has('111'), false);
|
|
assert.equal(layer.findByQuery('111'), null);
|
|
});
|
|
|
|
test('partial vessel snapshots preserve freshness and recover after a complete update', async (t) => {
|
|
const originalDocument = globalThis.document;
|
|
globalThis.document = { getElementById: () => null };
|
|
t.after(() => {
|
|
if (originalDocument === undefined) delete globalThis.document;
|
|
else globalThis.document = originalDocument;
|
|
});
|
|
const { vesselSnapshot } = await import('../../sources/live/vessels.js');
|
|
const { layerFeedState } = await import('../../data/feedState.js');
|
|
const valid = {
|
|
mmsi: '123456789',
|
|
lat: 51.93,
|
|
lon: 4.05,
|
|
last_position_epoch: 1,
|
|
};
|
|
let current = vesselSnapshot({
|
|
rows: [valid, { ...valid }, { mmsi: '987654321', lat: 200, lon: 4 }],
|
|
status: 'live',
|
|
});
|
|
const { layer } = setup({ getSnapshot: async () => current });
|
|
await layer.update();
|
|
assert.equal(layer.getStats().partial, true);
|
|
assert.equal(layer.getStats().stale, false);
|
|
assert.equal(layer.getStats().rawRowCount, 3);
|
|
assert.equal(layer.getStats().acceptedRowCount, 1);
|
|
assert.equal(layerFeedState(layer.getStats()), 'partial');
|
|
assert.equal(layer.hasContact('123456789'), true);
|
|
|
|
for (const extra of [
|
|
{ stale: true },
|
|
{ freshness: 'stale' },
|
|
{ freshness: 'unknown', observedAtMs: null },
|
|
{ transportStatus: 'stale' },
|
|
]) {
|
|
const original = current;
|
|
current = { ...original, ...extra };
|
|
await layer.update();
|
|
assert.equal(layer.getStats().partial, true);
|
|
assert.equal(layerFeedState(layer.getStats()), 'stale');
|
|
current = original;
|
|
}
|
|
current = { ...current, transportStatus: 'reconnecting' };
|
|
await layer.update();
|
|
assert.equal(layerFeedState(layer.getStats()), 'degraded');
|
|
assert.match(layer.getStats().error, /reconnecting/);
|
|
|
|
current = vesselSnapshot({ rows: [valid], status: 'live' });
|
|
await layer.update();
|
|
assert.equal(layer.getStats().partial, false);
|
|
assert.equal(layer.getStats().stale, false);
|
|
assert.equal(layer.getStats().error, null);
|
|
assert.equal(layerFeedState(layer.getStats()), 'nominal');
|
|
current = { ...current, complete: false };
|
|
await layer.update();
|
|
assert.equal(layer.getStats().partial, true);
|
|
layer.destroy();
|
|
assert.equal(layer.getStats().partial, false);
|
|
});
|
|
|
|
test('authoritative empty coverage clears old contacts without declaring an outage', async () => {
|
|
let current = snapshot([observation('111')]);
|
|
const { layer } = setup({
|
|
async getSnapshot() {
|
|
return current;
|
|
},
|
|
});
|
|
await layer.update();
|
|
current = snapshot([], { observedAtMs: null, lastMessageAt: 500 });
|
|
await layer.update();
|
|
assert.ok(!layer.hasContact('111'));
|
|
assert.equal(layer.getStats().count, 0);
|
|
assert.equal(layer.getStats().error, null);
|
|
assert.equal(layer.getStats().stale, false);
|
|
assert.equal(layer.getStats().lastUpdate, null);
|
|
});
|
|
|
|
test('empty coverage cannot hide stale, incomplete or rejected source data', async () => {
|
|
for (const patch of [
|
|
{ freshness: 'unknown' },
|
|
{ freshness: 'stale' },
|
|
{ complete: false },
|
|
{ rawRowCount: 1 },
|
|
{ transportStatus: 'stale' },
|
|
{ lastMessageAt: null },
|
|
]) {
|
|
let current = snapshot([observation('111')]);
|
|
const { layer } = setup({
|
|
async getSnapshot() {
|
|
return current;
|
|
},
|
|
});
|
|
await layer.update();
|
|
current = snapshot([], {
|
|
observedAtMs: null,
|
|
lastMessageAt: 500,
|
|
...patch,
|
|
});
|
|
await layer.update();
|
|
assert.equal(layer.hasContact('111'), true, JSON.stringify(patch));
|
|
assert.ok(layer.getStats().error, JSON.stringify(patch));
|
|
}
|
|
});
|
|
|
|
test('cards and detection judge the horizon where the icon shader culls the row', async () => {
|
|
// A camera over the limb that sees the row's cull point (lifted to 12 m) but
|
|
// not the drawn position (3 m above the ellipsoid before the geoid loads).
|
|
const ship = Cesium.Cartesian3.fromDegrees(4.05, 51.93, 3);
|
|
const lifted = Cesium.Cartesian3.fromDegrees(4.05, 51.93, 12);
|
|
const occluder = new Cesium.EllipsoidalOccluder(Cesium.Ellipsoid.WGS84, ship);
|
|
let positionWC = null;
|
|
for (let lon = 4.05; lon < 40 && !positionWC; lon += 0.0005) {
|
|
occluder.cameraPosition = Cesium.Cartesian3.fromDegrees(
|
|
lon,
|
|
51.93,
|
|
400_000,
|
|
);
|
|
if (occluder.isPointVisible(lifted) && !occluder.isPointVisible(ship))
|
|
positionWC = occluder.cameraPosition;
|
|
}
|
|
assert.ok(positionWC, 'found a camera between the two horizons');
|
|
const viewer = { camera: { positionWC, heading: 0, pitch: 0, roll: 0 } };
|
|
const current = snapshot([observation('111')]);
|
|
const { layer, icons } = setup(
|
|
{ getSnapshot: async () => current },
|
|
{},
|
|
viewer,
|
|
);
|
|
await layer.update();
|
|
occluder.cameraPosition = positionWC;
|
|
assert.equal(
|
|
occluder.isPointVisible(liftedForHorizon(icons.item('111').pos)),
|
|
true,
|
|
);
|
|
assert.deepEqual(
|
|
layer.getDetectableObjects().map((entry) => entry.sourceId),
|
|
['111'],
|
|
);
|
|
layer.testing._setVesselStateForTest({ enabled: false });
|
|
});
|