458 lines
19 KiB
JavaScript
458 lines
19 KiB
JavaScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import {
|
|
buildDriverActivePracticeStats,
|
|
buildDriverTrainingStats,
|
|
buildDriverTimingChannelStats,
|
|
buildTrainingAchievements,
|
|
buildTrainingMarkerComparisons,
|
|
buildTrainingPaceBuckets,
|
|
buildTrainingRecommendation,
|
|
buildTrainingStintAnalysis,
|
|
buildTrainingWeekdayStats,
|
|
getBestConsecutiveTrainingLaps,
|
|
getBestTrainingDurationResult,
|
|
getDriverTrainingLaps,
|
|
getNextTrainingMilestone,
|
|
getTrainingGoalProgress,
|
|
normalizeTrainingState,
|
|
splitTrainingStints,
|
|
syncTrainingLedger,
|
|
} from "../src/training_logic.js";
|
|
import { getDriverProfileGroups } from "../src/driver_profile_logic.js";
|
|
|
|
function createUid() {
|
|
let index = 0;
|
|
return (prefix) => `${prefix}_${++index}`;
|
|
}
|
|
|
|
test("normalization removes invalid and duplicate training records", () => {
|
|
const normalized = normalizeTrainingState({
|
|
goals: [
|
|
{ id: "goal_1", driverId: "driver_1", targetLaps: 500, title: " Bronze ", reward: " Badge " },
|
|
{ id: "goal_invalid", driverId: "", targetLaps: 100 },
|
|
],
|
|
ledger: [
|
|
{ id: "lap_1", sourceKey: "source_1", driverId: "driver_1", lapMs: 16000, timestamp: 1000 },
|
|
{ id: "lap_duplicate", sourceKey: "source_1", driverId: "driver_1", lapMs: 17000, timestamp: 2000 },
|
|
{ id: "lap_short", sourceKey: "source_2", driverId: "driver_1", lapMs: 500, timestamp: 3000 },
|
|
{ id: "lap_anonymous", sourceKey: "source_3", driverId: "", lapMs: 18000, timestamp: 4000 },
|
|
],
|
|
shares: [
|
|
{ driverId: "driver_1", token: "a".repeat(24), enabled: true },
|
|
{ driverId: "driver_1", token: "b".repeat(24), enabled: true },
|
|
{ driverId: "driver_2", token: "short", enabled: true },
|
|
],
|
|
markers: [
|
|
{ id: "marker_1", driverId: "driver_1", classId: "class_1", timestamp: 5000, type: "tires", note: " New tires " },
|
|
{ id: "marker_invalid", driverId: "", classId: "class_1", timestamp: 5000 },
|
|
],
|
|
}, { uid: createUid() });
|
|
|
|
assert.equal(normalized.goals.length, 1);
|
|
assert.equal(normalized.goals[0].title, "Bronze");
|
|
assert.equal(normalized.goals[0].reward, "Badge");
|
|
assert.deepEqual(normalized.ledger.map((lap) => lap.id), ["lap_1"]);
|
|
assert.deepEqual(normalized.shares.map((share) => share.token), ["a".repeat(24)]);
|
|
assert.equal(normalized.markers.length, 1);
|
|
assert.equal(normalized.markers[0].note, "New tires");
|
|
});
|
|
|
|
test("ledger sync retains archived laps and rebuilds current session laps", () => {
|
|
const training = {
|
|
goals: [{ id: "goal_1", driverId: "driver_1", targetLaps: 100 }],
|
|
shares: [{ driverId: "driver_1", token: "s".repeat(24), enabled: true }],
|
|
ledger: [
|
|
{ id: "archived", sourceKey: "old:1", sessionId: "old", driverId: "driver_1", lapMs: 19000, timestamp: 1000 },
|
|
{ id: "stale", sourceKey: "live:old", sessionId: "live", driverId: "driver_1", lapMs: 30000, timestamp: 2000 },
|
|
],
|
|
markers: [{ id: "marker_1", driverId: "driver_1", classId: "class_1", timestamp: 2500, type: "setup" }],
|
|
};
|
|
const state = {
|
|
sessions: [{ id: "live", name: "Free Practice", eventId: "event_1" }],
|
|
events: [{ id: "event_1", name: "Club practice" }],
|
|
resultsBySession: {
|
|
live: {
|
|
passings: [
|
|
{ driverId: "driver_1", competitorKey: "driver_1", lapMs: 16500, timestamp: 3000, validLap: true },
|
|
{ driverId: "driver_1", competitorKey: "driver_1", lapMs: 9000, timestamp: 4000, validLap: false },
|
|
{ driverId: "", competitorKey: "anonymous", lapMs: 17000, timestamp: 5000, validLap: true },
|
|
{ driverId: "driver_1", competitorKey: "driver_1", lapMs: 500, timestamp: 6000, validLap: true },
|
|
],
|
|
},
|
|
},
|
|
};
|
|
|
|
const synced = syncTrainingLedger(training, state, { uid: createUid() });
|
|
|
|
assert.equal(synced.ledger.length, 2);
|
|
assert.equal(synced.ledger.some((lap) => lap.id === "archived"), true);
|
|
assert.equal(synced.ledger.some((lap) => lap.id === "stale"), false);
|
|
const liveLap = synced.ledger.find((lap) => lap.sessionId === "live");
|
|
assert.equal(liveLap.lapMs, 16500);
|
|
assert.equal(liveLap.sessionName, "Free Practice");
|
|
assert.equal(liveLap.eventName, "Club practice");
|
|
assert.equal(synced.goals.length, 1);
|
|
assert.equal(synced.shares.length, 1);
|
|
assert.equal(synced.markers.length, 1);
|
|
});
|
|
|
|
test("driver statistics remain isolated and aggregate days and sessions", () => {
|
|
const firstDay = new Date(2026, 0, 10, 12, 0, 0).getTime();
|
|
const secondDay = new Date(2026, 0, 11, 12, 0, 0).getTime();
|
|
const state = {
|
|
training: {
|
|
ledger: [
|
|
{ driverId: "driver_1", sessionId: "practice_1", timestamp: firstDay, lapMs: 18000 },
|
|
{ driverId: "driver_1", sessionId: "practice_1", timestamp: firstDay + 20000, lapMs: 16500 },
|
|
{ driverId: "driver_1", sessionId: "practice_2", timestamp: secondDay, lapMs: 17000 },
|
|
{ driverId: "driver_2", sessionId: "practice_2", timestamp: secondDay + 20000, lapMs: 12000 },
|
|
],
|
|
},
|
|
};
|
|
|
|
assert.equal(getDriverTrainingLaps(state, "driver_1").length, 3);
|
|
const stats = buildDriverTrainingStats(state, "driver_1");
|
|
assert.equal(stats.totalLaps, 3);
|
|
assert.equal(stats.totalSessions, 2);
|
|
assert.equal(stats.trainingDays, 2);
|
|
assert.equal(stats.bestLapMs, 16500);
|
|
assert.equal(stats.averageLapMs, 17167);
|
|
assert.equal(stats.controlledLapStreak, 2);
|
|
assert.equal(stats.dailySummaries[0].laps, 1);
|
|
assert.equal(stats.dailySummaries[1].laps, 2);
|
|
});
|
|
|
|
test("split and pit statistics aggregate by personal profile and selected class", () => {
|
|
const state = {
|
|
drivers: [
|
|
{ id: "driver_2wd_a", name: "Driver", profileId: "profile_1", classId: "class_2wd" },
|
|
{ id: "driver_2wd_b", name: "Driver", profileId: "profile_1", classId: "class_2wd" },
|
|
{ id: "driver_4wd", name: "Driver", profileId: "profile_1", classId: "class_4wd" },
|
|
],
|
|
sessions: [
|
|
{ id: "session_1", name: "Practice", eventId: "event_1" },
|
|
{ id: "session_2", name: "Endurance", eventId: "event_1" },
|
|
],
|
|
events: [{ id: "event_1", name: "Club day" }],
|
|
resultsBySession: {
|
|
session_1: {
|
|
splits: [
|
|
{ driverId: "driver_2wd_a", splitMs: 8100, timestamp: 1000 },
|
|
{ driverId: "driver_2wd_b", splitMs: 7900, timestamp: 2000 },
|
|
{ driverId: "driver_4wd", splitMs: 6500, timestamp: 3000 },
|
|
],
|
|
pitStops: [],
|
|
},
|
|
session_2: {
|
|
splits: [],
|
|
pitStops: [
|
|
{ driverId: "driver_2wd_a", pitStopMs: 12500, enteredAt: 4000 },
|
|
{ driverId: "driver_2wd_b", pitStopMs: 9500, enteredAt: 5000 },
|
|
{ driverId: "driver_4wd", pitStopMs: 7000, enteredAt: 6000 },
|
|
],
|
|
},
|
|
},
|
|
};
|
|
|
|
const stats = buildDriverTimingChannelStats(state, "profile_1", "class_2wd");
|
|
assert.equal(stats.splitCount, 2);
|
|
assert.equal(stats.bestSplitMs, 7900);
|
|
assert.equal(stats.averageSplitMs, 8000);
|
|
assert.equal(stats.pitStopCount, 2);
|
|
assert.equal(stats.totalPitMs, 22000);
|
|
assert.equal(stats.bestPitStopMs, 9500);
|
|
assert.equal(stats.recentPitStops[0].sessionName, "Endurance");
|
|
});
|
|
|
|
test("one driver profile combines transponders within a class but keeps 2WD and 4WD separate", () => {
|
|
const state = {
|
|
drivers: [
|
|
{ id: "driver_2wd_a", name: "Same Driver", profileId: "profile_same", classId: "class_2wd" },
|
|
{ id: "driver_2wd_b", name: "Same Driver", profileId: "profile_same", classId: "class_2wd" },
|
|
{ id: "driver_4wd", name: "Same Driver", profileId: "profile_same", classId: "class_4wd" },
|
|
],
|
|
training: {
|
|
ledger: [
|
|
{ driverId: "driver_2wd_a", sessionId: "practice", timestamp: 10_000, lapMs: 18_000 },
|
|
{ driverId: "driver_2wd_b", sessionId: "practice", timestamp: 30_000, lapMs: 17_500 },
|
|
{ driverId: "driver_4wd", sessionId: "practice", timestamp: 50_000, lapMs: 15_000 },
|
|
],
|
|
},
|
|
};
|
|
|
|
const twoWheelDrive = buildDriverTrainingStats(state, "profile_same", "class_2wd");
|
|
const fourWheelDrive = buildDriverTrainingStats(state, "profile_same", "class_4wd");
|
|
|
|
assert.equal(twoWheelDrive.totalLaps, 2);
|
|
assert.equal(twoWheelDrive.bestLapMs, 17_500);
|
|
assert.equal(fourWheelDrive.totalLaps, 1);
|
|
assert.equal(fourWheelDrive.bestLapMs, 15_000);
|
|
});
|
|
|
|
test("legacy same-name entries share a profile while an explicit profile can remain separate", () => {
|
|
const groups = getDriverProfileGroups({
|
|
drivers: [
|
|
{ id: "legacy_2wd", name: "Test Driver", classId: "2wd", club: "JMK RB", country: "Sverige" },
|
|
{ id: "legacy_4wd", name: " test driver ", classId: "4wd" },
|
|
{ id: "separate", name: "Test Driver", profileId: "profile_other", classId: "2wd" },
|
|
],
|
|
});
|
|
|
|
assert.equal(groups.length, 2);
|
|
assert.equal(groups.find((group) => group.id.startsWith("legacy:"))?.drivers.length, 2);
|
|
assert.equal(groups.find((group) => group.id.startsWith("legacy:"))?.club, "JMK RB");
|
|
assert.equal(groups.find((group) => group.id.startsWith("legacy:"))?.country, "Sverige");
|
|
assert.equal(groups.find((group) => group.id === "profile_other")?.drivers.length, 1);
|
|
});
|
|
|
|
test("active practice profile statistics include only linked entries in the selected class", () => {
|
|
const state = {
|
|
activeSessionId: "practice",
|
|
drivers: [
|
|
{ id: "two_a", name: "Driver", profileId: "profile", classId: "2wd" },
|
|
{ id: "two_b", name: "Driver", profileId: "profile", classId: "2wd" },
|
|
{ id: "four", name: "Driver", profileId: "profile", classId: "4wd" },
|
|
],
|
|
sessions: [{ id: "practice", name: "Open", type: "open_practice", status: "running", startedAt: 1_000 }],
|
|
resultsBySession: {
|
|
practice: {
|
|
passings: [
|
|
{ driverId: "two_a", timestamp: 20_000, lapMs: 18_000, validLap: true },
|
|
{ driverId: "two_b", timestamp: 39_000, lapMs: 17_500, validLap: true },
|
|
{ driverId: "four", timestamp: 55_000, lapMs: 15_000, validLap: true },
|
|
],
|
|
},
|
|
},
|
|
};
|
|
|
|
const stats = buildDriverActivePracticeStats(state, "profile", 60_000, "2wd");
|
|
assert.equal(stats.laps, 2);
|
|
assert.equal(stats.bestLapMs, 17_500);
|
|
});
|
|
|
|
test("active practice stats include only the selected driver's current valid laps", () => {
|
|
const startedAt = 10_000;
|
|
const state = {
|
|
activeSessionId: "practice_1",
|
|
sessions: [{ id: "practice_1", name: "Wednesday Open Practice", type: "open_practice", status: "running", startedAt }],
|
|
resultsBySession: {
|
|
practice_1: {
|
|
passings: [
|
|
{ driverId: "driver_1", timestamp: 9_000, lapMs: 15_000, validLap: true },
|
|
{ driverId: "driver_1", timestamp: 20_000, lapMs: 16_000, validLap: true },
|
|
{ driverId: "driver_1", timestamp: 37_000, lapMs: 17_000, validLap: true },
|
|
{ driverId: "driver_1", timestamp: 45_000, lapMs: 8_000, validLap: false },
|
|
{ driverId: "driver_2", timestamp: 54_000, lapMs: 16_500, validLap: true },
|
|
],
|
|
},
|
|
},
|
|
};
|
|
|
|
assert.deepEqual(buildDriverActivePracticeStats(state, "driver_1", 70_000), {
|
|
sessionId: "practice_1",
|
|
sessionName: "Wednesday Open Practice",
|
|
startedAt,
|
|
elapsedMs: 60_000,
|
|
laps: 2,
|
|
bestLapMs: 16_000,
|
|
averageLapMs: 16_500,
|
|
lastLapMs: 17_000,
|
|
});
|
|
});
|
|
|
|
test("active practice stats ignore races and stopped practice sessions", () => {
|
|
const base = { activeSessionId: "session_1", resultsBySession: {} };
|
|
assert.equal(buildDriverActivePracticeStats({ ...base, sessions: [{ id: "session_1", type: "final", status: "running" }] }, "driver_1"), null);
|
|
assert.equal(buildDriverActivePracticeStats({ ...base, sessions: [{ id: "session_1", type: "free_practice", status: "finished" }] }, "driver_1"), null);
|
|
});
|
|
|
|
test("training stints split after a break over two minutes or a session change", () => {
|
|
const laps = [
|
|
{ sessionId: "practice_1", timestamp: 18_000, lapMs: 18_000 },
|
|
{ sessionId: "practice_1", timestamp: 36_000, lapMs: 18_000 },
|
|
{ sessionId: "practice_1", timestamp: 200_001, lapMs: 164_001 },
|
|
{ sessionId: "practice_2", timestamp: 218_001, lapMs: 18_000 },
|
|
];
|
|
const stints = splitTrainingStints(laps);
|
|
|
|
assert.equal(stints.length, 3);
|
|
assert.equal(stints[0].laps.length, 2);
|
|
assert.equal(stints[1].laps.length, 1);
|
|
assert.equal(stints[1].laps[0].excludedFromPace, true);
|
|
assert.equal(stints[2].sessionId, "practice_2");
|
|
});
|
|
|
|
test("best consecutive laps never cross a stint boundary", () => {
|
|
const stints = splitTrainingStints([
|
|
{ sessionId: "practice_1", timestamp: 18_000, lapMs: 18_000 },
|
|
{ sessionId: "practice_1", timestamp: 35_000, lapMs: 17_000 },
|
|
{ sessionId: "practice_1", timestamp: 51_000, lapMs: 16_000 },
|
|
{ sessionId: "practice_1", timestamp: 66_000, lapMs: 15_000 },
|
|
{ sessionId: "practice_1", timestamp: 201_001, lapMs: 15_000 },
|
|
]);
|
|
const best = getBestConsecutiveTrainingLaps(stints, 3);
|
|
|
|
assert.equal(best.totalMs, 48_000);
|
|
assert.equal(best.averageLapMs, 16_000);
|
|
assert.equal(best.startedAt, 18_000);
|
|
});
|
|
|
|
test("best five-minute result counts a final lap started before the cutoff and reports its pace", () => {
|
|
const laps = Array.from({ length: 16 }, (_, index) => ({
|
|
sessionId: "practice_1",
|
|
timestamp: (index + 1) * 18_000,
|
|
lapMs: 18_000,
|
|
}));
|
|
laps.push({ sessionId: "practice_1", timestamp: 314_123, lapMs: 26_123 });
|
|
const result = getBestTrainingDurationResult(splitTrainingStints(laps), 300_000);
|
|
|
|
assert.equal(result.lapCount, 17);
|
|
assert.equal(result.totalMs, 314_123);
|
|
assert.equal(result.averageLapMs, 18_478);
|
|
assert.equal(result.startedAt, 0);
|
|
assert.equal(result.endedAt, 314_123);
|
|
});
|
|
|
|
test("a stint shorter than the target duration has no five-minute result", () => {
|
|
const stints = splitTrainingStints([
|
|
{ sessionId: "practice_1", timestamp: 18_000, lapMs: 18_000 },
|
|
{ sessionId: "practice_1", timestamp: 36_000, lapMs: 18_000 },
|
|
]);
|
|
assert.equal(getBestTrainingDurationResult(stints, 300_000), null);
|
|
});
|
|
|
|
test("recommendations select baseline, consistency, and progression", () => {
|
|
assert.equal(buildTrainingRecommendation({ totalLaps: 9 }).level, "baseline");
|
|
assert.deepEqual(
|
|
buildTrainingRecommendation({ totalLaps: 30, recentLapCount: 30, consistencySpreadPct: 9, bestLapMs: 16000 }),
|
|
{
|
|
level: "consistency",
|
|
titleKey: "training.plan_consistency_title",
|
|
bodyKey: "training.plan_consistency_body",
|
|
targetLapMs: 17280,
|
|
}
|
|
);
|
|
assert.equal(buildTrainingRecommendation({ totalLaps: 30, recentLapCount: 30, consistencySpreadPct: 4, bestLapMs: 16000 }).level, "progression");
|
|
});
|
|
|
|
test("goal and automatic milestone progress are bounded", () => {
|
|
assert.deepEqual(getTrainingGoalProgress({ targetLaps: 500 }, { totalLaps: 125 }), {
|
|
currentLaps: 125,
|
|
targetLaps: 500,
|
|
remainingLaps: 375,
|
|
percent: 25,
|
|
reached: false,
|
|
});
|
|
assert.equal(getTrainingGoalProgress({ targetLaps: 100 }, { totalLaps: 150 }).percent, 100);
|
|
assert.equal(getTrainingGoalProgress({ targetLaps: 100 }, { totalLaps: 150 }).reached, true);
|
|
assert.equal(getNextTrainingMilestone({ totalLaps: 250 }).targetLaps, 500);
|
|
assert.equal(getNextTrainingMilestone({ totalLaps: 5200 }).targetLaps, 6000);
|
|
});
|
|
|
|
test("development trend compares the latest 30 laps with the preceding 30", () => {
|
|
const start = new Date(2026, 0, 10, 12, 0, 0).getTime();
|
|
const ledger = Array.from({ length: 60 }, (_, index) => ({
|
|
driverId: "driver_1",
|
|
sessionId: "practice_1",
|
|
timestamp: start + ((index + 1) * 18_000),
|
|
lapMs: index < 30 ? 18_000 : 17_000,
|
|
}));
|
|
const stats = buildDriverTrainingStats({ training: { ledger } }, "driver_1");
|
|
|
|
assert.equal(stats.trendSampleReady, true);
|
|
assert.equal(stats.previousRecentAverageMs, 18_000);
|
|
assert.equal(stats.recentAverageMs, 17_000);
|
|
assert.equal(stats.averageTrendMs, 1_000);
|
|
assert.equal(stats.consistencyTrendPct, 0);
|
|
});
|
|
|
|
test("automatic achievements expose unlocked and upcoming personal goals", () => {
|
|
const achievements = buildTrainingAchievements({
|
|
totalSessions: 2,
|
|
totalLaps: 520,
|
|
trainingDays: 4,
|
|
controlledLapStreak: 7,
|
|
bestFiveMinuteResult: { lapCount: 17 },
|
|
});
|
|
|
|
assert.equal(achievements.find((item) => item.id === "first_session").unlocked, true);
|
|
assert.equal(achievements.find((item) => item.id === "laps_500").unlocked, true);
|
|
assert.equal(achievements.find((item) => item.id === "laps_1000").percent, 52);
|
|
assert.equal(achievements.find((item) => item.id === "days_10").unlocked, false);
|
|
assert.equal(achievements.find((item) => item.id === "five_minute").unlocked, true);
|
|
});
|
|
|
|
test("pace buckets use a trimmed average and keep classes isolated", () => {
|
|
const start = new Date(2026, 7, 23, 12, 0, 0).getTime();
|
|
const twoWheelLaps = [10_000, ...Array.from({ length: 10 }, () => 20_000), 60_000];
|
|
const state = {
|
|
drivers: [
|
|
{ id: "driver_2wd", profileId: "profile", classId: "2wd" },
|
|
{ id: "driver_4wd", profileId: "profile", classId: "4wd" },
|
|
],
|
|
training: {
|
|
ledger: [
|
|
...twoWheelLaps.map((lapMs, index) => ({ driverId: "driver_2wd", sessionId: "practice", timestamp: start + index * 60_000, lapMs })),
|
|
{ driverId: "driver_4wd", sessionId: "practice", timestamp: start + 60_000, lapMs: 14_000 },
|
|
],
|
|
markers: [],
|
|
},
|
|
};
|
|
const buckets = buildTrainingPaceBuckets(state, "profile", "2wd", 30);
|
|
const weekdays = buildTrainingWeekdayStats(state, "profile", "2wd");
|
|
|
|
assert.equal(buckets.length, 1);
|
|
assert.equal(buckets[0].lapCount, 12);
|
|
assert.equal(buckets[0].paceMs, 20_000);
|
|
assert.equal(weekdays.find((day) => day.weekday === 0).lapCount, 12);
|
|
});
|
|
|
|
test("setup markers compare only the selected class before and after the change", () => {
|
|
const markerAt = new Date(2026, 7, 23, 13, 0, 0).getTime();
|
|
const state = {
|
|
drivers: [
|
|
{ id: "driver_2wd", profileId: "profile", classId: "2wd" },
|
|
{ id: "driver_4wd", profileId: "profile", classId: "4wd" },
|
|
],
|
|
training: {
|
|
ledger: [
|
|
...[25, 20, 15].map((minutes, index) => ({ driverId: "driver_2wd", timestamp: markerAt - minutes * 60_000, lapMs: 20_000 + index * 100 })),
|
|
...[5, 10, 15].map((minutes, index) => ({ driverId: "driver_2wd", timestamp: markerAt + minutes * 60_000, lapMs: 18_000 + index * 100 })),
|
|
{ driverId: "driver_4wd", timestamp: markerAt + 60_000, lapMs: 12_000 },
|
|
],
|
|
markers: [{ id: "marker", driverId: "driver_2wd", classId: "2wd", timestamp: markerAt, type: "tires" }],
|
|
},
|
|
};
|
|
const [comparison] = buildTrainingMarkerComparisons(state, "profile", "2wd", 30);
|
|
|
|
assert.equal(comparison.beforeLapCount, 3);
|
|
assert.equal(comparison.afterLapCount, 3);
|
|
assert.equal(comparison.beforePaceMs, 20_100);
|
|
assert.equal(comparison.afterPaceMs, 18_100);
|
|
assert.equal(comparison.improvementMs, 2_000);
|
|
});
|
|
|
|
test("stint analysis hides race pace 10 for short stints and flags slow laps", () => {
|
|
const firstStart = new Date(2026, 7, 23, 12, 0, 0).getTime();
|
|
const firstLaps = [...Array.from({ length: 10 }, () => 18_000), 30_000];
|
|
let timestamp = firstStart;
|
|
const ledger = firstLaps.map((lapMs) => {
|
|
timestamp += lapMs;
|
|
return { driverId: "driver", sessionId: "practice", timestamp, lapMs };
|
|
});
|
|
ledger.push({ driverId: "driver", sessionId: "practice", timestamp: timestamp + 180_001, lapMs: 18_000 });
|
|
ledger.push({ driverId: "driver", sessionId: "practice", timestamp: timestamp + 198_001, lapMs: 18_000 });
|
|
const analysis = buildTrainingStintAnalysis({ training: { ledger } }, "driver");
|
|
|
|
assert.equal(analysis.rows.length, 2);
|
|
const longStint = analysis.rows.find((row) => row.lapCount === 11);
|
|
const shortStint = analysis.rows.find((row) => row.lapCount === 2);
|
|
assert.equal(longStint.racePace10Ms, 18_000);
|
|
assert.equal(longStint.mistakes, 1);
|
|
assert.equal(shortStint.racePace10Ms, 0);
|
|
assert.equal(shortStint.consistencyPct, null);
|
|
assert.equal(shortStint.insufficient, true);
|
|
});
|