integration tests

tests/integration/leaderboards/global-leaderboards-use-cases.integration.test.ts

@@ -1,247 +1,667 @@
 /**
  * Integration Test: Global Leaderboards Use Case Orchestration
- * 
+ *
  * Tests the orchestration logic of global leaderboards-related Use Cases:
  * - GetGlobalLeaderboardsUseCase: Retrieves top drivers and teams for the main leaderboards page
  * - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
  * - Uses In-Memory adapters for fast, deterministic testing
- * 
+ *
  * Focus: Business logic orchestration, NOT UI rendering
  */
 
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
-import { InMemoryDriverRepository } from '../../../adapters/drivers/persistence/inmemory/InMemoryDriverRepository';
-import { InMemoryTeamRepository } from '../../../adapters/teams/persistence/inmemory/InMemoryTeamRepository';
-import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
-import { GetGlobalLeaderboardsUseCase } from '../../../core/leaderboards/use-cases/GetGlobalLeaderboardsUseCase';
-import { GlobalLeaderboardsQuery } from '../../../core/leaderboards/ports/GlobalLeaderboardsQuery';
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { InMemoryLeaderboardsRepository } from '../../../adapters/leaderboards/persistence/inmemory/InMemoryLeaderboardsRepository';
+import { InMemoryLeaderboardsEventPublisher } from '../../../adapters/leaderboards/events/InMemoryLeaderboardsEventPublisher';
+import { GetGlobalLeaderboardsUseCase } from '../../../core/leaderboards/application/use-cases/GetGlobalLeaderboardsUseCase';
 
 describe('Global Leaderboards Use Case Orchestration', () => {
-  let driverRepository: InMemoryDriverRepository;
-  let teamRepository: InMemoryTeamRepository;
-  let eventPublisher: InMemoryEventPublisher;
+  let leaderboardsRepository: InMemoryLeaderboardsRepository;
+  let eventPublisher: InMemoryLeaderboardsEventPublisher;
   let getGlobalLeaderboardsUseCase: GetGlobalLeaderboardsUseCase;
 
   beforeAll(() => {
-    // TODO: Initialize In-Memory repositories and event publisher
-    // driverRepository = new InMemoryDriverRepository();
-    // teamRepository = new InMemoryTeamRepository();
-    // eventPublisher = new InMemoryEventPublisher();
-    // getGlobalLeaderboardsUseCase = new GetGlobalLeaderboardsUseCase({
-    //   driverRepository,
-    //   teamRepository,
-    //   eventPublisher,
-    // });
+    leaderboardsRepository = new InMemoryLeaderboardsRepository();
+    eventPublisher = new InMemoryLeaderboardsEventPublisher();
+    getGlobalLeaderboardsUseCase = new GetGlobalLeaderboardsUseCase({
+      leaderboardsRepository,
+      eventPublisher,
+    });
   });
 
   beforeEach(() => {
-    // TODO: Clear all In-Memory repositories before each test
-    // driverRepository.clear();
-    // teamRepository.clear();
-    // eventPublisher.clear();
+    leaderboardsRepository.clear();
+    eventPublisher.clear();
   });
 
   describe('GetGlobalLeaderboardsUseCase - Success Path', () => {
     it('should retrieve top drivers and teams with complete data', async () => {
-      // TODO: Implement test
       // Scenario: System has multiple drivers and teams with complete data
       // Given: Multiple drivers exist with various ratings and team affiliations
+      leaderboardsRepository.addDriver({
+        id: 'driver-1',
+        name: 'John Smith',
+        rating: 5.0,
+        teamId: 'team-1',
+        teamName: 'Racing Team A',
+        raceCount: 50,
+      });
+      leaderboardsRepository.addDriver({
+        id: 'driver-2',
+        name: 'Jane Doe',
+        rating: 4.8,
+        teamId: 'team-2',
+        teamName: 'Speed Squad',
+        raceCount: 45,
+      });
+      leaderboardsRepository.addDriver({
+        id: 'driver-3',
+        name: 'Bob Johnson',
+        rating: 4.5,
+        teamId: 'team-1',
+        teamName: 'Racing Team A',
+        raceCount: 40,
+      });
+
       // And: Multiple teams exist with various ratings and member counts
-      // And: Drivers are ranked by rating (highest first)
-      // And: Teams are ranked by rating (highest first)
+      leaderboardsRepository.addTeam({
+        id: 'team-1',
+        name: 'Racing Team A',
+        rating: 4.9,
+        memberCount: 5,
+        raceCount: 100,
+      });
+      leaderboardsRepository.addTeam({
+        id: 'team-2',
+        name: 'Speed Squad',
+        rating: 4.7,
+        memberCount: 3,
+        raceCount: 80,
+      });
+      leaderboardsRepository.addTeam({
+        id: 'team-3',
+        name: 'Champions League',
+        rating: 4.3,
+        memberCount: 4,
+        raceCount: 60,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
-      // Then: The result should contain top 10 drivers
-      // And: The result should contain top 10 teams
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
+      // Then: The result should contain top 10 drivers (but we only have 3)
+      expect(result.drivers).toHaveLength(3);
+
+      // And: The result should contain top 10 teams (but we only have 3)
+      expect(result.teams).toHaveLength(3);
+
       // And: Driver entries should include rank, name, rating, and team affiliation
+      expect(result.drivers[0]).toMatchObject({
+        rank: 1,
+        id: 'driver-1',
+        name: 'John Smith',
+        rating: 5.0,
+        teamId: 'team-1',
+        teamName: 'Racing Team A',
+        raceCount: 50,
+      });
+
       // And: Team entries should include rank, name, rating, and member count
+      expect(result.teams[0]).toMatchObject({
+        rank: 1,
+        id: 'team-1',
+        name: 'Racing Team A',
+        rating: 4.9,
+        memberCount: 5,
+        raceCount: 100,
+      });
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should retrieve top drivers and teams with minimal data', async () => {
-      // TODO: Implement test
       // Scenario: System has minimal data
       // Given: Only a few drivers exist
+      leaderboardsRepository.addDriver({
+        id: 'driver-1',
+        name: 'John Smith',
+        rating: 5.0,
+        raceCount: 10,
+      });
+
       // And: Only a few teams exist
+      leaderboardsRepository.addTeam({
+        id: 'team-1',
+        name: 'Racing Team A',
+        rating: 4.9,
+        memberCount: 2,
+        raceCount: 20,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: The result should contain all available drivers
+      expect(result.drivers).toHaveLength(1);
+      expect(result.drivers[0].name).toBe('John Smith');
+
       // And: The result should contain all available teams
+      expect(result.teams).toHaveLength(1);
+      expect(result.teams[0].name).toBe('Racing Team A');
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should retrieve top drivers and teams when there are many', async () => {
-      // TODO: Implement test
       // Scenario: System has many drivers and teams
       // Given: More than 10 drivers exist
+      for (let i = 1; i <= 15; i++) {
+        leaderboardsRepository.addDriver({
+          id: `driver-${i}`,
+          name: `Driver ${i}`,
+          rating: 5.0 - i * 0.1,
+          raceCount: 10 + i,
+        });
+      }
+
       // And: More than 10 teams exist
+      for (let i = 1; i <= 15; i++) {
+        leaderboardsRepository.addTeam({
+          id: `team-${i}`,
+          name: `Team ${i}`,
+          rating: 5.0 - i * 0.1,
+          memberCount: 2 + i,
+          raceCount: 20 + i,
+        });
+      }
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: The result should contain only top 10 drivers
+      expect(result.drivers).toHaveLength(10);
+
       // And: The result should contain only top 10 teams
+      expect(result.teams).toHaveLength(10);
+
       // And: Drivers should be sorted by rating (highest first)
+      expect(result.drivers[0].rating).toBe(4.9); // Driver 1
+      expect(result.drivers[9].rating).toBe(4.0); // Driver 10
+
       // And: Teams should be sorted by rating (highest first)
+      expect(result.teams[0].rating).toBe(4.9); // Team 1
+      expect(result.teams[9].rating).toBe(4.0); // Team 10
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should retrieve top drivers and teams with consistent ranking order', async () => {
-      // TODO: Implement test
       // Scenario: Verify ranking consistency
       // Given: Multiple drivers exist with various ratings
+      leaderboardsRepository.addDriver({
+        id: 'driver-1',
+        name: 'Driver A',
+        rating: 5.0,
+        raceCount: 10,
+      });
+      leaderboardsRepository.addDriver({
+        id: 'driver-2',
+        name: 'Driver B',
+        rating: 4.8,
+        raceCount: 10,
+      });
+      leaderboardsRepository.addDriver({
+        id: 'driver-3',
+        name: 'Driver C',
+        rating: 4.5,
+        raceCount: 10,
+      });
+
       // And: Multiple teams exist with various ratings
+      leaderboardsRepository.addTeam({
+        id: 'team-1',
+        name: 'Team A',
+        rating: 4.9,
+        memberCount: 2,
+        raceCount: 20,
+      });
+      leaderboardsRepository.addTeam({
+        id: 'team-2',
+        name: 'Team B',
+        rating: 4.7,
+        memberCount: 2,
+        raceCount: 20,
+      });
+      leaderboardsRepository.addTeam({
+        id: 'team-3',
+        name: 'Team C',
+        rating: 4.3,
+        memberCount: 2,
+        raceCount: 20,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: Driver ranks should be sequential (1, 2, 3...)
+      expect(result.drivers[0].rank).toBe(1);
+      expect(result.drivers[1].rank).toBe(2);
+      expect(result.drivers[2].rank).toBe(3);
+
       // And: Team ranks should be sequential (1, 2, 3...)
+      expect(result.teams[0].rank).toBe(1);
+      expect(result.teams[1].rank).toBe(2);
+      expect(result.teams[2].rank).toBe(3);
+
       // And: No duplicate ranks should appear
+      const driverRanks = result.drivers.map((d) => d.rank);
+      const teamRanks = result.teams.map((t) => t.rank);
+      expect(new Set(driverRanks).size).toBe(driverRanks.length);
+      expect(new Set(teamRanks).size).toBe(teamRanks.length);
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should retrieve top drivers and teams with accurate data', async () => {
-      // TODO: Implement test
       // Scenario: Verify data accuracy
       // Given: Drivers exist with valid ratings and names
+      leaderboardsRepository.addDriver({
+        id: 'driver-1',
+        name: 'John Smith',
+        rating: 5.0,
+        raceCount: 50,
+      });
+
       // And: Teams exist with valid ratings and member counts
+      leaderboardsRepository.addTeam({
+        id: 'team-1',
+        name: 'Racing Team A',
+        rating: 4.9,
+        memberCount: 5,
+        raceCount: 100,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: All driver ratings should be valid numbers
+      expect(result.drivers[0].rating).toBeGreaterThan(0);
+      expect(typeof result.drivers[0].rating).toBe('number');
+
       // And: All team ratings should be valid numbers
+      expect(result.teams[0].rating).toBeGreaterThan(0);
+      expect(typeof result.teams[0].rating).toBe('number');
+
       // And: All team member counts should be valid numbers
+      expect(result.teams[0].memberCount).toBeGreaterThan(0);
+      expect(typeof result.teams[0].memberCount).toBe('number');
+
       // And: All names should be non-empty strings
+      expect(result.drivers[0].name).toBeTruthy();
+      expect(typeof result.drivers[0].name).toBe('string');
+      expect(result.teams[0].name).toBeTruthy();
+      expect(typeof result.teams[0].name).toBe('string');
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
   });
 
   describe('GetGlobalLeaderboardsUseCase - Edge Cases', () => {
     it('should handle system with no drivers', async () => {
-      // TODO: Implement test
       // Scenario: System has no drivers
       // Given: No drivers exist in the system
       // And: Teams exist
+      leaderboardsRepository.addTeam({
+        id: 'team-1',
+        name: 'Racing Team A',
+        rating: 4.9,
+        memberCount: 5,
+        raceCount: 100,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: The result should contain empty drivers list
+      expect(result.drivers).toHaveLength(0);
+
       // And: The result should contain top teams
+      expect(result.teams).toHaveLength(1);
+      expect(result.teams[0].name).toBe('Racing Team A');
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should handle system with no teams', async () => {
-      // TODO: Implement test
       // Scenario: System has no teams
       // Given: Drivers exist
+      leaderboardsRepository.addDriver({
+        id: 'driver-1',
+        name: 'John Smith',
+        rating: 5.0,
+        raceCount: 50,
+      });
+
       // And: No teams exist in the system
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: The result should contain top drivers
+      expect(result.drivers).toHaveLength(1);
+      expect(result.drivers[0].name).toBe('John Smith');
+
       // And: The result should contain empty teams list
+      expect(result.teams).toHaveLength(0);
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should handle system with no data at all', async () => {
-      // TODO: Implement test
       // Scenario: System has absolutely no data
       // Given: No drivers exist
       // And: No teams exist
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: The result should contain empty drivers list
+      expect(result.drivers).toHaveLength(0);
+
       // And: The result should contain empty teams list
+      expect(result.teams).toHaveLength(0);
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should handle drivers with same rating', async () => {
-      // TODO: Implement test
       // Scenario: Multiple drivers with identical ratings
       // Given: Multiple drivers exist with the same rating
+      leaderboardsRepository.addDriver({
+        id: 'driver-1',
+        name: 'Zoe',
+        rating: 5.0,
+        raceCount: 50,
+      });
+      leaderboardsRepository.addDriver({
+        id: 'driver-2',
+        name: 'Alice',
+        rating: 5.0,
+        raceCount: 45,
+      });
+      leaderboardsRepository.addDriver({
+        id: 'driver-3',
+        name: 'Bob',
+        rating: 5.0,
+        raceCount: 40,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: Drivers should be sorted by rating
-      // And: Drivers with same rating should have consistent ordering (e.g., by name)
+      expect(result.drivers[0].rating).toBe(5.0);
+      expect(result.drivers[1].rating).toBe(5.0);
+      expect(result.drivers[2].rating).toBe(5.0);
+
+      // And: Drivers with same rating should have consistent ordering (by name)
+      expect(result.drivers[0].name).toBe('Alice');
+      expect(result.drivers[1].name).toBe('Bob');
+      expect(result.drivers[2].name).toBe('Zoe');
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
 
     it('should handle teams with same rating', async () => {
-      // TODO: Implement test
       // Scenario: Multiple teams with identical ratings
       // Given: Multiple teams exist with the same rating
+      leaderboardsRepository.addTeam({
+        id: 'team-1',
+        name: 'Zeta Team',
+        rating: 4.9,
+        memberCount: 5,
+        raceCount: 100,
+      });
+      leaderboardsRepository.addTeam({
+        id: 'team-2',
+        name: 'Alpha Team',
+        rating: 4.9,
+        memberCount: 3,
+        raceCount: 80,
+      });
+      leaderboardsRepository.addTeam({
+        id: 'team-3',
+        name: 'Beta Team',
+        rating: 4.9,
+        memberCount: 4,
+        raceCount: 60,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: Teams should be sorted by rating
-      // And: Teams with same rating should have consistent ordering (e.g., by name)
+      expect(result.teams[0].rating).toBe(4.9);
+      expect(result.teams[1].rating).toBe(4.9);
+      expect(result.teams[2].rating).toBe(4.9);
+
+      // And: Teams with same rating should have consistent ordering (by name)
+      expect(result.teams[0].name).toBe('Alpha Team');
+      expect(result.teams[1].name).toBe('Beta Team');
+      expect(result.teams[2].name).toBe('Zeta Team');
+
       // And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
     });
   });
 
   describe('GetGlobalLeaderboardsUseCase - Error Handling', () => {
     it('should handle repository errors gracefully', async () => {
-      // TODO: Implement test
       // Scenario: Repository throws error
-      // Given: DriverRepository throws an error during query
+      // Given: LeaderboardsRepository throws an error during query
+      const originalFindAllDrivers = leaderboardsRepository.findAllDrivers.bind(leaderboardsRepository);
+      leaderboardsRepository.findAllDrivers = async () => {
+        throw new Error('Repository error');
+      };
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
-      // Then: Should propagate the error appropriately
+      try {
+        await getGlobalLeaderboardsUseCase.execute();
+        // Should not reach here
+        expect(true).toBe(false);
+      } catch (error) {
+        // Then: Should propagate the error appropriately
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Repository error');
+      }
+
       // And: EventPublisher should NOT emit any events
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(0);
+
+      // Restore original method
+      leaderboardsRepository.findAllDrivers = originalFindAllDrivers;
     });
 
     it('should handle team repository errors gracefully', async () => {
-      // TODO: Implement test
       // Scenario: Team repository throws error
-      // Given: TeamRepository throws an error during query
+      // Given: LeaderboardsRepository throws an error during query
+      const originalFindAllTeams = leaderboardsRepository.findAllTeams.bind(leaderboardsRepository);
+      leaderboardsRepository.findAllTeams = async () => {
+        throw new Error('Team repository error');
+      };
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
-      // Then: Should propagate the error appropriately
+      try {
+        await getGlobalLeaderboardsUseCase.execute();
+        // Should not reach here
+        expect(true).toBe(false);
+      } catch (error) {
+        // Then: Should propagate the error appropriately
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Team repository error');
+      }
+
       // And: EventPublisher should NOT emit any events
+      expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(0);
+
+      // Restore original method
+      leaderboardsRepository.findAllTeams = originalFindAllTeams;
     });
   });
 
   describe('Global Leaderboards Data Orchestration', () => {
     it('should correctly calculate driver rankings based on rating', async () => {
-      // TODO: Implement test
       // Scenario: Driver ranking calculation
       // Given: Drivers exist with ratings: 5.0, 4.8, 4.5, 4.2, 4.0
+      const ratings = [5.0, 4.8, 4.5, 4.2, 4.0];
+      ratings.forEach((rating, index) => {
+        leaderboardsRepository.addDriver({
+          id: `driver-${index}`,
+          name: `Driver ${index}`,
+          rating,
+          raceCount: 10 + index,
+        });
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
-      // Then: Driver rankings should be:
-      // - Rank 1: Driver with rating 5.0
-      // - Rank 2: Driver with rating 4.8
-      // - Rank 3: Driver with rating 4.5
-      // - Rank 4: Driver with rating 4.2
-      // - Rank 5: Driver with rating 4.0
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
+      // Then: Driver rankings should be correct
+      expect(result.drivers[0].rank).toBe(1);
+      expect(result.drivers[0].rating).toBe(5.0);
+      expect(result.drivers[1].rank).toBe(2);
+      expect(result.drivers[1].rating).toBe(4.8);
+      expect(result.drivers[2].rank).toBe(3);
+      expect(result.drivers[2].rating).toBe(4.5);
+      expect(result.drivers[3].rank).toBe(4);
+      expect(result.drivers[3].rating).toBe(4.2);
+      expect(result.drivers[4].rank).toBe(5);
+      expect(result.drivers[4].rating).toBe(4.0);
     });
 
     it('should correctly calculate team rankings based on rating', async () => {
-      // TODO: Implement test
       // Scenario: Team ranking calculation
       // Given: Teams exist with ratings: 4.9, 4.7, 4.6, 4.3, 4.1
+      const ratings = [4.9, 4.7, 4.6, 4.3, 4.1];
+      ratings.forEach((rating, index) => {
+        leaderboardsRepository.addTeam({
+          id: `team-${index}`,
+          name: `Team ${index}`,
+          rating,
+          memberCount: 2 + index,
+          raceCount: 20 + index,
+        });
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
-      // Then: Team rankings should be:
-      // - Rank 1: Team with rating 4.9
-      // - Rank 2: Team with rating 4.7
-      // - Rank 3: Team with rating 4.6
-      // - Rank 4: Team with rating 4.3
-      // - Rank 5: Team with rating 4.1
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
+      // Then: Team rankings should be correct
+      expect(result.teams[0].rank).toBe(1);
+      expect(result.teams[0].rating).toBe(4.9);
+      expect(result.teams[1].rank).toBe(2);
+      expect(result.teams[1].rating).toBe(4.7);
+      expect(result.teams[2].rank).toBe(3);
+      expect(result.teams[2].rating).toBe(4.6);
+      expect(result.teams[3].rank).toBe(4);
+      expect(result.teams[3].rating).toBe(4.3);
+      expect(result.teams[4].rank).toBe(5);
+      expect(result.teams[4].rating).toBe(4.1);
     });
 
     it('should correctly format driver entries with team affiliation', async () => {
-      // TODO: Implement test
       // Scenario: Driver entry formatting
       // Given: A driver exists with team affiliation
+      leaderboardsRepository.addDriver({
+        id: 'driver-1',
+        name: 'John Smith',
+        rating: 5.0,
+        teamId: 'team-1',
+        teamName: 'Racing Team A',
+        raceCount: 50,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
-      // Then: Driver entry should include:
-      // - Rank: Sequential number
-      // - Name: Driver's full name
-      // - Rating: Driver's rating (formatted)
-      // - Team: Team name and logo (if available)
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
+      // Then: Driver entry should include all required fields
+      const driver = result.drivers[0];
+      expect(driver.rank).toBe(1);
+      expect(driver.id).toBe('driver-1');
+      expect(driver.name).toBe('John Smith');
+      expect(driver.rating).toBe(5.0);
+      expect(driver.teamId).toBe('team-1');
+      expect(driver.teamName).toBe('Racing Team A');
+      expect(driver.raceCount).toBe(50);
     });
 
     it('should correctly format team entries with member count', async () => {
-      // TODO: Implement test
       // Scenario: Team entry formatting
       // Given: A team exists with members
+      leaderboardsRepository.addTeam({
+        id: 'team-1',
+        name: 'Racing Team A',
+        rating: 4.9,
+        memberCount: 5,
+        raceCount: 100,
+      });
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
-      // Then: Team entry should include:
-      // - Rank: Sequential number
-      // - Name: Team's name
-      // - Rating: Team's rating (formatted)
-      // - Member Count: Number of drivers in team
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
+      // Then: Team entry should include all required fields
+      const team = result.teams[0];
+      expect(team.rank).toBe(1);
+      expect(team.id).toBe('team-1');
+      expect(team.name).toBe('Racing Team A');
+      expect(team.rating).toBe(4.9);
+      expect(team.memberCount).toBe(5);
+      expect(team.raceCount).toBe(100);
     });
 
     it('should limit results to top 10 drivers and teams', async () => {
-      // TODO: Implement test
       // Scenario: Result limiting
       // Given: More than 10 drivers exist
+      for (let i = 1; i <= 15; i++) {
+        leaderboardsRepository.addDriver({
+          id: `driver-${i}`,
+          name: `Driver ${i}`,
+          rating: 5.0 - i * 0.1,
+          raceCount: 10 + i,
+        });
+      }
+
       // And: More than 10 teams exist
+      for (let i = 1; i <= 15; i++) {
+        leaderboardsRepository.addTeam({
+          id: `team-${i}`,
+          name: `Team ${i}`,
+          rating: 5.0 - i * 0.1,
+          memberCount: 2 + i,
+          raceCount: 20 + i,
+        });
+      }
+
       // When: GetGlobalLeaderboardsUseCase.execute() is called
+      const result = await getGlobalLeaderboardsUseCase.execute();
+
       // Then: Only top 10 drivers should be returned
+      expect(result.drivers).toHaveLength(10);
+
       // And: Only top 10 teams should be returned
+      expect(result.teams).toHaveLength(10);
+
       // And: Results should be sorted by rating (highest first)
+      expect(result.drivers[0].rating).toBe(4.9); // Driver 1
+      expect(result.drivers[9].rating).toBe(4.0); // Driver 10
+      expect(result.teams[0].rating).toBe(4.9); // Team 1
+      expect(result.teams[9].rating).toBe(4.0); // Team 10
     });
   });
 });