539 lines
15 KiB
TypeScript
539 lines
15 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
|
|
import { Race } from '@gridpilot/racing/domain/entities/Race';
|
|
import { League } from '@gridpilot/racing/domain/entities/League';
|
|
import { Result } from '@gridpilot/racing/domain/entities/Result';
|
|
import { Penalty } from '@gridpilot/racing/domain/entities/Penalty';
|
|
|
|
import { GetRaceResultsDetailUseCase } from '@gridpilot/racing/application/use-cases/GetRaceResultsDetailUseCase';
|
|
import { ImportRaceResultsUseCase } from '@gridpilot/racing/application/use-cases/ImportRaceResultsUseCase';
|
|
|
|
import type {
|
|
IRaceResultsDetailPresenter,
|
|
RaceResultsDetailViewModel,
|
|
} from '@gridpilot/racing/application/presenters/IRaceResultsDetailPresenter';
|
|
import type {
|
|
IImportRaceResultsPresenter,
|
|
ImportRaceResultsSummaryViewModel,
|
|
} from '@gridpilot/racing/application/presenters/IImportRaceResultsPresenter';
|
|
|
|
class FakeRaceResultsDetailPresenter implements IRaceResultsDetailPresenter {
|
|
viewModel: RaceResultsDetailViewModel | null = null;
|
|
|
|
present(viewModel: RaceResultsDetailViewModel): RaceResultsDetailViewModel {
|
|
this.viewModel = viewModel;
|
|
return viewModel;
|
|
}
|
|
|
|
getViewModel(): RaceResultsDetailViewModel | null {
|
|
return this.viewModel;
|
|
}
|
|
}
|
|
|
|
class FakeImportRaceResultsPresenter implements IImportRaceResultsPresenter {
|
|
viewModel: ImportRaceResultsSummaryViewModel | null = null;
|
|
|
|
present(viewModel: ImportRaceResultsSummaryViewModel): ImportRaceResultsSummaryViewModel {
|
|
this.viewModel = viewModel;
|
|
return viewModel;
|
|
}
|
|
|
|
getViewModel(): ImportRaceResultsSummaryViewModel | null {
|
|
return this.viewModel;
|
|
}
|
|
}
|
|
|
|
describe('ImportRaceResultsUseCase', () => {
|
|
it('imports results and triggers standings recalculation for the league', async () => {
|
|
// Given a league, a race, empty results, and a standing repository
|
|
const league = League.create({
|
|
id: 'league-1',
|
|
name: 'Import League',
|
|
description: 'League for import tests',
|
|
ownerId: 'owner-1',
|
|
});
|
|
|
|
const race = Race.create({
|
|
id: 'race-1',
|
|
leagueId: league.id,
|
|
scheduledAt: new Date(),
|
|
track: 'Import Circuit',
|
|
car: 'GT3',
|
|
sessionType: 'race',
|
|
status: 'completed',
|
|
});
|
|
|
|
const races = new Map<string, typeof race>();
|
|
races.set(race.id, race);
|
|
|
|
const leagues = new Map<string, typeof league>();
|
|
leagues.set(league.id, league);
|
|
|
|
const storedResults: Result[] = [];
|
|
let existsByRaceIdCalled = false;
|
|
const recalcCalls: string[] = [];
|
|
|
|
const raceRepository: {
|
|
findById: (id: string) => Promise<Race | null>;
|
|
} = {
|
|
findById: async (id: string) => races.get(id) ?? null,
|
|
};
|
|
|
|
const leagueRepository: {
|
|
findById: (id: string) => Promise<League | null>;
|
|
} = {
|
|
findById: async (id: string) => leagues.get(id) ?? null,
|
|
};
|
|
|
|
const resultRepository: {
|
|
existsByRaceId: (raceId: string) => Promise<boolean>;
|
|
createMany: (results: Result[]) => Promise<Result[]>;
|
|
} = {
|
|
existsByRaceId: async (raceId: string) => {
|
|
existsByRaceIdCalled = true;
|
|
return storedResults.some((r) => r.raceId === raceId);
|
|
},
|
|
createMany: async (results: Result[]) => {
|
|
storedResults.push(...results);
|
|
return results;
|
|
},
|
|
};
|
|
|
|
const standingRepository: {
|
|
recalculate: (leagueId: string) => Promise<void>;
|
|
} = {
|
|
recalculate: async (leagueId: string) => {
|
|
recalcCalls.push(leagueId);
|
|
},
|
|
};
|
|
|
|
const presenter = new FakeImportRaceResultsPresenter();
|
|
|
|
const useCase = new ImportRaceResultsUseCase(
|
|
raceRepository,
|
|
leagueRepository,
|
|
resultRepository,
|
|
standingRepository,
|
|
presenter,
|
|
);
|
|
|
|
const importedResults = [
|
|
Result.create({
|
|
id: 'result-1',
|
|
raceId: race.id,
|
|
driverId: 'driver-1',
|
|
position: 1,
|
|
fastestLap: 90.123,
|
|
incidents: 0,
|
|
startPosition: 3,
|
|
}),
|
|
Result.create({
|
|
id: 'result-2',
|
|
raceId: race.id,
|
|
driverId: 'driver-2',
|
|
position: 2,
|
|
fastestLap: 91.456,
|
|
incidents: 2,
|
|
startPosition: 1,
|
|
}),
|
|
];
|
|
|
|
// When executing the import
|
|
await useCase.execute({
|
|
raceId: race.id,
|
|
results: importedResults,
|
|
});
|
|
|
|
// Then new Result entries are persisted
|
|
expect(existsByRaceIdCalled).toBe(true);
|
|
expect(storedResults.length).toBe(2);
|
|
expect(storedResults.map((r) => r.id)).toEqual(['result-1', 'result-2']);
|
|
|
|
// And standings are recalculated exactly once for the correct league
|
|
expect(recalcCalls).toEqual([league.id]);
|
|
|
|
// And the presenter receives a summary
|
|
const viewModel = presenter.getViewModel();
|
|
expect(viewModel).not.toBeNull();
|
|
expect(viewModel!.importedCount).toBe(2);
|
|
expect(viewModel!.standingsRecalculated).toBe(true);
|
|
});
|
|
|
|
it('rejects import when results already exist for the race', async () => {
|
|
const league = League.create({
|
|
id: 'league-2',
|
|
name: 'Existing Results League',
|
|
description: 'League with existing results',
|
|
ownerId: 'owner-2',
|
|
});
|
|
|
|
const race = Race.create({
|
|
id: 'race-2',
|
|
leagueId: league.id,
|
|
scheduledAt: new Date(),
|
|
track: 'Existing Circuit',
|
|
car: 'GT4',
|
|
sessionType: 'race',
|
|
status: 'completed',
|
|
});
|
|
|
|
const races = new Map<string, typeof race>([[race.id, race]]);
|
|
const leagues = new Map<string, typeof league>([[league.id, league]]);
|
|
|
|
const storedResults: Result[] = [
|
|
Result.create({
|
|
id: 'existing',
|
|
raceId: race.id,
|
|
driverId: 'driver-x',
|
|
position: 1,
|
|
fastestLap: 90.0,
|
|
incidents: 1,
|
|
startPosition: 1,
|
|
}),
|
|
];
|
|
|
|
const raceRepository: {
|
|
findById: (id: string) => Promise<Race | null>;
|
|
} = {
|
|
findById: async (id: string) => races.get(id) ?? null,
|
|
};
|
|
|
|
const leagueRepository: {
|
|
findById: (id: string) => Promise<League | null>;
|
|
} = {
|
|
findById: async (id: string) => leagues.get(id) ?? null,
|
|
};
|
|
|
|
const resultRepository: {
|
|
existsByRaceId: (raceId: string) => Promise<boolean>;
|
|
createMany: (results: Result[]) => Promise<Result[]>;
|
|
} = {
|
|
existsByRaceId: async (raceId: string) => {
|
|
return storedResults.some((r) => r.raceId === raceId);
|
|
},
|
|
createMany: async (_results: Result[]) => {
|
|
throw new Error('Should not be called when results already exist');
|
|
},
|
|
};
|
|
|
|
const standingRepository: {
|
|
recalculate: (leagueId: string) => Promise<void>;
|
|
} = {
|
|
recalculate: async (_leagueId: string) => {
|
|
throw new Error('Should not be called when results already exist');
|
|
},
|
|
};
|
|
|
|
const presenter = new FakeImportRaceResultsPresenter();
|
|
|
|
const useCase = new ImportRaceResultsUseCase(
|
|
raceRepository,
|
|
leagueRepository,
|
|
resultRepository,
|
|
standingRepository,
|
|
presenter,
|
|
);
|
|
|
|
const importedResults = [
|
|
Result.create({
|
|
id: 'new-result',
|
|
raceId: race.id,
|
|
driverId: 'driver-1',
|
|
position: 2,
|
|
fastestLap: 91.0,
|
|
incidents: 0,
|
|
startPosition: 2,
|
|
}),
|
|
];
|
|
|
|
await expect(
|
|
useCase.execute({
|
|
raceId: race.id,
|
|
results: importedResults,
|
|
}),
|
|
).rejects.toThrow('Results already exist for this race');
|
|
});
|
|
});
|
|
|
|
describe('GetRaceResultsDetailUseCase', () => {
|
|
it('computes points system from league settings and identifies fastest lap', async () => {
|
|
// Given a league with default scoring configuration and two results
|
|
const league = League.create({
|
|
id: 'league-scoring',
|
|
name: 'Scoring League',
|
|
description: 'League with scoring settings',
|
|
ownerId: 'owner-scoring',
|
|
});
|
|
|
|
const race = Race.create({
|
|
id: 'race-scoring',
|
|
leagueId: league.id,
|
|
scheduledAt: new Date(),
|
|
track: 'Scoring Circuit',
|
|
car: 'Prototype',
|
|
sessionType: 'race',
|
|
status: 'completed',
|
|
});
|
|
|
|
const driver1: { id: string; name: string; country: string } = {
|
|
id: 'driver-a',
|
|
name: 'Driver A',
|
|
country: 'US',
|
|
};
|
|
const driver2: { id: string; name: string; country: string } = {
|
|
id: 'driver-b',
|
|
name: 'Driver B',
|
|
country: 'GB',
|
|
};
|
|
|
|
const result1 = Result.create({
|
|
id: 'r1',
|
|
raceId: race.id,
|
|
driverId: driver1.id,
|
|
position: 1,
|
|
fastestLap: 90.123,
|
|
incidents: 0,
|
|
startPosition: 3,
|
|
});
|
|
|
|
const result2 = Result.create({
|
|
id: 'r2',
|
|
raceId: race.id,
|
|
driverId: driver2.id,
|
|
position: 2,
|
|
fastestLap: 88.456,
|
|
incidents: 2,
|
|
startPosition: 1,
|
|
});
|
|
|
|
const races = new Map<string, typeof race>([[race.id, race]]);
|
|
const leagues = new Map<string, typeof league>([[league.id, league]]);
|
|
const results = [result1, result2];
|
|
const drivers = [driver1, driver2];
|
|
|
|
const raceRepository: {
|
|
findById: (id: string) => Promise<Race | null>;
|
|
} = {
|
|
findById: async (id: string) => races.get(id) ?? null,
|
|
};
|
|
|
|
const leagueRepository: {
|
|
findById: (id: string) => Promise<League | null>;
|
|
} = {
|
|
findById: async (id: string) => leagues.get(id) ?? null,
|
|
};
|
|
|
|
const resultRepository: {
|
|
findByRaceId: (raceId: string) => Promise<Result[]>;
|
|
} = {
|
|
findByRaceId: async (raceId: string) =>
|
|
results.filter((r) => r.raceId === raceId),
|
|
};
|
|
|
|
const driverRepository: {
|
|
findAll: () => Promise<Array<{ id: string; name: string; country: string }>>;
|
|
} = {
|
|
findAll: async () => drivers,
|
|
};
|
|
|
|
const penaltyRepository: {
|
|
findByRaceId: (raceId: string) => Promise<Penalty[]>;
|
|
} = {
|
|
findByRaceId: async () => [] as Penalty[],
|
|
};
|
|
|
|
const presenter = new FakeRaceResultsDetailPresenter();
|
|
|
|
const useCase = new GetRaceResultsDetailUseCase(
|
|
raceRepository,
|
|
leagueRepository,
|
|
resultRepository,
|
|
driverRepository,
|
|
penaltyRepository,
|
|
presenter,
|
|
);
|
|
|
|
// When executing the query
|
|
await useCase.execute({ raceId: race.id });
|
|
|
|
const viewModel = presenter.getViewModel();
|
|
expect(viewModel).not.toBeNull();
|
|
|
|
// Then points system matches the default F1-style configuration
|
|
expect(viewModel!.pointsSystem[1]).toBe(25);
|
|
expect(viewModel!.pointsSystem[2]).toBe(18);
|
|
|
|
// And fastest lap is identified correctly
|
|
expect(viewModel!.fastestLapTime).toBeCloseTo(88.456, 3);
|
|
});
|
|
|
|
it('builds race results view model including penalties', async () => {
|
|
// Given a race with one result and one applied penalty
|
|
const league = League.create({
|
|
id: 'league-penalties',
|
|
name: 'Penalty League',
|
|
description: 'League with penalties',
|
|
ownerId: 'owner-penalties',
|
|
});
|
|
|
|
const race = Race.create({
|
|
id: 'race-penalties',
|
|
leagueId: league.id,
|
|
scheduledAt: new Date(),
|
|
track: 'Penalty Circuit',
|
|
car: 'Touring',
|
|
sessionType: 'race',
|
|
status: 'completed',
|
|
});
|
|
|
|
const driver: { id: string; name: string; country: string } = {
|
|
id: 'driver-pen',
|
|
name: 'Penalty Driver',
|
|
country: 'DE',
|
|
};
|
|
|
|
const result = Result.create({
|
|
id: 'res-pen',
|
|
raceId: race.id,
|
|
driverId: driver.id,
|
|
position: 3,
|
|
fastestLap: 95.0,
|
|
incidents: 4,
|
|
startPosition: 5,
|
|
});
|
|
|
|
const penalty = Penalty.create({
|
|
id: 'pen-1',
|
|
raceId: race.id,
|
|
driverId: driver.id,
|
|
type: 'points_deduction',
|
|
value: 3,
|
|
reason: 'Track limits',
|
|
issuedBy: 'steward-1',
|
|
status: 'applied',
|
|
issuedAt: new Date(),
|
|
});
|
|
|
|
const races = new Map<string, typeof race>([[race.id, race]]);
|
|
const leagues = new Map<string, typeof league>([[league.id, league]]);
|
|
const results = [result];
|
|
const drivers = [driver];
|
|
const penalties = [penalty];
|
|
|
|
const raceRepository: {
|
|
findById: (id: string) => Promise<Race | null>;
|
|
} = {
|
|
findById: async (id: string) => races.get(id) ?? null,
|
|
};
|
|
|
|
const leagueRepository: {
|
|
findById: (id: string) => Promise<League | null>;
|
|
} = {
|
|
findById: async (id: string) => leagues.get(id) ?? null,
|
|
};
|
|
|
|
const resultRepository: {
|
|
findByRaceId: (raceId: string) => Promise<Result[]>;
|
|
} = {
|
|
findByRaceId: async (raceId: string) =>
|
|
results.filter((r) => r.raceId === raceId),
|
|
};
|
|
|
|
const driverRepository: {
|
|
findAll: () => Promise<Array<{ id: string; name: string; country: string }>>;
|
|
} = {
|
|
findAll: async () => drivers,
|
|
};
|
|
|
|
const penaltyRepository: {
|
|
findByRaceId: (raceId: string) => Promise<Penalty[]>;
|
|
} = {
|
|
findByRaceId: async (raceId: string) =>
|
|
penalties.filter((p) => p.raceId === raceId),
|
|
};
|
|
|
|
const presenter = new FakeRaceResultsDetailPresenter();
|
|
|
|
const useCase = new GetRaceResultsDetailUseCase(
|
|
raceRepository,
|
|
leagueRepository,
|
|
resultRepository,
|
|
driverRepository,
|
|
penaltyRepository,
|
|
presenter,
|
|
);
|
|
|
|
// When
|
|
await useCase.execute({ raceId: race.id });
|
|
|
|
const viewModel = presenter.getViewModel();
|
|
expect(viewModel).not.toBeNull();
|
|
|
|
// Then header and league info are present
|
|
expect(viewModel!.race).not.toBeNull();
|
|
expect(viewModel!.race!.id).toBe(race.id);
|
|
expect(viewModel!.league).not.toBeNull();
|
|
expect(viewModel!.league!.id).toBe(league.id);
|
|
|
|
// And classification and penalties match the underlying data
|
|
expect(viewModel!.results.length).toBe(1);
|
|
expect(viewModel!.results[0]!.id).toBe(result.id);
|
|
|
|
expect(viewModel!.penalties.length).toBe(1);
|
|
expect(viewModel!.penalties[0]!.driverId).toBe(driver.id);
|
|
expect(viewModel!.penalties[0]!.type).toBe('points_deduction');
|
|
expect(viewModel!.penalties[0]!.value).toBe(3);
|
|
});
|
|
|
|
it('presents an error when race does not exist', async () => {
|
|
// Given repositories without the requested race
|
|
const raceRepository: {
|
|
findById: (id: string) => Promise<Race | null>;
|
|
} = {
|
|
findById: async () => null,
|
|
};
|
|
|
|
const leagueRepository: {
|
|
findById: (id: string) => Promise<League | null>;
|
|
} = {
|
|
findById: async () => null,
|
|
};
|
|
|
|
const resultRepository: {
|
|
findByRaceId: (raceId: string) => Promise<Result[]>;
|
|
} = {
|
|
findByRaceId: async () => [] as Result[],
|
|
};
|
|
|
|
const driverRepository: {
|
|
findAll: () => Promise<Array<{ id: string; name: string; country: string }>>;
|
|
} = {
|
|
findAll: async () => [],
|
|
};
|
|
|
|
const penaltyRepository: {
|
|
findByRaceId: (raceId: string) => Promise<Penalty[]>;
|
|
} = {
|
|
findByRaceId: async () => [] as Penalty[],
|
|
};
|
|
|
|
const presenter = new FakeRaceResultsDetailPresenter();
|
|
|
|
const useCase = new GetRaceResultsDetailUseCase(
|
|
raceRepository,
|
|
leagueRepository,
|
|
resultRepository,
|
|
driverRepository,
|
|
penaltyRepository,
|
|
presenter,
|
|
);
|
|
|
|
// When
|
|
await useCase.execute({ raceId: 'missing-race' });
|
|
|
|
const viewModel = presenter.getViewModel();
|
|
expect(viewModel).not.toBeNull();
|
|
expect(viewModel!.race).toBeNull();
|
|
expect(viewModel!.error).toBe('Race not found');
|
|
});
|
|
}); |