integration tests

tests/integration/leaderboards/driver-rankings/driver-rankings-edge-cases.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaderboardsTestContext } from '../LeaderboardsTestContext';
+import { ValidationError } from '../../../../core/shared/errors/ValidationError';
+
+describe('GetDriverRankingsUseCase - Edge Cases & Errors', () => {
+  let context: LeaderboardsTestContext;
+
+  beforeEach(() => {
+    context = LeaderboardsTestContext.create();
+    context.clear();
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle system with no drivers', async () => {
+      const result = await context.getDriverRankingsUseCase.execute({});
+      expect(result.drivers).toHaveLength(0);
+      expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+    });
+
+    it('should handle drivers with same rating', async () => {
+      context.repository.addDriver({ id: 'driver-1', name: 'Zoe', rating: 5.0, raceCount: 50 });
+      context.repository.addDriver({ id: 'driver-2', name: 'Alice', rating: 5.0, raceCount: 45 });
+      context.repository.addDriver({ id: 'driver-3', name: 'Bob', rating: 5.0, raceCount: 40 });
+
+      const result = await context.getDriverRankingsUseCase.execute({});
+
+      expect(result.drivers[0].rating).toBe(5.0);
+      expect(result.drivers[1].rating).toBe(5.0);
+      expect(result.drivers[2].rating).toBe(5.0);
+      expect(result.drivers[0].name).toBe('Alice');
+      expect(result.drivers[1].name).toBe('Bob');
+      expect(result.drivers[2].name).toBe('Zoe');
+      expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+    });
+
+    it('should handle drivers with no team affiliation', async () => {
+      context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 5.0, teamId: 'team-1', teamName: 'Team 1', raceCount: 10 });
+      context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.8, raceCount: 10 });
+
+      const result = await context.getDriverRankingsUseCase.execute({});
+
+      expect(result.drivers).toHaveLength(2);
+      expect(result.drivers[0].teamId).toBe('team-1');
+      expect(result.drivers[1].teamId).toBeUndefined();
+      expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+    });
+
+    it('should handle pagination with empty results', async () => {
+      const result = await context.getDriverRankingsUseCase.execute({ page: 1, limit: 20 });
+      expect(result.drivers).toHaveLength(0);
+      expect(result.pagination.total).toBe(0);
+      expect(result.pagination.totalPages).toBe(0);
+      expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle driver repository errors gracefully', async () => {
+      const originalFindAllDrivers = context.repository.findAllDrivers.bind(context.repository);
+      context.repository.findAllDrivers = async () => {
+        throw new Error('Repository error');
+      };
+
+      try {
+        await context.getDriverRankingsUseCase.execute({});
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Repository error');
+      }
+
+      expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(0);
+      context.repository.findAllDrivers = originalFindAllDrivers;
+    });
+
+    it('should handle invalid query parameters', async () => {
+      try {
+        await context.getDriverRankingsUseCase.execute({ page: -1 });
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ValidationError);
+      }
+      expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(0);
+    });
+  });
+});

tests/integration/leaderboards/driver-rankings/driver-rankings-filter.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaderboardsTestContext } from '../LeaderboardsTestContext';
+
+describe('GetDriverRankingsUseCase - Filter Functionality', () => {
+  let context: LeaderboardsTestContext;
+
+  beforeEach(() => {
+    context = LeaderboardsTestContext.create();
+    context.clear();
+  });
+
+  it('should filter drivers by rating range', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 3.5, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Driver C', rating: 4.5, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-4', name: 'Driver D', rating: 5.0, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ minRating: 4.0 });
+
+    expect(result.drivers).toHaveLength(3);
+    expect(result.drivers.every((d) => d.rating >= 4.0)).toBe(true);
+    expect(result.drivers.map((d) => d.name)).not.toContain('Driver A');
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should filter drivers by team', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 5.0, teamId: 'team-1', teamName: 'Team 1', raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.8, teamId: 'team-2', teamName: 'Team 2', raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Driver C', rating: 4.5, teamId: 'team-1', teamName: 'Team 1', raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ teamId: 'team-1' });
+
+    expect(result.drivers).toHaveLength(2);
+    expect(result.drivers.every((d) => d.teamId === 'team-1')).toBe(true);
+    expect(result.drivers.map((d) => d.name)).not.toContain('Driver B');
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should filter drivers by multiple criteria', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 5.0, teamId: 'team-1', teamName: 'Team 1', raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.8, teamId: 'team-2', teamName: 'Team 2', raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Driver C', rating: 4.5, teamId: 'team-1', teamName: 'Team 1', raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-4', name: 'Driver D', rating: 3.5, teamId: 'team-1', teamName: 'Team 1', raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ minRating: 4.0, teamId: 'team-1' });
+
+    expect(result.drivers).toHaveLength(2);
+    expect(result.drivers.every((d) => d.teamId === 'team-1' && d.rating >= 4.0)).toBe(true);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should handle empty filter results', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 3.5, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ minRating: 10.0 });
+
+    expect(result.drivers).toHaveLength(0);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+});

tests/integration/leaderboards/driver-rankings/driver-rankings-search.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaderboardsTestContext } from '../LeaderboardsTestContext';
+
+describe('GetDriverRankingsUseCase - Search Functionality', () => {
+  let context: LeaderboardsTestContext;
+
+  beforeEach(() => {
+    context = LeaderboardsTestContext.create();
+    context.clear();
+  });
+
+  it('should search for drivers by name', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'John Smith', rating: 5.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Jane Doe', rating: 4.8, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Bob Johnson', rating: 4.5, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ search: 'John' });
+
+    expect(result.drivers).toHaveLength(2);
+    expect(result.drivers.map((d) => d.name)).toContain('John Smith');
+    expect(result.drivers.map((d) => d.name)).toContain('Bob Johnson');
+    expect(result.drivers.map((d) => d.name)).not.toContain('Jane Doe');
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should search for drivers by partial name', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Alexander', rating: 5.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Alex', rating: 4.8, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Alexandra', rating: 4.5, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ search: 'Alex' });
+
+    expect(result.drivers).toHaveLength(3);
+    expect(result.drivers.map((d) => d.name)).toContain('Alexander');
+    expect(result.drivers.map((d) => d.name)).toContain('Alex');
+    expect(result.drivers.map((d) => d.name)).toContain('Alexandra');
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should handle case-insensitive search', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'John Smith', rating: 5.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'JOHN DOE', rating: 4.8, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'johnson', rating: 4.5, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ search: 'john' });
+
+    expect(result.drivers).toHaveLength(3);
+    expect(result.drivers.map((d) => d.name)).toContain('John Smith');
+    expect(result.drivers.map((d) => d.name)).toContain('JOHN DOE');
+    expect(result.drivers.map((d) => d.name)).toContain('johnson');
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should return empty result when no drivers match search', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'John Smith', rating: 5.0, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ search: 'NonExistentDriver' });
+
+    expect(result.drivers).toHaveLength(0);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+});

tests/integration/leaderboards/driver-rankings/driver-rankings-sort.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaderboardsTestContext } from '../LeaderboardsTestContext';
+
+describe('GetDriverRankingsUseCase - Sort Functionality', () => {
+  let context: LeaderboardsTestContext;
+
+  beforeEach(() => {
+    context = LeaderboardsTestContext.create();
+    context.clear();
+  });
+
+  it('should sort drivers by rating (high to low)', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 3.5, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Driver C', rating: 4.5, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-4', name: 'Driver D', rating: 5.0, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ sortBy: 'rating', sortOrder: 'desc' });
+
+    expect(result.drivers[0].rating).toBe(5.0);
+    expect(result.drivers[1].rating).toBe(4.5);
+    expect(result.drivers[2].rating).toBe(4.0);
+    expect(result.drivers[3].rating).toBe(3.5);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should sort drivers by name (A-Z)', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Zoe', rating: 5.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Alice', rating: 4.8, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Bob', rating: 4.5, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ sortBy: 'name', sortOrder: 'asc' });
+
+    expect(result.drivers[0].name).toBe('Alice');
+    expect(result.drivers[1].name).toBe('Bob');
+    expect(result.drivers[2].name).toBe('Zoe');
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should sort drivers by rank (low to high)', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 5.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.8, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Driver C', rating: 4.5, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ sortBy: 'rank', sortOrder: 'asc' });
+
+    expect(result.drivers[0].rank).toBe(1);
+    expect(result.drivers[1].rank).toBe(2);
+    expect(result.drivers[2].rank).toBe(3);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should sort drivers by race count (high to low)', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 5.0, raceCount: 50 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.8, raceCount: 30 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Driver C', rating: 4.5, raceCount: 40 });
+
+    const result = await context.getDriverRankingsUseCase.execute({ sortBy: 'raceCount', sortOrder: 'desc' });
+
+    expect(result.drivers[0].raceCount).toBe(50);
+    expect(result.drivers[1].raceCount).toBe(40);
+    expect(result.drivers[2].raceCount).toBe(30);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+});

tests/integration/leaderboards/driver-rankings/driver-rankings-success.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaderboardsTestContext } from '../LeaderboardsTestContext';
+
+describe('GetDriverRankingsUseCase - Success Path', () => {
+  let context: LeaderboardsTestContext;
+
+  beforeEach(() => {
+    context = LeaderboardsTestContext.create();
+    context.clear();
+  });
+
+  it('should retrieve all drivers with complete data', async () => {
+    context.repository.addDriver({
+      id: 'driver-1',
+      name: 'John Smith',
+      rating: 5.0,
+      teamId: 'team-1',
+      teamName: 'Racing Team A',
+      raceCount: 50,
+    });
+    context.repository.addDriver({
+      id: 'driver-2',
+      name: 'Jane Doe',
+      rating: 4.8,
+      teamId: 'team-2',
+      teamName: 'Speed Squad',
+      raceCount: 45,
+    });
+    context.repository.addDriver({
+      id: 'driver-3',
+      name: 'Bob Johnson',
+      rating: 4.5,
+      teamId: 'team-1',
+      teamName: 'Racing Team A',
+      raceCount: 40,
+    });
+
+    const result = await context.getDriverRankingsUseCase.execute({});
+
+    expect(result.drivers).toHaveLength(3);
+    expect(result.drivers[0]).toMatchObject({
+      rank: 1,
+      id: 'driver-1',
+      name: 'John Smith',
+      rating: 5.0,
+      teamId: 'team-1',
+      teamName: 'Racing Team A',
+      raceCount: 50,
+    });
+    expect(result.drivers[0].rating).toBe(5.0);
+    expect(result.drivers[1].rating).toBe(4.8);
+    expect(result.drivers[2].rating).toBe(4.5);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should retrieve drivers with pagination', async () => {
+    for (let i = 1; i <= 25; i++) {
+      context.repository.addDriver({
+        id: `driver-${i}`,
+        name: `Driver ${i}`,
+        rating: 5.0 - i * 0.1,
+        raceCount: 10 + i,
+      });
+    }
+
+    const result = await context.getDriverRankingsUseCase.execute({ page: 1, limit: 20 });
+
+    expect(result.drivers).toHaveLength(20);
+    expect(result.pagination.total).toBe(25);
+    expect(result.pagination.page).toBe(1);
+    expect(result.pagination.limit).toBe(20);
+    expect(result.pagination.totalPages).toBe(2);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should retrieve drivers with different page sizes', async () => {
+    for (let i = 1; i <= 60; i++) {
+      context.repository.addDriver({
+        id: `driver-${i}`,
+        name: `Driver ${i}`,
+        rating: 5.0 - i * 0.1,
+        raceCount: 10 + i,
+      });
+    }
+
+    const result = await context.getDriverRankingsUseCase.execute({ limit: 50 });
+
+    expect(result.drivers).toHaveLength(50);
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should retrieve drivers with consistent ranking order', async () => {
+    context.repository.addDriver({ id: 'driver-1', name: 'Driver A', rating: 5.0, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-2', name: 'Driver B', rating: 4.8, raceCount: 10 });
+    context.repository.addDriver({ id: 'driver-3', name: 'Driver C', rating: 4.5, raceCount: 10 });
+
+    const result = await context.getDriverRankingsUseCase.execute({});
+
+    expect(result.drivers[0].rank).toBe(1);
+    expect(result.drivers[1].rank).toBe(2);
+    expect(result.drivers[2].rank).toBe(3);
+
+    const ranks = result.drivers.map((d) => d.rank);
+    expect(new Set(ranks).size).toBe(ranks.length);
+    for (let i = 0; i < ranks.length; i++) {
+      expect(ranks[i]).toBe(i + 1);
+    }
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+
+  it('should retrieve drivers with accurate data', async () => {
+    context.repository.addDriver({
+      id: 'driver-1',
+      name: 'John Smith',
+      rating: 5.0,
+      teamId: 'team-1',
+      teamName: 'Racing Team A',
+      raceCount: 50,
+    });
+
+    const result = await context.getDriverRankingsUseCase.execute({});
+
+    expect(result.drivers[0].rating).toBeGreaterThan(0);
+    expect(typeof result.drivers[0].rating).toBe('number');
+    expect(result.drivers[0].rank).toBe(1);
+    expect(result.drivers[0].name).toBeTruthy();
+    expect(typeof result.drivers[0].name).toBe('string');
+    expect(result.drivers[0].teamId).toBe('team-1');
+    expect(result.drivers[0].teamName).toBe('Racing Team A');
+    expect(context.eventPublisher.getDriverRankingsAccessedEventCount()).toBe(1);
+  });
+});