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

core tests

Browse Source
This commit is contained in:
Marc Mintel
2026-01-24 12:18:31 +01:00
parent 3bef15f3bd
commit 5da14b1b21
15 changed files with 809 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

320
core/racing/domain/services/ScheduleCalculator.test.ts
View File

@@ -1,278 +1,72 @@
import { calculateRaceDates, getNextWeekday, type ScheduleConfig } from '@core/racing/domain/services/ScheduleCalculator';
import type { Weekday } from '@core/racing/domain/types/Weekday';
import { describe, expect, it } from 'vitest';
import { describe, it, expect } from 'vitest';
import { calculateRaceDates, getNextWeekday, ScheduleConfig } from './ScheduleCalculator';
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([]);
});
it('should return empty array if no weekdays or rounds', () => {
const config: ScheduleConfig = {
weekdays: [],
frequency: 'weekly',
rounds: 10,
startDate: new Date('2024-01-01'),
};
expect(calculateRaceDates(config).raceDates).toHaveLength(0);
});
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
});
});
it('should schedule weekly races', () => {
const config: ScheduleConfig = {
weekdays: ['Mon'],
frequency: 'weekly',
rounds: 3,
startDate: new Date('2024-01-01'), // Monday
};
const result = calculateRaceDates(config);
expect(result.raceDates).toHaveLength(3);
expect(result.raceDates[0].getDay()).toBe(1);
expect(result.raceDates[1].getDay()).toBe(1);
expect(result.raceDates[2].getDay()).toBe(1);
// Check dates are 7 days apart
const diff = result.raceDates[1].getTime() - result.raceDates[0].getTime();
expect(diff).toBe(7 * 24 * 60 * 60 * 1000);
});
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');
});
it('should schedule bi-weekly races', () => {
const config: ScheduleConfig = {
weekdays: ['Mon'],
frequency: 'everyNWeeks',
intervalWeeks: 2,
rounds: 2,
startDate: new Date('2024-01-01'),
};
const result = calculateRaceDates(config);
expect(result.raceDates).toHaveLength(2);
const diff = result.raceDates[1].getTime() - result.raceDates[0].getTime();
expect(diff).toBe(14 * 24 * 60 * 60 * 1000);
});
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);
});
it('should distribute races between start and end date', () => {
const config: ScheduleConfig = {
weekdays: ['Mon', 'Wed', 'Fri'],
frequency: 'weekly',
rounds: 2,
startDate: new Date('2024-01-01'), // Mon
endDate: new Date('2024-01-15'), // Mon
};
const result = calculateRaceDates(config);
expect(result.raceDates).toHaveLength(2);
// Use getTime() to avoid timezone issues in comparison
const expectedDate = new Date('2024-01-01');
expectedDate.setHours(12, 0, 0, 0);
expect(result.raceDates[0].getTime()).toBe(expectedDate.getTime());
});
});
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);
it('should return the next Monday', () => {
const from = new Date('2024-01-01'); // Monday
const next = getNextWeekday(from, 'Mon');
expect(next.getDay()).toBe(1);
expect(next.getDate()).toBe(8);
});
});
});
});

12
core/racing/domain/services/SkillLevelService.test.ts
View File

@@ -8,19 +8,19 @@ describe('SkillLevelService', () => {
expect(SkillLevelService.getSkillLevel(5000)).toBe('pro');
});
it('should return advanced for rating >= 2500 and < 3000', () => {
it('should return advanced for rating >= 2500', () => {
expect(SkillLevelService.getSkillLevel(2500)).toBe('advanced');
expect(SkillLevelService.getSkillLevel(2999)).toBe('advanced');
});
it('should return intermediate for rating >= 1800 and < 2500', () => {
it('should return intermediate for rating >= 1800', () => {
expect(SkillLevelService.getSkillLevel(1800)).toBe('intermediate');
expect(SkillLevelService.getSkillLevel(2499)).toBe('intermediate');
});
it('should return beginner for rating < 1800', () => {
expect(SkillLevelService.getSkillLevel(1799)).toBe('beginner');
expect(SkillLevelService.getSkillLevel(500)).toBe('beginner');
expect(SkillLevelService.getSkillLevel(0)).toBe('beginner');
});
});
@@ -33,14 +33,12 @@ describe('SkillLevelService', () => {
expect(SkillLevelService.getTeamPerformanceLevel(4500)).toBe('pro');
});
it('should return advanced for rating >= 3000 and < 4500', () => {
it('should return advanced for rating >= 3000', () => {
expect(SkillLevelService.getTeamPerformanceLevel(3000)).toBe('advanced');
expect(SkillLevelService.getTeamPerformanceLevel(4499)).toBe('advanced');
});
it('should return intermediate for rating >= 2000 and < 3000', () => {
it('should return intermediate for rating >= 2000', () => {
expect(SkillLevelService.getTeamPerformanceLevel(2000)).toBe('intermediate');
expect(SkillLevelService.getTeamPerformanceLevel(2999)).toBe('intermediate');
});
it('should return beginner for rating < 2000', () => {

65
core/racing/domain/services/StrengthOfFieldCalculator.test.ts
View File

@@ -1,54 +1,35 @@
import { describe, it, expect } from 'vitest';
import { AverageStrengthOfFieldCalculator } from './StrengthOfFieldCalculator';
import { AverageStrengthOfFieldCalculator, DriverRating } from './StrengthOfFieldCalculator';
describe('AverageStrengthOfFieldCalculator', () => {
const calculator = new AverageStrengthOfFieldCalculator();
it('should calculate average SOF and round it', () => {
const ratings = [
{ driverId: 'd1', rating: 1500 },
{ driverId: 'd2', rating: 2000 },
{ driverId: 'd3', rating: 1750 },
];
const sof = calculator.calculate(ratings);
expect(sof).toBe(1750);
});
it('should handle rounding correctly', () => {
const ratings = [
{ driverId: 'd1', rating: 1000 },
{ driverId: 'd2', rating: 1001 },
];
const sof = calculator.calculate(ratings);
expect(sof).toBe(1001); // (1000 + 1001) / 2 = 1000.5 -> 1001
});
it('should return null for empty ratings', () => {
it('should return null for empty list', () => {
expect(calculator.calculate([])).toBeNull();
});
it('should filter out non-positive ratings', () => {
const ratings = [
{ driverId: 'd1', rating: 1500 },
{ driverId: 'd2', rating: 0 },
{ driverId: 'd3', rating: -100 },
it('should return null if no valid ratings (>0)', () => {
const ratings: DriverRating[] = [
{ driverId: '1', rating: 0 },
{ driverId: '2', rating: -100 },
];
const sof = calculator.calculate(ratings);
expect(sof).toBe(1500);
});
it('should return null if all ratings are non-positive', () => {
const ratings = [
{ driverId: 'd1', rating: 0 },
{ driverId: 'd2', rating: -500 },
];
expect(calculator.calculate(ratings)).toBeNull();
});
it('should calculate average of valid ratings', () => {
const ratings: DriverRating[] = [
{ driverId: '1', rating: 1000 },
{ driverId: '2', rating: 2000 },
{ driverId: '3', rating: 0 }, // Should be ignored
];
expect(calculator.calculate(ratings)).toBe(1500);
});
it('should round the result', () => {
const ratings: DriverRating[] = [
{ driverId: '1', rating: 1000 },
{ driverId: '2', rating: 1001 },
];
expect(calculator.calculate(ratings)).toBe(1001); // (1000+1001)/2 = 1000.5 -> 1001
});
});