From 239cac803366e84ea3eb63996a4e4d4b05b17b30 Mon Sep 17 00:00:00 2001 From: larssand Date: Sat, 14 Nov 2026 15:20:31 +0100 Subject: [PATCH] feat(decoder): alarm banner and warning sound when the decoder drops or goes silent during a heat (1.89.25) --- CHANGELOG.md | 6 ++++ README.md | 1 + README.sv.md | 1 + docs/javascript-architecture.md | 2 ++ index.html | 1 + package-lock.json | 4 +-- package.json | 2 +- src/app.js | 57 ++++++++++++++++++++++++++++++ src/decoder_runtime.js | 4 +++ src/decoder_watch.js | 36 +++++++++++++++++++ src/race_audio.js | 2 ++ src/settings.js | 2 ++ src/styles.css | 7 ++++ tests/browser_decoder_alarm.js | 61 +++++++++++++++++++++++++++++++++ tests/browser_fake_decoder.js | 5 +-- tests/browser_smoke.js | 2 ++ tests/decoder_watch.test.js | 36 +++++++++++++++++++ tests/run.js | 1 + 18 files changed, 225 insertions(+), 5 deletions(-) create mode 100644 src/decoder_watch.js create mode 100644 tests/browser_decoder_alarm.js create mode 100644 tests/decoder_watch.test.js diff --git a/CHANGELOG.md b/CHANGELOG.md index b7b58d6..40e61a2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,12 @@ The application version is maintained in `package.json` and displayed in the adm No changes recorded yet. +## 1.89.25 - 2026-11-14 + +### Added + +- **Decoder alarm:** a red banner on every page and a warning sound (every 30 s, with Reconnect and Silence) when the decoder disconnects during a heat or its count-down, or, in qualifying, heats and finals, when it is connected but no passing has come for 30 s or three of the fastest laps. When it works again the banner shows for 10 s how long timing was down. On the Race Controller Master; Settings → Audio → Decoder alarm during heats. + ## 1.89.24 - 2026-11-14 ### Fixed diff --git a/README.md b/README.md index 151a976..1765c3c 100644 --- a/README.md +++ b/README.md @@ -135,6 +135,7 @@ The menu follows how a race day works: **Start** (Dashboard, Race Day), **Create - **Flying start** (default for qualifying): the signal and "Clock is running". Each car's clock starts at its own first crossing, and a late car's clock starts at the latest 150 % of a lap (EFRA 9.3). - **Staggered start:** cars are called out one by one. - **Transponder check:** every driver in the heat gets a green tick when their transponder crosses during the count-down. A missing driver's transponder can be changed in the panel, or linked to an unknown transponder that just crossed. +- **Decoder alarm:** when the decoder disconnects during a heat (or its count-down), a red banner shows at the top of every page, "Decoder disconnected at 12:03 – laps are not being recorded", with **Reconnect** and **Silence**, and a warning sounds every 30 s. In qualifying, heats and finals it also alarms when the decoder is connected but no passing has come for 30 s (or three of the fastest laps), for example when the decoder box or loop has stopped working. Practice only alarms on a dropped link. When the decoder works again, the banner shows for 10 s how long timing was down, so the laps can be checked in Judging. It runs on the Race Controller Master computer and can be turned off under Settings → Audio → **Decoder alarm during heats**. - **Pause, resume and finish** work during the heat. Follow-up time lets the last lap finish after the clock. **Timing** shows the live leaderboard (laps, gap to leader and ahead, own delta, best and last lap), recent passings with invalid short laps marked, the grid for position starts, and a session replay (1-10x). diff --git a/README.sv.md b/README.sv.md index c38974c..7e60883 100644 --- a/README.sv.md +++ b/README.sv.md @@ -148,6 +148,7 @@ Gränssnittet finns på svenska och engelska. - **Flygande start** (standard för kval): signalen och "Klockan går". Varje bils tid startar vid dess första passering, och en sen bil får klockan startad senast efter 150 % av ett varv (EFRA 9.3). - **Staggered start:** bilarna ropas ut en och en. - **Transponderkontroll:** varje förare i heatet får en grön bock när transpondern passerar under nedräkningen. Saknas någon kan transpondern bytas direkt i panelen, eller kopplas till en okänd transponder som just passerat. +- **Decoderlarm:** tappar decodern anslutningen medan ett heat pågår (eller under nedräkningen) visas en röd banner överst på alla sidor, "Decodern tappade anslutningen 12:03 – varv registreras inte", med **Anslut igen** och **Tysta**, och ett varningsljud hörs var 30:e sekund. I kval, heat och finaler larmar det också när decodern är ansluten men ingen passering kommit på 30 s (eller tre av de snabbaste varven), till exempel när decoderboxen eller slingan slutat fungera. Träning larmar bara vid tappad anslutning. När decodern fungerar igen visas i 10 s hur länge tidtagningen var borta, så att varven kan kontrolleras i Domarvyn. Gäller datorn som är Race Controller Master och kan stängas av under Inställningar → Ljud → **Decoderlarm under heat**. - **Paus, fortsätt och avsluta** fungerar under heatet. Follow-up-tid låter sista varvet köras klart efter klockan. **Tidtagning** visar livetopplistan (varv, gap till ledaren och framför, eget delta, bästa och senaste varv), senaste passeringar med ogiltiga korta varv markerade, grid vid positionsstart, och repris av sessionen (1-10x). diff --git a/docs/javascript-architecture.md b/docs/javascript-architecture.md index c91a743..c28f747 100644 --- a/docs/javascript-architecture.md +++ b/docs/javascript-architecture.md @@ -2961,6 +2961,8 @@ Dependency graph: `app.js -> decoder_runtime.js -> decoder_diagnostics.js`; `app `decoder_diagnostics_view.js` mounts inside a details element outside settingsForm. A one-second timer patches only its own text nodes; it skips closed/paused panels, clears the old timer on remount, and self-clears after detachment. Pause affects display, not collection. Clearing diagnostics preserves socket state and timestamps. Copy uses Clipboard API with a selectable readonly textarea fallback for HTTP. Untrusted payloads are assigned through textContent/value, never interpolated into HTML. No SQLite/localStorage writes, backend endpoint, or public overlay exposure is added. Refresh resets diagnostics independently of saved settings. +`decoder_watch.js` (pure) decides the decoder alarm: `decoderAlarm(decoder, session, { startPending, bestLapMs, now })` returns `ok`, `lost` (main link down 3 s or more during a running heat or start count-down, counted from `state.decoder.disconnectedAt`, set on the first `onclose` and cleared on `onopen`) or `silent` (connected, a non-practice heat past its first 30 s, no PASSING since `state.decoder.lastPassingAt` or the start for `silentLimitMs(bestLapMs)` = max(30 s, 3 × best lap)). `app.js` `checkDecoderAlarm()` runs every second on the race master with a configured `wsUrl` and `settings.raceAudio.decoderAlarm` on; it renders `#decoderAlarm`, plays `timing_disconnected` (or the WebAudio siren when race audio is off) every 30 s until silenced, and shows 10 s of "working again" after recovery. No backend or SQLite change. + Reason codes: invalid_message (not an object), not_passing, no_running_session, missing_transponder, not_registered, already_in_pit, pit_exit_without_entry, split_without_reference, split_locktime, below_min (stored invalid lap). Handled events: pit_entry, pit_exit, split, start_reference, lap_counted or the existing validation warning. invalid_json means parsing failed before processing. The raw frame helps diagnose upstream protocol problems without changing parsing behavior. Tests: decoder_diagnostics.test.js covers bounds, isolation, snapshots and outcomes; decoder_runtime.test.js exercises socket reception/JSON errors/disconnection/open status without settings rerender. browser_smoke.js verifies live diagnostics update while an edited settings URL remains unchanged. Hardware/network reconnect behavior still requires a real-decoder smoke test. diff --git a/index.html b/index.html index 5c3ba60..80cd929 100644 --- a/index.html +++ b/index.html @@ -35,6 +35,7 @@
+

Dashboard

diff --git a/package-lock.json b/package-lock.json index 39545d5..179df16 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "rc-racecore", - "version": "1.89.24", + "version": "1.89.25", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "rc-racecore", - "version": "1.89.24", + "version": "1.89.25", "hasInstallScript": true, "dependencies": { "better-sqlite3": "^12.11.1", diff --git a/package.json b/package.json index d496d6c..bca1dc7 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "rc-racecore", - "version": "1.89.24", + "version": "1.89.25", "private": true, "description": "RC RaceCore live timing and race control with AMMC ingest and SQLite persistence", "engines": { diff --git a/src/app.js b/src/app.js index 8a9e7b6..b470c47 100644 --- a/src/app.js +++ b/src/app.js @@ -21,6 +21,7 @@ import { renderDaySchedulePanel, bindDaySchedulePanel, buildDaySchedulePrintHtml import { beginSession as beginSessionControl, finishSession as finishSessionControl, pauseSession as pauseSessionControl, resumeSession as resumeSessionControl } from "./session_control.js"; import { normalizeSeries, buildSeriesStandings, getSeriesRoundStatus, getSeriesRoundNextStep, getSeriesDayResult } from "./series_logic.js"; import { renderSeriesView } from "./series_view.js"; +import { decoderAlarm } from "./decoder_watch.js"; import { RACE_AUDIO_EVENT_DEFINITIONS, createRaceAudioEngine, normalizeRaceAudioSettings, isSilencedDuringRace, formatSpokenLapTime, resolveDriverCallStyle, formatCarCall, formatHeatCallDrivers } from "./race_audio.js"; import { renderRaceFormatField, renderRaceFormatContextCard, getRaceSummaryItems, getRaceSummaryWarnings, renderManageStatusBadge, renderRaceWizardSteps, renderRaceWizardContent, renderRaceStandingsTable } from "./race_setup_ui.js"; @@ -2978,6 +2979,13 @@ const TRANSLATIONS = { "audio.lap_time_calls_always": "Träning och race", "audio.lap_time_calls_off": "Av", "audio.lap_time_call_name": "Säg namnet före varvtiden", + "audio.decoder_alarm": "Decoderlarm under heat", + "audio.decoder_alarm_hint": "Röd banner och varningsljud om decodern tappar anslutningen eller blir tyst medan ett heat pågår.", + "decoder_alarm.lost": "⚠ Decodern tappade anslutningen {time} – varv registreras inte", + "decoder_alarm.silent": "⚠ Inga passeringar på {seconds} s – kolla decodern och slingan", + "decoder_alarm.back": "✓ Decodern fungerar igen – {seconds} s utan tidtagning. Kontrollera varven i Domarvyn.", + "decoder_alarm.reconnect": "Anslut igen", + "decoder_alarm.silence": "Tysta", "audio.practice_hype": "Peppande träningsutrop", "audio.practice_hype_hint": "Bara i träning, aldrig i kval eller final: varvjubileum, nära bästa varvet, snittet går ner, snabbare varv i rad, snabbare än förra gången, placering i klassen och dueller. Varje utrop kan också stängas av i listan nedan.", "audio.race_leader_calls": "Ledare i kval och final", @@ -5284,6 +5292,13 @@ const TRANSLATIONS = { "audio.lap_time_calls_always": "Practice and races", "audio.lap_time_calls_off": "Off", "audio.lap_time_call_name": "Say the name before the lap time", + "audio.decoder_alarm": "Decoder alarm during heats", + "audio.decoder_alarm_hint": "Red banner and a warning sound when the decoder disconnects or goes silent while a heat is running.", + "decoder_alarm.lost": "⚠ Decoder disconnected at {time} – laps are not being recorded", + "decoder_alarm.silent": "⚠ No passings for {seconds} s – check the decoder and the loop", + "decoder_alarm.back": "✓ Decoder working again – {seconds} s without timing. Check the laps in Judging.", + "decoder_alarm.reconnect": "Reconnect", + "decoder_alarm.silence": "Silence", "audio.practice_hype": "Practice hype calls", "audio.practice_hype_hint": "Practice only, never in qualifying or finals: lap milestones, close to best, average going down, faster laps in a row, faster than last time, class rank and duels. Each call can also be turned off in the list below.", "audio.race_leader_calls": "Leader in qualifying and finals", @@ -7717,6 +7732,48 @@ function updateConnectionBadge() { dom.connectionBadge.className = `badge ${isOnline ? "badge-online" : "badge-offline"}`; } +// Decoder alarm (decoder_watch.js): checked every second on the race master. Red banner, warning +// sound repeated every 30 s until fixed or silenced, then 10 s of "working again, X s without timing". +const decoderAlarmRuntime = { kind: "ok", since: 0, silenced: false, lastSoundAt: 0, backUntil: 0, backSeconds: 0 }; +function checkDecoderAlarm(now = Date.now()) { + const el = document.getElementById("decoderAlarm"); + if (!el) return; + const session = getActiveSession(); + const competitors = Object.values(state.resultsBySession?.[session?.id]?.competitors || {}); + const bestLapMs = Math.min(...competitors.map((item) => Number(item.bestLapMs) || Infinity)); + // Only the race master with a decoder configured (no decoder at all is a normal setup, not an alarm). + const enabled = state.settings.raceAudio?.decoderAlarm !== false && Boolean(state.settings.wsUrl) && isRaceMaster(); + const alarm = enabled ? decoderAlarm(state.decoder, session, { startPending: Boolean(pendingStartSessionId), bestLapMs: Number.isFinite(bestLapMs) ? bestLapMs : 0, now }) : { kind: "ok", sinceMs: 0 }; + const run = decoderAlarmRuntime; + if (alarm.kind !== run.kind) { + if (run.kind !== "ok" && alarm.kind === "ok" && enabled) Object.assign(run, { backUntil: now + 10000, backSeconds: Math.round((now - run.since) / 1000) }); + Object.assign(run, { kind: alarm.kind, since: now - alarm.sinceMs, silenced: false, lastSoundAt: 0 }); + } + if (run.kind !== "ok" && !run.silenced && now - run.lastSoundAt >= 30000) { + run.lastSoundAt = now; + const played = triggerRaceAudio("timing_disconnected", { interrupt: true, force: true }); + if (played?.skipped || !state.settings.raceAudio?.enabled || state.settings.raceAudio?.muted) playFinishSiren(); + } + const html = run.kind === "lost" ? t("decoder_alarm.lost", { time: new Date(run.since).toLocaleTimeString() }) + : run.kind === "silent" ? t("decoder_alarm.silent", { seconds: Math.round((now - run.since) / 1000) }) + : now < run.backUntil ? t("decoder_alarm.back", { seconds: run.backSeconds }) : ""; + el.hidden = !html; + el.classList.toggle("is-back", run.kind === "ok"); + const key = `${run.kind}|${html}|${run.silenced}`; + if (el.dataset.key === key) return; + el.dataset.key = key; + el.dataset.kind = html ? run.kind : ""; + el.innerHTML = html ? `${escapeHtml(html)}${run.kind === "lost" ? `` : ""}${run.kind !== "ok" && !run.silenced ? `` : ""}` : ""; +} +if (!overlayMode) { + document.addEventListener("click", (event) => { + const action = event.target instanceof Element ? event.target.closest("[data-decoder-alarm]")?.dataset.decoderAlarm : ""; + if (action === "silence") { decoderAlarmRuntime.silenced = true; checkDecoderAlarm(); } + if (action === "reconnect") connectDecoder(); + }); + setInterval(() => checkDecoderAlarm(), 1000); +} + function renderEvents() { renderEventWorkspace("track"); } diff --git a/src/decoder_runtime.js b/src/decoder_runtime.js index 00e881b..6811c12 100644 --- a/src/decoder_runtime.js +++ b/src/decoder_runtime.js @@ -253,6 +253,7 @@ function connectDecoderRole(role, deps) { decoderDiagnostics.socket(role, "connected", url); state.decoder[connectedKey] = true; state.decoder[lastErrorKey] = ""; + if (role === "main") state.decoder.disconnectedAt = null; // decoder alarm (decoder_watch.js) reconnectAttempts.delete(role); saveState({ skipBackend: true }); updateConnectionBadge(); @@ -285,6 +286,8 @@ function connectDecoderRole(role, deps) { wsClient.onclose = () => { decoderDiagnostics.socket(role, "disconnected", url); state.decoder[connectedKey] = false; + // The first drop is kept while reconnect attempts fail, so the alarm counts from it. + if (role === "main" && !state.decoder.disconnectedAt) state.decoder.disconnectedAt = Date.now(); saveState({ skipBackend: true }); updateConnectionBadge(); @@ -375,6 +378,7 @@ export function processDecoderMessageHelper(msg, deps, decoderRole = "main") { // check needs to see passings while the heat hasn't started yet. Main line only, the // same line that counts laps. if (decoderRole === "main") { + if (state.decoder) state.decoder.lastPassingAt = Date.now(); // the decoder alarm's silence check (wall clock, not the decoder's RTC) const seenTransponder = String(msg.transponder ?? msg.tran_code ?? "").replace("ID:", "").trim(); if (seenTransponder) onTransponderSeen(seenTransponder); } diff --git a/src/decoder_watch.js b/src/decoder_watch.js new file mode 100644 index 0000000..f64b782 --- /dev/null +++ b/src/decoder_watch.js @@ -0,0 +1,36 @@ +// Decoder alarm: during a running heat (or its start count-down) the race controller must know at +// once when timing stops - the decoder link dropped ("lost"), or the link is up but no passing has +// come for far longer than a lap ("silent": AMMC runs, the decoder box or loop is dead). +// Pure logic; the banner, sound and repeat live in app.js. + +export const LOST_GRACE_MS = 3000; // a quick reconnect doesn't alarm +export const SILENT_MIN_MS = 30000; // never "silent" sooner than this +export const START_GRACE_MS = 30000; // cars are still on the grid / first lap +const PRACTICE_TYPES = new Set(["open_practice", "free_practice", "practice"]); + +// The silence limit: 30 s, or 3 laps of the fastest lap so far when that is longer. +export function silentLimitMs(bestLapMs = 0) { + const best = Number(bestLapMs) || 0; + return Math.max(SILENT_MIN_MS, best > 0 ? best * 3 : 0); +} + +// decoder: { connected, disconnectedAt, lastPassingAt }; session: { status, startedAt }; +// options: { startPending, bestLapMs, now }. Returns { kind: "ok" | "lost" | "silent", sinceMs }. +export function decoderAlarm(decoder = {}, session = null, { startPending = false, bestLapMs = 0, now = Date.now() } = {}) { + const running = session?.status === "running"; + if (!running && !startPending) return { kind: "ok", sinceMs: 0 }; + if (!decoder.connected) { + const since = Number(decoder.disconnectedAt) || 0; + const sinceMs = since ? Math.max(0, now - since) : LOST_GRACE_MS; + return sinceMs >= LOST_GRACE_MS ? { kind: "lost", sinceMs } : { kind: "ok", sinceMs: 0 }; + } + if (!running) return { kind: "ok", sinceMs: 0 }; + // Practice can be quiet for long stretches (nobody driving): only a dropped link alarms there. + if (PRACTICE_TYPES.has(String(session.type || ""))) return { kind: "ok", sinceMs: 0 }; + const startedAt = Number(session.startedAt) || 0; + if (!startedAt || now - startedAt < START_GRACE_MS) return { kind: "ok", sinceMs: 0 }; + // Silence counts from the last passing, or from the start when none has come in this heat. + const lastPassingAt = Math.max(Number(decoder.lastPassingAt) || 0, startedAt); + const sinceMs = now - lastPassingAt; + return sinceMs >= silentLimitMs(bestLapMs) ? { kind: "silent", sinceMs } : { kind: "ok", sinceMs: 0 }; +} diff --git a/src/race_audio.js b/src/race_audio.js index 36b8d28..fa5a92a 100644 --- a/src/race_audio.js +++ b/src/race_audio.js @@ -103,6 +103,8 @@ export function normalizeRaceAudioSettings(value = {}) { raceCallouts: source.raceCallouts === "full" ? "full" : "passing", // Practice hype calls (practice_hype_logic.js); never in qualifying or finals. practiceHype: source.practiceHype !== false, + // Banner + warning when the decoder drops or goes silent during a heat (decoder_watch.js). + decoderAlarm: source.decoderAlarm !== false, // Short lap time per passing, "Anders, 17 six": "practice" (default), "always" or "off". lapTimeCalls: ["practice", "always", "off"].includes(source.lapTimeCalls) ? source.lapTimeCalls : "practice", lapTimeCallName: source.lapTimeCallName === true, diff --git a/src/settings.js b/src/settings.js index e1ef075..b97346b 100644 --- a/src/settings.js +++ b/src/settings.js @@ -254,6 +254,7 @@ export function renderSettings(deps) { + @@ -677,6 +678,7 @@ Erik Eriksson;654321;4WD;Associated;; maxStartDelay: Number(form.get("raceAudioMaxDelay")), perCompetitorPassingTone: form.get("raceAudioPerCompetitor") === "on", raceCallouts: String(form.get("raceAudioRaceCallouts") || "passing"), practiceHype: form.get("raceAudioPracticeHype") === "on", + decoderAlarm: form.get("raceAudioDecoderAlarm") === "on", lapTimeCalls: String(form.get("raceAudioLapTimeCalls") || "practice"), lapTimeCallName: form.get("raceAudioLapTimeCallName") === "on", raceLeaderCalls: String(form.get("raceAudioLeaderCalls") || "both"), diff --git a/src/styles.css b/src/styles.css index dacc4f4..6164f9d 100644 --- a/src/styles.css +++ b/src/styles.css @@ -4953,6 +4953,13 @@ tr:has(> td > .medal-3) { background: linear-gradient(90deg, rgba(205, 127, 60, /* Race Controller Master: banner for the browsers that follow, badge for the master. */ .controller-banner { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin: 0 0 10px; padding: 8px 12px; border: 1px solid var(--accent); border-radius: 8px; background: color-mix(in srgb, var(--accent) 12%, var(--panel)); color: var(--text); font-size: 0.85rem; } .controller-banner[hidden] { display: none; } +/* Decoder alarm (decoder_watch.js): red and pulsing while timing is down, green when it is back. */ +.decoder-alarm { position: sticky; top: 0; z-index: 50; display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; margin: 0 0 10px; padding: 10px 14px; border: 2px solid #ff4d4f; border-radius: 8px; background: color-mix(in srgb, #ff4d4f 22%, var(--panel)); color: var(--text); font-size: 1rem; box-shadow: 0 4px 18px rgb(0 0 0 / 35%); animation: decoder-alarm-pulse 1.2s ease-in-out infinite; } +.decoder-alarm[hidden] { display: none; } +.decoder-alarm strong { flex: 1 1 260px; } +.decoder-alarm.is-back { border-color: #2fa84f; background: color-mix(in srgb, #2fa84f 18%, var(--panel)); animation: none; } +@keyframes decoder-alarm-pulse { 50% { background: color-mix(in srgb, #ff4d4f 40%, var(--panel)); } } +@media (prefers-reduced-motion: reduce) { .decoder-alarm { animation: none; } } .controller-banner.is-flash { animation: controller-flash 0.9s ease 2; } @keyframes controller-flash { 50% { background: color-mix(in srgb, var(--accent) 45%, var(--panel)); } } .controller-badge { background: color-mix(in srgb, var(--accent) 22%, var(--panel)); color: var(--text); } diff --git a/tests/browser_decoder_alarm.js b/tests/browser_decoder_alarm.js new file mode 100644 index 0000000..1d0131a --- /dev/null +++ b/tests/browser_decoder_alarm.js @@ -0,0 +1,61 @@ +import assert from "node:assert/strict"; +import { startFakeDecoder } from "./browser_fake_decoder.js"; + +// Decoder alarm (src/decoder_watch.js): the decoder goes away mid-heat -> red banner with +// Reconnect / Silence; it comes back -> green "working again, X s without timing". +export async function runDecoderAlarmSmoke({ evaluate, navigate, fill, savedState, waitFor }) { + const click = id => evaluate(`document.getElementById(${JSON.stringify(id)}).click()`); + const submit = id => evaluate(`document.getElementById(${JSON.stringify(id)}).requestSubmit()`); + const findEvent = async name => (await savedState()).events.find(event => event.name === name); + const findSession = async name => (await savedState()).sessions.find(session => session.name === name); + const patchState = async patch => { + const current = await savedState(); + Object.assign(current, patch); + assert.equal((await fetch(new URL("/api/state", await evaluate("location.origin")), { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(current) })).ok, true); + }; + const banner = () => evaluate(`(() => { const el = document.getElementById("decoderAlarm"); return { hidden: el.hidden, kind: el.dataset.kind, text: el.textContent, reconnect: Boolean(el.querySelector('[data-decoder-alarm="reconnect"]')), silence: Boolean(el.querySelector('[data-decoder-alarm="silence"]')) }; })()`); + + let decoder = await startFakeDecoder(); + const port = decoder.port; + try { + const seeded = await savedState(); + await patchState({ settings: { ...seeded.settings, autoReconnect: true, wsUrl: `ws://127.0.0.1:${port}` } }); + await navigate("events", "eventForm"); + await waitFor(async () => await evaluate('document.getElementById("connectionBadge")?.classList.contains("badge-online")'), "fake decoder connected"); + await fill("eventForm", { name: "Decoder Alarm Event", date: "2026-09-10", classId: "test_class" }); + await submit("eventForm"); + await waitFor(async () => Boolean(await findEvent("Decoder Alarm Event")), "create event"); + await click("event-manage-" + (await findEvent("Decoder Alarm Event")).id); + await fill("sessionForm", { name: "Decoder Alarm Heat", type: "open_practice", durationMin: "5" }); + await submit("sessionForm"); + await waitFor(async () => Boolean(await findSession("Decoder Alarm Heat")), "create heat"); + await patchState({ activeSessionId: (await findSession("Decoder Alarm Heat")).id }); + await navigate("race_day", "raceDayStart"); + await waitFor(async () => (await evaluate('document.getElementById("raceDayStart")?.disabled')) === false, "start enabled"); + assert.equal((await banner()).hidden, true, "no alarm while the decoder is fine"); + await click("raceDayStart"); + await waitFor(async () => (await findSession("Decoder Alarm Heat")).status === "running", "heat running"); + + await decoder.close(); // the decoder goes away and stays away + await waitFor(async () => (await banner()).kind === "lost", "red banner once the decoder has been gone 3 s", 10000); + const lost = await banner(); + assert.match(lost.text, /Decodern tappade anslutningen|Decoder disconnected/); + assert.ok(lost.reconnect && lost.silence, "Reconnect and Silence buttons"); + await evaluate(`document.querySelector('[data-decoder-alarm="silence"]').click()`); + await waitFor(async () => !(await banner()).silence && (await banner()).kind === "lost", "silenced: the banner stays, the button goes"); + + decoder = await startFakeDecoder(port); + await evaluate(`document.querySelector('[data-decoder-alarm="reconnect"]').click()`); + await waitFor(async () => (await banner()).kind === "ok" && !(await banner()).hidden, "green banner when the decoder is back"); + assert.match((await banner()).text, /\d+ s/); + await waitFor(async () => (await banner()).hidden, "the green banner goes after 10 s", 15000); + console.log("PASS decoder alarm: red banner when the decoder drops mid-heat, silence, reconnect, then 'working again'"); + } finally { + // Pause the heat through the UI (like the OBS popup test), so no running heat leaks into later tests. + await evaluate('document.getElementById("raceDayPause")?.click()').catch(() => {}); + await waitFor(async () => (await findSession("Decoder Alarm Heat"))?.status !== "running", "heat paused").catch(() => {}); + const cleanup = await savedState(); + await patchState({ settings: { ...cleanup.settings, autoReconnect: false } }); + await decoder.close(); + } +} diff --git a/tests/browser_fake_decoder.js b/tests/browser_fake_decoder.js index 0b86a05..b91adb7 100644 --- a/tests/browser_fake_decoder.js +++ b/tests/browser_fake_decoder.js @@ -13,8 +13,9 @@ export async function freePort() { // Accepts the WebSocket upgrade handshake so the frontend's real decoder-connect path // (src/decoder_runtime.js) reaches `connected: true` without a physical AMMC decoder. // sendPassing() pushes a PASSING frame for scenarios that need the app to see a transponder. -export async function startFakeDecoder() { - const port = await freePort(); +// `fixedPort`: listen on a port used before (a decoder coming back on the same address). +export async function startFakeDecoder(fixedPort = 0) { + const port = fixedPort || await freePort(); const server = createServer(); // The upgraded sockets are intentionally left open (no decoder frames needed), so a // plain server.close() would wait forever for them to end; track and destroy them diff --git a/tests/browser_smoke.js b/tests/browser_smoke.js index 0f0619f..a70ab0e 100644 --- a/tests/browser_smoke.js +++ b/tests/browser_smoke.js @@ -33,6 +33,7 @@ import { runRaceDayQuickSmoke } from "./browser_race_day_quick.js"; import { runDayScheduleSmoke } from "./browser_day_schedule.js"; import { runObsPopupSmoke } from "./browser_obs_popup.js"; import { runDecoderReconnectSmoke } from "./browser_decoder_reconnect.js"; +import { runDecoderAlarmSmoke } from "./browser_decoder_alarm.js"; import { runRaceControllerSmoke } from "./browser_race_controller.js"; import assert from "node:assert/strict"; import { spawn } from "node:child_process"; @@ -197,6 +198,7 @@ try { await runRaceDayStartSequencesSmoke({ evaluate, navigate, waitFor, pause, base, dialogs }); await runObsPopupSmoke({ evaluate, navigate, fill, savedState, waitFor, pause, base, debugPort, dialogs, realClick }); await runDecoderReconnectSmoke({ evaluate, navigate, savedState, waitFor, pause, base }); + await runDecoderAlarmSmoke({ evaluate, navigate, fill, savedState, waitFor }); await runRaceControllerSmoke({ evaluate, navigate, savedState, waitFor, pause, base, debugPort }); await navigate("classes", "classForm"); await send("Network.emulateNetworkConditions", { offline: true, latency: 0, downloadThroughput: -1, uploadThroughput: -1 }); diff --git a/tests/decoder_watch.test.js b/tests/decoder_watch.test.js new file mode 100644 index 0000000..5e774fb --- /dev/null +++ b/tests/decoder_watch.test.js @@ -0,0 +1,36 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { decoderAlarm, silentLimitMs } from "../src/decoder_watch.js"; + +const t0 = 1_000_000; +const running = { status: "running", startedAt: t0 }; + +test("no alarm outside a running heat or its count-down", () => { + assert.equal(decoderAlarm({ connected: false, disconnectedAt: t0 }, { status: "finished" }, { now: t0 + 60000 }).kind, "ok"); + assert.equal(decoderAlarm({ connected: false, disconnectedAt: t0 }, { status: "paused", startedAt: t0 }, { now: t0 + 60000 }).kind, "ok"); + assert.equal(decoderAlarm({ connected: false }, null, { now: t0 }).kind, "ok"); +}); + +test("lost: the decoder link drops during the heat or the count-down, after 3 s", () => { + assert.equal(decoderAlarm({ connected: false, disconnectedAt: t0 + 60000 }, running, { now: t0 + 61000 }).kind, "ok", "quick reconnect window"); + assert.deepEqual(decoderAlarm({ connected: false, disconnectedAt: t0 + 60000 }, running, { now: t0 + 65000 }), { kind: "lost", sinceMs: 5000 }); + assert.equal(decoderAlarm({ connected: false }, { status: "ready" }, { startPending: true, now: t0 }).kind, "lost", "never connected during the count-down"); +}); + +test("silent: connected but no passing for 30 s, or 3 best laps", () => { + assert.equal(silentLimitMs(0), 30000); + assert.equal(silentLimitMs(18000), 54000); + const decoder = { connected: true, lastPassingAt: t0 + 40000 }; + assert.equal(decoderAlarm(decoder, running, { now: t0 + 65000 }).kind, "ok"); + assert.deepEqual(decoderAlarm(decoder, running, { now: t0 + 71000 }), { kind: "silent", sinceMs: 31000 }); + assert.equal(decoderAlarm(decoder, running, { bestLapMs: 18000, now: t0 + 71000 }).kind, "ok", "slow track: 3 laps of 18 s"); + assert.equal(decoderAlarm({ connected: true }, running, { now: t0 + 20000 }).kind, "ok", "first 30 s after the start"); + assert.equal(decoderAlarm({ connected: true, lastPassingAt: t0 - 99999 }, running, { now: t0 + 45000 }).kind, "silent", "a passing before the start doesn't count"); + assert.equal(decoderAlarm({ connected: true }, { status: "ready" }, { startPending: true, now: t0 + 99999 }).kind, "ok", "no silence alarm before the start"); +}); + +test("practice: no silence alarm (nobody may be driving), but a dropped link still alarms", () => { + const practice = { status: "running", startedAt: t0, type: "open_practice" }; + assert.equal(decoderAlarm({ connected: true }, practice, { now: t0 + 600000 }).kind, "ok"); + assert.equal(decoderAlarm({ connected: false, disconnectedAt: t0 + 1000 }, practice, { now: t0 + 9000 }).kind, "lost"); +}); diff --git a/tests/run.js b/tests/run.js index a79ad17..1d321ae 100644 --- a/tests/run.js +++ b/tests/run.js @@ -57,3 +57,4 @@ import "./driver_list.test.js"; import "./country_flags.test.js"; import "./pdf_flags.test.js"; import "./local_fonts.test.js"; +import "./decoder_watch.test.js";