gridpilot.gg/tests/integration/rating/rating-reliability-use-cases.integration.test.ts

import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { RatingTestContext } from './RatingTestContext';
import { CalculateRatingUseCase as CalculateReliabilityUseCase } from '../../../../core/rating/application/use-cases/CalculateRatingUseCase';
import { Driver } from '../../../../core/racing/domain/entities/Driver';
import { Race } from '../../../../core/racing/domain/entities/Race';
import { League } from '../../../../core/racing/domain/entities/League';
import { Result as RaceResult } from '../../../../core/racing/domain/entities/result/Result';

describe('Rating Reliability Use Cases', () => {
  let context: RatingTestContext;
  let calculateReliabilityUseCase: CalculateReliabilityUseCase;

  beforeAll(() => {
    context = RatingTestContext.create();
    calculateReliabilityUseCase = new CalculateReliabilityUseCase({
      driverRepository: context.driverRepository,
      raceRepository: context.raceRepository,
      resultRepository: context.resultRepository,
      ratingRepository: context.ratingRepository,
      eventPublisher: context.eventPublisher
    });
  });

  beforeEach(async () => {
    await context.clear();
  });

  describe('CalculateReliabilityUseCase', () => {
    describe('UseCase - Success Path', () => {
      it('should calculate reliability for driver with perfect attendance', async () => {
        // Given: A driver
        const driverId = 'd1';
        const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
        await context.driverRepository.create(driver);

        // Given: Multiple completed races with perfect attendance
        const leagueId = 'l1';
        const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
        await context.leagueRepository.create(league);

        for (let i = 1; i <= 5; i++) {
          const raceId = `r${i}`;
          const race = Race.create({
            id: raceId,
            leagueId,
            scheduledAt: new Date(Date.now() - (i * 86400000)),
            track: 'Spa',
            car: 'GT3',
            status: 'completed'
          });
          await context.raceRepository.create(race);

          const result = RaceResult.create({
            id: `res${i}`,
            raceId,
            driverId,
            position: 5,
            lapsCompleted: 20,
            totalTime: 3600,
            fastestLap: 105,
            points: 10,
            incidents: 1,
            startPosition: 5
          });
          await context.resultRepository.create(result);
        }

        // When: CalculateReliabilityUseCase.execute() is called
        const result = await calculateReliabilityUseCase.execute({
          driverId,
          raceId: 'r5'
        });

        // Then: The reliability should be calculated
        expect(result.isOk()).toBe(true);
        const reliability = result.unwrap();
        expect(reliability.driverId.toString()).toBe(driverId);
        expect(reliability.components.reliability).toBeGreaterThan(0);
      });
    });
  });
});