Files
Live_RC/tests/race_day_logic.test.js
T
larssand 35eb3eb059 feat(decoder): warn when the decoder's clock is off (1.42.4)
The decoder's time is never changed. Passings (also during warm-up)
measure it against the computer's clock, and Race Day's preflight and
the decoder diagnostics warn when it is over a minute off, e.g. after
the switch to winter time.
2026-10-25 18:40:35 +01:00

127 lines
7.2 KiB
JavaScript

import test from "node:test";
import assert from "node:assert/strict";
import { buildRaceDayPreflight, buildRaceDayQueue } from "../src/race_day_logic.js";
function createState() {
return {
activeSessionId: "session_1",
decoder: { connected: true, splitConnected: true, pitEntryConnected: true, pitExitConnected: true },
settings: { splitDecoderEnabled: false, pitDecoderEnabled: false, raceAudio: { enabled: true } },
classes: [{ id: "class_1", name: "2WD" }],
drivers: [
{ id: "driver_1", classId: "class_1", name: "One", transponder: "111" },
{ id: "driver_2", classId: "class_1", name: "Two", transponder: "222" },
],
cars: [],
events: [{
id: "event_1",
mode: "race",
classId: "class_1",
raceConfig: { participantsConfigured: true, driverIds: ["driver_1", "driver_2"], minLapMs: 10000, maxLapMs: 60000 },
}],
sessions: [
{ id: "session_1", eventId: "event_1", name: "Q1", mode: "race", type: "qualification", status: "ready", startMode: "mass", driverIds: ["driver_1", "driver_2"] },
{ id: "session_2", eventId: "event_1", name: "Q2", mode: "race", type: "qualification", status: "ready", startMode: "mass", driverIds: ["driver_1", "driver_2"] },
{ id: "session_3", eventId: "event_1", name: "A final", mode: "race", type: "final", status: "ready", startMode: "position", driverIds: ["driver_1", "driver_2"], manualGridIds: ["driver_1", "driver_2"] },
],
};
}
test("Race Day queue follows the selected event session order", () => {
const queue = buildRaceDayQueue(createState());
assert.equal(queue.current.id, "session_1");
assert.equal(queue.next.id, "session_2");
assert.equal(queue.afterNext.id, "session_3");
});
test("Race Day preflight accepts a complete race session", () => {
const state = createState();
const result = buildRaceDayPreflight(state, state.sessions[0], { backendAvailable: true });
assert.equal(result.ready, true);
assert.ok(result.checks.every((item) => item.level === "ok"));
});
test("Race Day preflight blocks decoder, transponder, duplicate and grid errors", () => {
const state = createState();
state.decoder.connected = false;
state.drivers[1].transponder = "111";
state.sessions[2].manualGridIds = ["driver_1"];
const result = buildRaceDayPreflight(state, state.sessions[2], { backendAvailable: true });
assert.equal(result.ready, false);
const levels = new Map(result.checks.map((item) => [item.id, item.level]));
assert.equal(levels.get("decoder"), "error");
assert.equal(levels.get("duplicate_transponders"), "error");
assert.equal(levels.get("grid"), "error");
});
test("open practice allows an unset lap window but still requires the main decoder", () => {
const state = createState();
state.events[0].raceConfig.minLapMs = 0;
state.events[0].raceConfig.maxLapMs = 0;
const practice = { ...state.sessions[0], type: "open_practice", driverIds: [] };
let result = buildRaceDayPreflight(state, practice, { backendAvailable: true });
assert.equal(result.ready, true);
assert.equal(result.checks.find((item) => item.id === "lap_window").level, "warning");
state.decoder.connected = false;
result = buildRaceDayPreflight(state, practice, { backendAvailable: true });
assert.equal(result.ready, false);
});
test("team_race preflight blocks a driver saved onto two teams at once, naming them instead of a generic transponder error", () => {
const state = createState();
state.sessions.push({ id: "session_team", eventId: "event_1", name: "Team Race", mode: "race", type: "team_race", status: "ready", startMode: "mass" });
state.events[0].raceConfig.teams = [
{ id: "team_a", name: "Team A", driverIds: ["driver_1"], carIds: [] },
{ id: "team_b", name: "Team B", driverIds: ["driver_1", "driver_2"], carIds: [] },
];
const result = buildRaceDayPreflight(state, state.sessions.find((s) => s.id === "session_team"), { backendAvailable: true });
assert.equal(result.ready, false);
const duplicateCheck = result.checks.find((item) => item.id === "duplicate_team_members");
assert.equal(duplicateCheck.level, "error");
assert.deepEqual(duplicateCheck.duplicateTeamMemberNames, ["One"]);
});
test("team_race preflight accepts teams with no members in common", () => {
const state = createState();
state.sessions.push({ id: "session_team", eventId: "event_1", name: "Team Race", mode: "race", type: "team_race", status: "ready", startMode: "mass" });
state.events[0].raceConfig.teams = [
{ id: "team_a", name: "Team A", driverIds: ["driver_1"], carIds: [] },
{ id: "team_b", name: "Team B", driverIds: ["driver_2"], carIds: [] },
];
const result = buildRaceDayPreflight(state, state.sessions.find((s) => s.id === "session_team"), { backendAvailable: true });
assert.equal(result.checks.find((item) => item.id === "duplicate_team_members").level, "ok");
});
test("preflight presents blockers before warnings without changing the original checks", async () => {
const { sortRaceDayChecks } = await import("../src/race_day_view.js");
const checks = [{ id: "audio", level: "warning" }, { id: "session", level: "ok" }, { id: "decoder", level: "error" }];
assert.deepEqual(sortRaceDayChecks(checks).map((item) => item.id), ["decoder", "audio", "session"]);
assert.equal(checks[0].id, "audio");
});
test("preflight shortcuts respect driver, shared-car and team setup", async () => {
const { getRaceDayCheckAction: action } = await import("../src/race_day_view.js");
const missing = { id: "transponders", level: "error" };
assert.equal(action(missing, { mode: "race", type: "qualification" }).view, "drivers");
assert.equal(action(missing, { mode: "track", type: "heat" }).view, "cars");
assert.equal(action(missing, { mode: "race", type: "team_race" }).view, "race_setup");
assert.equal(action({ id: "participants", level: "error" }, { mode: "track" }).view, "events");
assert.equal(action({ id: "decoder", level: "error" }).view, "settings");
assert.equal(action({ id: "decoder", level: "error" }).settingsTab, "connection", "the decoder fix opens the Connection tab");
assert.equal(action({ id: "audio", level: "warning" }).settingsTab, "audio", "the audio fix opens the Audio tab");
assert.equal(action({ id: "session", level: "error" }).view, "timing");
assert.equal(action({ id: "lap_window", level: "warning" }, { mode: "race" }).field, "minLapSec");
assert.equal(action({ id: "decoder", level: "ok" }), null);
});
test("Race Day preflight warns when the decoder's clock is off, but never blocks the start", () => {
const state = createState();
state.decoder.clockSkewMs = -3600000 - 40; // the decoder still on summer time: one hour ahead
const result = buildRaceDayPreflight(state, state.sessions[0], { backendAvailable: true });
const clock = result.checks.find((item) => item.id === "decoder_clock");
assert.deepEqual({ level: clock.level, ahead: clock.ahead, hours: clock.hours, minutes: clock.minutes }, { level: "warning", ahead: true, hours: 1, minutes: 0 });
assert.equal(result.ready, true, "a warning: the operator decides");
state.decoder.clockSkewMs = 25; // network delay only
assert.equal(buildRaceDayPreflight(state, state.sessions[0], { backendAvailable: true }).checks.some((item) => item.id === "decoder_clock"), false);
});