integration tests

tests/integration/drivers/DriversTestContext.ts

@@ -0,0 +1,97 @@
+import { Logger } from '../../../core/shared/domain/Logger';
+import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
+import { InMemoryTeamRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamRepository';
+import { InMemoryTeamMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository';
+import { InMemorySocialGraphRepository } from '../../../adapters/social/persistence/inmemory/InMemorySocialAndFeed';
+import { InMemoryDriverExtendedProfileProvider } from '../../../adapters/racing/ports/InMemoryDriverExtendedProfileProvider';
+import { InMemoryDriverStatsRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverStatsRepository';
+import { GetProfileOverviewUseCase } from '../../../core/racing/application/use-cases/GetProfileOverviewUseCase';
+import { UpdateDriverProfileUseCase } from '../../../core/racing/application/use-cases/UpdateDriverProfileUseCase';
+import { DriverStatsUseCase } from '../../../core/racing/application/use-cases/DriverStatsUseCase';
+import { RankingUseCase } from '../../../core/racing/application/use-cases/RankingUseCase';
+import { GetDriversLeaderboardUseCase } from '../../../core/racing/application/use-cases/GetDriversLeaderboardUseCase';
+import { GetDriverUseCase } from '../../../core/racing/application/use-cases/GetDriverUseCase';
+
+export class DriversTestContext {
+  public readonly logger: Logger;
+  public readonly driverRepository: InMemoryDriverRepository;
+  public readonly teamRepository: InMemoryTeamRepository;
+  public readonly teamMembershipRepository: InMemoryTeamMembershipRepository;
+  public readonly socialRepository: InMemorySocialGraphRepository;
+  public readonly driverExtendedProfileProvider: InMemoryDriverExtendedProfileProvider;
+  public readonly driverStatsRepository: InMemoryDriverStatsRepository;
+
+  public readonly driverStatsUseCase: DriverStatsUseCase;
+  public readonly rankingUseCase: RankingUseCase;
+  public readonly getProfileOverviewUseCase: GetProfileOverviewUseCase;
+  public readonly updateDriverProfileUseCase: UpdateDriverProfileUseCase;
+  public readonly getDriversLeaderboardUseCase: GetDriversLeaderboardUseCase;
+  public readonly getDriverUseCase: GetDriverUseCase;
+
+  private constructor() {
+    this.logger = {
+      info: () => {},
+      debug: () => {},
+      warn: () => {},
+      error: () => {},
+    } as unknown as Logger;
+
+    this.driverRepository = new InMemoryDriverRepository(this.logger);
+    this.teamRepository = new InMemoryTeamRepository(this.logger);
+    this.teamMembershipRepository = new InMemoryTeamMembershipRepository(this.logger);
+    this.socialRepository = new InMemorySocialGraphRepository(this.logger);
+    this.driverExtendedProfileProvider = new InMemoryDriverExtendedProfileProvider(this.logger);
+    this.driverStatsRepository = new InMemoryDriverStatsRepository(this.logger);
+
+    this.driverStatsUseCase = new DriverStatsUseCase(
+      {} as any,
+      {} as any,
+      this.driverStatsRepository,
+      this.logger
+    );
+
+    this.rankingUseCase = new RankingUseCase(
+      {} as any,
+      {} as any,
+      this.driverStatsRepository,
+      this.logger
+    );
+
+    this.getProfileOverviewUseCase = new GetProfileOverviewUseCase(
+      this.driverRepository,
+      this.teamRepository,
+      this.teamMembershipRepository,
+      this.socialRepository,
+      this.driverExtendedProfileProvider,
+      this.driverStatsUseCase,
+      this.rankingUseCase
+    );
+
+    this.updateDriverProfileUseCase = new UpdateDriverProfileUseCase(
+      this.driverRepository,
+      this.logger
+    );
+
+    this.getDriversLeaderboardUseCase = new GetDriversLeaderboardUseCase(
+      this.driverRepository,
+      this.rankingUseCase,
+      this.driverStatsUseCase,
+      this.logger
+    );
+
+    this.getDriverUseCase = new GetDriverUseCase(this.driverRepository);
+  }
+
+  public static create(): DriversTestContext {
+    return new DriversTestContext();
+  }
+
+  public clear(): void {
+    this.driverRepository.clear();
+    this.teamRepository.clear();
+    this.teamMembershipRepository.clear();
+    this.socialRepository.clear();
+    this.driverExtendedProfileProvider.clear();
+    this.driverStatsRepository.clear();
+  }
+}

tests/integration/drivers/driver-profile-use-cases.integration.test.ts

@@ -1,407 +0,0 @@
-/**
- * Integration Test: Driver Profile Use Cases Orchestration
- *
- * Tests the orchestration logic of driver profile-related Use Cases:
- * - GetProfileOverviewUseCase: Retrieves driver profile overview with statistics, teams, friends, and extended info
- * - UpdateDriverProfileUseCase: Updates driver profile information
- * - Validates that Use Cases correctly interact with their Ports (Repositories, Providers, other Use Cases)
- * - Uses In-Memory adapters for fast, deterministic testing
- *
- * Focus: Business logic orchestration, NOT UI rendering
- */
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
-import { InMemoryTeamRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamRepository';
-import { InMemoryTeamMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository';
-import { InMemorySocialGraphRepository } from '../../../adapters/social/persistence/inmemory/InMemorySocialAndFeed';
-import { InMemoryDriverExtendedProfileProvider } from '../../../adapters/racing/ports/InMemoryDriverExtendedProfileProvider';
-import { InMemoryDriverStatsRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverStatsRepository';
-import { GetProfileOverviewUseCase } from '../../../core/racing/application/use-cases/GetProfileOverviewUseCase';
-import { UpdateDriverProfileUseCase } from '../../../core/racing/application/use-cases/UpdateDriverProfileUseCase';
-import { DriverStatsUseCase } from '../../../core/racing/application/use-cases/DriverStatsUseCase';
-import { RankingUseCase } from '../../../core/racing/application/use-cases/RankingUseCase';
-import { Driver } from '../../../core/racing/domain/entities/Driver';
-import { Team } from '../../../core/racing/domain/entities/Team';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('Driver Profile Use Cases Orchestration', () => {
-  let driverRepository: InMemoryDriverRepository;
-  let teamRepository: InMemoryTeamRepository;
-  let teamMembershipRepository: InMemoryTeamMembershipRepository;
-  let socialRepository: InMemorySocialGraphRepository;
-  let driverExtendedProfileProvider: InMemoryDriverExtendedProfileProvider;
-  let driverStatsRepository: InMemoryDriverStatsRepository;
-  let driverStatsUseCase: DriverStatsUseCase;
-  let rankingUseCase: RankingUseCase;
-  let getProfileOverviewUseCase: GetProfileOverviewUseCase;
-  let updateDriverProfileUseCase: UpdateDriverProfileUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-    
-    driverRepository = new InMemoryDriverRepository(mockLogger);
-    teamRepository = new InMemoryTeamRepository(mockLogger);
-    teamMembershipRepository = new InMemoryTeamMembershipRepository(mockLogger);
-    socialRepository = new InMemorySocialGraphRepository(mockLogger);
-    driverExtendedProfileProvider = new InMemoryDriverExtendedProfileProvider(mockLogger);
-    driverStatsRepository = new InMemoryDriverStatsRepository(mockLogger);
-    
-    driverStatsUseCase = new DriverStatsUseCase(
-      {} as any,
-      {} as any,
-      driverStatsRepository,
-      mockLogger
-    );
-    
-    rankingUseCase = new RankingUseCase(
-      {} as any,
-      {} as any,
-      driverStatsRepository,
-      mockLogger
-    );
-
-    getProfileOverviewUseCase = new GetProfileOverviewUseCase(
-      driverRepository,
-      teamRepository,
-      teamMembershipRepository,
-      socialRepository,
-      driverExtendedProfileProvider,
-      driverStatsUseCase,
-      rankingUseCase
-    );
-    
-    updateDriverProfileUseCase = new UpdateDriverProfileUseCase(driverRepository, mockLogger);
-  });
-
-  beforeEach(() => {
-    driverRepository.clear();
-    teamRepository.clear();
-    teamMembershipRepository.clear();
-    socialRepository.clear();
-    driverExtendedProfileProvider.clear();
-    driverStatsRepository.clear();
-  });
-
-  describe('UpdateDriverProfileUseCase - Success Path', () => {
-    it('should update driver bio', async () => {
-      // Scenario: Update driver bio
-      // Given: A driver exists with bio
-      const driverId = 'd2';
-      const driver = Driver.create({ id: driverId, iracingId: '2', name: 'Update Driver', country: 'US', bio: 'Original bio' });
-      await driverRepository.create(driver);
-
-      // When: UpdateDriverProfileUseCase.execute() is called with new bio
-      const result = await updateDriverProfileUseCase.execute({
-        driverId,
-        bio: 'Updated bio',
-      });
-
-      // Then: The operation should succeed
-      expect(result.isOk()).toBe(true);
-
-      // And: The driver's bio should be updated
-      const updatedDriver = await driverRepository.findById(driverId);
-      expect(updatedDriver).not.toBeNull();
-      expect(updatedDriver!.bio?.toString()).toBe('Updated bio');
-    });
-
-    it('should update driver country', async () => {
-      // Scenario: Update driver country
-      // Given: A driver exists with country
-      const driverId = 'd3';
-      const driver = Driver.create({ id: driverId, iracingId: '3', name: 'Country Driver', country: 'US' });
-      await driverRepository.create(driver);
-
-      // When: UpdateDriverProfileUseCase.execute() is called with new country
-      const result = await updateDriverProfileUseCase.execute({
-        driverId,
-        country: 'DE',
-      });
-
-      // Then: The operation should succeed
-      expect(result.isOk()).toBe(true);
-
-      // And: The driver's country should be updated
-      const updatedDriver = await driverRepository.findById(driverId);
-      expect(updatedDriver).not.toBeNull();
-      expect(updatedDriver!.country.toString()).toBe('DE');
-    });
-
-    it('should update multiple profile fields at once', async () => {
-      // Scenario: Update multiple fields
-      // Given: A driver exists
-      const driverId = 'd4';
-      const driver = Driver.create({ id: driverId, iracingId: '4', name: 'Multi Update Driver', country: 'US', bio: 'Original bio' });
-      await driverRepository.create(driver);
-
-      // When: UpdateDriverProfileUseCase.execute() is called with multiple updates
-      const result = await updateDriverProfileUseCase.execute({
-        driverId,
-        bio: 'Updated bio',
-        country: 'FR',
-      });
-
-      // Then: The operation should succeed
-      expect(result.isOk()).toBe(true);
-
-      // And: Both fields should be updated
-      const updatedDriver = await driverRepository.findById(driverId);
-      expect(updatedDriver).not.toBeNull();
-      expect(updatedDriver!.bio?.toString()).toBe('Updated bio');
-      expect(updatedDriver!.country.toString()).toBe('FR');
-    });
-  });
-
-  describe('UpdateDriverProfileUseCase - Validation', () => {
-    it('should reject update with empty bio', async () => {
-      // Scenario: Empty bio
-      // Given: A driver exists
-      const driverId = 'd5';
-      const driver = Driver.create({ id: driverId, iracingId: '5', name: 'Empty Bio Driver', country: 'US' });
-      await driverRepository.create(driver);
-
-      // When: UpdateDriverProfileUseCase.execute() is called with empty bio
-      const result = await updateDriverProfileUseCase.execute({
-        driverId,
-        bio: '',
-      });
-
-      // Then: Should return error
-      expect(result.isErr()).toBe(true);
-      const error = result.unwrapErr();
-      expect(error.code).toBe('INVALID_PROFILE_DATA');
-      expect(error.details.message).toBe('Profile data is invalid');
-    });
-
-    it('should reject update with empty country', async () => {
-      // Scenario: Empty country
-      // Given: A driver exists
-      const driverId = 'd6';
-      const driver = Driver.create({ id: driverId, iracingId: '6', name: 'Empty Country Driver', country: 'US' });
-      await driverRepository.create(driver);
-
-      // When: UpdateDriverProfileUseCase.execute() is called with empty country
-      const result = await updateDriverProfileUseCase.execute({
-        driverId,
-        country: '',
-      });
-
-      // Then: Should return error
-      expect(result.isErr()).toBe(true);
-      const error = result.unwrapErr();
-      expect(error.code).toBe('INVALID_PROFILE_DATA');
-      expect(error.details.message).toBe('Profile data is invalid');
-    });
-  });
-
-  describe('UpdateDriverProfileUseCase - Error Handling', () => {
-    it('should return error when driver does not exist', async () => {
-      // Scenario: Non-existent driver
-      // Given: No driver exists with the given ID
-      const nonExistentDriverId = 'non-existent-driver';
-
-      // When: UpdateDriverProfileUseCase.execute() is called with non-existent driver ID
-      const result = await updateDriverProfileUseCase.execute({
-        driverId: nonExistentDriverId,
-        bio: 'New bio',
-      });
-
-      // Then: Should return error
-      expect(result.isErr()).toBe(true);
-      const error = result.unwrapErr();
-      expect(error.code).toBe('DRIVER_NOT_FOUND');
-      expect(error.details.message).toContain('Driver with id');
-    });
-
-    it('should return error when driver ID is invalid', async () => {
-      // Scenario: Invalid driver ID
-      // Given: An invalid driver ID (empty string)
-      const invalidDriverId = '';
-
-      // When: UpdateDriverProfileUseCase.execute() is called with invalid driver ID
-      const result = await updateDriverProfileUseCase.execute({
-        driverId: invalidDriverId,
-        bio: 'New bio',
-      });
-
-      // Then: Should return error
-      expect(result.isErr()).toBe(true);
-      const error = result.unwrapErr();
-      expect(error.code).toBe('DRIVER_NOT_FOUND');
-      expect(error.details.message).toContain('Driver with id');
-    });
-  });
-
-  describe('DriverStatsUseCase - Success Path', () => {
-    it('should compute driver statistics from race results', async () => {
-      // Scenario: Driver with race results
-      // Given: A driver exists
-      const driverId = 'd7';
-      const driver = Driver.create({ id: driverId, iracingId: '7', name: 'Stats Driver', country: 'US' });
-      await driverRepository.create(driver);
-
-      // And: The driver has race results
-      await driverStatsRepository.saveDriverStats(driverId, {
-        rating: 1800,
-        totalRaces: 15,
-        wins: 3,
-        podiums: 8,
-        overallRank: 5,
-        safetyRating: 4.2,
-        sportsmanshipRating: 90,
-        dnfs: 1,
-        avgFinish: 4.2,
-        bestFinish: 1,
-        worstFinish: 12,
-        consistency: 80,
-        experienceLevel: 'intermediate'
-      });
-
-      // When: DriverStatsUseCase.getDriverStats() is called
-      const stats = await driverStatsUseCase.getDriverStats(driverId);
-
-      // Then: Should return computed statistics
-      expect(stats).not.toBeNull();
-      expect(stats!.rating).toBe(1800);
-      expect(stats!.totalRaces).toBe(15);
-      expect(stats!.wins).toBe(3);
-      expect(stats!.podiums).toBe(8);
-      expect(stats!.overallRank).toBe(5);
-      expect(stats!.safetyRating).toBe(4.2);
-      expect(stats!.sportsmanshipRating).toBe(90);
-      expect(stats!.dnfs).toBe(1);
-      expect(stats!.avgFinish).toBe(4.2);
-      expect(stats!.bestFinish).toBe(1);
-      expect(stats!.worstFinish).toBe(12);
-      expect(stats!.consistency).toBe(80);
-      expect(stats!.experienceLevel).toBe('intermediate');
-    });
-
-    it('should handle driver with no race results', async () => {
-      // Scenario: New driver with no history
-      // Given: A driver exists
-      const driverId = 'd8';
-      const driver = Driver.create({ id: driverId, iracingId: '8', name: 'New Stats Driver', country: 'DE' });
-      await driverRepository.create(driver);
-
-      // When: DriverStatsUseCase.getDriverStats() is called
-      const stats = await driverStatsUseCase.getDriverStats(driverId);
-
-      // Then: Should return null stats
-      expect(stats).toBeNull();
-    });
-  });
-
-  describe('DriverStatsUseCase - Error Handling', () => {
-    it('should return error when driver does not exist', async () => {
-      // Scenario: Non-existent driver
-      // Given: No driver exists with the given ID
-      const nonExistentDriverId = 'non-existent-driver';
-
-      // When: DriverStatsUseCase.getDriverStats() is called
-      const stats = await driverStatsUseCase.getDriverStats(nonExistentDriverId);
-
-      // Then: Should return null (no error for non-existent driver)
-      expect(stats).toBeNull();
-    });
-  });
-
-  describe('GetProfileOverviewUseCase - Success Path', () => {
-    it('should retrieve complete driver profile overview', async () => {
-      // Scenario: Driver with complete data
-      // Given: A driver exists
-      const driverId = 'd1';
-      const driver = Driver.create({ id: driverId, iracingId: '1', name: 'John Doe', country: 'US' });
-      await driverRepository.create(driver);
-
-      // And: The driver has statistics
-      await driverStatsRepository.saveDriverStats(driverId, {
-        rating: 2000,
-        totalRaces: 10,
-        wins: 2,
-        podiums: 5,
-        overallRank: 1,
-        safetyRating: 4.5,
-        sportsmanshipRating: 95,
-        dnfs: 0,
-        avgFinish: 3.5,
-        bestFinish: 1,
-        worstFinish: 10,
-        consistency: 85,
-        experienceLevel: 'pro'
-      });
-
-      // And: The driver is in a team
-      const team = Team.create({ id: 't1', name: 'Team 1', tag: 'T1', description: 'Desc', ownerId: 'other', leagues: [] });
-      await teamRepository.create(team);
-      await teamMembershipRepository.saveMembership({
-        teamId: 't1',
-        driverId: driverId,
-        role: 'driver',
-        status: 'active',
-        joinedAt: new Date()
-      });
-
-      // And: The driver has friends
-      socialRepository.seed({
-        drivers: [driver, Driver.create({ id: 'f1', iracingId: '2', name: 'Friend 1', country: 'UK' })],
-        friendships: [{ driverId: driverId, friendId: 'f1' }],
-        feedEvents: []
-      });
-
-      // When: GetProfileOverviewUseCase.execute() is called
-      const result = await getProfileOverviewUseCase.execute({ driverId });
-
-      // Then: The result should contain all profile sections
-      expect(result.isOk()).toBe(true);
-      const overview = result.unwrap();
-      
-      expect(overview.driverInfo.driver.id).toBe(driverId);
-      expect(overview.stats?.rating).toBe(2000);
-      expect(overview.teamMemberships).toHaveLength(1);
-      expect(overview.teamMemberships[0].team.id).toBe('t1');
-      expect(overview.socialSummary.friendsCount).toBe(1);
-      expect(overview.extendedProfile).toBeDefined();
-    });
-
-    it('should handle driver with minimal data', async () => {
-      // Scenario: New driver with no history
-      // Given: A driver exists
-      const driverId = 'new';
-      const driver = Driver.create({ id: driverId, iracingId: '9', name: 'New Driver', country: 'DE' });
-      await driverRepository.create(driver);
-
-      // When: GetProfileOverviewUseCase.execute() is called
-      const result = await getProfileOverviewUseCase.execute({ driverId });
-
-      // Then: The result should contain basic info but null stats
-      expect(result.isOk()).toBe(true);
-      const overview = result.unwrap();
-      
-      expect(overview.driverInfo.driver.id).toBe(driverId);
-      expect(overview.stats).toBeNull();
-      expect(overview.teamMemberships).toHaveLength(0);
-      expect(overview.socialSummary.friendsCount).toBe(0);
-    });
-  });
-
-  describe('GetProfileOverviewUseCase - Error Handling', () => {
-    it('should return error when driver does not exist', async () => {
-      // Scenario: Non-existent driver
-      // When: GetProfileOverviewUseCase.execute() is called
-      const result = await getProfileOverviewUseCase.execute({ driverId: 'none' });
-
-      // Then: Should return DRIVER_NOT_FOUND
-      expect(result.isErr()).toBe(true);
-      const error = result.unwrapErr();
-      expect(error.code).toBe('DRIVER_NOT_FOUND');
-    });
-  });
-});

tests/integration/drivers/drivers-list-use-cases.integration.test.ts

@@ -1,236 +0,0 @@
-/**
- * Integration Test: GetDriversLeaderboardUseCase Orchestration
- * 
- * Tests the orchestration logic of GetDriversLeaderboardUseCase:
- * - GetDriversLeaderboardUseCase: Retrieves list of drivers with rankings and statistics
- * - Validates that Use Cases correctly interact with their Ports (Repositories, other Use Cases)
- * - Uses In-Memory adapters for fast, deterministic testing
- * 
- * Focus: Business logic orchestration, NOT UI rendering
- */
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
-import { InMemoryDriverStatsRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverStatsRepository';
-import { GetDriversLeaderboardUseCase } from '../../../core/racing/application/use-cases/GetDriversLeaderboardUseCase';
-import { RankingUseCase } from '../../../core/racing/application/use-cases/RankingUseCase';
-import { DriverStatsUseCase } from '../../../core/racing/application/use-cases/DriverStatsUseCase';
-import { Driver } from '../../../core/racing/domain/entities/Driver';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('GetDriversLeaderboardUseCase Orchestration', () => {
-  let driverRepository: InMemoryDriverRepository;
-  let driverStatsRepository: InMemoryDriverStatsRepository;
-  let rankingUseCase: RankingUseCase;
-  let driverStatsUseCase: DriverStatsUseCase;
-  let getDriversLeaderboardUseCase: GetDriversLeaderboardUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-    
-    driverRepository = new InMemoryDriverRepository(mockLogger);
-    driverStatsRepository = new InMemoryDriverStatsRepository(mockLogger);
-    
-    // RankingUseCase and DriverStatsUseCase are dependencies of GetDriversLeaderboardUseCase
-    rankingUseCase = new RankingUseCase(
-      {} as any, // standingRepository not used in getAllDriverRankings
-      {} as any, // driverRepository not used in getAllDriverRankings
-      driverStatsRepository,
-      mockLogger
-    );
-    
-    driverStatsUseCase = new DriverStatsUseCase(
-      {} as any, // resultRepository not used in getDriverStats
-      {} as any, // standingRepository not used in getDriverStats
-      driverStatsRepository,
-      mockLogger
-    );
-
-    getDriversLeaderboardUseCase = new GetDriversLeaderboardUseCase(
-      driverRepository,
-      rankingUseCase,
-      driverStatsUseCase,
-      mockLogger
-    );
-  });
-
-  beforeEach(() => {
-    driverRepository.clear();
-    driverStatsRepository.clear();
-  });
-
-  describe('GetDriversLeaderboardUseCase - Success Path', () => {
-    it('should retrieve complete list of drivers with all data', async () => {
-      // Scenario: System has multiple drivers
-      // Given: 3 drivers exist with various data
-      const drivers = [
-        Driver.create({ id: 'd1', iracingId: '1', name: 'Driver 1', country: 'US' }),
-        Driver.create({ id: 'd2', iracingId: '2', name: 'Driver 2', country: 'UK' }),
-        Driver.create({ id: 'd3', iracingId: '3', name: 'Driver 3', country: 'DE' }),
-      ];
-      
-      for (const d of drivers) {
-        await driverRepository.create(d);
-      }
-
-      // And: Each driver has statistics
-      await driverStatsRepository.saveDriverStats('d1', {
-        rating: 2000,
-        totalRaces: 10,
-        wins: 2,
-        podiums: 5,
-        overallRank: 1,
-        safetyRating: 4.5,
-        sportsmanshipRating: 95,
-        dnfs: 0,
-        avgFinish: 3.5,
-        bestFinish: 1,
-        worstFinish: 10,
-        consistency: 85,
-        experienceLevel: 'pro'
-      });
-      await driverStatsRepository.saveDriverStats('d2', {
-        rating: 1800,
-        totalRaces: 8,
-        wins: 1,
-        podiums: 3,
-        overallRank: 2,
-        safetyRating: 4.0,
-        sportsmanshipRating: 90,
-        dnfs: 1,
-        avgFinish: 5.2,
-        bestFinish: 1,
-        worstFinish: 15,
-        consistency: 75,
-        experienceLevel: 'intermediate'
-      });
-      await driverStatsRepository.saveDriverStats('d3', {
-        rating: 1500,
-        totalRaces: 5,
-        wins: 0,
-        podiums: 1,
-        overallRank: 3,
-        safetyRating: 3.5,
-        sportsmanshipRating: 80,
-        dnfs: 0,
-        avgFinish: 8.0,
-        bestFinish: 3,
-        worstFinish: 12,
-        consistency: 65,
-        experienceLevel: 'rookie'
-      });
-
-      // When: GetDriversLeaderboardUseCase.execute() is called
-      const result = await getDriversLeaderboardUseCase.execute({});
-
-      // Then: The result should contain all drivers
-      expect(result.isOk()).toBe(true);
-      const leaderboard = result.unwrap();
-      
-      expect(leaderboard.items).toHaveLength(3);
-      expect(leaderboard.totalRaces).toBe(23);
-      expect(leaderboard.totalWins).toBe(3);
-      expect(leaderboard.activeCount).toBe(3);
-
-      // And: Drivers should be sorted by rating (high to low)
-      expect(leaderboard.items[0].driver.id).toBe('d1');
-      expect(leaderboard.items[1].driver.id).toBe('d2');
-      expect(leaderboard.items[2].driver.id).toBe('d3');
-      
-      expect(leaderboard.items[0].rating).toBe(2000);
-      expect(leaderboard.items[1].rating).toBe(1800);
-      expect(leaderboard.items[2].rating).toBe(1500);
-    });
-
-    it('should handle empty drivers list', async () => {
-      // Scenario: System has no registered drivers
-      // Given: No drivers exist in the system
-      // When: GetDriversLeaderboardUseCase.execute() is called
-      const result = await getDriversLeaderboardUseCase.execute({});
-
-      // Then: The result should contain an empty array
-      expect(result.isOk()).toBe(true);
-      const leaderboard = result.unwrap();
-      expect(leaderboard.items).toHaveLength(0);
-      expect(leaderboard.totalRaces).toBe(0);
-      expect(leaderboard.totalWins).toBe(0);
-      expect(leaderboard.activeCount).toBe(0);
-    });
-
-    it('should correctly identify active drivers', async () => {
-      // Scenario: Some drivers have no races
-      // Given: 2 drivers exist, one with races, one without
-      await driverRepository.create(Driver.create({ id: 'active', iracingId: '1', name: 'Active', country: 'US' }));
-      await driverRepository.create(Driver.create({ id: 'inactive', iracingId: '2', name: 'Inactive', country: 'UK' }));
-      
-      await driverStatsRepository.saveDriverStats('active', {
-        rating: 1500,
-        totalRaces: 1,
-        wins: 0,
-        podiums: 0,
-        overallRank: 1,
-        safetyRating: 3.0,
-        sportsmanshipRating: 70,
-        dnfs: 0,
-        avgFinish: 10,
-        bestFinish: 10,
-        worstFinish: 10,
-        consistency: 50,
-        experienceLevel: 'rookie'
-      });
-      // No stats for inactive driver or totalRaces = 0
-      await driverStatsRepository.saveDriverStats('inactive', {
-        rating: 1000,
-        totalRaces: 0,
-        wins: 0,
-        podiums: 0,
-        overallRank: null,
-        safetyRating: 2.5,
-        sportsmanshipRating: 50,
-        dnfs: 0,
-        avgFinish: 0,
-        bestFinish: 0,
-        worstFinish: 0,
-        consistency: 0,
-        experienceLevel: 'rookie'
-      });
-
-      // When: GetDriversLeaderboardUseCase.execute() is called
-      const result = await getDriversLeaderboardUseCase.execute({});
-
-      // Then: Only one driver should be active
-      const leaderboard = result.unwrap();
-      expect(leaderboard.activeCount).toBe(1);
-      expect(leaderboard.items.find(i => i.driver.id === 'active')?.isActive).toBe(true);
-      expect(leaderboard.items.find(i => i.driver.id === 'inactive')?.isActive).toBe(false);
-    });
-  });
-
-  describe('GetDriversLeaderboardUseCase - Error Handling', () => {
-    it('should handle repository errors gracefully', async () => {
-      // Scenario: Repository throws error
-      // Given: DriverRepository throws an error during query
-      const originalFindAll = driverRepository.findAll.bind(driverRepository);
-      driverRepository.findAll = async () => {
-        throw new Error('Repository error');
-      };
-
-      // When: GetDriversLeaderboardUseCase.execute() is called
-      const result = await getDriversLeaderboardUseCase.execute({});
-
-      // Then: Should return a repository error
-      expect(result.isErr()).toBe(true);
-      const error = result.unwrapErr();
-      expect(error.code).toBe('REPOSITORY_ERROR');
-
-      // Restore original method
-      driverRepository.findAll = originalFindAll;
-    });
-  });
-});

tests/integration/drivers/get-driver/get-driver.integration.test.ts

@@ -1,47 +1,18 @@
-/**
- * Integration Test: GetDriverUseCase Orchestration
- * 
- * Tests the orchestration logic of GetDriverUseCase:
- * - GetDriverUseCase: Retrieves a single driver by ID
- * - Validates that Use Cases correctly interact with their Ports (Repositories)
- * - Uses In-Memory adapters for fast, deterministic testing
- * 
- * Focus: Business logic orchestration, NOT UI rendering
- */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DriversTestContext } from '../DriversTestContext';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+import { MediaReference } from '../../../../core/domain/media/MediaReference';
 
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
-import { GetDriverUseCase } from '../../../core/racing/application/use-cases/GetDriverUseCase';
-import { Driver } from '../../../core/racing/domain/entities/Driver';
-import { MediaReference } from '../../../core/domain/media/MediaReference';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('GetDriverUseCase Orchestration', () => {
-  let driverRepository: InMemoryDriverRepository;
-  let getDriverUseCase: GetDriverUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-    
-    driverRepository = new InMemoryDriverRepository(mockLogger);
-    getDriverUseCase = new GetDriverUseCase(driverRepository);
-  });
+describe('GetDriverUseCase Integration', () => {
+  let context: DriversTestContext;
 
   beforeEach(() => {
-    // Clear all In-Memory repositories before each test
-    driverRepository.clear();
+    context = DriversTestContext.create();
+    context.clear();
   });
 
-  describe('GetDriverUseCase - Success Path', () => {
+  describe('Success Path', () => {
     it('should retrieve complete driver with all data', async () => {
-      // Scenario: Driver with complete profile data
-      // Given: A driver exists with personal information (name, avatar, bio, country)
       const driverId = 'driver-123';
       const driver = Driver.create({
         id: driverId,
@@ -52,12 +23,10 @@ describe('GetDriverUseCase Orchestration', () => {
         avatarRef: MediaReference.createUploaded('avatar-123'),
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called with driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should contain all driver data
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -71,8 +40,6 @@ describe('GetDriverUseCase Orchestration', () => {
     });
 
     it('should retrieve driver with minimal data', async () => {
-      // Scenario: Driver with minimal profile data
-      // Given: A driver exists with only basic information (name, country)
       const driverId = 'driver-456';
       const driver = Driver.create({
         id: driverId,
@@ -81,12 +48,10 @@ describe('GetDriverUseCase Orchestration', () => {
         country: 'UK',
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called with driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should contain basic driver info
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -100,8 +65,6 @@ describe('GetDriverUseCase Orchestration', () => {
     });
 
     it('should retrieve driver with bio but no avatar', async () => {
-      // Scenario: Driver with bio but no avatar
-      // Given: A driver exists with bio but no avatar
       const driverId = 'driver-789';
       const driver = Driver.create({
         id: driverId,
@@ -111,12 +74,10 @@ describe('GetDriverUseCase Orchestration', () => {
         bio: 'Canadian racer',
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called with driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should contain driver info with bio
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -127,8 +88,6 @@ describe('GetDriverUseCase Orchestration', () => {
     });
 
     it('should retrieve driver with avatar but no bio', async () => {
-      // Scenario: Driver with avatar but no bio
-      // Given: A driver exists with avatar but no bio
       const driverId = 'driver-999';
       const driver = Driver.create({
         id: driverId,
@@ -138,12 +97,10 @@ describe('GetDriverUseCase Orchestration', () => {
         avatarRef: MediaReference.createUploaded('avatar-999'),
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called with driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should contain driver info with avatar
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -154,10 +111,8 @@ describe('GetDriverUseCase Orchestration', () => {
     });
   });
 
-  describe('GetDriverUseCase - Edge Cases', () => {
+  describe('Edge Cases', () => {
     it('should handle driver with no bio', async () => {
-      // Scenario: Driver with no bio
-      // Given: A driver exists
       const driverId = 'driver-no-bio';
       const driver = Driver.create({
         id: driverId,
@@ -166,12 +121,10 @@ describe('GetDriverUseCase Orchestration', () => {
         country: 'FR',
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called with driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should contain driver profile
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -181,8 +134,6 @@ describe('GetDriverUseCase Orchestration', () => {
     });
 
     it('should handle driver with no avatar', async () => {
-      // Scenario: Driver with no avatar
-      // Given: A driver exists
       const driverId = 'driver-no-avatar';
       const driver = Driver.create({
         id: driverId,
@@ -191,12 +142,10 @@ describe('GetDriverUseCase Orchestration', () => {
         country: 'ES',
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called with driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should contain driver profile
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -206,8 +155,6 @@ describe('GetDriverUseCase Orchestration', () => {
     });
 
     it('should handle driver with no data at all', async () => {
-      // Scenario: Driver with absolutely no data
-      // Given: A driver exists with only required fields
       const driverId = 'driver-minimal';
       const driver = Driver.create({
         id: driverId,
@@ -216,12 +163,10 @@ describe('GetDriverUseCase Orchestration', () => {
         country: 'IT',
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called with driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should contain basic driver info
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -235,23 +180,17 @@ describe('GetDriverUseCase Orchestration', () => {
     });
   });
 
-  describe('GetDriverUseCase - Error Handling', () => {
+  describe('Error Handling', () => {
     it('should return null when driver does not exist', async () => {
-      // Scenario: Non-existent driver
-      // Given: No driver exists with the given ID
       const driverId = 'non-existent-driver';
 
-      // When: GetDriverUseCase.execute() is called with non-existent driver ID
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The result should be null
       expect(result.isOk()).toBe(true);
       expect(result.unwrap()).toBeNull();
     });
 
     it('should handle repository errors gracefully', async () => {
-      // Scenario: Repository throws error
-      // Given: A driver exists
       const driverId = 'driver-error';
       const driver = Driver.create({
         id: driverId,
@@ -260,31 +199,25 @@ describe('GetDriverUseCase Orchestration', () => {
         country: 'US',
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // Mock the repository to throw an error
-      const originalFindById = driverRepository.findById.bind(driverRepository);
-      driverRepository.findById = async () => {
+      const originalFindById = context.driverRepository.findById.bind(context.driverRepository);
+      context.driverRepository.findById = async () => {
         throw new Error('Repository error');
       };
 
-      // When: GetDriverUseCase.execute() is called
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: Should propagate the error appropriately
       expect(result.isErr()).toBe(true);
       const error = result.unwrapErr();
       expect(error.message).toBe('Repository error');
 
-      // Restore original method
-      driverRepository.findById = originalFindById;
+      context.driverRepository.findById = originalFindById;
     });
   });
 
-  describe('GetDriverUseCase - Data Orchestration', () => {
+  describe('Data Orchestration', () => {
     it('should correctly retrieve driver with all fields populated', async () => {
-      // Scenario: Driver with all fields populated
-      // Given: A driver exists with all possible fields
       const driverId = 'driver-complete';
       const driver = Driver.create({
         id: driverId,
@@ -296,12 +229,10 @@ describe('GetDriverUseCase Orchestration', () => {
         category: 'pro',
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: All fields should be correctly retrieved
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -315,8 +246,6 @@ describe('GetDriverUseCase Orchestration', () => {
     });
 
     it('should correctly retrieve driver with system-default avatar', async () => {
-      // Scenario: Driver with system-default avatar
-      // Given: A driver exists with system-default avatar
       const driverId = 'driver-system-avatar';
       const driver = Driver.create({
         id: driverId,
@@ -326,12 +255,10 @@ describe('GetDriverUseCase Orchestration', () => {
         avatarRef: MediaReference.createSystemDefault('avatar'),
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The avatar reference should be correctly retrieved
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       
@@ -340,8 +267,6 @@ describe('GetDriverUseCase Orchestration', () => {
     });
 
     it('should correctly retrieve driver with generated avatar', async () => {
-      // Scenario: Driver with generated avatar
-      // Given: A driver exists with generated avatar
       const driverId = 'driver-generated-avatar';
       const driver = Driver.create({
         id: driverId,
@@ -351,12 +276,10 @@ describe('GetDriverUseCase Orchestration', () => {
         avatarRef: MediaReference.createGenerated('gen-123'),
       });
       
-      await driverRepository.create(driver);
+      await context.driverRepository.create(driver);
 
-      // When: GetDriverUseCase.execute() is called
-      const result = await getDriverUseCase.execute({ driverId });
+      const result = await context.getDriverUseCase.execute({ driverId });
 
-      // Then: The avatar reference should be correctly retrieved
       expect(result.isOk()).toBe(true);
       const retrievedDriver = result.unwrap();
       

tests/integration/drivers/leaderboard/get-drivers-leaderboard.integration.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DriversTestContext } from '../DriversTestContext';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+
+describe('GetDriversLeaderboardUseCase Integration', () => {
+  let context: DriversTestContext;
+
+  beforeEach(() => {
+    context = DriversTestContext.create();
+    context.clear();
+  });
+
+  describe('Success Path', () => {
+    it('should retrieve complete list of drivers with all data', async () => {
+      const drivers = [
+        Driver.create({ id: 'd1', iracingId: '1', name: 'Driver 1', country: 'US' }),
+        Driver.create({ id: 'd2', iracingId: '2', name: 'Driver 2', country: 'UK' }),
+        Driver.create({ id: 'd3', iracingId: '3', name: 'Driver 3', country: 'DE' }),
+      ];
+      
+      for (const d of drivers) {
+        await context.driverRepository.create(d);
+      }
+
+      await context.driverStatsRepository.saveDriverStats('d1', {
+        rating: 2000,
+        totalRaces: 10,
+        wins: 2,
+        podiums: 5,
+        overallRank: 1,
+        safetyRating: 4.5,
+        sportsmanshipRating: 95,
+        dnfs: 0,
+        avgFinish: 3.5,
+        bestFinish: 1,
+        worstFinish: 10,
+        consistency: 85,
+        experienceLevel: 'pro'
+      });
+      await context.driverStatsRepository.saveDriverStats('d2', {
+        rating: 1800,
+        totalRaces: 8,
+        wins: 1,
+        podiums: 3,
+        overallRank: 2,
+        safetyRating: 4.0,
+        sportsmanshipRating: 90,
+        dnfs: 1,
+        avgFinish: 5.2,
+        bestFinish: 1,
+        worstFinish: 15,
+        consistency: 75,
+        experienceLevel: 'intermediate'
+      });
+      await context.driverStatsRepository.saveDriverStats('d3', {
+        rating: 1500,
+        totalRaces: 5,
+        wins: 0,
+        podiums: 1,
+        overallRank: 3,
+        safetyRating: 3.5,
+        sportsmanshipRating: 80,
+        dnfs: 0,
+        avgFinish: 8.0,
+        bestFinish: 3,
+        worstFinish: 12,
+        consistency: 65,
+        experienceLevel: 'rookie'
+      });
+
+      const result = await context.getDriversLeaderboardUseCase.execute({});
+
+      expect(result.isOk()).toBe(true);
+      const leaderboard = result.unwrap();
+      
+      expect(leaderboard.items).toHaveLength(3);
+      expect(leaderboard.totalRaces).toBe(23);
+      expect(leaderboard.totalWins).toBe(3);
+      expect(leaderboard.activeCount).toBe(3);
+
+      expect(leaderboard.items[0].driver.id).toBe('d1');
+      expect(leaderboard.items[1].driver.id).toBe('d2');
+      expect(leaderboard.items[2].driver.id).toBe('d3');
+      
+      expect(leaderboard.items[0].rating).toBe(2000);
+      expect(leaderboard.items[1].rating).toBe(1800);
+      expect(leaderboard.items[2].rating).toBe(1500);
+    });
+
+    it('should handle empty drivers list', async () => {
+      const result = await context.getDriversLeaderboardUseCase.execute({});
+
+      expect(result.isOk()).toBe(true);
+      const leaderboard = result.unwrap();
+      expect(leaderboard.items).toHaveLength(0);
+      expect(leaderboard.totalRaces).toBe(0);
+      expect(leaderboard.totalWins).toBe(0);
+      expect(leaderboard.activeCount).toBe(0);
+    });
+
+    it('should correctly identify active drivers', async () => {
+      await context.driverRepository.create(Driver.create({ id: 'active', iracingId: '1', name: 'Active', country: 'US' }));
+      await context.driverRepository.create(Driver.create({ id: 'inactive', iracingId: '2', name: 'Inactive', country: 'UK' }));
+      
+      await context.driverStatsRepository.saveDriverStats('active', {
+        rating: 1500,
+        totalRaces: 1,
+        wins: 0,
+        podiums: 0,
+        overallRank: 1,
+        safetyRating: 3.0,
+        sportsmanshipRating: 70,
+        dnfs: 0,
+        avgFinish: 10,
+        bestFinish: 10,
+        worstFinish: 10,
+        consistency: 50,
+        experienceLevel: 'rookie'
+      });
+      await context.driverStatsRepository.saveDriverStats('inactive', {
+        rating: 1000,
+        totalRaces: 0,
+        wins: 0,
+        podiums: 0,
+        overallRank: null,
+        safetyRating: 2.5,
+        sportsmanshipRating: 50,
+        dnfs: 0,
+        avgFinish: 0,
+        bestFinish: 0,
+        worstFinish: 0,
+        consistency: 0,
+        experienceLevel: 'rookie'
+      });
+
+      const result = await context.getDriversLeaderboardUseCase.execute({});
+
+      const leaderboard = result.unwrap();
+      expect(leaderboard.activeCount).toBe(1);
+      expect(leaderboard.items.find(i => i.driver.id === 'active')?.isActive).toBe(true);
+      expect(leaderboard.items.find(i => i.driver.id === 'inactive')?.isActive).toBe(false);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle repository errors gracefully', async () => {
+      const originalFindAll = context.driverRepository.findAll.bind(context.driverRepository);
+      context.driverRepository.findAll = async () => {
+        throw new Error('Repository error');
+      };
+
+      const result = await context.getDriversLeaderboardUseCase.execute({});
+
+      expect(result.isErr()).toBe(true);
+      const error = result.unwrapErr();
+      expect(error.code).toBe('REPOSITORY_ERROR');
+
+      context.driverRepository.findAll = originalFindAll;
+    });
+  });
+});

tests/integration/drivers/profile/driver-stats.integration.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DriversTestContext } from '../DriversTestContext';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+
+describe('DriverStatsUseCase Integration', () => {
+  let context: DriversTestContext;
+
+  beforeEach(() => {
+    context = DriversTestContext.create();
+    context.clear();
+  });
+
+  describe('Success Path', () => {
+    it('should compute driver statistics from race results', async () => {
+      const driverId = 'd7';
+      const driver = Driver.create({ id: driverId, iracingId: '7', name: 'Stats Driver', country: 'US' });
+      await context.driverRepository.create(driver);
+
+      await context.driverStatsRepository.saveDriverStats(driverId, {
+        rating: 1800,
+        totalRaces: 15,
+        wins: 3,
+        podiums: 8,
+        overallRank: 5,
+        safetyRating: 4.2,
+        sportsmanshipRating: 90,
+        dnfs: 1,
+        avgFinish: 4.2,
+        bestFinish: 1,
+        worstFinish: 12,
+        consistency: 80,
+        experienceLevel: 'intermediate'
+      });
+
+      const stats = await context.driverStatsUseCase.getDriverStats(driverId);
+
+      expect(stats).not.toBeNull();
+      expect(stats!.rating).toBe(1800);
+      expect(stats!.totalRaces).toBe(15);
+      expect(stats!.wins).toBe(3);
+      expect(stats!.podiums).toBe(8);
+      expect(stats!.overallRank).toBe(5);
+      expect(stats!.safetyRating).toBe(4.2);
+      expect(stats!.sportsmanshipRating).toBe(90);
+      expect(stats!.dnfs).toBe(1);
+      expect(stats!.avgFinish).toBe(4.2);
+      expect(stats!.bestFinish).toBe(1);
+      expect(stats!.worstFinish).toBe(12);
+      expect(stats!.consistency).toBe(80);
+      expect(stats!.experienceLevel).toBe('intermediate');
+    });
+
+    it('should handle driver with no race results', async () => {
+      const driverId = 'd8';
+      const driver = Driver.create({ id: driverId, iracingId: '8', name: 'New Stats Driver', country: 'DE' });
+      await context.driverRepository.create(driver);
+
+      const stats = await context.driverStatsUseCase.getDriverStats(driverId);
+
+      expect(stats).toBeNull();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should return null when driver does not exist', async () => {
+      const nonExistentDriverId = 'non-existent-driver';
+
+      const stats = await context.driverStatsUseCase.getDriverStats(nonExistentDriverId);
+
+      expect(stats).toBeNull();
+    });
+  });
+});

tests/integration/drivers/profile/get-profile-overview.integration.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DriversTestContext } from '../DriversTestContext';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+import { Team } from '../../../../core/racing/domain/entities/Team';
+
+describe('GetProfileOverviewUseCase Integration', () => {
+  let context: DriversTestContext;
+
+  beforeEach(() => {
+    context = DriversTestContext.create();
+    context.clear();
+  });
+
+  describe('Success Path', () => {
+    it('should retrieve complete driver profile overview', async () => {
+      const driverId = 'd1';
+      const driver = Driver.create({ id: driverId, iracingId: '1', name: 'John Doe', country: 'US' });
+      await context.driverRepository.create(driver);
+
+      await context.driverStatsRepository.saveDriverStats(driverId, {
+        rating: 2000,
+        totalRaces: 10,
+        wins: 2,
+        podiums: 5,
+        overallRank: 1,
+        safetyRating: 4.5,
+        sportsmanshipRating: 95,
+        dnfs: 0,
+        avgFinish: 3.5,
+        bestFinish: 1,
+        worstFinish: 10,
+        consistency: 85,
+        experienceLevel: 'pro'
+      });
+
+      const team = Team.create({ id: 't1', name: 'Team 1', tag: 'T1', description: 'Desc', ownerId: 'other', leagues: [] });
+      await context.teamRepository.create(team);
+      await context.teamMembershipRepository.saveMembership({
+        teamId: 't1',
+        driverId: driverId,
+        role: 'driver',
+        status: 'active',
+        joinedAt: new Date()
+      });
+
+      context.socialRepository.seed({
+        drivers: [driver, Driver.create({ id: 'f1', iracingId: '2', name: 'Friend 1', country: 'UK' })],
+        friendships: [{ driverId: driverId, friendId: 'f1' }],
+        feedEvents: []
+      });
+
+      const result = await context.getProfileOverviewUseCase.execute({ driverId });
+
+      expect(result.isOk()).toBe(true);
+      const overview = result.unwrap();
+      
+      expect(overview.driverInfo.driver.id).toBe(driverId);
+      expect(overview.stats?.rating).toBe(2000);
+      expect(overview.teamMemberships).toHaveLength(1);
+      expect(overview.teamMemberships[0].team.id).toBe('t1');
+      expect(overview.socialSummary.friendsCount).toBe(1);
+      expect(overview.extendedProfile).toBeDefined();
+    });
+
+    it('should handle driver with minimal data', async () => {
+      const driverId = 'new';
+      const driver = Driver.create({ id: driverId, iracingId: '9', name: 'New Driver', country: 'DE' });
+      await context.driverRepository.create(driver);
+
+      const result = await context.getProfileOverviewUseCase.execute({ driverId });
+
+      expect(result.isOk()).toBe(true);
+      const overview = result.unwrap();
+      
+      expect(overview.driverInfo.driver.id).toBe(driverId);
+      expect(overview.stats).toBeNull();
+      expect(overview.teamMemberships).toHaveLength(0);
+      expect(overview.socialSummary.friendsCount).toBe(0);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should return error when driver does not exist', async () => {
+      const result = await context.getProfileOverviewUseCase.execute({ driverId: 'none' });
+
+      expect(result.isErr()).toBe(true);
+      const error = result.unwrapErr();
+      expect(error.code).toBe('DRIVER_NOT_FOUND');
+    });
+  });
+});

tests/integration/drivers/profile/update-driver-profile.integration.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DriversTestContext } from '../DriversTestContext';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+
+describe('UpdateDriverProfileUseCase Integration', () => {
+  let context: DriversTestContext;
+
+  beforeEach(() => {
+    context = DriversTestContext.create();
+    context.clear();
+  });
+
+  describe('Success Path', () => {
+    it('should update driver bio', async () => {
+      const driverId = 'd2';
+      const driver = Driver.create({ id: driverId, iracingId: '2', name: 'Update Driver', country: 'US', bio: 'Original bio' });
+      await context.driverRepository.create(driver);
+
+      const result = await context.updateDriverProfileUseCase.execute({
+        driverId,
+        bio: 'Updated bio',
+      });
+
+      expect(result.isOk()).toBe(true);
+
+      const updatedDriver = await context.driverRepository.findById(driverId);
+      expect(updatedDriver).not.toBeNull();
+      expect(updatedDriver!.bio?.toString()).toBe('Updated bio');
+    });
+
+    it('should update driver country', async () => {
+      const driverId = 'd3';
+      const driver = Driver.create({ id: driverId, iracingId: '3', name: 'Country Driver', country: 'US' });
+      await context.driverRepository.create(driver);
+
+      const result = await context.updateDriverProfileUseCase.execute({
+        driverId,
+        country: 'DE',
+      });
+
+      expect(result.isOk()).toBe(true);
+
+      const updatedDriver = await context.driverRepository.findById(driverId);
+      expect(updatedDriver).not.toBeNull();
+      expect(updatedDriver!.country.toString()).toBe('DE');
+    });
+
+    it('should update multiple profile fields at once', async () => {
+      const driverId = 'd4';
+      const driver = Driver.create({ id: driverId, iracingId: '4', name: 'Multi Update Driver', country: 'US', bio: 'Original bio' });
+      await context.driverRepository.create(driver);
+
+      const result = await context.updateDriverProfileUseCase.execute({
+        driverId,
+        bio: 'Updated bio',
+        country: 'FR',
+      });
+
+      expect(result.isOk()).toBe(true);
+
+      const updatedDriver = await context.driverRepository.findById(driverId);
+      expect(updatedDriver).not.toBeNull();
+      expect(updatedDriver!.bio?.toString()).toBe('Updated bio');
+      expect(updatedDriver!.country.toString()).toBe('FR');
+    });
+  });
+
+  describe('Validation', () => {
+    it('should reject update with empty bio', async () => {
+      const driverId = 'd5';
+      const driver = Driver.create({ id: driverId, iracingId: '5', name: 'Empty Bio Driver', country: 'US' });
+      await context.driverRepository.create(driver);
+
+      const result = await context.updateDriverProfileUseCase.execute({
+        driverId,
+        bio: '',
+      });
+
+      expect(result.isErr()).toBe(true);
+      const error = result.unwrapErr();
+      expect(error.code).toBe('INVALID_PROFILE_DATA');
+      expect(error.details.message).toBe('Profile data is invalid');
+    });
+
+    it('should reject update with empty country', async () => {
+      const driverId = 'd6';
+      const driver = Driver.create({ id: driverId, iracingId: '6', name: 'Empty Country Driver', country: 'US' });
+      await context.driverRepository.create(driver);
+
+      const result = await context.updateDriverProfileUseCase.execute({
+        driverId,
+        country: '',
+      });
+
+      expect(result.isErr()).toBe(true);
+      const error = result.unwrapErr();
+      expect(error.code).toBe('INVALID_PROFILE_DATA');
+      expect(error.details.message).toBe('Profile data is invalid');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should return error when driver does not exist', async () => {
+      const nonExistentDriverId = 'non-existent-driver';
+
+      const result = await context.updateDriverProfileUseCase.execute({
+        driverId: nonExistentDriverId,
+        bio: 'New bio',
+      });
+
+      expect(result.isErr()).toBe(true);
+      const error = result.unwrapErr();
+      expect(error.code).toBe('DRIVER_NOT_FOUND');
+      expect(error.details.message).toContain('Driver with id');
+    });
+
+    it('should return error when driver ID is invalid', async () => {
+      const invalidDriverId = '';
+
+      const result = await context.updateDriverProfileUseCase.execute({
+        driverId: invalidDriverId,
+        bio: 'New bio',
+      });
+
+      expect(result.isErr()).toBe(true);
+      const error = result.unwrapErr();
+      expect(error.code).toBe('DRIVER_NOT_FOUND');
+      expect(error.details.message).toContain('Driver with id');
+    });
+  });
+});