refactor

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { GetDriversLeaderboardUseCase } from './GetDriversLeaderboardUseCase';
 import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
 import type { IRankingService } from '../../domain/services/IRankingService';
@@ -7,31 +7,48 @@ 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;
+  const mockDriverFindAll = vi.fn();
+  const mockDriverRepo: IDriverRepository = {
+    findById: vi.fn(),
+    findAll: mockDriverFindAll,
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+    exists: vi.fn(),
+  };
+
+  const mockRankingGetAllDriverRankings = vi.fn();
+  const mockRankingService: IRankingService = {
+    getAllDriverRankings: mockRankingGetAllDriverRankings,
+  };
+
+  const mockDriverStatsGetDriverStats = vi.fn();
+  const mockDriverStatsService: IDriverStatsService = {
+    getDriverStats: mockDriverStatsGetDriverStats,
+  };
+
+  const mockImageGetDriverAvatar = vi.fn();
+  const mockImageService: IImageServicePort = {
+    getDriverAvatar: mockImageGetDriverAvatar,
+  };
+
+  const mockLogger: Logger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  };
 
   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(),
-    };
+    vi.clearAllMocks();
   });
 
   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,
+      mockDriverRepo,
+      mockRankingService,
+      mockDriverStatsService,
+      mockImageService,
       mockLogger,
     );
 
@@ -41,14 +58,14 @@ describe('GetDriversLeaderboardUseCase', () => {
     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) => {
+    mockDriverFindAll.mockResolvedValue([driver1, driver2]);
+    mockRankingGetAllDriverRankings.mockReturnValue(rankings);
+    mockDriverStatsGetDriverStats.mockImplementation((id) => {
       if (id === 'driver1') return stats1;
       if (id === 'driver2') return stats2;
       return null;
     });
-    mockImageService.getDriverAvatar.mockImplementation((id) => `avatar-${id}`);
+    mockImageGetDriverAvatar.mockImplementation((id) => `avatar-${id}`);
 
     const result = await useCase.execute();
 
@@ -59,21 +76,19 @@ describe('GetDriversLeaderboardUseCase', () => {
       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,
+      mockDriverRepo,
+      mockRankingService,
+      mockDriverStatsService,
+      mockImageService,
       mockLogger,
     );
 
-    mockDriverRepo.findAll.mockResolvedValue([]);
-    mockRankingService.getAllDriverRankings.mockReturnValue({});
+    mockDriverFindAll.mockResolvedValue([]);
+    mockRankingGetAllDriverRankings.mockReturnValue({});
 
     const result = await useCase.execute();
 
@@ -88,20 +103,20 @@ describe('GetDriversLeaderboardUseCase', () => {
 
   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,
+      mockDriverRepo,
+      mockRankingService,
+      mockDriverStatsService,
+      mockImageService,
       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');
+    mockDriverFindAll.mockResolvedValue([driver1]);
+    mockRankingGetAllDriverRankings.mockReturnValue(rankings);
+    mockDriverStatsGetDriverStats.mockReturnValue(null);
+    mockImageGetDriverAvatar.mockReturnValue('avatar-driver1');
 
     const result = await useCase.execute();
 
@@ -116,20 +131,20 @@ describe('GetDriversLeaderboardUseCase', () => {
 
   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,
+      mockDriverRepo,
+      mockRankingService,
+      mockDriverStatsService,
+      mockImageService,
       mockLogger,
     );
 
     const error = new Error('Repository error');
-    mockDriverRepo.findAll.mockRejectedValue(error);
+    mockDriverFindAll.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);
+    expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
+    expect(result.unwrapErr().details.message).toBe('Repository error');
   });
 });