125 lines
8.5 KiB
JavaScript
125 lines
8.5 KiB
JavaScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { orderDaySessions, buildDaySchedule, getAutopilotAction, normalizeRaceDays, moveInDayOrder, pickBoardDate } from "../src/day_schedule_logic.js";
|
|
|
|
const events = [
|
|
{ id: "e4", name: "Cup #1 4WD", date: "2026-11-08", mode: "race" },
|
|
{ id: "e2", name: "Cup #1 2WD", date: "2026-11-08", mode: "race" },
|
|
{ id: "other", name: "Other day", date: "2026-11-09", mode: "race" },
|
|
];
|
|
const s = (id, eventId, type, name, extra = {}) => ({ id, eventId, type, name, mode: "race", status: "ready", durationMin: 5, ...extra });
|
|
const sessions = [
|
|
s("a4", "e4", "final", "A Final 1"), s("q4", "e4", "qualification", "Q1 H1"), s("q4b", "e4", "qualification", "Q2 H1"),
|
|
s("b2", "e2", "final", "B Final 1"), s("a2", "e2", "final", "A Final 1"), s("q2b", "e2", "qualification", "Q2 H1"),
|
|
s("q2", "e2", "qualification", "Q1 H1"), s("q2h2", "e2", "qualification", "Q1 H2"), s("p2", "e2", "practice", "Seeding"),
|
|
s("x", "other", "qualification", "Q1 H1"),
|
|
];
|
|
|
|
test("the day runs every class step by step: practice, each qualifying round, finals lowest first", () => {
|
|
const ids = orderDaySessions({ events, sessions, date: "2026-11-08" }).map((item) => item.id);
|
|
assert.deepEqual(ids, ["p2", "q2", "q2h2", "q4", "q2b", "q4b", "b2", "a2", "a4"]);
|
|
});
|
|
|
|
test("a manual day order and a class's own order are kept", () => {
|
|
const ordered = orderDaySessions({ events, sessions, date: "2026-11-08" });
|
|
const manual = moveInDayOrder(ordered, "q4", -1);
|
|
assert.deepEqual(orderDaySessions({ events, sessions, date: "2026-11-08", manualOrder: manual }).slice(0, 4).map((item) => item.id), ["p2", "q2", "q4", "q2h2"]);
|
|
const swapped = events.map((event) => (event.id === "e2" ? { ...event, sessionOrder: ["q2h2", "q2"] } : event));
|
|
assert.deepEqual(orderDaySessions({ events: swapped, sessions, date: "2026-11-08" }).slice(1, 3).map((item) => item.id), ["q2h2", "q2"]);
|
|
});
|
|
|
|
test("the schedule cascades from the start time and a late or paused day pushes the rest", () => {
|
|
const start = Date.UTC(2026, 10, 8, 10, 0);
|
|
const list = [s("one", "e2", "qualification", "Q1 H1"), s("two", "e2", "qualification", "Q1 H2")];
|
|
const day = { startAt: start, gapMin: 3 };
|
|
const plan = buildDaySchedule(list, day, start - 3600000);
|
|
assert.deepEqual(plan.map((row) => row.start), [start, start + 8 * 60000]);
|
|
assert.equal(plan[1].upcomingIndex, 1);
|
|
// Nothing started 4 minutes after the planned time: expected now, everything after moves.
|
|
const late = buildDaySchedule(list, day, start + 4 * 60000);
|
|
assert.equal(late[0].start, start + 4 * 60000);
|
|
assert.equal(late[0].delayed, true);
|
|
assert.equal(late[1].start, start + 12 * 60000);
|
|
// A heat running with a 2 minute pause ends 2 minutes later.
|
|
const running = [{ ...list[0], status: "running", startedAt: start + 60000, totalPausedMs: 120000 }, list[1]];
|
|
const live = buildDaySchedule(running, day, start + 2 * 60000);
|
|
assert.equal(live[0].state, "live");
|
|
assert.equal(live[0].end, start + 8 * 60000);
|
|
assert.equal(live[1].start, start + 11 * 60000);
|
|
});
|
|
|
|
test("the autopilot waits for the planned time minus the count-down, never while something runs or the day is paused", () => {
|
|
const start = Date.UTC(2026, 10, 8, 10, 0);
|
|
const rows = buildDaySchedule([s("one", "e2", "qualification", "Q1 H1")], { startAt: start }, start - 600000);
|
|
const prologueMs = () => 120000;
|
|
assert.deepEqual(getAutopilotAction(rows, { day: {}, now: start - 300000, prologueMs }).reason, "until");
|
|
assert.equal(getAutopilotAction(rows, { day: {}, now: start - 120000, prologueMs }).type, "start");
|
|
assert.equal(getAutopilotAction(rows, { day: {}, now: start, busy: true, prologueMs }).reason, "running");
|
|
assert.equal(getAutopilotAction(rows, { day: { pausedAt: start }, now: start, prologueMs }).reason, "paused");
|
|
assert.equal(getAutopilotAction([], { day: {}, now: start }).reason, "done");
|
|
assert.deepEqual(getAutopilotAction([], { day: {}, now: start, finalsPending: ["Buggy 4WD", "Buggy 2WD"] }), { type: "wait", reason: "finals", classes: ["Buggy 4WD", "Buggy 2WD"] });
|
|
assert.equal(getAutopilotAction(rows, { day: {}, now: start - 120000, prologueMs, finalsPending: ["Buggy 4WD"] }).type, "start", "a heat still to run goes first");
|
|
});
|
|
|
|
test("race days are stored one per date, and the board shows today or the next day still to race", () => {
|
|
const days = normalizeRaceDays([{ date: "2026-11-08", gapMin: 0 }, { date: "bad" }, { date: "2026-11-08", gapMin: 5, autopilot: true }]);
|
|
assert.equal(days.length, 1);
|
|
assert.equal(days[0].gapMin, 5);
|
|
assert.equal(normalizeRaceDays([{ date: "2026-11-08", gapMin: 0 }])[0].gapMin, 0);
|
|
assert.equal(pickBoardDate({ events, sessions, today: "2026-11-08" }), "2026-11-08");
|
|
assert.equal(pickBoardDate({ events, sessions, today: "2026-11-01" }), "2026-11-08");
|
|
assert.equal(pickBoardDate({ events, sessions, today: "2026-12-01" }), "2026-12-01");
|
|
});
|
|
|
|
test("a heat is due for its call within callMin, once, and not while put off or the day is paused", async () => {
|
|
const { getDueCall } = await import("../src/day_schedule_logic.js");
|
|
const start = Date.UTC(2026, 10, 8, 10, 0);
|
|
const rows = buildDaySchedule([s("one", "e2", "qualification", "Q1 H1"), s("two", "e2", "qualification", "Q1 H2")], { startAt: start, gapMin: 3 }, start - 3600000);
|
|
const day = { callMin: 10 };
|
|
assert.equal(getDueCall(rows, { day, now: start - 11 * 60000 }), null);
|
|
assert.equal(getDueCall(rows, { day, now: start - 10 * 60000 }).session.id, "one");
|
|
const called = rows.map((row, i) => (i === 0 ? { ...row, session: { ...row.session, calledAt: start - 600000 } } : row));
|
|
assert.equal(getDueCall(called, { day, now: start - 5 * 60000 }), null, "the next heat is not due yet");
|
|
assert.equal(getDueCall(called, { day, now: start }).session.id, "two");
|
|
assert.equal(getDueCall(rows, { day, now: start - 5 * 60000, snoozedUntil: () => start - 3 * 60000 }), null, "put off");
|
|
assert.equal(getDueCall(rows, { day: { ...day, pausedAt: 1 }, now: start }), null);
|
|
});
|
|
|
|
test("breaks: between heats, between rounds, before the finals (lunch) and an extra break before one heat", () => {
|
|
const start = new Date("2026-11-08T09:00:00").getTime();
|
|
const list = [
|
|
s("p1", "e2", "practice", "Practice 1"), s("p2", "e2", "practice", "Practice 2"),
|
|
s("q1", "e2", "qualification", "Q1 H1"), s("q2", "e2", "qualification", "Q1 H2"),
|
|
s("q3", "e2", "qualification", "Q2 H1"),
|
|
s("f1", "e2", "final", "B Final 1"), s("f2", "e2", "final", "A Final 1"),
|
|
];
|
|
const at = (plan, id) => (plan.find((row) => row.session.id === id).start - start) / 60000;
|
|
const day = { date: "2026-11-08", startAt: start, gapMin: 2, roundGapMin: 10, finalsGapMin: 45, breaks: { q3: 15 } };
|
|
const plan = buildDaySchedule(list, day, start - 3600000);
|
|
// 5-minute heats: p1 0, p2 7, round gap -> q1 22, q2 29, round gap + 15 extra -> q3 59, lunch -> f1 109, f2 116.
|
|
assert.deepEqual(list.map((x) => at(plan, x.id)), [0, 7, 22, 29, 59, 109, 116]);
|
|
assert.equal(plan.find((row) => row.session.id === "q3").breakMin, 25);
|
|
// Without round / finals gaps every break is the heat gap, as before.
|
|
const flat = buildDaySchedule(list, { date: "2026-11-08", startAt: start, gapMin: 2 }, start - 3600000);
|
|
assert.deepEqual(list.map((x) => at(flat, x.id)), [0, 7, 14, 21, 28, 35, 42]);
|
|
// No finals gap: the round gap is used before the finals.
|
|
const noLunch = buildDaySchedule(list, { ...day, finalsGapMin: null, breaks: {} }, start - 3600000);
|
|
assert.equal(at(noLunch, "f1") - at(noLunch, "q3"), 15);
|
|
});
|
|
|
|
test("finals created after a finished qualifier wait for the finals break, measured from the end of qualifying", () => {
|
|
const start = new Date("2026-11-08T09:00:00").getTime();
|
|
const qualEnd = start + 5 * 60000;
|
|
const list = [s("q1", "e2", "qualification", "Q1 H1", { status: "finished", startedAt: start, endedAt: qualEnd }), s("f1", "e2", "final", "A Final 1")];
|
|
const plan = buildDaySchedule(list, { date: "2026-11-08", startAt: start, gapMin: 2, finalsGapMin: 45 }, qualEnd + 20 * 60000);
|
|
assert.equal(plan[1].start, qualEnd + 45 * 60000, "finals made 20 min later still start 45 min after qualifying");
|
|
assert.equal(getAutopilotAction(plan, { day: {}, now: qualEnd + 20 * 60000 }).reason, "until");
|
|
});
|
|
|
|
test("race day plan keeps the round and finals gaps and drops empty breaks", () => {
|
|
const [day] = normalizeRaceDays([{ date: "2026-11-08", gapMin: 2, roundGapMin: "10", finalsGapMin: "", breaks: { q3: 15, q4: 0, "": 5 } }]);
|
|
assert.equal(day.roundGapMin, 10);
|
|
assert.equal(day.finalsGapMin, null);
|
|
assert.deepEqual(day.breaks, { q3: 15 });
|
|
});
|