wip

tests/unit/domain/services/DropScoreApplier.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+
+import { DropScoreApplier } from '@gridpilot/racing/domain/services/DropScoreApplier';
+import type { EventPointsEntry } from '@gridpilot/racing/domain/services/DropScoreApplier';
+import type { DropScorePolicy } from '@gridpilot/racing/domain/value-objects/DropScorePolicy';
+
+describe('DropScoreApplier', () => {
+  it('with strategy none counts all events and drops none', () => {
+    const applier = new DropScoreApplier();
+
+    const policy: DropScorePolicy = {
+      strategy: 'none',
+    };
+
+    const events: EventPointsEntry[] = [
+      { eventId: 'event-1', points: 25 },
+      { eventId: 'event-2', points: 18 },
+      { eventId: 'event-3', points: 15 },
+    ];
+
+    const result = applier.apply(policy, events);
+
+    expect(result.counted).toHaveLength(3);
+    expect(result.dropped).toHaveLength(0);
+    expect(result.totalPoints).toBe(25 + 18 + 15);
+  });
+
+  it('with bestNResults keeps the highest scoring events and drops the rest', () => {
+    const applier = new DropScoreApplier();
+
+    const policy: DropScorePolicy = {
+      strategy: 'bestNResults',
+      count: 6,
+    };
+
+    const events: EventPointsEntry[] = [
+      { eventId: 'event-1', points: 25 },
+      { eventId: 'event-2', points: 18 },
+      { eventId: 'event-3', points: 15 },
+      { eventId: 'event-4', points: 12 },
+      { eventId: 'event-5', points: 10 },
+      { eventId: 'event-6', points: 8 },
+      { eventId: 'event-7', points: 6 },
+      { eventId: 'event-8', points: 4 },
+    ];
+
+    const result = applier.apply(policy, events);
+
+    expect(result.counted).toHaveLength(6);
+    expect(result.dropped).toHaveLength(2);
+
+    const countedIds = result.counted.map((e) => e.eventId);
+    expect(countedIds).toEqual([
+      'event-1',
+      'event-2',
+      'event-3',
+      'event-4',
+      'event-5',
+      'event-6',
+    ]);
+
+    const droppedIds = result.dropped.map((e) => e.eventId);
+    expect(droppedIds).toEqual(['event-7', 'event-8']);
+
+    expect(result.totalPoints).toBe(25 + 18 + 15 + 12 + 10 + 8);
+  });
+
+  it('bestNResults with count greater than available events counts all of them', () => {
+    const applier = new DropScoreApplier();
+
+    const policy: DropScorePolicy = {
+      strategy: 'bestNResults',
+      count: 10,
+    };
+
+    const events: EventPointsEntry[] = [
+      { eventId: 'event-1', points: 25 },
+      { eventId: 'event-2', points: 18 },
+      { eventId: 'event-3', points: 15 },
+    ];
+
+    const result = applier.apply(policy, events);
+
+    expect(result.counted).toHaveLength(3);
+    expect(result.dropped).toHaveLength(0);
+    expect(result.totalPoints).toBe(25 + 18 + 15);
+  });
+});

tests/unit/domain/services/EventScoringService.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect } from 'vitest';
+
+import { EventScoringService } from '@gridpilot/racing/domain/services/EventScoringService';
+import type { ParticipantRef } from '@gridpilot/racing/domain/value-objects/ParticipantRef';
+import type { SessionType } from '@gridpilot/racing/domain/value-objects/SessionType';
+import { PointsTable } from '@gridpilot/racing/domain/value-objects/PointsTable';
+import type { BonusRule } from '@gridpilot/racing/domain/value-objects/BonusRule';
+import type { ChampionshipConfig } from '@gridpilot/racing/domain/value-objects/ChampionshipConfig';
+import type { Result } from '@gridpilot/racing/domain/entities/Result';
+import type { Penalty } from '@gridpilot/racing/domain/entities/Penalty';
+import type { ChampionshipType } from '@gridpilot/racing/domain/value-objects/ChampionshipType';
+
+function makeDriverRef(id: string): ParticipantRef {
+  return {
+    type: 'driver' as ChampionshipType,
+    id,
+  };
+}
+
+function makePointsTable(points: number[]): PointsTable {
+  const pointsByPosition: Record<number, number> = {};
+  points.forEach((value, index) => {
+    pointsByPosition[index + 1] = value;
+  });
+  return new PointsTable(pointsByPosition);
+}
+
+function makeChampionshipConfig(params: {
+  id: string;
+  name: string;
+  sessionTypes: SessionType[];
+  mainPoints: number[];
+  sprintPoints?: number[];
+  mainBonusRules?: BonusRule[];
+}): ChampionshipConfig {
+  const { id, name, sessionTypes, mainPoints, sprintPoints, mainBonusRules } = params;
+
+  const pointsTableBySessionType: Record<SessionType, PointsTable> = {} as Record<SessionType, PointsTable>;
+
+  sessionTypes.forEach((sessionType) => {
+    if (sessionType === 'main') {
+      pointsTableBySessionType[sessionType] = makePointsTable(mainPoints);
+    } else if (sessionType === 'sprint' && sprintPoints) {
+      pointsTableBySessionType[sessionType] = makePointsTable(sprintPoints);
+    } else {
+      pointsTableBySessionType[sessionType] = new PointsTable({});
+    }
+  });
+
+  const bonusRulesBySessionType: Record<SessionType, BonusRule[]> = {} as Record<SessionType, BonusRule[]>;
+  sessionTypes.forEach((sessionType) => {
+    if (sessionType === 'main' && mainBonusRules) {
+      bonusRulesBySessionType[sessionType] = mainBonusRules;
+    } else {
+      bonusRulesBySessionType[sessionType] = [];
+    }
+  });
+
+  return {
+    id,
+    name,
+    type: 'driver',
+    sessionTypes,
+    pointsTableBySessionType,
+    bonusRulesBySessionType,
+    dropScorePolicy: {
+      strategy: 'none',
+    },
+  };
+}
+
+describe('EventScoringService', () => {
+  const seasonId = 'season-1';
+
+  it('assigns base points based on finishing positions for a main race', () => {
+    const service = new EventScoringService();
+
+    const championship = makeChampionshipConfig({
+      id: 'champ-1',
+      name: 'Driver Championship',
+      sessionTypes: ['main'],
+      mainPoints: [25, 18, 15, 12, 10],
+    });
+
+    const results: Result[] = [
+      {
+        id: 'result-1',
+        raceId: 'race-1',
+        driverId: 'driver-1',
+        position: 1,
+        fastestLap: 90000,
+        incidents: 0,
+        startPosition: 1,
+      },
+      {
+        id: 'result-2',
+        raceId: 'race-1',
+        driverId: 'driver-2',
+        position: 2,
+        fastestLap: 90500,
+        incidents: 0,
+        startPosition: 2,
+      },
+      {
+        id: 'result-3',
+        raceId: 'race-1',
+        driverId: 'driver-3',
+        position: 3,
+        fastestLap: 91000,
+        incidents: 0,
+        startPosition: 3,
+      },
+      {
+        id: 'result-4',
+        raceId: 'race-1',
+        driverId: 'driver-4',
+        position: 4,
+        fastestLap: 91500,
+        incidents: 0,
+        startPosition: 4,
+      },
+      {
+        id: 'result-5',
+        raceId: 'race-1',
+        driverId: 'driver-5',
+        position: 5,
+        fastestLap: 92000,
+        incidents: 0,
+        startPosition: 5,
+      },
+    ];
+
+    const penalties: Penalty[] = [];
+
+    const points = service.scoreSession({
+      seasonId,
+      championship,
+      sessionType: 'main',
+      results,
+      penalties,
+    });
+
+    const byParticipant = new Map(points.map((p) => [p.participant.id, p]));
+
+    expect(byParticipant.get('driver-1')?.basePoints).toBe(25);
+    expect(byParticipant.get('driver-2')?.basePoints).toBe(18);
+    expect(byParticipant.get('driver-3')?.basePoints).toBe(15);
+    expect(byParticipant.get('driver-4')?.basePoints).toBe(12);
+    expect(byParticipant.get('driver-5')?.basePoints).toBe(10);
+
+    for (const entry of byParticipant.values()) {
+      expect(entry.bonusPoints).toBe(0);
+      expect(entry.penaltyPoints).toBe(0);
+      expect(entry.totalPoints).toBe(entry.basePoints);
+    }
+  });
+
+  it('applies fastest lap bonus only when inside top 10', () => {
+    const service = new EventScoringService();
+
+    const fastestLapBonus: BonusRule = {
+      id: 'bonus-fastest-lap',
+      type: 'fastestLap',
+      points: 1,
+      requiresFinishInTopN: 10,
+    };
+
+    const championship = makeChampionshipConfig({
+      id: 'champ-1',
+      name: 'Driver Championship',
+      sessionTypes: ['main'],
+      mainPoints: [25, 18, 15, 12, 10, 8, 6, 4, 2, 1],
+      mainBonusRules: [fastestLapBonus],
+    });
+
+    const baseResultTemplate = {
+      raceId: 'race-1',
+      incidents: 0,
+    } as const;
+
+    const resultsP11Fastest: Result[] = [
+      {
+        id: 'result-1',
+        ...baseResultTemplate,
+        driverId: 'driver-1',
+        position: 1,
+        startPosition: 1,
+        fastestLap: 91000,
+      },
+      {
+        id: 'result-2',
+        ...baseResultTemplate,
+        driverId: 'driver-2',
+        position: 2,
+        startPosition: 2,
+        fastestLap: 90500,
+      },
+      {
+        id: 'result-3',
+        ...baseResultTemplate,
+        driverId: 'driver-3',
+        position: 11,
+        startPosition: 15,
+        fastestLap: 90000,
+      },
+    ];
+
+    const penalties: Penalty[] = [];
+
+    const pointsNoBonus = service.scoreSession({
+      seasonId,
+      championship,
+      sessionType: 'main',
+      results: resultsP11Fastest,
+      penalties,
+    });
+
+    const mapNoBonus = new Map(pointsNoBonus.map((p) => [p.participant.id, p]));
+
+    expect(mapNoBonus.get('driver-3')?.bonusPoints).toBe(0);
+
+    const resultsP8Fastest: Result[] = [
+      {
+        id: 'result-1',
+        ...baseResultTemplate,
+        driverId: 'driver-1',
+        position: 1,
+        startPosition: 1,
+        fastestLap: 91000,
+      },
+      {
+        id: 'result-2',
+        ...baseResultTemplate,
+        driverId: 'driver-2',
+        position: 2,
+        startPosition: 2,
+        fastestLap: 90500,
+      },
+      {
+        id: 'result-3',
+        ...baseResultTemplate,
+        driverId: 'driver-3',
+        position: 8,
+        startPosition: 15,
+        fastestLap: 90000,
+      },
+    ];
+
+    const pointsWithBonus = service.scoreSession({
+      seasonId,
+      championship,
+      sessionType: 'main',
+      results: resultsP8Fastest,
+      penalties,
+    });
+
+    const mapWithBonus = new Map(pointsWithBonus.map((p) => [p.participant.id, p]));
+
+    expect(mapWithBonus.get('driver-3')?.bonusPoints).toBe(1);
+    expect(mapWithBonus.get('driver-3')?.totalPoints).toBe(
+      (mapWithBonus.get('driver-3')?.basePoints || 0) +
+        (mapWithBonus.get('driver-3')?.bonusPoints || 0) -
+        (mapWithBonus.get('driver-3')?.penaltyPoints || 0),
+    );
+  });
+});