mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 00:32:21 +00:00
Brings in fire intensity and the draped heatmap (#1426), provider labels (#1521), Rio transit (#1481), chat autocomplete and provider switching (#1561, #1546) and Cockpit entry by the ridden layer alone (#1556). What main added that reached Cesium or the viewer: - The fires heatmap drapes as one image through the globe port's imagery (heatImagery.js), above the port's other imagery, and drapes again when the map stack's surface changes. The far bands no longer draw heat rectangles; the layer's shape set stays as its initialized marker and the visibility the context store reads. - The hand-off between heatmap and markers fades the glow icons' own alpha and the icon set's visibility. Markers keep their glows across rebuilds; the set culls the horizon itself. - A double-click on the followed track enters the Cockpit through the input dispatcher. The renderer's own double-click follow would let go of the track first and cannot be refused from a subscriber, so a press on the followed track holds that behaviour off for the press. - Cockpit entry and the ridden layer read the follow service; the camera takes its eye offsets from a profile.
480 lines
17 KiB
JavaScript
480 lines
17 KiB
JavaScript
// src/ui/cockpitContext.test.mjs — the Cockpit Contact card renders what the
|
|
// Cockpit controller presents, over happy-dom.
|
|
import '../testSupport/registerDom.mjs';
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createPinia } from 'pinia';
|
|
import { createApp, nextTick } from 'vue';
|
|
import { setLocale, t as translate } from '../i18n/index.js';
|
|
import {
|
|
publishContextView,
|
|
showContextCard,
|
|
updateContext,
|
|
} from './cockpitContext.js';
|
|
import { fromDegrees } from '../geo/index.js';
|
|
import { createContextState } from './cockpitContextState.js';
|
|
import {
|
|
dropCockpitSignal,
|
|
dropContextSnapshotSignals,
|
|
publishCockpitSignals,
|
|
pushCockpitSignal,
|
|
updateCockpitSignals,
|
|
} from './cockpitSignals.js';
|
|
import { syncWeatherToggle } from './cockpitInstruments.js';
|
|
import { setContextCollapsed } from './cockpitLayout.js';
|
|
import { useCockpitStore } from './stores/cockpit.js';
|
|
import CockpitContext from './views/panels/CockpitContext.vue';
|
|
|
|
function fixture(t, snapshot = null) {
|
|
document.body.replaceChildren();
|
|
const host = document.body.appendChild(document.createElement('div'));
|
|
const pinia = createPinia();
|
|
const app = createApp(CockpitContext).use(pinia);
|
|
app.mount(host);
|
|
t.after(() => app.unmount());
|
|
const store = useCockpitStore(pinia);
|
|
const $ = (selector) => document.querySelector(selector);
|
|
const signals = [];
|
|
const layouts = [];
|
|
// The Contact presenter needs only this much of the controller.
|
|
const owner = {
|
|
context: $('#cockpit-context'),
|
|
presence: { context: false },
|
|
contextView: createContextState(),
|
|
contextLayoutStamp: null,
|
|
publishContext: (view) => store.publishContext(view),
|
|
publishContextView,
|
|
publishPresenceView: () => store.publishPresence({ ...owner.presence }),
|
|
showContextCard,
|
|
pushCockpitSignal: (...args) => signals.push(args),
|
|
updateCockpitSignals() {},
|
|
scheduleContextLayout: () => layouts.push(true),
|
|
services: {
|
|
militaryAwarenessLayer: { getContextSnapshot: () => owner.snapshot },
|
|
formatAwarenessLabel: (item) => item?.id ?? '—',
|
|
},
|
|
snapshot,
|
|
};
|
|
const text = (selector) => $(selector).textContent.trim();
|
|
return { $, text, owner, signals, layouts };
|
|
}
|
|
|
|
const INFO = {
|
|
layerId: 'flights',
|
|
icao24: 'abc123',
|
|
latitude: 30,
|
|
longitude: -97,
|
|
};
|
|
|
|
const snapshot = (overrides = {}) => ({
|
|
subject: { layerId: 'military', id: 'm1', label: 'RCH123' },
|
|
radiusM: 250_000,
|
|
evaluatedAt: Date.UTC(2026, 9, 31, 12, 34, 56),
|
|
navigation: { canPrevious: false, canNext: true },
|
|
cohorts: [
|
|
{
|
|
id: 'flights',
|
|
label: 'Flights',
|
|
count: 12,
|
|
relationship: 'OBSERVED',
|
|
nearest: [{ id: 'N1', distanceM: 4200 }],
|
|
},
|
|
{
|
|
id: 'military',
|
|
label: 'Military',
|
|
count: null,
|
|
relationship: 'UNKNOWN',
|
|
nearest: [],
|
|
},
|
|
],
|
|
...overrides,
|
|
});
|
|
|
|
test('before the controller presents, the card shows the state it starts in', (t) => {
|
|
const { $, text } = fixture(t);
|
|
const card = $('#cockpit-context');
|
|
assert.equal(card.hidden, true);
|
|
assert.equal(card.hasAttribute('data-state'), false);
|
|
assert.equal(text('#cockpit-context-subject'), 'CONTACTS · 250 KM');
|
|
assert.equal($('#cockpit-context-previous').disabled, false);
|
|
assert.equal($('#cockpit-context-next').disabled, false);
|
|
assert.deepEqual(
|
|
[...document.querySelectorAll('[data-context-cohort] strong')].map(
|
|
(count) => count.textContent,
|
|
),
|
|
['—', '—', '—', '—'],
|
|
);
|
|
// No provider is named before a snapshot reports one.
|
|
assert.deepEqual(
|
|
[...document.querySelectorAll('[data-context-cohort] small')].map(
|
|
(source) => source.textContent,
|
|
),
|
|
['—', '—', '—', '—'],
|
|
);
|
|
assert.equal(text('#cockpit-context-nearest-label'), 'NO AVAILABLE EXAMPLE');
|
|
assert.equal(
|
|
$('#cockpit-context-nearest-label').hasAttribute('aria-label'),
|
|
false,
|
|
);
|
|
assert.equal($('#cockpit-context-direction').getAttribute('style'), null);
|
|
assert.equal(
|
|
text('#cockpit-context-uncertainty'),
|
|
'AVAILABLE INPUTS ONLY · NOT AN ALL-CLEAR',
|
|
);
|
|
assert.equal(text('#cockpit-context-updated'), '--:--:--Z');
|
|
const weather = $('#cockpit-weather-toggle');
|
|
assert.equal(weather.getAttribute('aria-pressed'), 'false');
|
|
assert.equal(
|
|
weather.getAttribute('aria-label'),
|
|
'Enable cockpit weather effects',
|
|
);
|
|
assert.equal(weather.title, 'Enable cockpit weather effects');
|
|
assert.equal(text('#cockpit-weather-state'), 'OFF');
|
|
});
|
|
|
|
test('a snapshot fills the card and keeps classes other code sets', async (t) => {
|
|
const { $, text, owner, layouts } = fixture(t, snapshot());
|
|
const flights = $('[data-context-cohort="flights"]');
|
|
flights.classList.add('voice-highlight');
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
const card = $('#cockpit-context');
|
|
assert.equal(card.hidden, false);
|
|
assert.equal(card.dataset.state, 'uncertain');
|
|
assert.equal(owner.presence.context, true);
|
|
assert.match(
|
|
text('#cockpit-context-subject'),
|
|
/^RCH123 · 250\u00a0KM AIR\/SEA WINDOW$/,
|
|
);
|
|
assert.equal($('#cockpit-context-previous').disabled, true);
|
|
assert.equal($('#cockpit-context-next').disabled, false);
|
|
assert.equal(flights.querySelector('strong').textContent, '12');
|
|
assert.equal(flights.classList.contains('unknown'), false);
|
|
assert.equal(flights.classList.contains('voice-highlight'), true);
|
|
const military = $('[data-context-cohort="military"]');
|
|
assert.equal(military.querySelector('strong').textContent, '?');
|
|
assert.equal(military.classList.contains('unknown'), true);
|
|
assert.equal(text('#cockpit-context-nearest-label'), 'FLIGHTS · N1');
|
|
assert.equal(
|
|
$('#cockpit-context-nearest-label').getAttribute('aria-label'),
|
|
'FLIGHTS · N1',
|
|
);
|
|
assert.match(text('#cockpit-context-distance'), /^4\.2/);
|
|
// The tracked aircraft is not the subject: the nose-relative half dashes.
|
|
assert.equal(text('#cockpit-context-bearing'), 'BRG —');
|
|
const direction = $('#cockpit-context-direction');
|
|
assert.equal(direction.style.transform, 'rotate(0deg)');
|
|
assert.equal(direction.classList.contains('unknown'), true);
|
|
assert.equal(direction.classList.contains('material-symbols-outlined'), true);
|
|
assert.equal(
|
|
text('#cockpit-context-uncertainty'),
|
|
'1 INPUT UNKNOWN · NOT AN ALL-CLEAR',
|
|
);
|
|
assert.equal(text('#cockpit-context-updated'), '12:34:56Z');
|
|
assert.equal(layouts.length, 1);
|
|
});
|
|
|
|
test('when the tracked aircraft is the subject, the bearing points at the nearest contact', async (t) => {
|
|
const tracked = { layerId: 'flights', id: 'abc123', label: 'ABC123' };
|
|
const contact = (lon, lat) =>
|
|
snapshot({
|
|
subject: tracked,
|
|
cohorts: [
|
|
{
|
|
id: 'flights',
|
|
label: 'Flights',
|
|
count: 1,
|
|
relationship: 'OBSERVED',
|
|
nearest: [
|
|
{ id: 'N1', distanceM: 96_000, position: fromDegrees(lon, lat) },
|
|
],
|
|
},
|
|
],
|
|
});
|
|
const { text, owner } = fixture(t, contact(-96, 30));
|
|
// Due east of a north-facing nose.
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
assert.equal(text('#cockpit-context-bearing'), 'R 090°');
|
|
// Due north: inside the dead-ahead cone.
|
|
owner.snapshot = contact(-97, 31);
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
assert.equal(text('#cockpit-context-bearing'), 'AHEAD');
|
|
// Due west of a nose turned to the north-east.
|
|
owner.snapshot = contact(-98, 30);
|
|
updateContext.call(owner, INFO, 45);
|
|
await nextTick();
|
|
assert.equal(text('#cockpit-context-bearing'), 'L 135°');
|
|
});
|
|
|
|
test('each count names the provider its snapshot reports, with its feed state', async (t) => {
|
|
const reported = snapshot();
|
|
reported.cohorts[0].source = 'adsb.lol';
|
|
reported.cohorts[0].sourceStatus = 'fallback';
|
|
reported.cohorts[1].source = 'Plane Finder';
|
|
reported.cohorts.push(
|
|
{
|
|
id: 'ais-live-vessels',
|
|
label: 'AIS vessels',
|
|
source: 'Datalastic',
|
|
sourceStatus: 'stale',
|
|
count: 3,
|
|
relationship: 'OBSERVED',
|
|
nearest: [],
|
|
},
|
|
{
|
|
id: 'military-installations',
|
|
label: 'Mapped installations',
|
|
source: 'OpenStreetMap',
|
|
sourceStatus: null,
|
|
count: 0,
|
|
relationship: 'MAPPED',
|
|
nearest: [],
|
|
},
|
|
);
|
|
const { $, owner } = fixture(t, reported);
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
const source = (id) => $(`[data-context-cohort="${id}"] small`);
|
|
assert.equal(source('flights').textContent, 'adsb.lol · FALLBACK');
|
|
assert.equal(source('military').textContent, 'Plane Finder');
|
|
assert.equal(source('ais-live-vessels').textContent, 'Datalastic · STALE');
|
|
assert.equal(source('military-installations').textContent, 'OpenStreetMap');
|
|
// The tile ellipsizes; the full name stays readable on hover.
|
|
assert.equal(source('flights').title, 'adsb.lol · FALLBACK');
|
|
});
|
|
|
|
test('a lost contact holds its readout behind the CONTACT LOST cue', async (t) => {
|
|
const { $, text, owner, layouts } = fixture(t, snapshot());
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
const readout = () =>
|
|
[
|
|
'#cockpit-context-nearest-label',
|
|
'#cockpit-context-distance',
|
|
'#cockpit-context-bearing',
|
|
'#cockpit-context-updated',
|
|
].map(text);
|
|
const held = readout();
|
|
owner.snapshot = snapshot({
|
|
subjectPresent: false,
|
|
navigation: { canPrevious: true, canNext: false },
|
|
cohorts: [{ id: 'flights', label: 'Flights', count: 1, nearest: [] }],
|
|
});
|
|
updateContext.call(owner, INFO, 0);
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
assert.equal($('#cockpit-context').dataset.state, 'lost');
|
|
assert.equal(
|
|
text('#cockpit-context-uncertainty'),
|
|
'CONTACT LOST · LAST KNOWN READOUT · NOT AN ALL-CLEAR',
|
|
);
|
|
// Navigation follows the lost snapshot; the readout holds.
|
|
assert.deepEqual(readout(), held);
|
|
assert.equal($('#cockpit-context-previous').disabled, false);
|
|
assert.equal($('#cockpit-context-next').disabled, true);
|
|
assert.equal($('[data-context-cohort="flights"] strong').textContent, '12');
|
|
// Layout reruns once on the way in, not every update.
|
|
assert.equal(layouts.length, 2);
|
|
});
|
|
|
|
test('without a snapshot the card stands by, hidden', async (t) => {
|
|
const { $, owner, signals } = fixture(t, snapshot());
|
|
updateContext.call(owner, INFO, 0);
|
|
owner.snapshot = null;
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
assert.equal($('#cockpit-context').hidden, true);
|
|
assert.equal(owner.presence.context, false);
|
|
assert.equal(signals.at(-1)[2], 'CONTEXT STANDBY');
|
|
});
|
|
|
|
test('a feed that is off makes the card and Live Signals say the picture is partial', async (t) => {
|
|
// Every input known, so only the feed that is off can make it partial.
|
|
const { $, text, owner } = fixture(
|
|
t,
|
|
snapshot({
|
|
cohorts: [
|
|
{
|
|
id: 'flights',
|
|
label: 'Flights',
|
|
count: 12,
|
|
relationship: 'OBSERVED',
|
|
nearest: [{ id: 'N1', distanceM: 4200 }],
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
const rebuilt = [];
|
|
owner.updateCockpitSignals = (...args) => rebuilt.push(args);
|
|
owner.services.isLayerEnabled = () => true;
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
assert.equal($('#cockpit-context').dataset.state, 'current');
|
|
assert.equal(rebuilt.at(-1)[2], null, 'both feeds on: nothing to add');
|
|
|
|
owner.services.isLayerEnabled = (layerId) => layerId !== 'military';
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
assert.equal($('#cockpit-context').dataset.state, 'uncertain');
|
|
assert.equal(
|
|
text('#cockpit-context-uncertainty'),
|
|
'MILITARY FEED OFF · PARTIAL PICTURE',
|
|
);
|
|
assert.deepEqual(rebuilt.at(-1)[2], {
|
|
title: 'MILITARY FEED OFF · PARTIAL PICTURE',
|
|
detail: 'NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR',
|
|
});
|
|
});
|
|
|
|
test('without Contacts, a feed that is off adds a signal until it is back', async (t) => {
|
|
const { owner, signals } = fixture(t, null);
|
|
const dropped = [];
|
|
owner.dropCockpitSignal = (key) => dropped.push(key);
|
|
// Riding a military aircraft with Live Flights off.
|
|
owner.services.isLayerEnabled = (layerId) => layerId === 'military';
|
|
updateContext.call(owner, { ...INFO, layerId: 'military' }, 0);
|
|
assert.equal(signals.at(-2)[2], 'CONTEXT STANDBY');
|
|
assert.deepEqual(signals.at(-1), [
|
|
'feed-status',
|
|
'warning',
|
|
'FLIGHTS FEED OFF · PARTIAL PICTURE',
|
|
'NEARBY AIRCRAFT INCOMPLETE · NOT AN ALL-CLEAR',
|
|
]);
|
|
owner.services.isLayerEnabled = () => true;
|
|
updateContext.call(owner, { ...INFO, layerId: 'military' }, 0);
|
|
assert.deepEqual(dropped, ['feed-status']);
|
|
});
|
|
|
|
/** The fixture's owner with the real Live Signals presenters. */
|
|
function withSignals(owner) {
|
|
const published = [];
|
|
Object.assign(owner, {
|
|
signalItems: [],
|
|
signalSignatures: new Map(),
|
|
publishSignals: (rows) => published.push(rows),
|
|
publishCockpitSignals,
|
|
pushCockpitSignal,
|
|
dropCockpitSignal,
|
|
dropContextSnapshotSignals,
|
|
updateCockpitSignals,
|
|
});
|
|
return () => published.at(-1).map((row) => row.title);
|
|
}
|
|
|
|
test('Contacts going off clears its contact rows and leaves standby', async (t) => {
|
|
const { owner } = fixture(t, snapshot());
|
|
const rows = withSignals(owner);
|
|
owner.services.isLayerEnabled = () => true;
|
|
updateContext.call(owner, INFO, 0);
|
|
assert.ok(
|
|
owner.signalItems.some((item) => item.key.startsWith('flight:')),
|
|
'Contacts fills the rows',
|
|
);
|
|
assert.ok(owner.signalItems.some((item) => item.key === 'input-status'));
|
|
// Both feeds stay on; only Contacts goes.
|
|
owner.snapshot = null;
|
|
updateContext.call(owner, INFO, 0);
|
|
assert.deepEqual(rows(), ['CONTEXT STANDBY']);
|
|
updateContext.call(owner, INFO, 0);
|
|
assert.deepEqual(rows(), ['CONTEXT STANDBY'], 'standby holds still');
|
|
});
|
|
|
|
test('Contacts going off with a feed off keeps the feed row beside standby', async (t) => {
|
|
const { owner } = fixture(t, snapshot());
|
|
const rows = withSignals(owner);
|
|
owner.services.isLayerEnabled = (layerId) => layerId !== 'military';
|
|
updateContext.call(owner, INFO, 0);
|
|
owner.snapshot = null;
|
|
updateContext.call(owner, INFO, 0);
|
|
assert.deepEqual(rows(), [
|
|
'MILITARY FEED OFF · PARTIAL PICTURE',
|
|
'CONTEXT STANDBY',
|
|
]);
|
|
});
|
|
|
|
test('standby without Contacts keeps the rows the session already shows', async (t) => {
|
|
const { owner } = fixture(t, null);
|
|
const rows = withSignals(owner);
|
|
owner.services.isLayerEnabled = () => true;
|
|
owner.pushCockpitSignal('track', 'track', 'TRACK ACQUIRED', 'UAL123');
|
|
updateContext.call(owner, INFO, 0);
|
|
assert.deepEqual(rows(), ['CONTEXT STANDBY', 'TRACK ACQUIRED']);
|
|
});
|
|
|
|
test('the weather toggle renders its state and the action it offers', async (t) => {
|
|
const { $, text, owner } = fixture(t);
|
|
syncWeatherToggle.call(owner, true);
|
|
await nextTick();
|
|
const weather = $('#cockpit-weather-toggle');
|
|
assert.equal(weather.getAttribute('aria-pressed'), 'true');
|
|
assert.equal(
|
|
weather.getAttribute('aria-label'),
|
|
'Disable cockpit weather effects',
|
|
);
|
|
assert.equal(weather.title, 'Disable cockpit weather effects');
|
|
assert.equal(text('#cockpit-weather-state'), 'ON');
|
|
assert.equal(owner.contextView.weather, true);
|
|
});
|
|
|
|
test('re-renders keep the collapse the controller presents and leave it the layout', async (t) => {
|
|
const { $, owner } = fixture(t, snapshot());
|
|
updateContext.call(owner, INFO, 0);
|
|
const card = $('#cockpit-context');
|
|
owner.presence.contextCollapsed = true;
|
|
owner.publishPresenceView();
|
|
card.dataset.layoutMode = 'compact-bottom';
|
|
owner.snapshot = snapshot({ evaluatedAt: Date.UTC(2026, 9, 31, 12, 35) });
|
|
updateContext.call(owner, INFO, 0);
|
|
await nextTick();
|
|
assert.equal(card.hidden, false);
|
|
assert.equal(card.dataset.collapsed, 'true');
|
|
assert.equal(card.dataset.layoutMode, 'compact-bottom');
|
|
const toggle = $('#cockpit-context-toggle');
|
|
assert.equal(toggle.getAttribute('aria-expanded'), 'false');
|
|
assert.equal(toggle.getAttribute('aria-label'), 'Expand Contact panel');
|
|
assert.equal(toggle.title, 'Expand contact panel');
|
|
assert.equal(toggle.textContent.trim(), 'chevron_right');
|
|
});
|
|
|
|
test('the card is labelled in the UI language', async (t) => {
|
|
t.after(() => setLocale('en'));
|
|
setLocale('ru');
|
|
const { $, text, owner } = fixture(t);
|
|
const subject = translate('CONTACTS · 250 KM');
|
|
assert.notEqual(subject, 'CONTACTS · 250 KM');
|
|
assert.equal(text('#cockpit-context-subject'), subject);
|
|
assert.equal(text('#cockpit-weather-state'), translate('OFF'));
|
|
syncWeatherToggle.call(owner, true);
|
|
await nextTick();
|
|
assert.equal(text('#cockpit-weather-state'), translate('ON'));
|
|
assert.equal(
|
|
$('#cockpit-weather-toggle').getAttribute('aria-label'),
|
|
translate('Disable cockpit weather effects'),
|
|
);
|
|
});
|
|
|
|
test('collapsing the card publishes once per change', async (t) => {
|
|
const { $, owner } = fixture(t);
|
|
let published = 0;
|
|
const publish = owner.publishPresenceView;
|
|
Object.assign(owner, {
|
|
contextCollapsed: false,
|
|
presence: { context: true, contextCollapsed: false },
|
|
publishPresenceView: () => {
|
|
published += 1;
|
|
publish();
|
|
},
|
|
});
|
|
setContextCollapsed.call(owner, true);
|
|
setContextCollapsed.call(owner, true);
|
|
assert.equal(published, 1);
|
|
await nextTick();
|
|
assert.equal($('#cockpit-context').dataset.collapsed, 'true');
|
|
assert.equal(
|
|
$('#cockpit-context-toggle').getAttribute('aria-expanded'),
|
|
'false',
|
|
);
|
|
});
|