Files
gods-eye-view/src/layers/vessels/ingestion.test.mjs
T
Sameh Khamis e8e49a49e0 feat: ask for vessels by area
The vessel source accepts an optional area and sends it as lat, lon and
radius_km. The vessel layer asks for the area the camera shows (centered
on the middle of the screen, sized by camera height), or every vessel
from high enough up, and asks again when the view moves or zooms by a
quarter of that radius. vessels_in_area names its area too. Servers that
hold every vessel may ignore the area; callers still keep only what is
inside it.
2026-10-03 22:44:45 -07:00

150 lines
4.5 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { createIngestion, createVesselFeed } from './ingestion.js';
function setup(source) {
const feed = createVesselFeed();
feed.enabled = true;
feed.sessionId = 1;
const applied = [];
const labels = [];
let count = 0;
const ingestion = createIngestion({
feed,
readSource: () => source,
readViewer: () => ({}),
getRowLimit: () => 500,
readCount: () => count,
now: () => 9999,
setSourceLabel: (value) => labels.push(value),
applyRows: (_, rows) => {
applied.push(rows);
count = rows.length;
},
classifySnapshot: (payload) => ({
acceptedRows: payload.rows,
acceptedRowCount: payload.rows.length,
rawRowCount: payload.rows.length,
transportStatus: payload.status,
lastMessageAt: payload.lastMessageAt,
error: payload.rows.length ? null : 'No accepted positions',
}),
isDefinitiveTransportFailure: () => false,
isGraceEligibleTransport: () => false,
markUnavailable: (error) => {
feed.error = error;
},
settleFirstConnect: (phase) => {
feed.firstConnectPhase = phase;
},
});
return { feed, applied, labels, ...ingestion };
}
test('an old vessel request cannot publish or clear the loading state of a newer enable session', async () => {
let release;
const probe = setup({
getSnapshot: () =>
new Promise((resolve) => {
release = resolve;
}),
});
const request = probe.methods.update();
const old = probe.feed.abort;
probe.feed.sessionId++;
probe.feed.abort = new AbortController();
probe.feed.loading = true;
release({ records: [], source: 'Old session' });
await request;
assert.equal(probe.applied.length, 0);
assert.equal(probe.labels.length, 0);
assert.equal(probe.feed.loading, true);
assert.notEqual(probe.feed.abort, old);
});
test('vessel ingestion converts source units once and retains warm records on a zero-row snapshot', async () => {
let snapshot = {
records: [
{
id: '111',
reference: '111',
latitude: 51.93,
longitude: 4.05,
speedMps: 5.14444,
courseDeg: 90,
headingDeg: 100,
observedAtMs: 1700000000000,
},
],
source: 'Fixture',
observedAtMs: null,
freshness: 'unknown',
complete: false,
transportStatus: 'live',
};
const probe = setup({
async getSnapshot(query) {
assert.equal(query.maxRows, 500);
return snapshot;
},
});
await probe.methods.update();
const record = probe.applied[0][0];
assert.equal(record.speed, 5.14444 / 0.514444);
assert.equal(record.last_position_epoch, 1700000000);
assert.equal(record.last_position_UTC, new Date(1700000000000).toISOString());
assert.equal(probe.feed.lastUpdate, null);
assert.equal(probe.feed.stale, true);
assert.equal(probe.feed.count, 1);
snapshot = { ...snapshot, records: [] };
await probe.methods.update();
assert.equal(probe.applied.length, 1);
assert.equal(probe.feed.count, 1);
assert.equal(probe.feed.stale, true);
assert.equal(probe.feed.error, 'No accepted positions');
assert.equal(probe.feed.loading, false);
assert.equal(probe.feed.abort, null);
});
test('vessels are asked for by the area in view, and again only when the view moves away', async () => {
const asked = [];
let area = { lat: 37.8, lon: -122.4, radiusKm: 40 };
const feed = createVesselFeed();
feed.enabled = true;
feed.sessionId = 1;
const ingestion = createIngestion({
feed,
readSource: () => ({
getSnapshot: async (query) => {
asked.push(query);
return { records: [], source: 'Feed' };
},
}),
readViewer: () => ({}),
readArea: () => area,
getRowLimit: () => 500,
readCount: () => 0,
now: () => 0,
setSourceLabel: () => {},
applyRows: () => {},
classifySnapshot: () => ({
acceptedRows: [],
acceptedRowCount: 0,
rawRowCount: 0,
}),
isDefinitiveTransportFailure: () => false,
isGraceEligibleTransport: () => false,
markUnavailable: () => {},
settleFirstConnect: () => {},
});
await ingestion.methods.update();
assert.deepEqual(asked, [{ maxRows: 500, area }]);
await ingestion.refreshIfMoved();
assert.equal(asked.length, 1);
area = { ...area, lat: 38.2 };
await ingestion.refreshIfMoved();
assert.deepEqual(asked.at(-1), { maxRows: 500, area });
area = null;
await ingestion.refreshIfMoved();
assert.deepEqual(asked.at(-1), { maxRows: 500 });
});