mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
AIS Vessels are keyed by the id their live source gives, with the MMSI as an attribute: an MMSI can be shared, spoofed or reused, so two vessels with one MMSI are now two vessels. Looking a vessel up or selecting it by MMSI still finds it. A share link made while a vessel is selected opens that vessel. A UUID vessel id travels as 16 bytes in a new thing field (13). A shared thing that is not reporting now says so in a sentence per kind, with its id (ICAO, NORAD, MMSI or vessel UUID) on a second line.
1232 lines
38 KiB
JavaScript
1232 lines
38 KiB
JavaScript
import { ShareRestoration } from './ui/shareRestoration.js';
|
|
import {
|
|
readShellSource,
|
|
shellMethod,
|
|
} from './testSupport/readShellSource.mjs';
|
|
import { renderApplicationHtml } from './testSupport/applicationHtml.mjs';
|
|
import { readStylesheet } from './testSupport/readStylesheet.mjs';
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
const retrySite = (stats = {}) => ({
|
|
id: 'military-installations',
|
|
name: 'Mapped Installations',
|
|
enabled: true,
|
|
stats: {
|
|
status: 'unavailable',
|
|
error: 'Unavailable',
|
|
retryAt: Date.now() + 30000,
|
|
...stats,
|
|
},
|
|
});
|
|
|
|
test('installation retry remains visible after failure dwell without a false spinner', () => {
|
|
const summary = aggregateLayerLoading([retrySite()]);
|
|
const view = presentLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
summary,
|
|
100,
|
|
);
|
|
assert.equal(view.state, 'retry');
|
|
assert.equal(view.label, 'OVERPASS TEMPORARILY UNAVAILABLE');
|
|
assert.match(view.detail, /retrying in 30s/);
|
|
assert.equal(
|
|
presentLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
aggregateLayerLoading([{ ...retrySite(), enabled: false }]),
|
|
100,
|
|
),
|
|
null,
|
|
);
|
|
});
|
|
test('an installation retry never conceals another participant failure', () => {
|
|
const state = {
|
|
visible: true,
|
|
phase: 'terminal',
|
|
terminal: 'error',
|
|
activeIds: ['military-installations', 'flights'],
|
|
};
|
|
const summary = aggregateLayerLoading([
|
|
retrySite(),
|
|
{ id: 'flights', enabled: true, stats: { error: 'Failed' } },
|
|
]);
|
|
assert.equal(
|
|
presentLoadingFeedback(state, summary, 100).label,
|
|
'LOAD FAILED',
|
|
);
|
|
const healthyNow = aggregateLayerLoading([retrySite()]);
|
|
assert.equal(
|
|
presentLoadingFeedback(
|
|
{ ...state, failedEventIds: ['flights'] },
|
|
healthyNow,
|
|
100,
|
|
).label,
|
|
'LOAD FAILED',
|
|
);
|
|
});
|
|
test('a fresh installation retry can finish successfully without inheriting the old error', () => {
|
|
let state = {
|
|
...createLoadingFeedbackState(),
|
|
phase: 'terminal',
|
|
terminal: 'error',
|
|
visible: true,
|
|
activeIds: ['military-installations'],
|
|
};
|
|
const loading = aggregateLayerLoading([
|
|
retrySite({
|
|
status: 'loading',
|
|
error: null,
|
|
loading: true,
|
|
retryAt: 0,
|
|
retrying: true,
|
|
}),
|
|
]);
|
|
state = reduceLoadingFeedback(state, loading, 1000);
|
|
state = reduceLoadingFeedback(state, loading, 1200);
|
|
assert.equal(
|
|
presentLoadingFeedback(state, loading, 1200).label,
|
|
'RETRYING MAPPED SITES',
|
|
);
|
|
const done = aggregateLayerLoading([
|
|
retrySite({
|
|
status: 'ready',
|
|
error: null,
|
|
loading: false,
|
|
retryAt: 0,
|
|
retrying: false,
|
|
count: 3,
|
|
}),
|
|
]);
|
|
state = reduceLoadingFeedback(state, done, 1500);
|
|
assert.equal(
|
|
presentLoadingFeedback(state, done, 1500).label,
|
|
'MAPPED SITES LOADED',
|
|
);
|
|
});
|
|
test('turning off a retrying installation layer does not report the old fetch failure as a disable failure', () => {
|
|
const stopping = aggregateLayerLoading([
|
|
{ ...retrySite(), lifecycleState: 'disabling' },
|
|
]);
|
|
let state = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
stopping,
|
|
1000,
|
|
);
|
|
state = reduceLoadingFeedback(state, stopping, 1200);
|
|
const off = aggregateLayerLoading([
|
|
{
|
|
...retrySite({ status: 'idle', error: null, retryAt: 0 }),
|
|
enabled: false,
|
|
},
|
|
]);
|
|
state = reduceLoadingFeedback(state, off, 1400);
|
|
assert.equal(presentLoadingFeedback(state, off, 1400).label, 'LIVE DATA OFF');
|
|
});
|
|
import {
|
|
aggregateLayerLoading,
|
|
canPresentDeferredStatusNotice,
|
|
createGlobalStatusNotice,
|
|
createLoadingFeedbackState,
|
|
createTrafficSyncFeedbackState,
|
|
LOADING_FAILURE_DWELL_MS,
|
|
normalizeLayerLoading,
|
|
presentGlobalLoadingStatus,
|
|
presentGlobalStatusNotice,
|
|
presentLoadingFeedback,
|
|
reduceLoadingFeedback,
|
|
reduceTrafficSyncFeedback,
|
|
TRAFFIC_SYNC_CONFIRM_MS,
|
|
} from './loadingFeedback.js';
|
|
|
|
test('universal status notices reuse the standard failure dwell', () => {
|
|
const notice = createGlobalStatusNotice(
|
|
'Shared satellite is unavailable',
|
|
1000,
|
|
);
|
|
assert.equal(
|
|
notice.hideAt,
|
|
null,
|
|
'finite dwell waits until first presentation',
|
|
);
|
|
assert.equal(
|
|
presentGlobalStatusNotice(notice, 1001).label,
|
|
'Shared satellite is unavailable',
|
|
);
|
|
assert.equal(notice.hideAt, 1001 + LOADING_FAILURE_DWELL_MS);
|
|
assert.deepEqual(presentGlobalStatusNotice(notice, notice.hideAt - 1), {
|
|
state: 'error',
|
|
label: 'Shared satellite is unavailable',
|
|
detail: '',
|
|
});
|
|
assert.equal(presentGlobalStatusNotice(notice, notice.hideAt), null);
|
|
});
|
|
|
|
test('acquiring notices persist without a dwell until explicitly cleared', () => {
|
|
const notice = createGlobalStatusNotice('ACQUIRING', 1000, {
|
|
state: 'acquiring',
|
|
detail: 'SHARED FLIGHT',
|
|
persistent: true,
|
|
});
|
|
assert.equal(notice.hideAt, null);
|
|
assert.deepEqual(presentGlobalStatusNotice(notice, 1_000_000), {
|
|
state: 'acquiring',
|
|
label: 'ACQUIRING',
|
|
detail: 'SHARED FLIGHT',
|
|
});
|
|
});
|
|
|
|
test('deferred terminal notices lose ownership to newer acquisition epochs and disposal', () => {
|
|
assert.equal(canPresentDeferredStatusNotice(4, 4, false), true);
|
|
assert.equal(
|
|
canPresentDeferredStatusNotice(4, 5, false),
|
|
false,
|
|
'a newer ACQUIRING epoch blocks the older deferred failure',
|
|
);
|
|
assert.equal(
|
|
canPresentDeferredStatusNotice(5, 5, true),
|
|
false,
|
|
'disposal blocks even the current deferred notice',
|
|
);
|
|
});
|
|
|
|
test('share-follow failures use the universal top-center status instead of the bottom toast', () => {
|
|
const handler = shellMethod('_handleShareTrackingRestoreStatus').toString();
|
|
const present = shellMethod('_presentAfterStartupCover').toString();
|
|
assert.match(
|
|
handler,
|
|
/this\.initialRestorePromise\.then\(\(\) =>\s*this\._presentAfterStartupCover\(notice, noticeGeneration\),?\s*\)/,
|
|
);
|
|
assert.match(present, /this\.showStatus\(notice\.message\)/);
|
|
assert.match(present, /state: 'last-known'/);
|
|
assert.match(present, /this\._lifetime\.frame\(\(\) => \{/);
|
|
assert.match(
|
|
present,
|
|
/this\._lifetime\.listen\(\s*startupCover,\s*'transitionend',\s*showOnce,\s*\{ once: true \},?\s*\)/,
|
|
);
|
|
assert.match(
|
|
present,
|
|
/fallbackTimer = this\._lifetime\.timeout\(showOnce, 1000\)/,
|
|
);
|
|
assert.match(present, /canPresentDeferredStatusNotice\(/);
|
|
for (const source of [handler, present]) {
|
|
assert.doesNotMatch(source, /this\._showToast\(/);
|
|
assert.doesNotMatch(source, /pushCockpitSignal/);
|
|
}
|
|
assert.match(handler, /result\.classification === 'pending'/);
|
|
assert.match(handler, /state: 'acquiring'/);
|
|
assert.match(handler, /persistent: true/);
|
|
assert.match(handler, /this\._shareTrackingNoticeGeneration \+= 1/);
|
|
assert.match(handler, /if \(this\._shareTrackingAcquiringKey\) return/);
|
|
assert.match(handler, /result\.classification === 'followed'/);
|
|
assert.match(handler, /result\.classification === 'cancelled'\) return/);
|
|
});
|
|
|
|
test('universal notice masks active loading only for its own fixed dwell', () => {
|
|
const summary = aggregateLayerLoading([
|
|
{ id: 'satellites', name: 'Satellites', lifecycleState: 'enabling' },
|
|
]);
|
|
let loading = reduceLoadingFeedback(createLoadingFeedbackState(), summary, 0);
|
|
loading = reduceLoadingFeedback(loading, summary, 200);
|
|
const notice = createGlobalStatusNotice(
|
|
'Shared satellite is unavailable',
|
|
300,
|
|
);
|
|
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(notice, loading, summary, 301).label,
|
|
'Shared satellite is unavailable',
|
|
);
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(notice, loading, summary, notice.hideAt).label,
|
|
'LOADING LIVE DATA',
|
|
);
|
|
});
|
|
|
|
test('terminal failure preempts a finite notice, whose full dwell starts afterward', () => {
|
|
const active = aggregateLayerLoading([
|
|
{ id: 'satellites', name: 'Satellites', lifecycleState: 'enabling' },
|
|
]);
|
|
let loading = reduceLoadingFeedback(createLoadingFeedbackState(), active, 0);
|
|
loading = reduceLoadingFeedback(loading, active, 200);
|
|
loading = reduceLoadingFeedback(loading, aggregateLayerLoading([]), 300, {
|
|
type: 'visibility-failed',
|
|
layerId: 'satellites',
|
|
error: new Error('offline'),
|
|
});
|
|
const notice = createGlobalStatusNotice(
|
|
'Shared satellite is unavailable',
|
|
400,
|
|
);
|
|
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(notice, loading, aggregateLayerLoading([]), 401)
|
|
.label,
|
|
'LOAD FAILED',
|
|
);
|
|
assert.equal(
|
|
notice.hideAt,
|
|
null,
|
|
'masked finite notice has not started its dwell',
|
|
);
|
|
loading = reduceLoadingFeedback(loading, aggregateLayerLoading([]), 5300);
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(notice, loading, aggregateLayerLoading([]), 5300)
|
|
.label,
|
|
'Shared satellite is unavailable',
|
|
);
|
|
assert.equal(notice.hideAt, 5300 + LOADING_FAILURE_DWELL_MS);
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(
|
|
notice,
|
|
loading,
|
|
aggregateLayerLoading([]),
|
|
notice.hideAt - 1,
|
|
).label,
|
|
'Shared satellite is unavailable',
|
|
);
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(
|
|
notice,
|
|
loading,
|
|
aggregateLayerLoading([]),
|
|
notice.hideAt,
|
|
),
|
|
null,
|
|
);
|
|
});
|
|
|
|
test('persistent acquisition never hides an unrelated manager failure', () => {
|
|
const active = aggregateLayerLoading([
|
|
{
|
|
id: 'traffic',
|
|
name: 'Street Traffic',
|
|
lifecycleState: 'enabling',
|
|
},
|
|
]);
|
|
const idle = aggregateLayerLoading([]);
|
|
let loading = reduceLoadingFeedback(createLoadingFeedbackState(), active, 0);
|
|
loading = reduceLoadingFeedback(loading, active, 200);
|
|
loading = reduceLoadingFeedback(loading, idle, 300, {
|
|
type: 'visibility-failed',
|
|
layerId: 'traffic',
|
|
error: new Error('offline'),
|
|
});
|
|
const acquiring = createGlobalStatusNotice('ACQUIRING', 100, {
|
|
state: 'acquiring',
|
|
detail: 'SHARED FLIGHT',
|
|
persistent: true,
|
|
});
|
|
|
|
assert.deepEqual(presentGlobalLoadingStatus(acquiring, loading, idle, 301), {
|
|
state: 'error',
|
|
label: 'LOAD FAILED',
|
|
detail: '',
|
|
});
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(
|
|
acquiring,
|
|
loading,
|
|
idle,
|
|
300 + LOADING_FAILURE_DWELL_MS - 1,
|
|
).label,
|
|
'LOAD FAILED',
|
|
);
|
|
loading = reduceLoadingFeedback(
|
|
loading,
|
|
idle,
|
|
300 + LOADING_FAILURE_DWELL_MS,
|
|
);
|
|
assert.equal(
|
|
presentGlobalLoadingStatus(
|
|
acquiring,
|
|
loading,
|
|
idle,
|
|
300 + LOADING_FAILURE_DWELL_MS,
|
|
).label,
|
|
'ACQUIRING',
|
|
'the still-owned acquisition resumes only after the full failure dwell is visible',
|
|
);
|
|
});
|
|
|
|
test('replacement, repetition, and hidden-tab elapsed time use the newest fixed deadline', () => {
|
|
const first = createGlobalStatusNotice(
|
|
'Shared satellite is unavailable',
|
|
100,
|
|
);
|
|
const repeated = createGlobalStatusNotice(
|
|
'Shared satellite is unavailable',
|
|
200,
|
|
);
|
|
const replacement = createGlobalStatusNotice(
|
|
'Shared satellite follow expired',
|
|
300,
|
|
);
|
|
|
|
presentGlobalStatusNotice(first, 100);
|
|
presentGlobalStatusNotice(repeated, 200);
|
|
presentGlobalStatusNotice(replacement, 300);
|
|
|
|
assert.ok(
|
|
repeated.hideAt > first.hideAt,
|
|
'a repeated event is a new accessible notice epoch',
|
|
);
|
|
assert.equal(
|
|
presentGlobalStatusNotice(replacement, replacement.hideAt - 1).label,
|
|
'Shared satellite follow expired',
|
|
);
|
|
assert.equal(
|
|
presentGlobalStatusNotice(replacement, replacement.hideAt),
|
|
null,
|
|
'elapsed wall time while hidden expires the notice instead of replaying it',
|
|
);
|
|
});
|
|
|
|
test('universal notice lifecycle clears on dispose and uses the one top-center live region', async () => {
|
|
const ui = readShellSource();
|
|
const html = await renderApplicationHtml(
|
|
readFileSync(new URL('../index.html', import.meta.url), 'utf8'),
|
|
);
|
|
const disposeStart = ui.indexOf(' async dispose() {');
|
|
const disposeEnd = ui.indexOf('\n }\n', disposeStart);
|
|
const dispose = ui.slice(disposeStart, disposeEnd);
|
|
|
|
assert.match(dispose, /this\._feedback\.clearLoadingStatus\(\);/);
|
|
assert.match(dispose, /this\._shareRestoration\.destroy\(\)/);
|
|
assert.match(
|
|
ShareRestoration.prototype.destroy.toString(),
|
|
/this\._shareTrackingNoticeGeneration \+= 1;/,
|
|
);
|
|
assert.match(
|
|
html,
|
|
/<div id="global-loading-status" role="status" aria-live="polite" aria-atomic="true" hidden>/,
|
|
);
|
|
});
|
|
|
|
test('normalizes lifecycle and refresh loading without owning manager state', () => {
|
|
assert.equal(
|
|
normalizeLayerLoading({ lifecycleState: 'enabling' }).loading,
|
|
true,
|
|
);
|
|
assert.equal(
|
|
normalizeLayerLoading({ lifecycleState: 'disabling' }).disabling,
|
|
true,
|
|
);
|
|
assert.equal(
|
|
normalizeLayerLoading({ enabled: true, stats: { loading: true, count: 8 } })
|
|
.refresh,
|
|
true,
|
|
);
|
|
assert.equal(
|
|
normalizeLayerLoading({ enabled: true, stats: { refreshing: true } })
|
|
.refresh,
|
|
true,
|
|
);
|
|
assert.match(
|
|
normalizeLayerLoading({ stats: { managerRefreshError: 'refresh failed' } })
|
|
.error,
|
|
/refresh failed/,
|
|
);
|
|
});
|
|
|
|
test('delays initial loading so instant operations never flash', () => {
|
|
const summary = aggregateLayerLoading([
|
|
{ id: 'a', name: 'A', lifecycleState: 'enabling' },
|
|
]);
|
|
const pending = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
summary,
|
|
100,
|
|
);
|
|
assert.equal(pending.visible, false);
|
|
const finished = reduceLoadingFeedback(
|
|
pending,
|
|
aggregateLayerLoading([]),
|
|
150,
|
|
);
|
|
assert.equal(
|
|
presentLoadingFeedback(finished, aggregateLayerLoading([]), 150),
|
|
null,
|
|
);
|
|
});
|
|
|
|
test('reveals sustained loading and then a bounded completion state', () => {
|
|
const summary = aggregateLayerLoading([
|
|
{ id: 'a', name: 'A', lifecycleState: 'enabling' },
|
|
]);
|
|
const pending = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
summary,
|
|
100,
|
|
);
|
|
const visible = reduceLoadingFeedback(pending, summary, 300);
|
|
assert.equal(
|
|
presentLoadingFeedback(visible, summary, 300).label,
|
|
'LOADING LIVE DATA',
|
|
);
|
|
const complete = reduceLoadingFeedback(
|
|
visible,
|
|
aggregateLayerLoading([]),
|
|
350,
|
|
);
|
|
assert.equal(
|
|
presentLoadingFeedback(complete, aggregateLayerLoading([]), 350).label,
|
|
'LOAD COMPLETE',
|
|
);
|
|
});
|
|
|
|
test('terminal loading feedback centers its label without an empty detail slot', () => {
|
|
const css = readStylesheet(new URL('../style.css', import.meta.url));
|
|
assert.match(
|
|
css,
|
|
/#global-loading-status:is\(\s*\[data-state='complete'\],\s*\[data-state='cancelled'\],\s*\[data-state='error'\]\s*\)\s*\{[\s\S]*?justify-content:\s*center;[\s\S]*?text-align:\s*center;/,
|
|
);
|
|
assert.match(
|
|
css,
|
|
/#global-loading-status:is\(\s*\[data-state='complete'\],\s*\[data-state='cancelled'\],\s*\[data-state='error'\]\s*\)\s*#global-loading-detail\s*\{\s*display:\s*none;/,
|
|
);
|
|
});
|
|
|
|
test('distinguishes accepted-data refresh from initial loading', () => {
|
|
const summary = aggregateLayerLoading([
|
|
{
|
|
id: 'a',
|
|
name: 'A',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats: { loading: true, count: 4 },
|
|
},
|
|
]);
|
|
assert.equal(summary.refresh, true);
|
|
});
|
|
|
|
test('surfaces cancellation and failure terminal states', () => {
|
|
const summary = aggregateLayerLoading([
|
|
{ id: 'a', lifecycleState: 'enabling' },
|
|
]);
|
|
const pending = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
summary,
|
|
0,
|
|
);
|
|
const visible = reduceLoadingFeedback(pending, summary, 200);
|
|
assert.equal(
|
|
reduceLoadingFeedback(visible, aggregateLayerLoading([]), 250, {
|
|
type: 'visibility-cancelled',
|
|
layerId: 'a',
|
|
cancelled: true,
|
|
}).terminal,
|
|
'cancelled',
|
|
);
|
|
assert.equal(
|
|
reduceLoadingFeedback(visible, aggregateLayerLoading([]), 250, {
|
|
type: 'visibility-failed',
|
|
layerId: 'a',
|
|
error: new Error('no'),
|
|
}).terminal,
|
|
'error',
|
|
);
|
|
});
|
|
|
|
test('surfaces manager-owned refresh failure and recovery through the shared banner', () => {
|
|
const refreshing = aggregateLayerLoading([
|
|
{
|
|
id: 'satellites',
|
|
name: 'Satellites',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats: { refreshing: true, count: 0, lastUpdate: null },
|
|
},
|
|
]);
|
|
let state = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
refreshing,
|
|
0,
|
|
{
|
|
type: 'refresh-transition',
|
|
layerId: 'satellites',
|
|
refreshEpoch: 1,
|
|
},
|
|
);
|
|
state = reduceLoadingFeedback(state, refreshing, 200);
|
|
assert.equal(
|
|
presentLoadingFeedback(state, refreshing, 200).label,
|
|
'REFRESHING LIVE DATA',
|
|
);
|
|
state = reduceLoadingFeedback(state, aggregateLayerLoading([]), 250, {
|
|
type: 'refresh-failed',
|
|
layerId: 'satellites',
|
|
error: new Error('offline'),
|
|
refreshEpoch: 1,
|
|
});
|
|
assert.equal(
|
|
presentLoadingFeedback(state, aggregateLayerLoading([]), 250).label,
|
|
'LOAD FAILED',
|
|
);
|
|
|
|
const recovered = reduceLoadingFeedback(state, refreshing, 6000, {
|
|
type: 'refresh-transition',
|
|
layerId: 'satellites',
|
|
refreshEpoch: 2,
|
|
});
|
|
const complete = reduceLoadingFeedback(
|
|
recovered,
|
|
aggregateLayerLoading([]),
|
|
6200,
|
|
{
|
|
type: 'refresh',
|
|
layerId: 'satellites',
|
|
refreshEpoch: 2,
|
|
},
|
|
);
|
|
assert.equal(complete.terminal, 'complete');
|
|
});
|
|
|
|
test('AIS first-connect grace expiry reports failure even without a terminal manager event', () => {
|
|
const waiting = aggregateLayerLoading([
|
|
{
|
|
id: 'ais-live-vessels',
|
|
name: 'AIS Vessels',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats: { loading: true, count: 0, lastUpdate: null },
|
|
},
|
|
]);
|
|
let state = reduceLoadingFeedback(createLoadingFeedbackState(), waiting, 0);
|
|
state = reduceLoadingFeedback(state, waiting, 200);
|
|
|
|
const unavailable = aggregateLayerLoading([
|
|
{
|
|
id: 'ais-live-vessels',
|
|
name: 'AIS Vessels',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats: {
|
|
loading: false,
|
|
count: 0,
|
|
lastUpdate: null,
|
|
status: 'unavailable',
|
|
error: 'awaiting first AIS message…',
|
|
},
|
|
},
|
|
]);
|
|
state = reduceLoadingFeedback(state, unavailable, 300);
|
|
|
|
assert.equal(state.terminal, 'error');
|
|
assert.equal(
|
|
presentLoadingFeedback(state, unavailable, 300).label,
|
|
'LOAD FAILED',
|
|
);
|
|
});
|
|
|
|
test('participant stats failure outranks a simultaneous visibility completion', () => {
|
|
const enabling = aggregateLayerLoading([
|
|
{
|
|
id: 'ais-live-vessels',
|
|
name: 'AIS Vessels',
|
|
lifecycleState: 'enabling',
|
|
stats: { loading: true },
|
|
},
|
|
]);
|
|
let state = reduceLoadingFeedback(createLoadingFeedbackState(), enabling, 0);
|
|
state = reduceLoadingFeedback(state, enabling, 200);
|
|
|
|
const missingKey = aggregateLayerLoading([
|
|
{
|
|
id: 'ais-live-vessels',
|
|
name: 'AIS Vessels',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats: { loading: false, keyRequired: true },
|
|
},
|
|
]);
|
|
state = reduceLoadingFeedback(state, missingKey, 250, {
|
|
type: 'visibility',
|
|
layerId: 'ais-live-vessels',
|
|
enabled: true,
|
|
});
|
|
|
|
assert.equal(state.terminal, 'error');
|
|
});
|
|
|
|
test('retains the worst terminal outcome until every concurrent load drains', () => {
|
|
const both = aggregateLayerLoading([
|
|
{ id: 'a', name: 'A', lifecycleState: 'enabling' },
|
|
{ id: 'b', name: 'B', lifecycleState: 'enabling' },
|
|
]);
|
|
const onlyB = aggregateLayerLoading([
|
|
{ id: 'b', name: 'B', lifecycleState: 'enabling' },
|
|
]);
|
|
let state = reduceLoadingFeedback(createLoadingFeedbackState(), both, 0, {
|
|
type: 'visibility-transition',
|
|
layerId: 'a',
|
|
});
|
|
state = reduceLoadingFeedback(state, both, 200, {
|
|
type: 'visibility-transition',
|
|
layerId: 'b',
|
|
});
|
|
state = reduceLoadingFeedback(state, onlyB, 250, {
|
|
type: 'visibility-failed',
|
|
layerId: 'a',
|
|
error: new Error('A failed'),
|
|
});
|
|
assert.deepEqual(state.activeIds, ['a', 'b']);
|
|
assert.equal(state.batchOutcome, 'error');
|
|
state = reduceLoadingFeedback(state, onlyB, 300);
|
|
state = reduceLoadingFeedback(state, aggregateLayerLoading([]), 350, {
|
|
type: 'visibility',
|
|
layerId: 'b',
|
|
enabled: true,
|
|
});
|
|
assert.equal(state.terminal, 'error');
|
|
assert.equal(
|
|
presentLoadingFeedback(state, aggregateLayerLoading([]), 350).label,
|
|
'LOAD FAILED',
|
|
);
|
|
});
|
|
|
|
test('retains cancellation across overlapping success and resets it for a later epoch', () => {
|
|
const both = aggregateLayerLoading([
|
|
{ id: 'a', name: 'A', lifecycleState: 'enabling' },
|
|
{ id: 'b', name: 'B', lifecycleState: 'enabling' },
|
|
]);
|
|
const onlyB = aggregateLayerLoading([
|
|
{ id: 'b', name: 'B', lifecycleState: 'enabling' },
|
|
]);
|
|
let state = reduceLoadingFeedback(createLoadingFeedbackState(), both, 0);
|
|
state = reduceLoadingFeedback(state, onlyB, 200, {
|
|
type: 'visibility-cancelled',
|
|
layerId: 'a',
|
|
cancelled: true,
|
|
});
|
|
state = reduceLoadingFeedback(state, aggregateLayerLoading([]), 250, {
|
|
type: 'visibility',
|
|
layerId: 'b',
|
|
enabled: true,
|
|
});
|
|
assert.equal(state.terminal, 'cancelled');
|
|
|
|
const next = aggregateLayerLoading([
|
|
{ id: 'c', name: 'C', lifecycleState: 'enabling' },
|
|
]);
|
|
state = reduceLoadingFeedback(state, next, 300, {
|
|
type: 'visibility-transition',
|
|
layerId: 'c',
|
|
});
|
|
assert.equal(state.batchOutcome, null);
|
|
assert.deepEqual(state.activeIds, ['c']);
|
|
state = reduceLoadingFeedback(state, aggregateLayerLoading([]), 500, {
|
|
type: 'visibility',
|
|
layerId: 'c',
|
|
enabled: true,
|
|
});
|
|
assert.equal(state.terminal, 'complete');
|
|
});
|
|
|
|
test('ignores terminal events from layers outside the active loading epoch', () => {
|
|
const active = aggregateLayerLoading([
|
|
{ id: 'a', name: 'A', lifecycleState: 'enabling' },
|
|
]);
|
|
let state = reduceLoadingFeedback(createLoadingFeedbackState(), active, 0);
|
|
state = reduceLoadingFeedback(state, active, 200, {
|
|
type: 'visibility-failed',
|
|
layerId: 'unrelated',
|
|
error: new Error('not this batch'),
|
|
});
|
|
assert.equal(state.batchOutcome, null);
|
|
state = reduceLoadingFeedback(state, aggregateLayerLoading([]), 250, {
|
|
type: 'visibility',
|
|
layerId: 'a',
|
|
enabled: true,
|
|
});
|
|
assert.equal(state.terminal, 'complete');
|
|
});
|
|
|
|
test('a final failure outranks an earlier success in the same loading epoch', () => {
|
|
const both = aggregateLayerLoading([
|
|
{ id: 'a', lifecycleState: 'enabling' },
|
|
{ id: 'b', lifecycleState: 'enabling' },
|
|
]);
|
|
const onlyB = aggregateLayerLoading([
|
|
{ id: 'b', lifecycleState: 'enabling' },
|
|
]);
|
|
let state = reduceLoadingFeedback(createLoadingFeedbackState(), both, 0);
|
|
state = reduceLoadingFeedback(state, onlyB, 200, {
|
|
type: 'visibility',
|
|
layerId: 'a',
|
|
enabled: true,
|
|
});
|
|
state = reduceLoadingFeedback(state, aggregateLayerLoading([]), 250, {
|
|
type: 'visibility-failed',
|
|
layerId: 'b',
|
|
error: new Error('B failed'),
|
|
});
|
|
assert.equal(state.terminal, 'error');
|
|
});
|
|
|
|
test('describes disable work without reporting it as a completed load', () => {
|
|
const summary = aggregateLayerLoading([
|
|
{
|
|
id: 'a',
|
|
name: 'A',
|
|
enabled: true,
|
|
lifecycleState: 'disabling',
|
|
},
|
|
]);
|
|
const pending = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
summary,
|
|
0,
|
|
);
|
|
const visible = reduceLoadingFeedback(pending, summary, 200);
|
|
assert.equal(
|
|
presentLoadingFeedback(visible, summary, 200).label,
|
|
'TURNING OFF LIVE DATA',
|
|
);
|
|
const complete = reduceLoadingFeedback(
|
|
visible,
|
|
aggregateLayerLoading([]),
|
|
250,
|
|
);
|
|
assert.equal(
|
|
presentLoadingFeedback(complete, aggregateLayerLoading([]), 250).label,
|
|
'LIVE DATA OFF',
|
|
);
|
|
});
|
|
|
|
test('a flow failure landing after the roads settle still ends the batch as LOAD FAILED', () => {
|
|
// Traffic's 250 ms paint race lets a TomTom request outlive the road load
|
|
// that started it. The layer keeps stats.loading true while it still owns
|
|
// that request, so the batch cannot close early and report LOAD COMPLETE
|
|
// over a failure that has not landed yet.
|
|
const sample = (stats) =>
|
|
aggregateLayerLoading([
|
|
{
|
|
id: 'traffic',
|
|
name: 'Street Traffic',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats,
|
|
},
|
|
]);
|
|
// Roads loading; flow request outstanding.
|
|
const roadsLoading = sample({
|
|
loading: true,
|
|
count: 0,
|
|
mode: 'live',
|
|
error: null,
|
|
});
|
|
let state = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
roadsLoading,
|
|
0,
|
|
);
|
|
state = reduceLoadingFeedback(state, roadsLoading, 200);
|
|
assert.equal(state.visible, true);
|
|
// Cached roads have painted, but the flow fetch has NOT settled: the layer
|
|
// still reports loading, so the batch stays open.
|
|
const flowStillPending = sample({
|
|
loading: true,
|
|
count: 544,
|
|
mode: 'live',
|
|
error: null,
|
|
});
|
|
state = reduceLoadingFeedback(state, flowStillPending, 400);
|
|
assert.equal(state.phase, 'loading');
|
|
// Flow fails late.
|
|
const flowFailed = sample({
|
|
loading: false,
|
|
count: 544,
|
|
mode: 'live',
|
|
error: 'SIMULATED — TomTom daily budget reached',
|
|
});
|
|
state = reduceLoadingFeedback(state, flowFailed, 900);
|
|
assert.equal(state.terminal, 'error');
|
|
assert.equal(
|
|
presentLoadingFeedback(state, flowFailed, 900).label,
|
|
'LOAD FAILED',
|
|
'a late flow failure must not be announced as LOAD COMPLETE',
|
|
);
|
|
});
|
|
|
|
test('keeps cold idle traffic hidden even with a truthful zero-coverage label', () => {
|
|
let state = createTrafficSyncFeedbackState();
|
|
const sample = {
|
|
enabled: true,
|
|
stats: {
|
|
loading: false,
|
|
loadingLabel: 'LIVE · TomTom flow · 0% cov',
|
|
flowCoveragePct: 0,
|
|
},
|
|
};
|
|
for (const now of [0, 220, 440, 2200])
|
|
state = reduceTrafficSyncFeedback(state, sample, now);
|
|
assert.equal(state.visible, false);
|
|
assert.equal(state.busy, false);
|
|
});
|
|
|
|
test('shows traffic busy work and one fixed busy-to-idle confirmation', () => {
|
|
const busySample = {
|
|
enabled: true,
|
|
stats: { loading: true, loadingLabel: 'syncing LIVE traffic flow' },
|
|
};
|
|
const idleSample = {
|
|
enabled: true,
|
|
stats: { loading: false, loadingLabel: 'LIVE · TomTom flow · 0% cov' },
|
|
};
|
|
let state = reduceTrafficSyncFeedback(
|
|
createTrafficSyncFeedbackState(),
|
|
busySample,
|
|
100,
|
|
);
|
|
assert.deepEqual(
|
|
{ visible: state.visible, progress: state.progressText },
|
|
{ visible: true, progress: '...' },
|
|
);
|
|
state = reduceTrafficSyncFeedback(state, busySample, 320);
|
|
state = reduceTrafficSyncFeedback(state, idleSample, 500);
|
|
const fixedDeadline = state.confirmationUntil;
|
|
assert.equal(fixedDeadline, 500 + TRAFFIC_SYNC_CONFIRM_MS);
|
|
assert.equal(state.progressText, '');
|
|
state = reduceTrafficSyncFeedback(state, idleSample, 900);
|
|
assert.equal(state.confirmationUntil, fixedDeadline);
|
|
state = reduceTrafficSyncFeedback(state, idleSample, fixedDeadline + 1);
|
|
assert.equal(state.visible, false);
|
|
});
|
|
|
|
test('the settled traffic chip shows exactly one percentage — the coverage it measured', () => {
|
|
// "LIVE · TomTom flow · 0% cov" beside a hard-coded "100%" read as a chip
|
|
// arguing with itself. The 100% was never a measurement: a settled chip is
|
|
// complete by definition, so the progress slot goes quiet and the label's
|
|
// coverage figure is the only number left.
|
|
const idleSample = {
|
|
enabled: true,
|
|
stats: { loading: false, loadingLabel: 'LIVE · TomTom flow · 0% cov' },
|
|
};
|
|
let state = reduceTrafficSyncFeedback(
|
|
createTrafficSyncFeedbackState(),
|
|
{
|
|
enabled: true,
|
|
stats: { loading: true, loadingLabel: 'syncing LIVE traffic flow' },
|
|
},
|
|
0,
|
|
);
|
|
state = reduceTrafficSyncFeedback(state, idleSample, 100);
|
|
assert.equal(state.visible, true);
|
|
assert.equal(state.label, 'LIVE · TomTom flow · 0% cov');
|
|
assert.equal(state.progressText, '');
|
|
const rendered = `${state.label} ${state.progressText}`.trim();
|
|
assert.equal(
|
|
rendered.match(/\d+%/g).length,
|
|
1,
|
|
'the settled chip must carry one percentage',
|
|
);
|
|
assert.doesNotMatch(rendered, /100%/);
|
|
});
|
|
|
|
test('an emptied progress slot collapses rather than leaving a min-width stub', () => {
|
|
// ShellFeedback publishes the empty settled progress
|
|
// (src/ui/statusChipOwners.test.mjs); the slot must then take no room.
|
|
const css = readStylesheet(new URL('../style.css', import.meta.url));
|
|
assert.match(css, /#traffic-sync-progress:empty \{\s*display: none;\s*\}/);
|
|
});
|
|
|
|
test('work still in flight keeps its progress number beside a label that has none', () => {
|
|
const state = reduceTrafficSyncFeedback(
|
|
createTrafficSyncFeedbackState(),
|
|
{
|
|
enabled: true,
|
|
stats: { phaseLabel: 'warming roads', phaseProgressPct: 42 },
|
|
},
|
|
0,
|
|
);
|
|
assert.deepEqual(
|
|
{ busy: state.busy, label: state.label, progress: state.progressText },
|
|
{ busy: true, label: 'warming roads', progress: '42%' },
|
|
);
|
|
assert.doesNotMatch(
|
|
state.label,
|
|
/%/,
|
|
'a busy label must not carry its own percentage',
|
|
);
|
|
});
|
|
|
|
test('resets traffic feedback on disable and permits a later fresh cycle', () => {
|
|
const busy = { enabled: true, stats: { loading: true } };
|
|
const idle = {
|
|
enabled: true,
|
|
stats: { loading: false, loadingLabel: 'simulated traffic' },
|
|
};
|
|
let state = reduceTrafficSyncFeedback(
|
|
createTrafficSyncFeedbackState(),
|
|
busy,
|
|
0,
|
|
);
|
|
state = reduceTrafficSyncFeedback(state, idle, 100);
|
|
state = reduceTrafficSyncFeedback(
|
|
state,
|
|
{ enabled: false, stats: {}, forceShow: true },
|
|
200,
|
|
);
|
|
assert.deepEqual(state, createTrafficSyncFeedbackState());
|
|
state = reduceTrafficSyncFeedback(state, idle, 300);
|
|
assert.equal(state.visible, false);
|
|
state = reduceTrafficSyncFeedback(state, busy, 400);
|
|
state = reduceTrafficSyncFeedback(state, idle, 500);
|
|
assert.equal(state.visible, true);
|
|
});
|
|
|
|
test('new busy work replaces confirmation and force-show remains bounded', () => {
|
|
const idle = { enabled: true, stats: { loadingLabel: 'simulated traffic' } };
|
|
const busy = {
|
|
enabled: true,
|
|
stats: {
|
|
phaseProgressPct: -20,
|
|
prewarmQueueDepth: 1,
|
|
phaseLabel: 'warming roads',
|
|
},
|
|
};
|
|
let state = reduceTrafficSyncFeedback(
|
|
createTrafficSyncFeedbackState(),
|
|
idle,
|
|
0,
|
|
);
|
|
state = reduceTrafficSyncFeedback(state, { ...idle, forceShow: true }, 100);
|
|
const forcedDeadline = state.confirmationUntil;
|
|
state = reduceTrafficSyncFeedback(state, { ...idle, forceShow: true }, 300);
|
|
assert.equal(state.confirmationUntil, forcedDeadline);
|
|
state = reduceTrafficSyncFeedback(state, busy, 400);
|
|
assert.deepEqual(
|
|
{ busy: state.busy, progress: state.progressText },
|
|
{ busy: true, progress: '0%' },
|
|
);
|
|
state = reduceTrafficSyncFeedback(state, idle, 500);
|
|
assert.equal(state.confirmationUntil, 500 + TRAFFIC_SYNC_CONFIRM_MS);
|
|
state = reduceTrafficSyncFeedback(
|
|
state,
|
|
idle,
|
|
500 + TRAFFIC_SYNC_CONFIRM_MS + 1,
|
|
);
|
|
assert.equal(state.visible, false);
|
|
});
|
|
|
|
test('aggregates Mapped Installations refresh beside CCTV without changing either owner', () => {
|
|
const summary = aggregateLayerLoading([
|
|
{
|
|
id: 'cctv',
|
|
name: 'CCTV',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats: { count: 500, lastUpdate: 10, loading: true },
|
|
},
|
|
{
|
|
id: 'military-installations',
|
|
name: 'Mapped Installations',
|
|
enabled: true,
|
|
lifecycleState: 'enabled',
|
|
stats: { count: 4, lastUpdate: 20, loading: true },
|
|
},
|
|
]);
|
|
assert.deepEqual(summary.activeIds, ['cctv', 'military-installations']);
|
|
assert.equal(summary.refresh, true);
|
|
const pending = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
summary,
|
|
0,
|
|
);
|
|
const visible = reduceLoadingFeedback(pending, summary, 200);
|
|
assert.deepEqual(presentLoadingFeedback(visible, summary, 200), {
|
|
state: 'refresh',
|
|
label: 'REFRESHING LIVE DATA',
|
|
detail: 'CCTV · Mapped Installations',
|
|
});
|
|
});
|
|
|
|
// The reducer above is pure and fully covered; its DRIVER lives inside the
|
|
// StyleManager class (a full viewer to instantiate), so — as with the panel
|
|
// stack layout contract — the ticker's lifecycle is pinned against ui.js
|
|
// source. (perf rebase 2026-08-17)
|
|
test('the loading ticker never runs hidden and stops after loading and notices settle', () => {
|
|
const ui = readFileSync(
|
|
new URL('./ui/shellFeedback.js', import.meta.url),
|
|
'utf8',
|
|
);
|
|
// Scope every assertion to _armLoadingFeedbackTicker's own body. The
|
|
// neighbouring _startTrafficChipTicker is a deliberately PERMANENT 500ms
|
|
// safety-net poll, so its `if (document.hidden) return;` is correct there
|
|
// and must not be confused with this self-stopping ticker's leak.
|
|
const armBody = ui.slice(ui.indexOf('_armLoadingFeedbackTicker() {'));
|
|
assert.ok(
|
|
armBody.startsWith('_armLoadingFeedbackTicker() {'),
|
|
'ticker function not found in the UI shell source',
|
|
);
|
|
const arm = armBody.slice(0, armBody.indexOf('\n }\n') + 5);
|
|
|
|
// 1. The ARM guard itself refuses while hidden. Previously the only hidden
|
|
// check sat INSIDE the interval body, so a batch that completed while
|
|
// hidden left the 60ms timer scheduled for the whole hidden period: the
|
|
// idle check that clears it was unreachable behind the hidden `return`.
|
|
assert.match(
|
|
arm,
|
|
/if \(this\._loadingFeedbackTicker \|\| document\.hidden\) return;/,
|
|
'the ticker must not arm while the document is hidden',
|
|
);
|
|
|
|
// 2. Going hidden STOPS the interval rather than idling inside it.
|
|
assert.match(
|
|
arm,
|
|
/if \(document\.hidden\) \{\s*this\._stopLoadingFeedbackTicker\(\);\s*return;\s*\}/,
|
|
'a hidden tick must clear the interval, not just skip the work',
|
|
);
|
|
assert.doesNotMatch(
|
|
arm,
|
|
/setInterval\(\(\) => \{\s*if \(document\.hidden\) return;/,
|
|
'the bare hidden `return` inside this interval is the leak — it must be gone',
|
|
);
|
|
|
|
// 3. Reaching idle stops it after any time-driven notice has completed.
|
|
// Persistent ACQUIRING notices remain visible without a 60ms timer.
|
|
assert.match(
|
|
arm,
|
|
/const noticeNeedsTicker = Number\.isFinite\(\s*this\._globalStatusNotice\?\.hideAt,?\s*\);[\s\S]*?if \(\s*this\._loadingFeedbackState\?\.phase === 'idle'\s*&&\s*!noticeNeedsTicker\s*\) \{\s*this\._stopLoadingFeedbackTicker\(\);\s*\}/,
|
|
'an idle phase with no expiring notice must stop the ticker',
|
|
);
|
|
assert.match(
|
|
ui,
|
|
/_stopLoadingFeedbackTicker\(\)\s*\{[\s\S]*?clearInterval\(this\._loadingFeedbackTicker\);[\s\S]*?this\._loadingFeedbackTicker = null;/,
|
|
'the shared stopper must actually clear and null the handle',
|
|
);
|
|
|
|
// 4. Returning to visible resamples, so a batch that finished while hidden
|
|
// is reconciled and a still-running one re-arms its ticker. The handler
|
|
// must live on the class that OWNS _updateGlobalLoadingFeedback
|
|
// (ShellFeedback) — wiring it into a neighbouring controller instead
|
|
// throws on every visibilitychange — and must be torn down with the rest.
|
|
assert.match(
|
|
ui,
|
|
/this\._loadingVisibilityHandler = \(\) => \{\s*if \(!document\.hidden\) this\._updateGlobalLoadingFeedback\(\);\s*else this\._stopLoadingFeedbackTicker\(\);\s*\};\s*document\.addEventListener\(\s*'visibilitychange',\s*this\._loadingVisibilityHandler,?\s*\);/,
|
|
'visibilitychange must resample the chip on return',
|
|
);
|
|
const styleManager = ui.slice(ui.indexOf('export class ShellFeedback'));
|
|
assert.ok(
|
|
styleManager.includes('this._loadingVisibilityHandler'),
|
|
'the resample handler must be owned by ShellFeedback, which defines _updateGlobalLoadingFeedback',
|
|
);
|
|
assert.match(
|
|
ui,
|
|
/document\.removeEventListener\(\s*'visibilitychange',\s*this\._loadingVisibilityHandler,?\s*\);/,
|
|
'the resample handler must be removed on teardown',
|
|
);
|
|
});
|
|
|
|
test('a guidance status such as zoom-in never counts as a participant failure', () => {
|
|
const zoomIn = {
|
|
id: 'military-installations',
|
|
name: 'Mapped Installations',
|
|
enabled: true,
|
|
stats: {
|
|
status: 'zoom-in',
|
|
error: 'Zoom in to load mapped installation context',
|
|
loading: true,
|
|
count: 0,
|
|
},
|
|
};
|
|
const loading = aggregateLayerLoading([zoomIn]);
|
|
assert.equal(loading.records[0].error, null);
|
|
assert.equal(loading.records[0].degraded, false);
|
|
let state = reduceLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
loading,
|
|
1000,
|
|
);
|
|
state = reduceLoadingFeedback(state, loading, 1200);
|
|
const settled = aggregateLayerLoading([
|
|
{ ...zoomIn, stats: { ...zoomIn.stats, loading: false } },
|
|
]);
|
|
state = reduceLoadingFeedback(state, settled, 1500);
|
|
assert.equal(state.terminal, 'complete');
|
|
assert.equal(
|
|
presentLoadingFeedback(state, settled, 1500).label,
|
|
'MAPPED SITES LOADED',
|
|
);
|
|
});
|
|
|
|
test('guidance does not suppress independent manager and feed failures', () => {
|
|
for (const field of ['lastError', 'managerRefreshError']) {
|
|
const record = normalizeLayerLoading({
|
|
id: 'militaryInstallations',
|
|
enabled: true,
|
|
stats: {
|
|
status: 'zoom-in',
|
|
error: 'Zoom in to load mapped sites.',
|
|
[field]: 'Network unavailable',
|
|
},
|
|
});
|
|
assert.equal(record.error, 'Network unavailable');
|
|
}
|
|
});
|
|
|
|
test('ALPR retries show a countdown, preserve other failures, and clear when disabled', () => {
|
|
const camera = {
|
|
...retrySite({ error: 'Overpass rate-limited' }),
|
|
id: 'alpr-cameras',
|
|
name: 'ALPR cameras',
|
|
};
|
|
const summary = aggregateLayerLoading([camera]);
|
|
const view = presentLoadingFeedback(createLoadingFeedbackState(), summary, 0);
|
|
assert.equal(view.state, 'retry');
|
|
assert.equal(view.label, 'OVERPASS RATE-LIMITED');
|
|
assert.match(view.detail, /ALPR cameras · retrying in 30s/);
|
|
const failed = {
|
|
visible: true,
|
|
phase: 'terminal',
|
|
terminal: 'error',
|
|
activeIds: ['alpr-cameras', 'flights'],
|
|
};
|
|
const otherFailure = aggregateLayerLoading([
|
|
camera,
|
|
{ id: 'flights', enabled: true, stats: { error: 'Failed' } },
|
|
]);
|
|
assert.equal(
|
|
presentLoadingFeedback(failed, otherFailure, 0).label,
|
|
'LOAD FAILED',
|
|
);
|
|
assert.equal(
|
|
presentLoadingFeedback(
|
|
{ ...failed, failedEventIds: ['flights'] },
|
|
summary,
|
|
0,
|
|
).label,
|
|
'LOAD FAILED',
|
|
);
|
|
assert.equal(
|
|
presentLoadingFeedback(
|
|
createLoadingFeedbackState(),
|
|
aggregateLayerLoading([{ ...camera, enabled: false }]),
|
|
0,
|
|
),
|
|
null,
|
|
);
|
|
});
|
|
|
|
test('ALPR retry success does not inherit its prior error, including turning the layer off', () => {
|
|
const camera = (stats) => ({ id: 'alpr-cameras', enabled: true, stats });
|
|
const loading = aggregateLayerLoading([
|
|
camera({ status: 'loading', loading: true, retrying: true }),
|
|
]);
|
|
let state = reduceLoadingFeedback(createLoadingFeedbackState(), loading, 0);
|
|
state = reduceLoadingFeedback(state, loading, 200);
|
|
assert.equal(
|
|
presentLoadingFeedback(state, loading, 200).label,
|
|
'RETRYING ALPR CAMERAS',
|
|
);
|
|
const done = aggregateLayerLoading([camera({ status: 'ready', count: 3 })]);
|
|
state = reduceLoadingFeedback(state, done, 300);
|
|
assert.equal(presentLoadingFeedback(state, done, 300).label, 'LOAD COMPLETE');
|
|
const stopping = normalizeLayerLoading({
|
|
...camera({ status: 'unavailable', error: 'Old failure' }),
|
|
lifecycleState: 'disabling',
|
|
});
|
|
assert.equal(stopping.error, null);
|
|
assert.equal(stopping.unavailable, false);
|
|
});
|