mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor

Browse Source
This commit is contained in:
Marc Mintel
2025-12-16 12:14:06 +01:00
parent 9a891ac8b3
commit 7d3393e1b9
90 changed files with 20 additions and 974 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
core/racing/domain/services/DropScoreApplier.test.ts Normal file
View File

@@ -0,0 +1,88 @@
import { describe, it, expect } from 'vitest';
import { DropScoreApplier } from '@core/racing/domain/services/DropScoreApplier';
import type { EventPointsEntry } from '@core/racing/domain/services/DropScoreApplier';
import type { DropScorePolicy } from '@core/racing/domain/types/DropScorePolicy';
describe('DropScoreApplier', () => {
it('with strategy none counts all events and drops none', () => {
const applier = new DropScoreApplier();
const policy: DropScorePolicy = {
strategy: 'none',
};
const events: EventPointsEntry[] = [
{ eventId: 'event-1', points: 25 },
{ eventId: 'event-2', points: 18 },
{ eventId: 'event-3', points: 15 },
];
const result = applier.apply(policy, events);
expect(result.counted).toHaveLength(3);
expect(result.dropped).toHaveLength(0);
expect(result.totalPoints).toBe(25 + 18 + 15);
});
it('with bestNResults keeps the highest scoring events and drops the rest', () => {
const applier = new DropScoreApplier();
const policy: DropScorePolicy = {
strategy: 'bestNResults',
count: 6,
};
const events: EventPointsEntry[] = [
{ eventId: 'event-1', points: 25 },
{ eventId: 'event-2', points: 18 },
{ eventId: 'event-3', points: 15 },
{ eventId: 'event-4', points: 12 },
{ eventId: 'event-5', points: 10 },
{ eventId: 'event-6', points: 8 },
{ eventId: 'event-7', points: 6 },
{ eventId: 'event-8', points: 4 },
];
const result = applier.apply(policy, events);
expect(result.counted).toHaveLength(6);
expect(result.dropped).toHaveLength(2);
const countedIds = result.counted.map((e) => e.eventId);
expect(countedIds).toEqual([
'event-1',
'event-2',
'event-3',
'event-4',
'event-5',
'event-6',
]);
const droppedIds = result.dropped.map((e) => e.eventId);
expect(droppedIds).toEqual(['event-7', 'event-8']);
expect(result.totalPoints).toBe(25 + 18 + 15 + 12 + 10 + 8);
});
it('bestNResults with count greater than available events counts all of them', () => {
const applier = new DropScoreApplier();
const policy: DropScorePolicy = {
strategy: 'bestNResults',
count: 10,
};
const events: EventPointsEntry[] = [
{ eventId: 'event-1', points: 25 },
{ eventId: 'event-2', points: 18 },
{ eventId: 'event-3', points: 15 },
];
const result = applier.apply(policy, events);
expect(result.counted).toHaveLength(3);
expect(result.dropped).toHaveLength(0);
expect(result.totalPoints).toBe(25 + 18 + 15);
});
});

211
core/racing/domain/services/EventScoringService.test.ts Normal file
View File

@@ -0,0 +1,211 @@
import { describe, it, expect } from 'vitest';
import { EventScoringService } from '@core/racing/domain/services/EventScoringService';
import type { ParticipantRef } from '@core/racing/domain/types/ParticipantRef';
import type { SessionType } from '@core/racing/domain/types/SessionType';
import { PointsTable } from '@core/racing/domain/value-objects/PointsTable';
import type { BonusRule } from '@core/racing/domain/types/BonusRule';
import type { ChampionshipConfig } from '@core/racing/domain/types/ChampionshipConfig';
import { Result } from '@core/racing/domain/entities/Result';
import type { Penalty } from '@core/racing/domain/entities/Penalty';
import type { ChampionshipType } from '@core/racing/domain/types/ChampionshipType';
import { makeDriverRef } from '../../testing/factories/racing/DriverRefFactory';
import { makePointsTable } from '../../testing/factories/racing/PointsTableFactory';
import { makeChampionshipConfig } from '../../testing/factories/racing/ChampionshipConfigFactory';
describe('EventScoringService', () => {
const seasonId = 'season-1';
it('assigns base points based on finishing positions for a main race', () => {
const service = new EventScoringService();
const championship = makeChampionshipConfig({
id: 'champ-1',
name: 'Driver Championship',
sessionTypes: ['main'],
mainPoints: [25, 18, 15, 12, 10],
});
const results: Result[] = [
Result.create({
id: 'result-1',
raceId: 'race-1',
driverId: 'driver-1',
position: 1,
fastestLap: 90000,
incidents: 0,
startPosition: 1,
}),
Result.create({
id: 'result-2',
raceId: 'race-1',
driverId: 'driver-2',
position: 2,
fastestLap: 90500,
incidents: 0,
startPosition: 2,
}),
Result.create({
id: 'result-3',
raceId: 'race-1',
driverId: 'driver-3',
position: 3,
fastestLap: 91000,
incidents: 0,
startPosition: 3,
}),
Result.create({
id: 'result-4',
raceId: 'race-1',
driverId: 'driver-4',
position: 4,
fastestLap: 91500,
incidents: 0,
startPosition: 4,
}),
Result.create({
id: 'result-5',
raceId: 'race-1',
driverId: 'driver-5',
position: 5,
fastestLap: 92000,
incidents: 0,
startPosition: 5,
}),
];
const penalties: Penalty[] = [];
const points = service.scoreSession({
seasonId,
championship,
sessionType: 'main',
results,
penalties,
});
const byParticipant = new Map(points.map((p) => [p.participant.id, p]));
expect(byParticipant.get('driver-1')?.basePoints).toBe(25);
expect(byParticipant.get('driver-2')?.basePoints).toBe(18);
expect(byParticipant.get('driver-3')?.basePoints).toBe(15);
expect(byParticipant.get('driver-4')?.basePoints).toBe(12);
expect(byParticipant.get('driver-5')?.basePoints).toBe(10);
for (const entry of byParticipant.values()) {
expect(entry.bonusPoints).toBe(0);
expect(entry.penaltyPoints).toBe(0);
expect(entry.totalPoints).toBe(entry.basePoints);
}
});
it('applies fastest lap bonus only when inside top 10', () => {
const service = new EventScoringService();
const fastestLapBonus: BonusRule = {
id: 'bonus-fastest-lap',
type: 'fastestLap',
points: 1,
requiresFinishInTopN: 10,
};
const championship = makeChampionshipConfig({
id: 'champ-1',
name: 'Driver Championship',
sessionTypes: ['main'],
mainPoints: [25, 18, 15, 12, 10, 8, 6, 4, 2, 1],
mainBonusRules: [fastestLapBonus],
});
const baseResultTemplate = {
raceId: 'race-1',
incidents: 0,
} as const;
const resultsP11Fastest: Result[] = [
Result.create({
id: 'result-1',
...baseResultTemplate,
driverId: 'driver-1',
position: 1,
startPosition: 1,
fastestLap: 91000,
}),
Result.create({
id: 'result-2',
...baseResultTemplate,
driverId: 'driver-2',
position: 2,
startPosition: 2,
fastestLap: 90500,
}),
Result.create({
id: 'result-3',
...baseResultTemplate,
driverId: 'driver-3',
position: 11,
startPosition: 15,
fastestLap: 90000,
}),
];
const penalties: Penalty[] = [];
const pointsNoBonus = service.scoreSession({
seasonId,
championship,
sessionType: 'main',
results: resultsP11Fastest,
penalties,
});
const mapNoBonus = new Map(pointsNoBonus.map((p) => [p.participant.id, p]));
expect(mapNoBonus.get('driver-3')?.bonusPoints).toBe(0);
const resultsP8Fastest: Result[] = [
Result.create({
id: 'result-1',
...baseResultTemplate,
driverId: 'driver-1',
position: 1,
startPosition: 1,
fastestLap: 91000,
}),
Result.create({
id: 'result-2',
...baseResultTemplate,
driverId: 'driver-2',
position: 2,
startPosition: 2,
fastestLap: 90500,
}),
Result.create({
id: 'result-3',
...baseResultTemplate,
driverId: 'driver-3',
position: 8,
startPosition: 15,
fastestLap: 90000,
}),
];
const pointsWithBonus = service.scoreSession({
seasonId,
championship,
sessionType: 'main',
results: resultsP8Fastest,
penalties,
});
const mapWithBonus = new Map(pointsWithBonus.map((p) => [p.participant.id, p]));
expect(mapWithBonus.get('driver-3')?.bonusPoints).toBe(1);
expect(mapWithBonus.get('driver-3')?.totalPoints).toBe(
(mapWithBonus.get('driver-3')?.basePoints || 0) +
(mapWithBonus.get('driver-3')?.bonusPoints || 0) -
(mapWithBonus.get('driver-3')?.penaltyPoints || 0),
);
});
});

278
core/racing/domain/services/ScheduleCalculator.test.ts Normal file
View File

@@ -0,0 +1,278 @@
import { describe, it, expect } from 'vitest';
import { calculateRaceDates, getNextWeekday, type ScheduleConfig } from '@core/racing/domain/services/ScheduleCalculator';
import type { Weekday } from '@core/racing/domain/types/Weekday';
describe('ScheduleCalculator', () => {
describe('calculateRaceDates', () => {
describe('with empty or invalid input', () => {
it('should return empty array when weekdays is empty', () => {
// Given
const config: ScheduleConfig = {
weekdays: [],
frequency: 'weekly',
rounds: 8,
startDate: new Date('2024-01-01'),
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates).toEqual([]);
expect(result.seasonDurationWeeks).toBe(0);
});
it('should return empty array when rounds is 0', () => {
// Given
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'weekly',
rounds: 0,
startDate: new Date('2024-01-01'),
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates).toEqual([]);
});
it('should return empty array when rounds is negative', () => {
// Given
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'weekly',
rounds: -5,
startDate: new Date('2024-01-01'),
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates).toEqual([]);
});
});
describe('weekly scheduling', () => {
it('should schedule 8 races on Saturdays starting from a Saturday', () => {
// Given - January 6, 2024 is a Saturday
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'weekly',
rounds: 8,
startDate: new Date('2024-01-06'),
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates.length).toBe(8);
// All dates should be Saturdays
result.raceDates.forEach(date => {
expect(date.getDay()).toBe(6); // Saturday
});
// First race should be Jan 6
expect(result.raceDates[0]!.toISOString().split('T')[0]).toBe('2024-01-06');
// Last race should be 7 weeks later (Feb 24)
expect(result.raceDates[7]!.toISOString().split('T')[0]).toBe('2024-02-24');
});
it('should schedule races on multiple weekdays', () => {
// Given
const config: ScheduleConfig = {
weekdays: ['Wed', 'Sat'] as Weekday[],
frequency: 'weekly',
rounds: 8,
startDate: new Date('2024-01-01'), // Monday
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates.length).toBe(8);
// Should alternate between Wednesday and Saturday
result.raceDates.forEach(date => {
const day = date.getDay();
expect([3, 6]).toContain(day); // Wed=3, Sat=6
});
});
it('should schedule 8 races on Sundays', () => {
// Given - January 7, 2024 is a Sunday
const config: ScheduleConfig = {
weekdays: ['Sun'] as Weekday[],
frequency: 'weekly',
rounds: 8,
startDate: new Date('2024-01-01'),
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates.length).toBe(8);
result.raceDates.forEach(date => {
expect(date.getDay()).toBe(0); // Sunday
});
});
});
describe('bi-weekly scheduling', () => {
it('should schedule races every 2 weeks on Saturdays', () => {
// Given - January 6, 2024 is a Saturday
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'everyNWeeks',
rounds: 4,
startDate: new Date('2024-01-06'),
intervalWeeks: 2,
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates.length).toBe(4);
// First race Jan 6
expect(result.raceDates[0]!.toISOString().split('T')[0]).toBe('2024-01-06');
// Second race 2 weeks later (Jan 20)
expect(result.raceDates[1]!.toISOString().split('T')[0]).toBe('2024-01-20');
// Third race 2 weeks later (Feb 3)
expect(result.raceDates[2]!.toISOString().split('T')[0]).toBe('2024-02-03');
// Fourth race 2 weeks later (Feb 17)
expect(result.raceDates[3]!.toISOString().split('T')[0]).toBe('2024-02-17');
});
});
describe('with start and end dates', () => {
it('should evenly distribute races across the date range', () => {
// Given - 3 month season
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'weekly',
rounds: 8,
startDate: new Date('2024-01-06'),
endDate: new Date('2024-03-30'),
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates.length).toBe(8);
// First race should be at or near start
expect(result.raceDates[0]!.toISOString().split('T')[0]).toBe('2024-01-06');
// Races should be spread across the range, not consecutive weeks
});
it('should use all available days if fewer than rounds requested', () => {
// Given - short period with only 3 Saturdays
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'weekly',
rounds: 10,
startDate: new Date('2024-01-06'),
endDate: new Date('2024-01-21'),
};
// When
const result = calculateRaceDates(config);
// Then
// Only 3 Saturdays in this range: Jan 6, 13, 20
expect(result.raceDates.length).toBe(3);
});
});
describe('season duration calculation', () => {
it('should calculate correct season duration in weeks', () => {
// Given
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'weekly',
rounds: 8,
startDate: new Date('2024-01-06'),
};
// When
const result = calculateRaceDates(config);
// Then
// 8 races, 1 week apart = 7 weeks duration
expect(result.seasonDurationWeeks).toBe(7);
});
it('should return 0 duration for single race', () => {
// Given
const config: ScheduleConfig = {
weekdays: ['Sat'] as Weekday[],
frequency: 'weekly',
rounds: 1,
startDate: new Date('2024-01-06'),
};
// When
const result = calculateRaceDates(config);
// Then
expect(result.raceDates.length).toBe(1);
expect(result.seasonDurationWeeks).toBe(0);
});
});
});
describe('getNextWeekday', () => {
it('should return next Saturday from a Monday', () => {
// Given - January 1, 2024 is a Monday
const fromDate = new Date('2024-01-01');
// When
const result = getNextWeekday(fromDate, 'Sat');
// Then
expect(result.toISOString().split('T')[0]).toBe('2024-01-06');
expect(result.getDay()).toBe(6);
});
it('should return next occurrence when already on that weekday', () => {
// Given - January 6, 2024 is a Saturday
const fromDate = new Date('2024-01-06');
// When
const result = getNextWeekday(fromDate, 'Sat');
// Then
// Should return NEXT Saturday (7 days later), not same day
expect(result.toISOString().split('T')[0]).toBe('2024-01-13');
});
it('should return next Sunday from a Friday', () => {
// Given - January 5, 2024 is a Friday
const fromDate = new Date('2024-01-05');
// When
const result = getNextWeekday(fromDate, 'Sun');
// Then
expect(result.toISOString().split('T')[0]).toBe('2024-01-07');
expect(result.getDay()).toBe(0);
});
it('should return next Wednesday from a Thursday', () => {
// Given - January 4, 2024 is a Thursday
const fromDate = new Date('2024-01-04');
// When
const result = getNextWeekday(fromDate, 'Wed');
// Then
// Next Wednesday is 6 days later
expect(result.toISOString().split('T')[0]).toBe('2024-01-10');
expect(result.getDay()).toBe(3);
});
});
});