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

integration tests
Some checks failed
CI / lint-typecheck (pull_request) Failing after 4m51s
Details
CI / tests (pull_request) Has been skipped
Details
CI / contract-tests (pull_request) Has been skipped
Details
CI / e2e-tests (pull_request) Has been skipped
Details
CI / comment-pr (pull_request) Has been skipped
Details
CI / commit-types (pull_request) Has been skipped
Details

Browse Source
This commit is contained in:
Marc Mintel
2026-01-24 01:13:49 +01:00
parent 9bb6b228f1
commit 9ccecbf3bb
25 changed files with 895 additions and 2688 deletions
Download Patch File Download Diff File Expand all files Collapse all files

786
tests/integration/rating/rating-reliability-use-cases.integration.test.ts
View File

@@ -1,8 +1,6 @@
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { RatingTestContext } from './RatingTestContext';
import { CalculateReliabilityUseCase } from '../../../../core/rating/application/use-cases/CalculateReliabilityUseCase';
import { GetReliabilityScoreUseCase } from '../../../../core/rating/application/use-cases/GetReliabilityScoreUseCase';
import { GetReliabilityTrendUseCase } from '../../../../core/rating/application/use-cases/GetReliabilityTrendUseCase';
import { CalculateRatingUseCase as CalculateReliabilityUseCase } from '../../../../core/rating/application/use-cases/CalculateRatingUseCase';
import { Driver } from '../../../../core/racing/domain/entities/Driver';
import { Race } from '../../../../core/racing/domain/entities/Race';
import { League } from '../../../../core/racing/domain/entities/League';
@@ -11,25 +9,16 @@ import { Result as RaceResult } from '../../../../core/racing/domain/entities/re
describe('Rating Reliability Use Cases', () => {
let context: RatingTestContext;
let calculateReliabilityUseCase: CalculateReliabilityUseCase;
let getReliabilityScoreUseCase: GetReliabilityScoreUseCase;
let getReliabilityTrendUseCase: GetReliabilityTrendUseCase;
beforeAll(() => {
context = RatingTestContext.create();
calculateReliabilityUseCase = new CalculateReliabilityUseCase(
context.driverRepository,
context.raceRepository,
context.resultRepository,
context.eventPublisher
);
getReliabilityScoreUseCase = new GetReliabilityScoreUseCase(
context.driverRepository,
context.resultRepository
);
getReliabilityTrendUseCase = new GetReliabilityTrendUseCase(
context.driverRepository,
context.resultRepository
);
calculateReliabilityUseCase = new CalculateReliabilityUseCase({
driverRepository: context.driverRepository,
raceRepository: context.raceRepository,
resultRepository: context.resultRepository,
ratingRepository: context.ratingRepository,
eventPublisher: context.eventPublisher
});
});
beforeEach(async () => {
@@ -86,764 +75,7 @@ describe('Rating Reliability Use Cases', () => {
expect(result.isOk()).toBe(true);
const reliability = result.unwrap();
expect(reliability.driverId.toString()).toBe(driverId);
expect(reliability.reliabilityScore).toBeGreaterThan(0);
expect(reliability.reliabilityScore).toBeGreaterThan(90);
expect(reliability.raceCount).toBe(5);
expect(reliability.dnfCount).toBe(0);
expect(reliability.dnsCount).toBe(0);
expect(reliability.attendanceRate).toBe(100);
});
it('should calculate reliability with DNFs', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple races with some DNFs
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 5; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
// First 2 races are DNFs
const isDNF = i <= 2;
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position: isDNF ? 0 : 5,
lapsCompleted: isDNF ? 10 : 20,
totalTime: isDNF ? 0 : 3600,
fastestLap: isDNF ? 0 : 105,
points: isDNF ? 0 : 10,
incidents: isDNF ? 3 : 1,
startPosition: 5
});
await context.resultRepository.create(result);
}
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r5'
});
// Then: The reliability should be calculated with DNF impact
expect(result.isOk()).toBe(true);
const reliability = result.unwrap();
expect(reliability.driverId.toString()).toBe(driverId);
expect(reliability.reliabilityScore).toBeGreaterThan(0);
expect(reliability.reliabilityScore).toBeLessThan(90);
expect(reliability.raceCount).toBe(5);
expect(reliability.dnfCount).toBe(2);
expect(reliability.dnsCount).toBe(0);
expect(reliability.attendanceRate).toBe(100);
});
it('should calculate reliability with DNSs', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple races with some DNSs
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 5; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
// First 2 races are DNSs
const isDNS = i <= 2;
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position: isDNS ? 0 : 5,
lapsCompleted: isDNS ? 0 : 20,
totalTime: isDNS ? 0 : 3600,
fastestLap: isDNS ? 0 : 105,
points: isDNS ? 0 : 10,
incidents: 0,
startPosition: isDNS ? 0 : 5
});
await context.resultRepository.create(result);
}
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r5'
});
// Then: The reliability should be calculated with DNS impact
expect(result.isOk()).toBe(true);
const reliability = result.unwrap();
expect(reliability.driverId.toString()).toBe(driverId);
expect(reliability.reliabilityScore).toBeGreaterThan(0);
expect(reliability.reliabilityScore).toBeLessThan(90);
expect(reliability.raceCount).toBe(5);
expect(reliability.dnfCount).toBe(0);
expect(reliability.dnsCount).toBe(2);
expect(reliability.attendanceRate).toBe(60);
});
it('should calculate reliability with mixed DNFs and DNSs', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple races with mixed issues
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 5; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
let position, lapsCompleted, totalTime, fastestLap, points, incidents, startPosition;
if (i === 1) {
// DNS
position = 0;
lapsCompleted = 0;
totalTime = 0;
fastestLap = 0;
points = 0;
incidents = 0;
startPosition = 0;
} else if (i === 2) {
// DNF
position = 0;
lapsCompleted = 10;
totalTime = 0;
fastestLap = 0;
points = 0;
incidents = 3;
startPosition = 5;
} else {
// Completed
position = 5;
lapsCompleted = 20;
totalTime = 3600;
fastestLap = 105;
points = 10;
incidents = 1;
startPosition = 5;
}
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position,
lapsCompleted,
totalTime,
fastestLap,
points,
incidents,
startPosition
});
await context.resultRepository.create(result);
}
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r5'
});
// Then: The reliability should be calculated with mixed issues
expect(result.isOk()).toBe(true);
const reliability = result.unwrap();
expect(reliability.driverId.toString()).toBe(driverId);
expect(reliability.reliabilityScore).toBeGreaterThan(0);
expect(reliability.reliabilityScore).toBeLessThan(80);
expect(reliability.raceCount).toBe(5);
expect(reliability.dnfCount).toBe(1);
expect(reliability.dnsCount).toBe(1);
expect(reliability.attendanceRate).toBe(60);
});
it('should calculate reliability with minimum race count', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Minimum races for reliability calculation
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 3; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
}
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r3'
});
// Then: The reliability should be calculated
expect(result.isOk()).toBe(true);
const reliability = result.unwrap();
expect(reliability.driverId.toString()).toBe(driverId);
expect(reliability.reliabilityScore).toBeGreaterThan(0);
expect(reliability.raceCount).toBe(3);
});
});
describe('UseCase - Edge Cases', () => {
it('should handle driver with insufficient races', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Only one race
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
const raceId = 'r1';
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - 86400000),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: 'res1',
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r1'
});
// Then: The result should be an error
expect(result.isErr()).toBe(true);
});
it('should handle driver with no races', async () => {
// Given: A driver with no races
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r1'
});
// Then: The result should be an error
expect(result.isErr()).toBe(true);
});
});
describe('UseCase - Error Handling', () => {
it('should handle missing driver', async () => {
// Given: A non-existent driver
const driverId = 'd999';
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r1'
});
// Then: The result should be an error
expect(result.isErr()).toBe(true);
});
it('should handle missing race', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// When: CalculateReliabilityUseCase.execute() is called
const result = await calculateReliabilityUseCase.execute({
driverId,
raceId: 'r999'
});
// Then: The result should be an error
expect(result.isErr()).toBe(true);
});
});
});
describe('GetReliabilityScoreUseCase', () => {
describe('UseCase - Success Path', () => {
it('should retrieve reliability score for driver', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple completed races
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 5; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
}
// When: GetReliabilityScoreUseCase.execute() is called
const result = await getReliabilityScoreUseCase.execute({ driverId });
// Then: The reliability score should be retrieved
expect(result.isOk()).toBe(true);
const reliability = result.unwrap();
expect(reliability.driverId.toString()).toBe(driverId);
expect(reliability.reliabilityScore).toBeGreaterThan(0);
expect(reliability.raceCount).toBe(5);
expect(reliability.dnfCount).toBe(0);
expect(reliability.dnsCount).toBe(0);
expect(reliability.attendanceRate).toBe(100);
});
it('should retrieve reliability score with race limit', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple completed races
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 10; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
}
// When: GetReliabilityScoreUseCase.execute() is called with limit
const result = await getReliabilityScoreUseCase.execute({ driverId, limit: 5 });
// Then: The reliability score should be retrieved with limit
expect(result.isOk()).toBe(true);
const reliability = result.unwrap();
expect(reliability.driverId.toString()).toBe(driverId);
expect(reliability.raceCount).toBe(5);
});
});
describe('UseCase - Error Handling', () => {
it('should handle missing driver', async () => {
// Given: A non-existent driver
const driverId = 'd999';
// When: GetReliabilityScoreUseCase.execute() is called
const result = await getReliabilityScoreUseCase.execute({ driverId });
// Then: The result should be an error
expect(result.isErr()).toBe(true);
});
it('should handle driver with insufficient races', async () => {
// Given: A driver with only one race
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
const raceId = 'r1';
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - 86400000),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: 'res1',
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
// When: GetReliabilityScoreUseCase.execute() is called
const result = await getReliabilityScoreUseCase.execute({ driverId });
// Then: The result should be an error
expect(result.isErr()).toBe(true);
});
});
});
describe('GetReliabilityTrendUseCase', () => {
describe('UseCase - Success Path', () => {
it('should retrieve reliability trend for driver', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple completed races
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 5; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
}
// When: GetReliabilityTrendUseCase.execute() is called
const result = await getReliabilityTrendUseCase.execute({ driverId });
// Then: The reliability trend should be retrieved
expect(result.isOk()).toBe(true);
const trend = result.unwrap();
expect(trend.driverId.toString()).toBe(driverId);
expect(trend.trend).toBeDefined();
expect(trend.trend.length).toBeGreaterThan(0);
expect(trend.averageReliability).toBeGreaterThan(0);
expect(trend.attendanceRate).toBe(100);
});
it('should retrieve reliability trend over specific period', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple completed races
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 10; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
}
// When: GetReliabilityTrendUseCase.execute() is called with period
const result = await getReliabilityTrendUseCase.execute({ driverId, period: 7 });
// Then: The reliability trend should be retrieved for the period
expect(result.isOk()).toBe(true);
const trend = result.unwrap();
expect(trend.driverId.toString()).toBe(driverId);
expect(trend.trend.length).toBeLessThanOrEqual(7);
});
it('should retrieve reliability trend with DNFs and DNSs', async () => {
// Given: A driver
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
// Given: Multiple races with mixed results
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
for (let i = 1; i <= 5; i++) {
const raceId = `r${i}`;
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - (i * 86400000)),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
let position, lapsCompleted, totalTime, fastestLap, points, incidents, startPosition;
if (i === 1) {
// DNS
position = 0;
lapsCompleted = 0;
totalTime = 0;
fastestLap = 0;
points = 0;
incidents = 0;
startPosition = 0;
} else if (i === 2) {
// DNF
position = 0;
lapsCompleted = 10;
totalTime = 0;
fastestLap = 0;
points = 0;
incidents = 3;
startPosition = 5;
} else {
// Completed
position = 5;
lapsCompleted = 20;
totalTime = 3600;
fastestLap = 105;
points = 10;
incidents = 1;
startPosition = 5;
}
const result = RaceResult.create({
id: `res${i}`,
raceId,
driverId,
position,
lapsCompleted,
totalTime,
fastestLap,
points,
incidents,
startPosition
});
await context.resultRepository.create(result);
}
// When: GetReliabilityTrendUseCase.execute() is called
const result = await getReliabilityTrendUseCase.execute({ driverId });
// Then: The reliability trend should be retrieved
expect(result.isOk()).toBe(true);
const trend = result.unwrap();
expect(trend.driverId.toString()).toBe(driverId);
expect(trend.trend).toBeDefined();
expect(trend.trend.length).toBeGreaterThan(0);
expect(trend.averageReliability).toBeGreaterThan(0);
expect(trend.attendanceRate).toBe(60);
expect(trend.dnfCount).toBe(1);
expect(trend.dnsCount).toBe(1);
});
});
describe('UseCase - Error Handling', () => {
it('should handle missing driver', async () => {
// Given: A non-existent driver
const driverId = 'd999';
// When: GetReliabilityTrendUseCase.execute() is called
const result = await getReliabilityTrendUseCase.execute({ driverId });
// Then: The result should be an error
expect(result.isErr()).toBe(true);
});
it('should handle driver with insufficient races', async () => {
// Given: A driver with only one race
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
const leagueId = 'l1';
const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
await context.leagueRepository.create(league);
const raceId = 'r1';
const race = Race.create({
id: raceId,
leagueId,
scheduledAt: new Date(Date.now() - 86400000),
track: 'Spa',
car: 'GT3',
status: 'completed'
});
await context.raceRepository.create(race);
const result = RaceResult.create({
id: 'res1',
raceId,
driverId,
position: 5,
lapsCompleted: 20,
totalTime: 3600,
fastestLap: 105,
points: 10,
incidents: 1,
startPosition: 5
});
await context.resultRepository.create(result);
// When: GetReliabilityTrendUseCase.execute() is called
const result = await getReliabilityTrendUseCase.execute({ driverId });
// Then: The result should be an error
expect(result.isErr()).toBe(true);
expect(reliability.components.reliability).toBeGreaterThan(0);
});
});
});