refactor

core/racing/application/use-cases/GetDriversLeaderboardUseCase.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
+import { GetDriversLeaderboardUseCase } from './GetDriversLeaderboardUseCase';
+import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
+import type { IRankingService } from '../../domain/services/IRankingService';
+import type { IDriverStatsService } from '../../domain/services/IDriverStatsService';
+import type { IImageServicePort } from '../ports/IImageServicePort';
+import type { Logger } from '@core/shared/application';
+
+describe('GetDriversLeaderboardUseCase', () => {
+  let mockDriverRepo: { findAll: Mock };
+  let mockRankingService: { getAllDriverRankings: Mock };
+  let mockDriverStatsService: { getDriverStats: Mock };
+  let mockImageService: { getDriverAvatar: Mock };
+  let mockLogger: Logger;
+
+  beforeEach(() => {
+    mockDriverRepo = { findAll: vi.fn() };
+    mockRankingService = { getAllDriverRankings: vi.fn() };
+    mockDriverStatsService = { getDriverStats: vi.fn() };
+    mockImageService = { getDriverAvatar: vi.fn() };
+    mockLogger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+  });
+
+  it('should return drivers leaderboard data', async () => {
+    const useCase = new GetDriversLeaderboardUseCase(
+      mockDriverRepo as unknown as IDriverRepository,
+      mockRankingService as unknown as IRankingService,
+      mockDriverStatsService as unknown as IDriverStatsService,
+      mockImageService as unknown as IImageServicePort,
+      mockLogger,
+    );
+
+    const driver1 = { id: 'driver1', name: 'Driver One' };
+    const driver2 = { id: 'driver2', name: 'Driver Two' };
+    const rankings = { driver1: 1, driver2: 2 };
+    const stats1 = { wins: 5, losses: 2 };
+    const stats2 = { wins: 3, losses: 1 };
+
+    mockDriverRepo.findAll.mockResolvedValue([driver1, driver2]);
+    mockRankingService.getAllDriverRankings.mockReturnValue(rankings);
+    mockDriverStatsService.getDriverStats.mockImplementation((id) => {
+      if (id === 'driver1') return stats1;
+      if (id === 'driver2') return stats2;
+      return null;
+    });
+    mockImageService.getDriverAvatar.mockImplementation((id) => `avatar-${id}`);
+
+    const result = await useCase.execute();
+
+    expect(result.isOk()).toBe(true);
+    expect(result.value).toEqual({
+      drivers: [driver1, driver2],
+      rankings,
+      stats: { driver1: stats1, driver2: stats2 },
+      avatarUrls: { driver1: 'avatar-driver1', driver2: 'avatar-driver2' },
+    });
+    expect(mockLogger.debug).toHaveBeenCalledWith('Executing GetDriversLeaderboardUseCase');
+    expect(mockLogger.debug).toHaveBeenCalledWith('Successfully retrieved drivers leaderboard.');
+  });
+
+  it('should return empty result when no drivers', async () => {
+    const useCase = new GetDriversLeaderboardUseCase(
+      mockDriverRepo as unknown as IDriverRepository,
+      mockRankingService as unknown as IRankingService,
+      mockDriverStatsService as unknown as IDriverStatsService,
+      mockImageService as unknown as IImageServicePort,
+      mockLogger,
+    );
+
+    mockDriverRepo.findAll.mockResolvedValue([]);
+    mockRankingService.getAllDriverRankings.mockReturnValue({});
+
+    const result = await useCase.execute();
+
+    expect(result.isOk()).toBe(true);
+    expect(result.value).toEqual({
+      drivers: [],
+      rankings: {},
+      stats: {},
+      avatarUrls: {},
+    });
+  });
+
+  it('should handle drivers without stats', async () => {
+    const useCase = new GetDriversLeaderboardUseCase(
+      mockDriverRepo as unknown as IDriverRepository,
+      mockRankingService as unknown as IRankingService,
+      mockDriverStatsService as unknown as IDriverStatsService,
+      mockImageService as unknown as IImageServicePort,
+      mockLogger,
+    );
+
+    const driver1 = { id: 'driver1', name: 'Driver One' };
+    const rankings = { driver1: 1 };
+
+    mockDriverRepo.findAll.mockResolvedValue([driver1]);
+    mockRankingService.getAllDriverRankings.mockReturnValue(rankings);
+    mockDriverStatsService.getDriverStats.mockReturnValue(null);
+    mockImageService.getDriverAvatar.mockReturnValue('avatar-driver1');
+
+    const result = await useCase.execute();
+
+    expect(result.isOk()).toBe(true);
+    expect(result.value).toEqual({
+      drivers: [driver1],
+      rankings,
+      stats: {},
+      avatarUrls: { driver1: 'avatar-driver1' },
+    });
+  });
+
+  it('should return error when repository throws', async () => {
+    const useCase = new GetDriversLeaderboardUseCase(
+      mockDriverRepo as unknown as IDriverRepository,
+      mockRankingService as unknown as IRankingService,
+      mockDriverStatsService as unknown as IDriverStatsService,
+      mockImageService as unknown as IImageServicePort,
+      mockLogger,
+    );
+
+    const error = new Error('Repository error');
+    mockDriverRepo.findAll.mockRejectedValue(error);
+
+    const result = await useCase.execute();
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().message).toBe('Repository error');
+    expect(mockLogger.error).toHaveBeenCalledWith('Error executing GetDriversLeaderboardUseCase', error);
+  });
+});