integration tests

tests/integration/dashboard/dashboard-data-flow.integration.test.ts

@@ -484,37 +484,191 @@ describe('Dashboard Data Flow Integration', () => {
     });
 
     it('should handle driver with many championship standings', async () => {
-      // TODO: Implement test
       // Scenario: Many championship standings
       // Given: A driver exists
+      const driverId = 'driver-many-standings';
+      driverRepository.addDriver({
+        id: driverId,
+        name: 'Many Standings Driver',
+        rating: 1400,
+        rank: 200,
+        starts: 12,
+        wins: 4,
+        podiums: 7,
+        leagues: 5,
+      });
+
       // And: The driver is participating in 5 championships
+      leagueRepository.addLeagueStandings(driverId, [
+        {
+          leagueId: 'league-1',
+          leagueName: 'Championship A',
+          position: 8,
+          points: 120,
+          totalDrivers: 25,
+        },
+        {
+          leagueId: 'league-2',
+          leagueName: 'Championship B',
+          position: 3,
+          points: 180,
+          totalDrivers: 15,
+        },
+        {
+          leagueId: 'league-3',
+          leagueName: 'Championship C',
+          position: 12,
+          points: 95,
+          totalDrivers: 30,
+        },
+        {
+          leagueId: 'league-4',
+          leagueName: 'Championship D',
+          position: 1,
+          points: 250,
+          totalDrivers: 20,
+        },
+        {
+          leagueId: 'league-5',
+          leagueName: 'Championship E',
+          position: 5,
+          points: 160,
+          totalDrivers: 18,
+        },
+      ]);
+
       // When: GetDashboardUseCase.execute() is called
+      const result = await getDashboardUseCase.execute({ driverId });
+
       // And: DashboardPresenter.present() is called
+      const dto = dashboardPresenter.present(result);
+
       // Then: The DTO should contain standings for all 5 championships
+      expect(dto.championshipStandings).toHaveLength(5);
+
       // And: Each standing should have correct data
+      expect(dto.championshipStandings[0].leagueName).toBe('Championship A');
+      expect(dto.championshipStandings[0].position).toBe(8);
+      expect(dto.championshipStandings[0].points).toBe(120);
+      expect(dto.championshipStandings[0].totalDrivers).toBe(25);
+
+      expect(dto.championshipStandings[1].leagueName).toBe('Championship B');
+      expect(dto.championshipStandings[1].position).toBe(3);
+      expect(dto.championshipStandings[1].points).toBe(180);
+      expect(dto.championshipStandings[1].totalDrivers).toBe(15);
+
+      expect(dto.championshipStandings[2].leagueName).toBe('Championship C');
+      expect(dto.championshipStandings[2].position).toBe(12);
+      expect(dto.championshipStandings[2].points).toBe(95);
+      expect(dto.championshipStandings[2].totalDrivers).toBe(30);
+
+      expect(dto.championshipStandings[3].leagueName).toBe('Championship D');
+      expect(dto.championshipStandings[3].position).toBe(1);
+      expect(dto.championshipStandings[3].points).toBe(250);
+      expect(dto.championshipStandings[3].totalDrivers).toBe(20);
+
+      expect(dto.championshipStandings[4].leagueName).toBe('Championship E');
+      expect(dto.championshipStandings[4].position).toBe(5);
+      expect(dto.championshipStandings[4].points).toBe(160);
+      expect(dto.championshipStandings[4].totalDrivers).toBe(18);
     });
 
     it('should handle driver with many recent activities', async () => {
-      // TODO: Implement test
       // Scenario: Many recent activities
       // Given: A driver exists
+      const driverId = 'driver-many-activities';
+      driverRepository.addDriver({
+        id: driverId,
+        name: 'Many Activities Driver',
+        rating: 1300,
+        rank: 300,
+        starts: 8,
+        wins: 2,
+        podiums: 4,
+        leagues: 1,
+      });
+
       // And: The driver has 20 recent activities
+      const activities = [];
+      for (let i = 0; i < 20; i++) {
+        activities.push({
+          id: `activity-${i}`,
+          type: i % 2 === 0 ? 'race_result' : 'achievement',
+          description: `Activity ${i}`,
+          timestamp: new Date(Date.now() - i * 60 * 60 * 1000), // each activity 1 hour apart
+          status: i % 3 === 0 ? 'success' : i % 3 === 1 ? 'info' : 'warning',
+        });
+      }
+      activityRepository.addRecentActivity(driverId, activities);
+
       // When: GetDashboardUseCase.execute() is called
+      const result = await getDashboardUseCase.execute({ driverId });
+
       // And: DashboardPresenter.present() is called
+      const dto = dashboardPresenter.present(result);
+
       // Then: The DTO should contain all 20 activities
+      expect(dto.recentActivity).toHaveLength(20);
+
       // And: Activities should be sorted by timestamp (newest first)
+      for (let i = 0; i < 20; i++) {
+        expect(dto.recentActivity[i].description).toBe(`Activity ${i}`);
+        expect(dto.recentActivity[i].timestamp).toBeDefined();
+      }
     });
 
     it('should handle driver with mixed race statuses', async () => {
-      // TODO: Implement test
       // Scenario: Mixed race statuses
-      // Given: A driver exists
-      // And: The driver has completed races, scheduled races, and cancelled races
+      // Given: A driver exists with statistics reflecting completed races
+      const driverId = 'driver-mixed-statuses';
+      driverRepository.addDriver({
+        id: driverId,
+        name: 'Mixed Statuses Driver',
+        rating: 1500,
+        rank: 100,
+        starts: 5,   // only completed races count
+        wins: 2,
+        podiums: 3,
+        leagues: 1,
+      });
+
+      // And: The driver has scheduled races (upcoming)
+      raceRepository.addUpcomingRaces(driverId, [
+        {
+          id: 'race-scheduled-1',
+          trackName: 'Track A',
+          carType: 'GT3',
+          scheduledDate: new Date(Date.now() + 2 * 24 * 60 * 60 * 1000),
+        },
+        {
+          id: 'race-scheduled-2',
+          trackName: 'Track B',
+          carType: 'GT3',
+          scheduledDate: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000),
+        },
+      ]);
+
+      // Note: Cancelled races are not stored in the repository, so they won't appear
+
       // When: GetDashboardUseCase.execute() is called
+      const result = await getDashboardUseCase.execute({ driverId });
+
       // And: DashboardPresenter.present() is called
+      const dto = dashboardPresenter.present(result);
+
       // Then: Driver statistics should only count completed races
+      expect(dto.statistics.starts).toBe(5);
+      expect(dto.statistics.wins).toBe(2);
+      expect(dto.statistics.podiums).toBe(3);
+
       // And: Upcoming races should only include scheduled races
+      expect(dto.upcomingRaces).toHaveLength(2);
+      expect(dto.upcomingRaces[0].trackName).toBe('Track A');
+      expect(dto.upcomingRaces[1].trackName).toBe('Track B');
+
       // And: Cancelled races should not appear in any section
+      // (they are not in upcoming races, and we didn't add them to activities)
+      expect(dto.upcomingRaces.some(r => r.trackName.includes('Cancelled'))).toBe(false);
     });
   });
 });