Files
gods-eye-view/src/library/datasetLayer.test.mjs
T
Sameh Khamis e3865f462f Merge origin/main into the renderer-contract branch: the procedural fleet models drawn through the renderer's model sets
Aircraft, military, local ADS-B, vessel, transit and rail models come from
the fleet model set, loaded up front and drawn life size through the draw
port's models sets; no layer touches the viewer or Cesium outside
src/render/cesium/. The models capability gains glTF bytes (gltf), a
per-axis stretch (axisScale), a colour for tinted parts (maskColor) and a
cut below the origin (clip: 'belowOrigin'), with conformance checks.

Main's rail layer and Data Library are ported to the ports; the CCTV
footprint probe keeps the globe-terrain clamp through the query port.
2026-11-13 14:14:42 -08:00

354 lines
12 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import test from 'node:test';
import assert from 'node:assert/strict';
import { localGeoJsonServices } from '../app/localGeojsonServices.js';
import {
getContextStore,
getSelectedEntityContext,
selectEntityContext,
} from '../data/contextStore.js';
import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs';
import { createLibraryDatasetLayer } from './layers.js';
const entry = {
id: 'test-alerts',
kind: 'dataset',
title: 'Test alerts',
icon: '!',
provider: 'Test',
display: { color: '#ff0000' },
source: { cacheSeconds: 60 },
attribution: { text: 'Test' },
licence: { name: 'CC0', url: 'https://example.org/licence' },
};
// One small triangle per name, each in its own place.
const point = (name) => {
const x = name.charCodeAt(0) / 100;
return {
type: 'Feature',
properties: { name },
geometry: {
type: 'Polygon',
coordinates: [
[
[x, 0],
[x + 0.01, 0],
[x, 0.01],
[x, 0],
],
],
},
};
};
// A clock that is never 0, which reads as "never loaded".
const START = 1_000_000;
const deferred = () => {
let resolve;
let reject;
const promise = new Promise((done, fail) => {
resolve = done;
reject = fail;
});
return { promise, resolve, reject };
};
function harness(t, loads) {
const previousWindow = globalThis.window;
globalThis.window = { dispatchEvent() {} };
const viewer = {};
const fake = bindFakeGroundRenderer(viewer, {
eye: { lon: 0.6, lat: 0, height: 50_000 },
});
let calls = 0;
const source = {
async loadDataset(_entry, { signal }) {
const answer = loads[calls++];
return typeof answer === 'function' ? answer(signal) : answer;
},
};
const layer = createLibraryDatasetLayer(entry, {
services: {
...localGeoJsonServices,
overlayHost: { setVisible() {}, setEntries() {}, clearSource() {} },
},
source,
inputFor: () => ({ onClick: () => () => {}, onPointer: () => () => {} }),
});
t.after(() => {
layer.destroy(viewer);
fake.unbind();
if (previousWindow === undefined) delete globalThis.window;
else globalThis.window = previousWindow;
});
// The fill sets drawn now: one per build still in the scene.
const builds = () =>
fake.liveSets().filter((set) => set.spec.id.endsWith(':fills'));
return { layer, viewer, fake, builds, calls: () => calls };
}
const result = (...names) => ({
features: names.map(point),
truncated: false,
});
test('a library dataset refreshes on the manager tick once older than cacheSeconds', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('a'), result('b', 'c')]);
assert.equal(env.layer.refreshInterval, 60_000);
await env.layer.enable(env.viewer);
assert.equal(env.layer.getStats().count, 1);
await env.layer.update(env.viewer);
assert.equal(env.calls(), 1, 'fresh data is not refetched');
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
assert.equal(env.calls(), 2);
assert.equal(env.layer.getStats().count, 2);
assert.equal(env.builds().length, 1, 'the old build is replaced, not kept');
});
test('a slow upstream still refreshes on every tick, not every other one', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
// Each request takes two seconds to answer.
const slow = (value) => async () => {
t.mock.timers.tick(2000);
return value;
};
const env = harness(t, [
slow(result('a')),
slow(result('b')),
slow(result('c')),
]);
await env.layer.enable(env.viewer);
// The manager ticks every refreshInterval from when the layer came on.
t.mock.timers.setTime(START + 60_000);
await env.layer.update(env.viewer);
t.mock.timers.setTime(START + 120_000);
await env.layer.update(env.viewer);
assert.equal(env.calls(), 3);
});
test('a failed first load is not retried by the tick that follows enable', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
t.mock.method(console, 'error', () => {});
const env = harness(t, [
() => Promise.reject(new Error('HTTP 503')),
result('a'),
]);
await env.layer.enable(env.viewer);
assert.ok(env.layer.getStats().error);
// Resolving (not rejecting) keeps the manager from failing the switch-on.
await env.layer.update(env.viewer);
assert.equal(env.calls(), 1);
});
test('a refresh keeps the old features drawn until the new ones are in, and the selection', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('a', 'b'), result('a', 'c')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
const carrierOf = (set, name) =>
[...set.items.values()].find(
(item) => item.meta.record.properties.name === name,
).meta;
selectEntityContext(carrierOf(first, 'a'));
// Drawn while the new build is made: watch the shapes sets made.
const shapes = env.fake.draw.shapes;
const drawnWhileBuilding = [];
env.fake.draw.shapes = (spec) => {
drawnWhileBuilding.push(first.disposed === false);
return shapes(spec);
};
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
assert.ok(drawnWhileBuilding.length > 0);
assert.ok(drawnWhileBuilding.every(Boolean), 'the old build was still drawn');
assert.equal(first.disposed, true);
const [next] = env.builds();
assert.notEqual(next, first);
assert.equal(next.show, true);
const selected = getSelectedEntityContext();
assert.equal(selected?.entity, carrierOf(next, 'a'));
assert.equal(selected.properties.name, 'a');
// Only the new set's features keep a context.
const labels = [...getContextStore().entities.values()]
.filter((record) => record.layerId === env.layer.id)
.map((record) => record.label)
.sort();
assert.deepEqual(labels, ['a', 'c']);
});
test('a selected feature without an id stays selected by its place and label', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
// Without ids, a feature's part id is its index: 'a' moves from 1 to 0.
const env = harness(t, [result('b', 'a'), result('a', 'c')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
const carrier = [...first.items.values()].find(
(item) => item.meta.record.properties.name === 'a',
).meta;
selectEntityContext(carrier);
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
const selected = getSelectedEntityContext();
assert.equal(selected?.properties.name, 'a');
assert.notEqual(selected.entity, carrier);
});
test('a refresh whose rebuild fails keeps the drawn features', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
t.mock.method(console, 'error', () => {});
const env = harness(t, [result('a'), result('b', 'c')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
env.fake.draw.shapes = () => {
throw new Error('scene full');
};
t.mock.timers.tick(60_000);
await assert.rejects(env.layer.update(env.viewer), /scene full/);
assert.deepEqual(env.builds(), [first]);
assert.equal(first.show, true);
assert.equal(env.layer.getStats().count, 1);
assert.equal(env.layer.getStats().error, null);
// The kept features keep their contexts.
assert.ok(
[...getContextStore().entities.values()].some(
(record) => record.layerId === env.layer.id && record.label === 'a',
),
);
});
test('a stale library dataset reloads on the next enable', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('a'), result('b', 'c')]);
await env.layer.enable(env.viewer);
env.layer.disable(env.viewer);
await env.layer.enable(env.viewer);
assert.equal(
env.calls(),
1,
'a re-enable within cacheSeconds reuses the data',
);
env.layer.disable(env.viewer);
t.mock.timers.tick(60_000);
await env.layer.enable(env.viewer);
assert.equal(env.calls(), 2);
assert.equal(env.layer.getStats().count, 2);
});
test('a failed refresh keeps the drawn features', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [
result('a'),
() => Promise.reject(new Error('HTTP 503')),
]);
await env.layer.enable(env.viewer);
t.mock.timers.tick(60_000);
await assert.rejects(env.layer.update(env.viewer), /HTTP 503/);
assert.equal(env.layer.getStats().count, 1);
assert.equal(env.builds().length, 1);
});
test('disable during a refresh cancels it and draws nothing late', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const pending = deferred();
let refreshSignal = null;
const env = harness(t, [
result('a'),
(signal) => {
refreshSignal = signal;
return pending.promise;
},
]);
await env.layer.enable(env.viewer);
t.mock.timers.tick(60_000);
const refreshing = env.layer.update(env.viewer);
env.layer.disable(env.viewer);
assert.equal(refreshSignal.aborted, true);
pending.resolve(result('b', 'c'));
await refreshing;
assert.equal(env.builds().length, 0);
});
test('a refresh that drops the selected feature clears the selection', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('b', 'a'), result('c', 'd')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
selectEntityContext(
[...first.items.values()].find(
(item) => item.meta.record.properties.name === 'a',
).meta,
);
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
assert.equal(getSelectedEntityContext(), null);
});
test('colorBy colours each feature’s fill, stem, dot and label accent', async (t) => {
const previousWindow = globalThis.window;
globalThis.window = { dispatchEvent() {} };
const viewer = {};
const fake = bindFakeGroundRenderer(viewer, {
eye: { lon: 0.6, lat: 0, height: 50_000 },
});
const colored = {
...entry,
display: {
color: '#ff0000',
colorBy: { field: 'kind', colors: { hot: '#00ff00' } },
},
};
const entries = [];
const features = [point('a'), point('b')];
features[0].properties.__gevColorKey = 'hot';
// A manifest rank raises a label's priority, at most by 600.
features[1].properties.__gevRank = 9999;
const layer = createLibraryDatasetLayer(colored, {
services: {
...localGeoJsonServices,
overlayHost: {
setVisible() {},
setEntries: (_source, next) => entries.push(...next),
clearSource() {},
},
},
source: { loadDataset: async () => ({ features, truncated: false }) },
inputFor: () => ({ onClick: () => () => {}, onPointer: () => () => {} }),
});
t.after(() => {
layer.destroy(viewer);
fake.unbind();
if (previousWindow === undefined) delete globalThis.window;
else globalThis.window = previousWindow;
});
await layer.enable(viewer);
const byName = (role, name) =>
[...fake.set(role).items.values()].find(
(item) => item.meta.record.properties.name === name,
);
assert.deepEqual(byName('fills', 'a').fill, [0, 1, 0, 0.3]);
assert.deepEqual(byName('fills', 'b').fill, [1, 0, 0, 0.3]);
assert.deepEqual(byName('stems', 'a').style.color, [0, 1, 0, 1]);
assert.deepEqual(byName('dots', 'b').color, [1, 0, 0, 1]);
assert.equal(byName('fills', 'a').meta.record.entry.accent, '#00ff00');
assert.equal(byName('fills', 'b').meta.record.entry.accent, '#ff0000');
assert.equal(
byName('fills', 'b').meta.record.priority -
byName('fills', 'a').meta.record.priority,
600,
);
});
test('library card lines reach the label copy, the first two only', async () => {
const { localInfrastructureOverlayCopy } =
await import('../data/localGeojsonCore.js');
assert.deepEqual(
localInfrastructureOverlayCopy(
{ name: 'Dam', __gevDetails: ['River: Nile', ' ', 'Height: 111 m', 'x'] },
'lib-test',
),
{ title: 'Dam', details: ['River: Nile'] },
);
});