Extract vessel components and preserve source lifecycle

This commit is contained in:
Sameh Khamis committed 2026-09-13 10:54:32 -07:00
1 parent 8b3fad0672
commit 2f4839e8f2
23 files changed
+2967 -2182

No files matched your search

+158
View File
@@ -0,0 +1,158 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { createVesselLayer } from './index.js';
import { createVesselState } from './state.js';
const noop = () => {};
function services() {
return {
context: { clearSelectedEntityContextForLayer: noop, registerEntityContext: () => null },
trails: { createTrail: () => ({ setPositions: noop, clear: noop, destroy: noop }) },
labels: {},
picking: { unregisterPickOwner: noop },
overlay: { setOverlayEntries: noop, setOverlaySourceVisible: noop, clearOverlaySource: noop },
geoid: {}, sprites: {},
focus: { focusNowMs: (now) => now, getFocusTarget: () => null, focusPassIsNeeded: () => false, forgetSpriteFocus: noop },
worldFocus: {}, render: { releaseContinuousRender: noop },
};
}
function setup(source, options = {}) {
const layer = createVesselLayer({ source, services: services(), options });
layer.testing._setVesselStateForTest({ viewer: {}, billboardCollection: { add: (options) => ({ ...options }), remove: noop } });
let now = 1000;
layer.testing._setAisRuntimeForTest({ now: () => now, setTimeout, clearTimeout });
return { layer, 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', '_scratchFocusScreen']) assert.notEqual(one[key], two[key]);
assert.notEqual(one.state.vesselMap, two.state.vesselMap);
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, 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);
});