integration tests

tests/integration/races/RacesTestContext.ts

@@ -0,0 +1,54 @@
+import { Logger } from '../../../core/shared/domain/Logger';
+import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
+import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
+import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
+import { InMemoryRaceRegistrationRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRegistrationRepository';
+import { InMemoryResultRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryResultRepository';
+import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
+import { InMemoryPenaltyRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryPenaltyRepository';
+import { InMemoryProtestRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryProtestRepository';
+
+export class RacesTestContext {
+  public readonly logger: Logger;
+  public readonly raceRepository: InMemoryRaceRepository;
+  public readonly leagueRepository: InMemoryLeagueRepository;
+  public readonly driverRepository: InMemoryDriverRepository;
+  public readonly raceRegistrationRepository: InMemoryRaceRegistrationRepository;
+  public readonly resultRepository: InMemoryResultRepository;
+  public readonly leagueMembershipRepository: InMemoryLeagueMembershipRepository;
+  public readonly penaltyRepository: InMemoryPenaltyRepository;
+  public readonly protestRepository: InMemoryProtestRepository;
+
+  private constructor() {
+    this.logger = {
+      info: () => {},
+      debug: () => {},
+      warn: () => {},
+      error: () => {},
+    } as unknown as Logger;
+
+    this.raceRepository = new InMemoryRaceRepository(this.logger);
+    this.leagueRepository = new InMemoryLeagueRepository(this.logger);
+    this.driverRepository = new InMemoryDriverRepository(this.logger);
+    this.raceRegistrationRepository = new InMemoryRaceRegistrationRepository(this.logger);
+    this.resultRepository = new InMemoryResultRepository(this.logger, this.raceRepository);
+    this.leagueMembershipRepository = new InMemoryLeagueMembershipRepository(this.logger);
+    this.penaltyRepository = new InMemoryPenaltyRepository(this.logger);
+    this.protestRepository = new InMemoryProtestRepository(this.logger);
+  }
+
+  public static create(): RacesTestContext {
+    return new RacesTestContext();
+  }
+
+  public async clear(): Promise<void> {
+    (this.raceRepository as any).races.clear();
+    this.leagueRepository.clear();
+    await this.driverRepository.clear();
+    (this.raceRegistrationRepository as any).registrations.clear();
+    (this.resultRepository as any).results.clear();
+    this.leagueMembershipRepository.clear();
+    (this.penaltyRepository as any).penalties.clear();
+    (this.protestRepository as any).protests.clear();
+  }
+}

tests/integration/races/detail/get-race-detail.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { RacesTestContext } from '../RacesTestContext';
+import { GetRaceDetailUseCase } from '../../../../core/racing/application/use-cases/GetRaceDetailUseCase';
+import { Race } from '../../../../core/racing/domain/entities/Race';
+import { League } from '../../../../core/racing/domain/entities/League';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+
+describe('GetRaceDetailUseCase', () => {
+  let context: RacesTestContext;
+  let getRaceDetailUseCase: GetRaceDetailUseCase;
+
+  beforeAll(() => {
+    context = RacesTestContext.create();
+    getRaceDetailUseCase = new GetRaceDetailUseCase(
+      context.raceRepository,
+      context.leagueRepository,
+      context.driverRepository,
+      context.raceRegistrationRepository,
+      context.resultRepository,
+      context.leagueMembershipRepository
+    );
+  });
+
+  beforeEach(async () => {
+    await context.clear();
+  });
+
+  it('should retrieve race detail with complete information', async () => {
+    // Given: A race and league exist
+    const leagueId = 'l1';
+    const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
+    await context.leagueRepository.create(league);
+
+    const raceId = 'r1';
+    const race = Race.create({
+      id: raceId,
+      leagueId,
+      scheduledAt: new Date(Date.now() + 86400000),
+      track: 'Spa',
+      car: 'GT3',
+      status: 'scheduled'
+    });
+    await context.raceRepository.create(race);
+
+    // When: GetRaceDetailUseCase.execute() is called
+    const result = await getRaceDetailUseCase.execute({ raceId });
+
+    // Then: The result should contain race and league information
+    expect(result.isOk()).toBe(true);
+    const data = result.unwrap();
+    expect(data.race.id).toBe(raceId);
+    expect(data.league?.id.toString()).toBe(leagueId);
+    expect(data.isUserRegistered).toBe(false);
+  });
+
+  it('should throw error when race does not exist', async () => {
+    // When: GetRaceDetailUseCase.execute() is called with non-existent race ID
+    const result = await getRaceDetailUseCase.execute({ raceId: 'non-existent' });
+
+    // Then: Should return RACE_NOT_FOUND error
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('RACE_NOT_FOUND');
+  });
+
+  it('should identify if a driver is registered', async () => {
+    // Given: A race and a registered driver
+    const leagueId = 'l1';
+    const raceId = 'r1';
+    const driverId = 'd1';
+    
+    const race = Race.create({
+      id: raceId,
+      leagueId,
+      scheduledAt: new Date(Date.now() + 86400000),
+      track: 'Spa',
+      car: 'GT3',
+      status: 'scheduled'
+    });
+    await context.raceRepository.create(race);
+
+    const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
+    await context.driverRepository.create(driver);
+
+    // Mock registration
+    await context.raceRegistrationRepository.register({
+      raceId: raceId as any,
+      driverId: driverId as any,
+      registeredAt: new Date()
+    } as any);
+
+    // When: GetRaceDetailUseCase.execute() is called with driverId
+    const result = await getRaceDetailUseCase.execute({ raceId, driverId });
+
+    // Then: isUserRegistered should be true
+    expect(result.isOk()).toBe(true);
+    expect(result.unwrap().isUserRegistered).toBe(true);
+  });
+});

tests/integration/races/list/get-all-races.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { RacesTestContext } from '../RacesTestContext';
+import { GetAllRacesUseCase } from '../../../../core/racing/application/use-cases/GetAllRacesUseCase';
+import { Race } from '../../../../core/racing/domain/entities/Race';
+import { League } from '../../../../core/racing/domain/entities/League';
+
+describe('GetAllRacesUseCase', () => {
+  let context: RacesTestContext;
+  let getAllRacesUseCase: GetAllRacesUseCase;
+
+  beforeAll(() => {
+    context = RacesTestContext.create();
+    getAllRacesUseCase = new GetAllRacesUseCase(
+      context.raceRepository,
+      context.leagueRepository,
+      context.logger
+    );
+  });
+
+  beforeEach(async () => {
+    await context.clear();
+  });
+
+  it('should retrieve comprehensive list of all races', async () => {
+    // Given: Multiple races exist
+    const leagueId = 'l1';
+    const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
+    await context.leagueRepository.create(league);
+
+    const race1 = Race.create({
+      id: 'r1',
+      leagueId,
+      scheduledAt: new Date(Date.now() + 86400000),
+      track: 'Spa',
+      car: 'GT3',
+      status: 'scheduled'
+    });
+    const race2 = Race.create({
+      id: 'r2',
+      leagueId,
+      scheduledAt: new Date(Date.now() - 86400000),
+      track: 'Monza',
+      car: 'GT3',
+      status: 'completed'
+    });
+    await context.raceRepository.create(race1);
+    await context.raceRepository.create(race2);
+
+    // When: GetAllRacesUseCase.execute() is called
+    const result = await getAllRacesUseCase.execute({});
+
+    // Then: The result should contain all races and leagues
+    expect(result.isOk()).toBe(true);
+    const data = result.unwrap();
+    expect(data.races).toHaveLength(2);
+    expect(data.leagues).toHaveLength(1);
+    expect(data.totalCount).toBe(2);
+  });
+
+  it('should return empty list when no races exist', async () => {
+    // When: GetAllRacesUseCase.execute() is called
+    const result = await getAllRacesUseCase.execute({});
+
+    // Then: The result should be empty
+    expect(result.isOk()).toBe(true);
+    expect(result.unwrap().races).toHaveLength(0);
+    expect(result.unwrap().totalCount).toBe(0);
+  });
+
+  it('should retrieve upcoming and recent races (main page logic)', async () => {
+    // Given: Upcoming and completed races exist
+    const leagueId = 'l1';
+    const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
+    await context.leagueRepository.create(league);
+
+    const upcomingRace = Race.create({
+      id: 'r1',
+      leagueId,
+      scheduledAt: new Date(Date.now() + 86400000),
+      track: 'Spa',
+      car: 'GT3',
+      status: 'scheduled'
+    });
+    const completedRace = Race.create({
+      id: 'r2',
+      leagueId,
+      scheduledAt: new Date(Date.now() - 86400000),
+      track: 'Monza',
+      car: 'GT3',
+      status: 'completed'
+    });
+    await context.raceRepository.create(upcomingRace);
+    await context.raceRepository.create(completedRace);
+
+    // When: GetAllRacesUseCase.execute() is called
+    const result = await getAllRacesUseCase.execute({});
+
+    // Then: The result should contain both races
+    expect(result.isOk()).toBe(true);
+    const data = result.unwrap();
+    expect(data.races).toHaveLength(2);
+    expect(data.races.some(r => r.status.isScheduled())).toBe(true);
+    expect(data.races.some(r => r.status.isCompleted())).toBe(true);
+  });
+});

tests/integration/races/race-detail-use-cases.integration.test.ts

@@ -1,145 +0,0 @@
-/**
- * Integration Test: Race Detail Use Case Orchestration
- * 
- * Tests the orchestration logic of race detail page-related Use Cases:
- * - GetRaceDetailUseCase: Retrieves comprehensive race details
- * 
- * Adheres to Clean Architecture:
- * - Tests Core Use Cases directly
- * - Uses In-Memory adapters for repositories
- * - Follows Given/When/Then pattern
- * 
- * Focus: Business logic orchestration, NOT UI rendering
- */
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
-import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
-import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
-import { InMemoryRaceRegistrationRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRegistrationRepository';
-import { InMemoryResultRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryResultRepository';
-import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
-import { GetRaceDetailUseCase } from '../../../core/racing/application/use-cases/GetRaceDetailUseCase';
-import { Race } from '../../../core/racing/domain/entities/Race';
-import { League } from '../../../core/racing/domain/entities/League';
-import { Driver } from '../../../core/racing/domain/entities/Driver';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('Race Detail Use Case Orchestration', () => {
-  let raceRepository: InMemoryRaceRepository;
-  let leagueRepository: InMemoryLeagueRepository;
-  let driverRepository: InMemoryDriverRepository;
-  let raceRegistrationRepository: InMemoryRaceRegistrationRepository;
-  let resultRepository: InMemoryResultRepository;
-  let leagueMembershipRepository: InMemoryLeagueMembershipRepository;
-  let getRaceDetailUseCase: GetRaceDetailUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-
-    raceRepository = new InMemoryRaceRepository(mockLogger);
-    leagueRepository = new InMemoryLeagueRepository(mockLogger);
-    driverRepository = new InMemoryDriverRepository(mockLogger);
-    raceRegistrationRepository = new InMemoryRaceRegistrationRepository(mockLogger);
-    resultRepository = new InMemoryResultRepository(mockLogger, raceRepository);
-    leagueMembershipRepository = new InMemoryLeagueMembershipRepository(mockLogger);
-
-    getRaceDetailUseCase = new GetRaceDetailUseCase(
-      raceRepository,
-      leagueRepository,
-      driverRepository,
-      raceRegistrationRepository,
-      resultRepository,
-      leagueMembershipRepository
-    );
-  });
-
-  beforeEach(async () => {
-    // Clear repositories
-    (raceRepository as any).races.clear();
-    leagueRepository.clear();
-    await driverRepository.clear();
-    (raceRegistrationRepository as any).registrations.clear();
-    (resultRepository as any).results.clear();
-    leagueMembershipRepository.clear();
-  });
-
-  describe('GetRaceDetailUseCase', () => {
-    it('should retrieve race detail with complete information', async () => {
-      // Given: A race and league exist
-      const leagueId = 'l1';
-      const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
-      await leagueRepository.create(league);
-
-      const raceId = 'r1';
-      const race = Race.create({
-        id: raceId,
-        leagueId,
-        scheduledAt: new Date(Date.now() + 86400000),
-        track: 'Spa',
-        car: 'GT3',
-        status: 'scheduled'
-      });
-      await raceRepository.create(race);
-
-      // When: GetRaceDetailUseCase.execute() is called
-      const result = await getRaceDetailUseCase.execute({ raceId });
-
-      // Then: The result should contain race and league information
-      expect(result.isOk()).toBe(true);
-      const data = result.unwrap();
-      expect(data.race.id).toBe(raceId);
-      expect(data.league?.id).toBe(leagueId);
-      expect(data.isUserRegistered).toBe(false);
-    });
-
-    it('should throw error when race does not exist', async () => {
-      // When: GetRaceDetailUseCase.execute() is called with non-existent race ID
-      const result = await getRaceDetailUseCase.execute({ raceId: 'non-existent' });
-
-      // Then: Should return RACE_NOT_FOUND error
-      expect(result.isErr()).toBe(true);
-      expect(result.unwrapErr().code).toBe('RACE_NOT_FOUND');
-    });
-
-    it('should identify if a driver is registered', async () => {
-      // Given: A race and a registered driver
-      const leagueId = 'l1';
-      const raceId = 'r1';
-      const driverId = 'd1';
-      
-      const race = Race.create({
-        id: raceId,
-        leagueId,
-        scheduledAt: new Date(Date.now() + 86400000),
-        track: 'Spa',
-        car: 'GT3',
-        status: 'scheduled'
-      });
-      await raceRepository.create(race);
-
-      const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
-      await driverRepository.create(driver);
-
-      // Mock registration (using any to bypass private access if needed, but InMemoryRaceRegistrationRepository has register method)
-      await raceRegistrationRepository.register({
-        raceId: raceId as any,
-        driverId: driverId as any,
-        registeredAt: new Date()
-      } as any);
-
-      // When: GetRaceDetailUseCase.execute() is called with driverId
-      const result = await getRaceDetailUseCase.execute({ raceId, driverId });
-
-      // Then: isUserRegistered should be true
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().isUserRegistered).toBe(true);
-    });
-  });
-});

tests/integration/races/race-results-use-cases.integration.test.ts

@@ -1,159 +0,0 @@
-/**
- * Integration Test: Race Results Use Case Orchestration
- * 
- * Tests the orchestration logic of race results page-related Use Cases:
- * - GetRaceResultsDetailUseCase: Retrieves complete race results (all finishers)
- * - GetRacePenaltiesUseCase: Retrieves race penalties and incidents
- * 
- * Adheres to Clean Architecture:
- * - Tests Core Use Cases directly
- * - Uses In-Memory adapters for repositories
- * - Follows Given/When/Then pattern
- * 
- * Focus: Business logic orchestration, NOT UI rendering
- */
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
-import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
-import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
-import { InMemoryResultRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryResultRepository';
-import { InMemoryPenaltyRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryPenaltyRepository';
-import { GetRaceResultsDetailUseCase } from '../../../core/racing/application/use-cases/GetRaceResultsDetailUseCase';
-import { GetRacePenaltiesUseCase } from '../../../core/racing/application/use-cases/GetRacePenaltiesUseCase';
-import { Race } from '../../../core/racing/domain/entities/Race';
-import { League } from '../../../core/racing/domain/entities/League';
-import { Driver } from '../../../core/racing/domain/entities/Driver';
-import { Result as RaceResult } from '../../../core/racing/domain/entities/result/Result';
-import { Penalty } from '../../../core/racing/domain/entities/penalty/Penalty';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('Race Results Use Case Orchestration', () => {
-  let raceRepository: InMemoryRaceRepository;
-  let leagueRepository: InMemoryLeagueRepository;
-  let driverRepository: InMemoryDriverRepository;
-  let resultRepository: InMemoryResultRepository;
-  let penaltyRepository: InMemoryPenaltyRepository;
-  let getRaceResultsDetailUseCase: GetRaceResultsDetailUseCase;
-  let getRacePenaltiesUseCase: GetRacePenaltiesUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-
-    raceRepository = new InMemoryRaceRepository(mockLogger);
-    leagueRepository = new InMemoryLeagueRepository(mockLogger);
-    driverRepository = new InMemoryDriverRepository(mockLogger);
-    resultRepository = new InMemoryResultRepository(mockLogger, raceRepository);
-    penaltyRepository = new InMemoryPenaltyRepository(mockLogger);
-
-    getRaceResultsDetailUseCase = new GetRaceResultsDetailUseCase(
-      raceRepository,
-      leagueRepository,
-      resultRepository,
-      driverRepository,
-      penaltyRepository
-    );
-
-    getRacePenaltiesUseCase = new GetRacePenaltiesUseCase(
-      penaltyRepository,
-      driverRepository
-    );
-  });
-
-  beforeEach(async () => {
-    (raceRepository as any).races.clear();
-    leagueRepository.clear();
-    await driverRepository.clear();
-    (resultRepository as any).results.clear();
-    (penaltyRepository as any).penalties.clear();
-  });
-
-  describe('GetRaceResultsDetailUseCase', () => {
-    it('should retrieve complete race results with all finishers', async () => {
-      // Given: A completed race with results
-      const leagueId = 'l1';
-      const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
-      await leagueRepository.create(league);
-
-      const raceId = 'r1';
-      const race = Race.create({
-        id: raceId,
-        leagueId,
-        scheduledAt: new Date(Date.now() - 86400000),
-        track: 'Spa',
-        car: 'GT3',
-        status: 'completed'
-      });
-      await raceRepository.create(race);
-
-      const driverId = 'd1';
-      const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
-      await driverRepository.create(driver);
-
-      const raceResult = RaceResult.create({
-        id: 'res1',
-        raceId,
-        driverId,
-        position: 1,
-        lapsCompleted: 20,
-        totalTime: 3600,
-        fastestLap: 105,
-        points: 25
-      });
-      await resultRepository.create(raceResult);
-
-      // When: GetRaceResultsDetailUseCase.execute() is called
-      const result = await getRaceResultsDetailUseCase.execute({ raceId });
-
-      // Then: The result should contain race and results
-      expect(result.isOk()).toBe(true);
-      const data = result.unwrap();
-      expect(data.race.id).toBe(raceId);
-      expect(data.results).toHaveLength(1);
-      expect(data.results[0].driverId.toString()).toBe(driverId);
-    });
-  });
-
-  describe('GetRacePenaltiesUseCase', () => {
-    it('should retrieve race penalties with driver information', async () => {
-      // Given: A race with penalties
-      const raceId = 'r1';
-      const driverId = 'd1';
-      const stewardId = 's1';
-
-      const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
-      await driverRepository.create(driver);
-      
-      const steward = Driver.create({ id: stewardId, iracingId: '200', name: 'Steward', country: 'UK' });
-      await driverRepository.create(steward);
-
-      const penalty = Penalty.create({
-        id: 'p1',
-        raceId,
-        driverId,
-        type: 'time',
-        value: 5,
-        reason: 'Track limits',
-        issuedBy: stewardId,
-        status: 'applied'
-      });
-      await penaltyRepository.create(penalty);
-
-      // When: GetRacePenaltiesUseCase.execute() is called
-      const result = await getRacePenaltiesUseCase.execute({ raceId });
-
-      // Then: It should return penalties and drivers
-      expect(result.isOk()).toBe(true);
-      const data = result.unwrap();
-      expect(data.penalties).toHaveLength(1);
-      expect(data.drivers.some(d => d.id === driverId)).toBe(true);
-      expect(data.drivers.some(d => d.id === stewardId)).toBe(true);
-    });
-  });
-});

tests/integration/races/race-stewarding-use-cases.integration.test.ts

@@ -1,177 +0,0 @@
-/**
- * Integration Test: Race Stewarding Use Case Orchestration
- * 
- * Tests the orchestration logic of race stewarding page-related Use Cases:
- * - GetLeagueProtestsUseCase: Retrieves comprehensive race stewarding information
- * - ReviewProtestUseCase: Reviews a protest
- * 
- * Adheres to Clean Architecture:
- * - Tests Core Use Cases directly
- * - Uses In-Memory adapters for repositories
- * - Follows Given/When/Then pattern
- * 
- * Focus: Business logic orchestration, NOT UI rendering
- */
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
-import { InMemoryProtestRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryProtestRepository';
-import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
-import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
-import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
-import { GetLeagueProtestsUseCase } from '../../../core/racing/application/use-cases/GetLeagueProtestsUseCase';
-import { ReviewProtestUseCase } from '../../../core/racing/application/use-cases/ReviewProtestUseCase';
-import { Race } from '../../../core/racing/domain/entities/Race';
-import { League } from '../../../core/racing/domain/entities/League';
-import { Driver } from '../../../core/racing/domain/entities/Driver';
-import { Protest } from '../../../core/racing/domain/entities/Protest';
-import { LeagueMembership } from '../../../core/racing/domain/entities/LeagueMembership';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('Race Stewarding Use Case Orchestration', () => {
-  let raceRepository: InMemoryRaceRepository;
-  let protestRepository: InMemoryProtestRepository;
-  let driverRepository: InMemoryDriverRepository;
-  let leagueRepository: InMemoryLeagueRepository;
-  let leagueMembershipRepository: InMemoryLeagueMembershipRepository;
-  let getLeagueProtestsUseCase: GetLeagueProtestsUseCase;
-  let reviewProtestUseCase: ReviewProtestUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-
-    raceRepository = new InMemoryRaceRepository(mockLogger);
-    protestRepository = new InMemoryProtestRepository(mockLogger);
-    driverRepository = new InMemoryDriverRepository(mockLogger);
-    leagueRepository = new InMemoryLeagueRepository(mockLogger);
-    leagueMembershipRepository = new InMemoryLeagueMembershipRepository(mockLogger);
-
-    getLeagueProtestsUseCase = new GetLeagueProtestsUseCase(
-      raceRepository,
-      protestRepository,
-      driverRepository,
-      leagueRepository
-    );
-
-    reviewProtestUseCase = new ReviewProtestUseCase(
-      protestRepository,
-      raceRepository,
-      leagueMembershipRepository
-    );
-  });
-
-  beforeEach(async () => {
-    (raceRepository as any).races.clear();
-    (protestRepository as any).protests.clear();
-    await driverRepository.clear();
-    leagueRepository.clear();
-    leagueMembershipRepository.clear();
-  });
-
-  describe('GetLeagueProtestsUseCase', () => {
-    it('should retrieve league protests with all related entities', async () => {
-      // Given: A league, race, drivers and a protest exist
-      const leagueId = 'l1';
-      const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
-      await leagueRepository.create(league);
-
-      const raceId = 'r1';
-      const race = Race.create({
-        id: raceId,
-        leagueId,
-        scheduledAt: new Date(),
-        track: 'Spa',
-        car: 'GT3',
-        status: 'completed'
-      });
-      await raceRepository.create(race);
-
-      const driver1Id = 'd1';
-      const driver2Id = 'd2';
-      const driver1 = Driver.create({ id: driver1Id, iracingId: '100', name: 'Protester', country: 'US' });
-      const driver2 = Driver.create({ id: driver2Id, iracingId: '200', name: 'Accused', country: 'UK' });
-      await driverRepository.create(driver1);
-      await driverRepository.create(driver2);
-
-      const protest = Protest.create({
-        id: 'p1',
-        raceId,
-        protestingDriverId: driver1Id,
-        accusedDriverId: driver2Id,
-        reason: 'Unsafe rejoin',
-        timestamp: new Date()
-      });
-      await protestRepository.create(protest);
-
-      // When: GetLeagueProtestsUseCase.execute() is called
-      const result = await getLeagueProtestsUseCase.execute({ leagueId });
-
-      // Then: It should return the protest with race and driver info
-      expect(result.isOk()).toBe(true);
-      const data = result.unwrap();
-      expect(data.protests).toHaveLength(1);
-      expect(data.protests[0].protest.id).toBe('p1');
-      expect(data.protests[0].race?.id).toBe(raceId);
-      expect(data.protests[0].protestingDriver?.id).toBe(driver1Id);
-      expect(data.protests[0].accusedDriver?.id).toBe(driver2Id);
-    });
-  });
-
-  describe('ReviewProtestUseCase', () => {
-    it('should allow a steward to review a protest', async () => {
-      // Given: A protest and a steward membership
-      const leagueId = 'l1';
-      const raceId = 'r1';
-      const stewardId = 's1';
-      
-      const race = Race.create({
-        id: raceId,
-        leagueId,
-        scheduledAt: new Date(),
-        track: 'Spa',
-        car: 'GT3',
-        status: 'completed'
-      });
-      await raceRepository.create(race);
-
-      const protest = Protest.create({
-        id: 'p1',
-        raceId,
-        protestingDriverId: 'd1',
-        accusedDriverId: 'd2',
-        reason: 'Unsafe rejoin',
-        timestamp: new Date()
-      });
-      await protestRepository.create(protest);
-
-      const membership = LeagueMembership.create({
-        id: 'm1',
-        leagueId,
-        driverId: stewardId,
-        role: 'steward',
-        status: 'active'
-      });
-      await leagueMembershipRepository.saveMembership(membership);
-
-      // When: ReviewProtestUseCase.execute() is called
-      const result = await reviewProtestUseCase.execute({
-        protestId: 'p1',
-        stewardId,
-        decision: 'accepted',
-        comment: 'Clear violation'
-      });
-
-      // Then: The protest should be updated
-      expect(result.isOk()).toBe(true);
-      const updatedProtest = await protestRepository.findById('p1');
-      expect(updatedProtest?.status.toString()).toBe('accepted');
-      expect(updatedProtest?.reviewedBy).toBe(stewardId);
-    });
-  });
-});

tests/integration/races/races-all-use-cases.integration.test.ts

@@ -1,99 +0,0 @@
-/**
- * Integration Test: All Races Use Case Orchestration
- * 
- * Tests the orchestration logic of all races page-related Use Cases:
- * - GetAllRacesUseCase: Retrieves comprehensive list of all races
- * 
- * Adheres to Clean Architecture:
- * - Tests Core Use Cases directly
- * - Uses In-Memory adapters for repositories
- * - Follows Given/When/Then pattern
- * 
- * Focus: Business logic orchestration, NOT UI rendering
- */
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
-import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
-import { GetAllRacesUseCase } from '../../../core/racing/application/use-cases/GetAllRacesUseCase';
-import { Race } from '../../../core/racing/domain/entities/Race';
-import { League } from '../../../core/racing/domain/entities/League';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('All Races Use Case Orchestration', () => {
-  let raceRepository: InMemoryRaceRepository;
-  let leagueRepository: InMemoryLeagueRepository;
-  let getAllRacesUseCase: GetAllRacesUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-
-    raceRepository = new InMemoryRaceRepository(mockLogger);
-    leagueRepository = new InMemoryLeagueRepository(mockLogger);
-
-    getAllRacesUseCase = new GetAllRacesUseCase(
-      raceRepository,
-      leagueRepository,
-      mockLogger
-    );
-  });
-
-  beforeEach(async () => {
-    (raceRepository as any).races.clear();
-    leagueRepository.clear();
-  });
-
-  describe('GetAllRacesUseCase', () => {
-    it('should retrieve comprehensive list of all races', async () => {
-      // Given: Multiple races exist
-      const leagueId = 'l1';
-      const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
-      await leagueRepository.create(league);
-
-      const race1 = Race.create({
-        id: 'r1',
-        leagueId,
-        scheduledAt: new Date(Date.now() + 86400000),
-        track: 'Spa',
-        car: 'GT3',
-        status: 'scheduled'
-      });
-      const race2 = Race.create({
-        id: 'r2',
-        leagueId,
-        scheduledAt: new Date(Date.now() - 86400000),
-        track: 'Monza',
-        car: 'GT3',
-        status: 'completed'
-      });
-      await raceRepository.create(race1);
-      await raceRepository.create(race2);
-
-      // When: GetAllRacesUseCase.execute() is called
-      const result = await getAllRacesUseCase.execute({});
-
-      // Then: The result should contain all races and leagues
-      expect(result.isOk()).toBe(true);
-      const data = result.unwrap();
-      expect(data.races).toHaveLength(2);
-      expect(data.leagues).toHaveLength(1);
-      expect(data.totalCount).toBe(2);
-    });
-
-    it('should return empty list when no races exist', async () => {
-      // When: GetAllRacesUseCase.execute() is called
-      const result = await getAllRacesUseCase.execute({});
-
-      // Then: The result should be empty
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().races).toHaveLength(0);
-      expect(result.unwrap().totalCount).toBe(0);
-    });
-  });
-});

tests/integration/races/races-main-use-cases.integration.test.ts

@@ -1,89 +0,0 @@
-/**
- * Integration Test: Races Main Use Case Orchestration
- * 
- * Tests the orchestration logic of races main page-related Use Cases:
- * - GetAllRacesUseCase: Used to retrieve upcoming and recent races
- * 
- * Adheres to Clean Architecture:
- * - Tests Core Use Cases directly
- * - Uses In-Memory adapters for repositories
- * - Follows Given/When/Then pattern
- * 
- * Focus: Business logic orchestration, NOT UI rendering
- */
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
-import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
-import { GetAllRacesUseCase } from '../../../core/racing/application/use-cases/GetAllRacesUseCase';
-import { Race } from '../../../core/racing/domain/entities/Race';
-import { League } from '../../../core/racing/domain/entities/League';
-import { Logger } from '../../../core/shared/domain/Logger';
-
-describe('Races Main Use Case Orchestration', () => {
-  let raceRepository: InMemoryRaceRepository;
-  let leagueRepository: InMemoryLeagueRepository;
-  let getAllRacesUseCase: GetAllRacesUseCase;
-  let mockLogger: Logger;
-
-  beforeAll(() => {
-    mockLogger = {
-      info: () => {},
-      debug: () => {},
-      warn: () => {},
-      error: () => {},
-    } as unknown as Logger;
-
-    raceRepository = new InMemoryRaceRepository(mockLogger);
-    leagueRepository = new InMemoryLeagueRepository(mockLogger);
-
-    getAllRacesUseCase = new GetAllRacesUseCase(
-      raceRepository,
-      leagueRepository,
-      mockLogger
-    );
-  });
-
-  beforeEach(async () => {
-    (raceRepository as any).races.clear();
-    leagueRepository.clear();
-  });
-
-  describe('Races Main Page Data', () => {
-    it('should retrieve upcoming and recent races', async () => {
-      // Given: Upcoming and completed races exist
-      const leagueId = 'l1';
-      const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
-      await leagueRepository.create(league);
-
-      const upcomingRace = Race.create({
-        id: 'r1',
-        leagueId,
-        scheduledAt: new Date(Date.now() + 86400000),
-        track: 'Spa',
-        car: 'GT3',
-        status: 'scheduled'
-      });
-      const completedRace = Race.create({
-        id: 'r2',
-        leagueId,
-        scheduledAt: new Date(Date.now() - 86400000),
-        track: 'Monza',
-        car: 'GT3',
-        status: 'completed'
-      });
-      await raceRepository.create(upcomingRace);
-      await raceRepository.create(completedRace);
-
-      // When: GetAllRacesUseCase.execute() is called
-      const result = await getAllRacesUseCase.execute({});
-
-      // Then: The result should contain both races
-      expect(result.isOk()).toBe(true);
-      const data = result.unwrap();
-      expect(data.races).toHaveLength(2);
-      expect(data.races.some(r => r.status.isScheduled())).toBe(true);
-      expect(data.races.some(r => r.status.isCompleted())).toBe(true);
-    });
-  });
-});

tests/integration/races/results/get-race-penalties.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { RacesTestContext } from '../RacesTestContext';
+import { GetRacePenaltiesUseCase } from '../../../../core/racing/application/use-cases/GetRacePenaltiesUseCase';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+import { Penalty } from '../../../../core/racing/domain/entities/penalty/Penalty';
+
+describe('GetRacePenaltiesUseCase', () => {
+  let context: RacesTestContext;
+  let getRacePenaltiesUseCase: GetRacePenaltiesUseCase;
+
+  beforeAll(() => {
+    context = RacesTestContext.create();
+    getRacePenaltiesUseCase = new GetRacePenaltiesUseCase(
+      context.penaltyRepository,
+      context.driverRepository
+    );
+  });
+
+  beforeEach(async () => {
+    await context.clear();
+  });
+
+  it('should retrieve race penalties with driver information', async () => {
+    // Given: A race with penalties
+    const leagueId = 'l1';
+    const raceId = 'r1';
+    const driverId = 'd1';
+    const stewardId = 's1';
+
+    const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
+    await context.driverRepository.create(driver);
+    
+    const steward = Driver.create({ id: stewardId, iracingId: '200', name: 'Steward', country: 'UK' });
+    await context.driverRepository.create(steward);
+
+    const penalty = Penalty.create({
+      id: 'p1',
+      leagueId,
+      raceId,
+      driverId,
+      type: 'time_penalty',
+      value: 5,
+      reason: 'Track limits',
+      issuedBy: stewardId,
+      status: 'applied'
+    });
+    await context.penaltyRepository.create(penalty);
+
+    // When: GetRacePenaltiesUseCase.execute() is called
+    const result = await getRacePenaltiesUseCase.execute({ raceId });
+
+    // Then: It should return penalties and drivers
+    expect(result.isOk()).toBe(true);
+    const data = result.unwrap();
+    expect(data.penalties).toHaveLength(1);
+    expect(data.drivers.some(d => d.id === driverId)).toBe(true);
+    expect(data.drivers.some(d => d.id === stewardId)).toBe(true);
+  });
+});

tests/integration/races/results/get-race-results-detail.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { RacesTestContext } from '../RacesTestContext';
+import { GetRaceResultsDetailUseCase } from '../../../../core/racing/application/use-cases/GetRaceResultsDetailUseCase';
+import { Race } from '../../../../core/racing/domain/entities/Race';
+import { League } from '../../../../core/racing/domain/entities/League';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+import { Result as RaceResult } from '../../../../core/racing/domain/entities/result/Result';
+
+describe('GetRaceResultsDetailUseCase', () => {
+  let context: RacesTestContext;
+  let getRaceResultsDetailUseCase: GetRaceResultsDetailUseCase;
+
+  beforeAll(() => {
+    context = RacesTestContext.create();
+    getRaceResultsDetailUseCase = new GetRaceResultsDetailUseCase(
+      context.raceRepository,
+      context.leagueRepository,
+      context.resultRepository,
+      context.driverRepository,
+      context.penaltyRepository
+    );
+  });
+
+  beforeEach(async () => {
+    await context.clear();
+  });
+
+  it('should retrieve complete race results with all finishers', async () => {
+    // Given: A completed race with results
+    const leagueId = 'l1';
+    const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
+    await context.leagueRepository.create(league);
+
+    const raceId = 'r1';
+    const race = Race.create({
+      id: raceId,
+      leagueId,
+      scheduledAt: new Date(Date.now() - 86400000),
+      track: 'Spa',
+      car: 'GT3',
+      status: 'completed'
+    });
+    await context.raceRepository.create(race);
+
+    const driverId = 'd1';
+    const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
+    await context.driverRepository.create(driver);
+
+    const raceResult = RaceResult.create({
+      id: 'res1',
+      raceId,
+      driverId,
+      position: 1,
+      lapsCompleted: 20,
+      totalTime: 3600,
+      fastestLap: 105,
+      points: 25,
+      incidents: 0,
+      startPosition: 1
+    });
+    await context.resultRepository.create(raceResult);
+
+    // When: GetRaceResultsDetailUseCase.execute() is called
+    const result = await getRaceResultsDetailUseCase.execute({ raceId });
+
+    // Then: The result should contain race and results
+    expect(result.isOk()).toBe(true);
+    const data = result.unwrap();
+    expect(data.race.id).toBe(raceId);
+    expect(data.results).toHaveLength(1);
+    expect(data.results[0].driverId.toString()).toBe(driverId);
+  });
+});

tests/integration/races/stewarding/get-league-protests.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { RacesTestContext } from '../RacesTestContext';
+import { GetLeagueProtestsUseCase } from '../../../../core/racing/application/use-cases/GetLeagueProtestsUseCase';
+import { Race } from '../../../../core/racing/domain/entities/Race';
+import { League } from '../../../../core/racing/domain/entities/League';
+import { Driver } from '../../../../core/racing/domain/entities/Driver';
+import { Protest } from '../../../../core/racing/domain/entities/Protest';
+
+describe('GetLeagueProtestsUseCase', () => {
+  let context: RacesTestContext;
+  let getLeagueProtestsUseCase: GetLeagueProtestsUseCase;
+
+  beforeAll(() => {
+    context = RacesTestContext.create();
+    getLeagueProtestsUseCase = new GetLeagueProtestsUseCase(
+      context.raceRepository,
+      context.protestRepository,
+      context.driverRepository,
+      context.leagueRepository
+    );
+  });
+
+  beforeEach(async () => {
+    await context.clear();
+  });
+
+  it('should retrieve league protests with all related entities', async () => {
+    // Given: A league, race, drivers and a protest exist
+    const leagueId = 'l1';
+    const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
+    await context.leagueRepository.create(league);
+
+    const raceId = 'r1';
+    const race = Race.create({
+      id: raceId,
+      leagueId,
+      scheduledAt: new Date(),
+      track: 'Spa',
+      car: 'GT3',
+      status: 'completed'
+    });
+    await context.raceRepository.create(race);
+
+    const driver1Id = 'd1';
+    const driver2Id = 'd2';
+    const driver1 = Driver.create({ id: driver1Id, iracingId: '100', name: 'Protester', country: 'US' });
+    const driver2 = Driver.create({ id: driver2Id, iracingId: '200', name: 'Accused', country: 'UK' });
+    await context.driverRepository.create(driver1);
+    await context.driverRepository.create(driver2);
+
+    const protest = Protest.create({
+      id: 'p1',
+      raceId,
+      protestingDriverId: driver1Id,
+      accusedDriverId: driver2Id,
+      incident: { lap: 1, description: 'Unsafe rejoin' },
+      timestamp: new Date()
+    });
+    await context.protestRepository.create(protest);
+
+    // When: GetLeagueProtestsUseCase.execute() is called
+    const result = await getLeagueProtestsUseCase.execute({ leagueId });
+
+    // Then: It should return the protest with race and driver info
+    expect(result.isOk()).toBe(true);
+    const data = result.unwrap();
+    expect(data.protests).toHaveLength(1);
+    expect(data.protests[0].protest.id).toBe('p1');
+    expect(data.protests[0].race?.id).toBe(raceId);
+    expect(data.protests[0].protestingDriver?.id).toBe(driver1Id);
+    expect(data.protests[0].accusedDriver?.id).toBe(driver2Id);
+  });
+});

tests/integration/races/stewarding/review-protest.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { RacesTestContext } from '../RacesTestContext';
+import { ReviewProtestUseCase } from '../../../../core/racing/application/use-cases/ReviewProtestUseCase';
+import { Race } from '../../../../core/racing/domain/entities/Race';
+import { Protest } from '../../../../core/racing/domain/entities/Protest';
+import { LeagueMembership } from '../../../../core/racing/domain/entities/LeagueMembership';
+
+describe('ReviewProtestUseCase', () => {
+  let context: RacesTestContext;
+  let reviewProtestUseCase: ReviewProtestUseCase;
+
+  beforeAll(() => {
+    context = RacesTestContext.create();
+    reviewProtestUseCase = new ReviewProtestUseCase(
+      context.protestRepository,
+      context.raceRepository,
+      context.leagueMembershipRepository,
+      context.logger
+    );
+  });
+
+  beforeEach(async () => {
+    await context.clear();
+  });
+
+  it('should allow a steward to review a protest', async () => {
+    // Given: A protest and a steward membership
+    const leagueId = 'l1';
+    const raceId = 'r1';
+    const stewardId = 's1';
+    
+    const race = Race.create({
+      id: raceId,
+      leagueId,
+      scheduledAt: new Date(),
+      track: 'Spa',
+      car: 'GT3',
+      status: 'completed'
+    });
+    await context.raceRepository.create(race);
+
+    const protest = Protest.create({
+      id: 'p1',
+      raceId,
+      protestingDriverId: 'd1',
+      accusedDriverId: 'd2',
+      incident: { lap: 1, description: 'Unsafe rejoin' },
+      filedAt: new Date()
+    });
+    await context.protestRepository.create(protest);
+
+    const membership = LeagueMembership.create({
+      id: 'm1',
+      leagueId,
+      driverId: stewardId,
+      role: 'admin',
+      status: 'active'
+    });
+    await context.leagueMembershipRepository.saveMembership(membership);
+
+    // When: ReviewProtestUseCase.execute() is called
+    const result = await reviewProtestUseCase.execute({
+      protestId: 'p1',
+      stewardId,
+      decision: 'uphold',
+      decisionNotes: 'Clear violation'
+    });
+
+    // Then: The protest should be updated
+    expect(result.isOk()).toBe(true);
+    const updatedProtest = await context.protestRepository.findById('p1');
+    expect(updatedProtest?.status.toString()).toBe('upheld');
+    expect(updatedProtest?.reviewedBy).toBe(stewardId);
+  });
+});