website refactor

core/racing/application/use-cases/CompleteRaceUseCase.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
+import type { LeagueRepository } from '../../domain/repositories/LeagueRepository';
 import type { RaceRegistrationRepository } from '../../domain/repositories/RaceRegistrationRepository';
 import type { RaceRepository } from '../../domain/repositories/RaceRepository';
 import type { ResultRepository } from '../../domain/repositories/ResultRepository';
@@ -7,6 +8,9 @@ import { CompleteRaceUseCase, type CompleteRaceInput } from './CompleteRaceUseCa
 
 describe('CompleteRaceUseCase', () => {
   let useCase: CompleteRaceUseCase;
+  let leagueRepository: {
+    findById: Mock;
+  };
   let raceRepository: {
     findById: Mock;
     update: Mock;
@@ -24,6 +28,9 @@ describe('CompleteRaceUseCase', () => {
   let getDriverRating: Mock;
 
   beforeEach(() => {
+    leagueRepository = {
+      findById: vi.fn(),
+    };
     raceRepository = {
       findById: vi.fn(),
       update: vi.fn(),
@@ -39,11 +46,14 @@ describe('CompleteRaceUseCase', () => {
       save: vi.fn(),
     };
     getDriverRating = vi.fn();
-    useCase = new CompleteRaceUseCase(raceRepository as unknown as RaceRepository,
+    useCase = new CompleteRaceUseCase(
+      leagueRepository as unknown as LeagueRepository,
+      raceRepository as unknown as RaceRepository,
       raceRegistrationRepository as unknown as RaceRegistrationRepository,
       resultRepository as unknown as ResultRepository,
       standingRepository as unknown as StandingRepository,
-      getDriverRating);
+      getDriverRating
+    );
   });
 
   it('should complete race successfully when race exists and has registered drivers', async () => {
@@ -51,12 +61,17 @@ describe('CompleteRaceUseCase', () => {
       raceId: 'race-1',
     };
 
+    const mockLeague = {
+      id: 'league-1',
+      settings: { pointsSystem: 'f1-2024', customPoints: null },
+    };
     const mockRace = {
       id: 'race-1',
       leagueId: 'league-1',
       status: 'scheduled',
       complete: vi.fn().mockReturnValue({ id: 'race-1', status: 'completed' }),
     };
+    leagueRepository.findById.mockResolvedValue(mockLeague);
     raceRepository.findById.mockResolvedValue(mockRace);
     raceRegistrationRepository.getRegisteredDrivers.mockResolvedValue(['driver-1', 'driver-2']);
     getDriverRating.mockImplementation((input) => {
@@ -74,6 +89,7 @@ describe('CompleteRaceUseCase', () => {
     expect(result.isOk()).toBe(true);
     const presented = result.unwrap();
     expect(presented.raceId).toBe('race-1');
+    expect(leagueRepository.findById).toHaveBeenCalledWith('league-1');
     expect(raceRepository.findById).toHaveBeenCalledWith('race-1');
     expect(raceRegistrationRepository.getRegisteredDrivers).toHaveBeenCalledWith('race-1');
     expect(getDriverRating).toHaveBeenCalledTimes(2);
@@ -139,4 +155,71 @@ describe('CompleteRaceUseCase', () => {
     expect(error.code).toBe('REPOSITORY_ERROR');
     expect(error.details?.message).toBe('DB error');
   });
+  it('should use league\'s points system when calculating standings', async () => {
+    const command: CompleteRaceInput = {
+      raceId: 'race-1',
+    };
+
+    const mockLeague = {
+      id: 'league-1',
+      settings: { pointsSystem: 'indycar', customPoints: null },
+    };
+    const mockRace = {
+      id: 'race-1',
+      leagueId: 'league-1',
+      status: 'scheduled',
+      complete: vi.fn().mockReturnValue({ id: 'race-1', status: 'completed' }),
+    };
+    leagueRepository.findById.mockResolvedValue(mockLeague);
+    raceRepository.findById.mockResolvedValue(mockRace);
+    raceRegistrationRepository.getRegisteredDrivers.mockResolvedValue(['driver-1']);
+    getDriverRating.mockResolvedValue({ rating: 1600, ratingChange: null });
+    resultRepository.create.mockResolvedValue(undefined);
+    standingRepository.findByDriverIdAndLeagueId.mockResolvedValue(null);
+    standingRepository.save.mockResolvedValue(undefined);
+    raceRepository.update.mockResolvedValue(undefined);
+
+    const result = await useCase.execute(command);
+
+    expect(result.isOk()).toBe(true);
+    expect(standingRepository.save).toHaveBeenCalledTimes(1);
+    
+    // Verify that the standing was saved with indycar points (50 for 1st place)
+    const savedStanding = standingRepository.save.mock.calls[0][0];
+    expect(savedStanding.points.toNumber()).toBe(50);
+  });
+
+  it('should use custom points system when calculating standings', async () => {
+    const command: CompleteRaceInput = {
+      raceId: 'race-1',
+    };
+
+    const mockLeague = {
+      id: 'league-1',
+      settings: { pointsSystem: 'custom', customPoints: { 1: 100, 2: 80 } },
+    };
+    const mockRace = {
+      id: 'race-1',
+      leagueId: 'league-1',
+      status: 'scheduled',
+      complete: vi.fn().mockReturnValue({ id: 'race-1', status: 'completed' }),
+    };
+    leagueRepository.findById.mockResolvedValue(mockLeague);
+    raceRepository.findById.mockResolvedValue(mockRace);
+    raceRegistrationRepository.getRegisteredDrivers.mockResolvedValue(['driver-1']);
+    getDriverRating.mockResolvedValue({ rating: 1600, ratingChange: null });
+    resultRepository.create.mockResolvedValue(undefined);
+    standingRepository.findByDriverIdAndLeagueId.mockResolvedValue(null);
+    standingRepository.save.mockResolvedValue(undefined);
+    raceRepository.update.mockResolvedValue(undefined);
+
+    const result = await useCase.execute(command);
+
+    expect(result.isOk()).toBe(true);
+    expect(standingRepository.save).toHaveBeenCalledTimes(1);
+    
+    // Verify that the standing was saved with custom points (100 for 1st place)
+    const savedStanding = standingRepository.save.mock.calls[0][0];
+    expect(savedStanding.points.toNumber()).toBe(100);
+  });
 });