Files
gods-eye-view/src/data/satellitesTrackedRefresh.test.mjs
T
Sameh Khamis d513034f3d Draw the satellites layer through the renderer ports
The satellite dots, the tracked satellite's dot and the orbit rings now go
through the draw port instead of a raw point collection, an entity and
primitives, so the layer's rendering no longer drives Cesium and leaves the
Cesium allow-list.

- Dots are one points set, patched in place and sent once per frame.
- The tracked dot is its own set, drawn at the sample the follow camera
  framed (or after the frame's own sample when no camera read it).
- Rings are geodesic lines with a behind-the-globe colour, turned about the
  pole by the sidereal angle in the layer each second, since the port has no
  inertial frame. The orbit frame matrix is a plain 16-number array, and
  the launches layer now receives plain ECEF orbit positions.
- Clicks match the draw hit against the layer's own sets.
- The focus pass projects every dot in one batched call.
- Depth-fail lines in the Cesium draw port honour pickable: false.
2026-11-08 13:06:52 -08:00

413 lines
14 KiB
JavaScript

import assert from 'node:assert/strict';
import test from 'node:test';
import * as Cesium from 'cesium';
import { twoline2satrec } from 'satellite.js';
import {
ISS_OVERLAY_SOURCE_OPTIONS,
_applyPendingSatelliteTrackingRestoreForTest,
_clearSatelliteLabelLifecycleForTest,
_pendingSatelliteTrackingRestoreForTest,
_removeSatelliteTrackingCandidateForTest,
_runSatellitePreRenderForTest,
_setSatelliteLabelLifecycleStateForTest,
_setSatelliteTrackingRefreshOutcomeForTest,
_setTrackedSatelliteRefreshStateForTest,
_trackedFrameCartesianForTest,
_trackIssForTest,
createIssOverlayEntry,
} from './satellites.js';
import { followedOf } from './followed.js';
import { bindRenderer } from '../render/rendererOf.js';
import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs';
import satellitesLayer from './satellites.js';
import { createTrackedOverlayEntry } from './trackedReadout.js';
import { readEntityRecord, withEntityRecord } from './entityRecords.js';
const L1 =
'1 25544U 98067A 08264.51782528 -.00002182 00000-0 -11606-4 0 2927';
const L2 =
'2 25544 51.6416 247.4627 0006703 130.5360 325.0288 15.72125391563537';
/** A camera port that only follows, for viewers without a Cesium camera. */
function followingPort() {
let followed = null;
return {
on: () => () => {},
get followed() {
return followed;
},
follow(target) {
followed = target;
},
cancelFlight() {},
};
}
test('partial and dense catalogs do not make an early false missing decision', async () => {
_setSatelliteTrackingRefreshOutcomeForTest({
status: 'partial',
failedGroups: ['stations.txt'],
});
const partial = await satellitesLayer.resolveTrackingRestoreTarget(987654);
assert.equal(partial.status, 'source-unavailable');
assert.match(partial.reason, /partial CelesTrak catalog/);
let releaseDense;
const densePromise = new Promise((resolve) => {
releaseDense = resolve;
});
_setSatelliteTrackingRefreshOutcomeForTest({
status: 'accepted',
catalog: 'dense',
densePromise,
});
let settled = false;
const resolution = satellitesLayer
.resolveTrackingRestoreTarget(987654)
.then((result) => {
settled = true;
return result;
});
await Promise.resolve();
assert.equal(settled, false, 'dense absence must wait for the dense catalog');
releaseDense({ status: 'ready' });
assert.equal((await resolution).status, 'missing');
_setSatelliteTrackingRefreshOutcomeForTest({
status: 'accepted',
catalog: 'core',
});
});
test('satellite first update aborts every parallel catalog request', async () => {
const realFetch = globalThis.fetch;
const observedSignals = [];
globalThis.fetch = (_url, options = {}) =>
new Promise((_resolve, reject) => {
observedSignals.push(options.signal);
options.signal?.addEventListener(
'abort',
() => {
reject(new DOMException('aborted', 'AbortError'));
},
{ once: true },
);
});
try {
const controller = new AbortController();
const work = satellitesLayer.update({}, { signal: controller.signal });
await Promise.resolve();
assert.ok(observedSignals.length > 1);
controller.abort();
await assert.rejects(work, { name: 'AbortError' });
assert.equal(
observedSignals.every((signal) => signal?.aborted),
true,
);
} finally {
globalThis.fetch = realFetch;
}
});
test('selected satellite params survive delayed arrival and yield to newer explicit intent', (t) => {
const point = {
pos: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000),
show: true,
pixelSize: 12,
color: [1, 0, 0, 1],
outlineColor: [1, 1, 1, 1],
outlineWidth: 2,
disableDepthTest: 0,
};
const viewer = {};
const draw = fakeDrawPort();
t.after(bindRenderer(viewer, { camera: followingPort(), draw }));
_setSatelliteLabelLifecycleStateForTest({
viewer,
satrec: twoline2satrec(L1, L2),
point,
});
try {
assert.doesNotThrow(() =>
satellitesLayer.setParams({ selectedSatTrackingId: 25544 }),
);
assert.equal(satellitesLayer.getParams().selectedSatTrackingId, 25544);
assert.equal(followedOf(viewer)?.key, 'satellites:25544');
satellitesLayer.stopTracking();
_removeSatelliteTrackingCandidateForTest(25544);
satellitesLayer.setParams(
{ selectedSatTrackingId: 25544 },
{ origin: 'share-restore' },
);
assert.equal(_pendingSatelliteTrackingRestoreForTest(), 25544);
_setSatelliteLabelLifecycleStateForTest({
viewer,
satrec: twoline2satrec(L1, L2),
point,
preservePending: true,
});
assert.equal(_applyPendingSatelliteTrackingRestoreForTest(), true);
assert.equal(satellitesLayer.getParams().selectedSatTrackingId, 25544);
satellitesLayer.setParams(
{ selectedSatTrackingId: 99999 },
{ origin: 'share-restore' },
);
assert.equal(_pendingSatelliteTrackingRestoreForTest(), 99999);
assert.equal(satellitesLayer.trackById(25544, { origin: 'user' }), true);
assert.equal(
_pendingSatelliteTrackingRestoreForTest(),
null,
'new user selection cancels stale restore',
);
_applyPendingSatelliteTrackingRestoreForTest();
assert.equal(satellitesLayer.getParams().selectedSatTrackingId, 25544);
satellitesLayer.stopTracking();
_removeSatelliteTrackingCandidateForTest(25544);
satellitesLayer.setParams(
{ selectedSatTrackingId: 25544 },
{ origin: 'local-restore' },
);
assert.equal(_pendingSatelliteTrackingRestoreForTest(), 25544);
satellitesLayer.stopTracking({ origin: 'user' });
assert.equal(
_pendingSatelliteTrackingRestoreForTest(),
null,
'explicit clear cancels stale restore',
);
_setSatelliteLabelLifecycleStateForTest({
viewer,
satrec: twoline2satrec(L1, L2),
point,
preservePending: true,
});
_applyPendingSatelliteTrackingRestoreForTest();
assert.equal(satellitesLayer.getParams().selectedSatTrackingId, null);
satellitesLayer.setParams(
{ selectedSatTrackingId: 50003 },
{ origin: 'share-restore' },
);
assert.equal(_pendingSatelliteTrackingRestoreForTest(), 50003);
satellitesLayer.setParams({ showPoints: true }, { origin: 'tool' });
assert.equal(
_pendingSatelliteTrackingRestoreForTest(),
null,
'a newer explicit non-selection option cancels stale restore',
);
_applyPendingSatelliteTrackingRestoreForTest();
assert.equal(satellitesLayer.getParams().selectedSatTrackingId, null);
} finally {
_clearSatelliteLabelLifecycleForTest();
}
});
test('a tracked docked cluster consolidates its companions onto one card', () => {
// ISS and everything berthed to it are separate real tracks at one position,
// so their ambient labels stack underneath the tracked card. Owner ruling:
// consolidate them as secondary info on that card, and suppress only those
// members — never unrelated satellites that merely happen to be nearby.
const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } });
const point = { pos: new Cesium.Cartesian3() };
const viewer = { camera: null, scene: { frameState: { frameNumber: 1 } } };
let nowMs = Date.UTC(2008, 8, 20, 12, 30);
// The tracked satellite moves ~7.6 km/s, so neighbours are defined RELATIVE to
// wherever it is at scan time rather than pinned to a stale sample.
const near = (metres) => ({
get pos() {
const tracked = _trackedFrameCartesianForTest();
return new Cesium.Cartesian3(tracked.x + metres, tracked.y, tracked.z);
},
});
_setTrackedSatelliteRefreshStateForTest({
noradId: 25544,
name: 'ISS (ZARYA)',
satrec: twoline2satrec(L1, L2),
entity,
point,
viewer,
now: () => nowMs,
neighbours: [
{ noradId: 55555, name: 'PROGRESS-MS 34', point: near(120) }, // berthed
{ noradId: 55556, name: 'SOYUZ-MS 12', point: near(-90) }, // berthed
{ noradId: 99999, name: 'UNRELATED SAT', point: near(50_000) }, // 50 km away
],
});
_runSatellitePreRenderForTest();
// The cluster scan is throttled, so advance past its interval before the frame
// that must observe the cluster.
nowMs += 2000;
_runSatellitePreRenderForTest();
const details = readEntityRecord(entity)?.labelModel.details;
// Class leads the detail block; the altitude line follows it, and the
// consolidated companions stay last.
assert.equal(
details[0],
'STATION · ISS',
'the class line names what this is',
);
assert.match(details[1], /NORAD 25544$/, 'the altitude line is unchanged');
assert.equal(
details[2],
'DOCKED · PROGRESS-MS 34 · +1',
'companions are consolidated, named, and counted on the tracked card',
);
// Scoping is encoded in that string: THREE neighbours were seeded but only two
// are counted (the named one plus "+1"). The satellite 50 km away is not part
// of the cluster and keeps its own identity and label — the owner's explicit
// constraint that unrelated nearby satellites are never suppressed.
assert.doesNotMatch(details[2], /UNRELATED/);
assert.doesNotMatch(details[2], /\+2/);
});
test('satellite pre-render refreshes the tracked altitude on each propagated frame', () => {
const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } });
const point = { pos: new Cesium.Cartesian3() };
const viewer = {
camera: null,
scene: { frameState: { frameNumber: 1 } },
};
const epochs = [Date.UTC(2008, 8, 20, 12, 30), Date.UTC(2008, 8, 20, 13, 0)];
let epochIndex = 0;
_setTrackedSatelliteRefreshStateForTest({
noradId: 25544,
name: 'ISS (ZARYA)',
satrec: twoline2satrec(L1, L2),
entity,
point,
viewer,
now: () => epochs[epochIndex],
});
_runSatellitePreRenderForTest();
assert.equal(readEntityRecord(entity)?.labelModel.title, 'ISS (ZARYA)');
assert.equal(readEntityRecord(entity)?.labelModel.details[0], 'STATION · ISS');
// formatQuantity keeps the number and its unit together with a no-break space.
assert.equal(readEntityRecord(entity)?.labelModel.details[1], '353\u00a0km · NORAD 25544');
epochIndex = 1;
_runSatellitePreRenderForTest();
assert.equal(readEntityRecord(entity)?.labelModel.details[1], '366\u00a0km · NORAD 25544');
assert.equal(
readEntityRecord(entity)?.labelModel.details[0],
'STATION · ISS',
'the class line survives an altitude-only republish',
);
});
test('ISS ambient and tracked lifecycle uses cached host entries with no native labels or duplicate text', (t) => {
const calls = [];
const overlayHost = {
setEntries: (...args) => calls.push(['entries', ...args]),
setVisible: (...args) => calls.push(['visible', ...args]),
clearSource: (...args) => calls.push(['clear', ...args]),
};
const point = {
pos: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000),
show: true,
pixelSize: 12,
color: [1, 0, 0, 1],
outlineColor: [1, 1, 1, 1],
outlineWidth: 2,
disableDepthTest: 0,
};
const viewer = {};
const draw = fakeDrawPort();
t.after(bindRenderer(viewer, { camera: followingPort(), draw }));
let cleaned = false;
_setSatelliteLabelLifecycleStateForTest({
viewer,
satrec: twoline2satrec(L1, L2),
point,
overlayHost,
});
try {
const ambientPublication = calls.find(([type]) => type === 'entries');
assert.ok(ambientPublication);
assert.equal(ambientPublication[1], 'satellites-iss');
assert.deepEqual(ambientPublication[3], ISS_OVERLAY_SOURCE_OPTIONS);
const ambient = ambientPublication[2][0];
assert.equal(ambient.title, 'ISS');
assert.equal(
ambient.position(),
point.pos,
'ISS getter reads the existing point cache',
);
assert.equal(
point.label,
undefined,
'ISS point primitive carries no label graphic',
);
const trackedEntity = _trackIssForTest();
assert.ok(trackedEntity);
const tracked = [...draw.sets.values()].find(
(set) => !set.disposed && /^satellites:\d+:tracked$/.test(set.spec.id),
);
assert.ok(tracked, 'the tracked dot has a set of its own');
_runSatellitePreRenderForTest();
assert.equal(
tracked.items.get('25544')?.pixelSize,
14,
'the tracked dot draws, as the follow camera frames it',
);
assert.equal(trackedEntity.label, undefined);
const trackedEntry = createTrackedOverlayEntry(trackedEntity);
assert.ok(trackedEntry);
assert.equal(trackedEntry.id, 'satellites:25544');
assert.equal(trackedEntry.protected, true);
assert.equal(trackedEntry.paintLane, 'tracked');
assert.equal(
calls.filter(
([type, sourceId]) =>
type === 'entries' && sourceId === 'satellites-iss',
).length,
2,
'tracking may refresh before ownership changes but must not publish a second ISS entry',
);
assert.deepEqual(
calls.slice(-2),
[
['clear', 'satellites-iss'],
['visible', 'satellites-iss', false],
],
'tracked ISS suppresses ambient text so the tracked card is the only text surface',
);
_clearSatelliteLabelLifecycleForTest();
cleaned = true;
assert.equal(tracked.items.size, 0);
assert.ok(tracked.disposed);
assert.equal(
calls.filter(
([type, sourceId]) =>
type === 'entries' && sourceId === 'satellites-iss',
).length,
3,
'untracking republishes exactly one persistent ISS ambient entry before teardown',
);
} finally {
if (!cleaned) _clearSatelliteLabelLifecycleForTest();
}
});
test('ISS overlay entry retains the native distance scale and source text', () => {
const position = new Cesium.Cartesian3(1, 2, 3);
const entry = createIssOverlayEntry(() => position);
assert.equal(entry.title, 'ISS');
assert.equal(entry.position(), position);
assert.deepEqual(entry.distanceScale, {
near: 1_000_000,
nearValue: 1,
far: 30_000_000,
farValue: 0.4,
});
assert.equal(entry.edgeFade, 'keyhole');
assert.equal(entry.horizonCull, true);
});