website service tests

apps/website/lib/services/leagues/LeagueStewardingService.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect, vi, Mocked } from 'vitest';
+import { LeagueStewardingService } from './LeagueStewardingService';
+import { RaceService } from '../races/RaceService';
+import { ProtestService } from '../protests/ProtestService';
+import { PenaltyService } from '../penalties/PenaltyService';
+import { DriverService } from '../drivers/DriverService';
+import { LeagueMembershipService } from './LeagueMembershipService';
+import { LeagueStewardingViewModel } from '../../view-models/LeagueStewardingViewModel';
+
+describe('LeagueStewardingService', () => {
+  let mockRaceService: Mocked<RaceService>;
+  let mockProtestService: Mocked<ProtestService>;
+  let mockPenaltyService: Mocked<PenaltyService>;
+  let mockDriverService: Mocked<DriverService>;
+  let mockLeagueMembershipService: Mocked<LeagueMembershipService>;
+  let service: LeagueStewardingService;
+
+  beforeEach(() => {
+    mockRaceService = {
+      findByLeagueId: vi.fn(),
+    } as Mocked<RaceService>;
+
+    mockProtestService = {
+      findByRaceId: vi.fn(),
+    } as Mocked<ProtestService>;
+
+    mockPenaltyService = {
+      findByRaceId: vi.fn(),
+    } as Mocked<PenaltyService>;
+
+    mockDriverService = {
+      findByIds: vi.fn(),
+    } as Mocked<DriverService>;
+
+    mockLeagueMembershipService = {} as Mocked<LeagueMembershipService>;
+
+    service = new LeagueStewardingService(
+      mockRaceService,
+      mockProtestService,
+      mockPenaltyService,
+      mockDriverService,
+      mockLeagueMembershipService
+    );
+  });
+
+  describe('getLeagueStewardingData', () => {
+    it('should return stewarding data with all races and their protests/penalties', async () => {
+      const leagueId = 'league-123';
+
+      // Mock races
+      mockRaceService.findByLeagueId.mockResolvedValue([
+        { id: 'race-1', track: 'Monza', scheduledAt: '2023-10-01T10:00:00Z' },
+        { id: 'race-2', track: 'Silverstone', scheduledAt: '2023-09-15T10:00:00Z' },
+      ]);
+
+      // Mock protests for race-1
+      mockProtestService.findByRaceId.mockImplementation(async (raceId) => {
+        if (raceId === 'race-1') {
+          return [
+            { id: 'protest-1', protestingDriverId: 'driver-1', accusedDriverId: 'driver-2', status: 'pending' },
+            { id: 'protest-2', protestingDriverId: 'driver-3', accusedDriverId: 'driver-4', status: 'upheld' },
+          ];
+        }
+        return [];
+      });
+
+      // Mock penalties for race-1
+      mockPenaltyService.findByRaceId.mockImplementation(async (raceId) => {
+        if (raceId === 'race-1') {
+          return [
+            { id: 'penalty-1', driverId: 'driver-2', type: 'time', value: 5, reason: 'Incident' },
+          ];
+        }
+        return [];
+      });
+
+      // Mock driver service
+      mockDriverService.findByIds.mockResolvedValue([
+        { id: 'driver-1', name: 'Driver 1' },
+        { id: 'driver-2', name: 'Driver 2' },
+        { id: 'driver-3', name: 'Driver 3' },
+        { id: 'driver-4', name: 'Driver 4' },
+      ]);
+
+      const result = await service.getLeagueStewardingData(leagueId);
+
+      expect(result).toBeInstanceOf(LeagueStewardingViewModel);
+      expect(result.racesWithData).toHaveLength(2);
+      expect(result.totalPending).toBe(1);
+      expect(result.totalResolved).toBe(1);
+      expect(result.totalPenalties).toBe(1);
+      expect(result.pendingRaces).toHaveLength(1);
+      expect(result.historyRaces).toHaveLength(1);
+    });
+
+    it('should handle empty races array', async () => {
+      const leagueId = 'league-123';
+
+      mockRaceService.findByLeagueId.mockResolvedValue([]);
+      mockProtestService.findByRaceId.mockResolvedValue([]);
+      mockPenaltyService.findByRaceId.mockResolvedValue([]);
+      mockDriverService.findByIds.mockResolvedValue([]);
+
+      const result = await service.getLeagueStewardingData(leagueId);
+
+      expect(result.racesWithData).toHaveLength(0);
+      expect(result.totalPending).toBe(0);
+      expect(result.totalResolved).toBe(0);
+      expect(result.totalPenalties).toBe(0);
+    });
+  });
+
+  describe('reviewProtest', () => {
+    it('should call protestService.reviewProtest', async () => {
+      const input = {
+        protestId: 'protest-123',
+        stewardId: 'steward-456',
+        decision: 'upheld',
+        decisionNotes: 'Test notes',
+      };
+
+      mockProtestService.reviewProtest = vi.fn().mockResolvedValue(undefined);
+
+      await service.reviewProtest(input);
+
+      expect(mockProtestService.reviewProtest).toHaveBeenCalledWith(input);
+    });
+  });
+
+  describe('applyPenalty', () => {
+    it('should call penaltyService.applyPenalty', async () => {
+      const input = {
+        driverId: 'driver-123',
+        raceId: 'race-456',
+        type: 'time',
+        value: 10,
+        reason: 'Test reason',
+      };
+
+      mockPenaltyService.applyPenalty = vi.fn().mockResolvedValue(undefined);
+
+      await service.applyPenalty(input);
+
+      expect(mockPenaltyService.applyPenalty).toHaveBeenCalledWith(input);
+    });
+  });
+});