refactor core presenters

apps/api/src/domain/driver/DriverService.test.ts

@@ -8,6 +8,9 @@ import { IsDriverRegisteredForRaceUseCase } from '@core/racing/application/use-c
 import { UpdateDriverProfileUseCase } from '@core/racing/application/use-cases/UpdateDriverProfileUseCase';
 import type { Logger } from '@core/shared/application';
 import type { IDriverRepository } from '@core/racing/domain/repositories/IDriverRepository';
+import { Result } from '@core/shared/application/Result';
+import type { CompleteDriverOnboardingOutputPort } from '@core/racing/application/ports/output/CompleteDriverOnboardingOutputPort';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('DriverService', () => {
   let service: DriverService;
@@ -15,7 +18,9 @@ describe('DriverService', () => {
   let getTotalDriversUseCase: ReturnType<typeof vi.mocked<GetTotalDriversUseCase>>;
   let completeDriverOnboardingUseCase: ReturnType<typeof vi.mocked<CompleteDriverOnboardingUseCase>>;
   let isDriverRegisteredForRaceUseCase: ReturnType<typeof vi.mocked<IsDriverRegisteredForRaceUseCase>>;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   let updateDriverProfileUseCase: ReturnType<typeof vi.mocked<UpdateDriverProfileUseCase>>;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   let driverRepository: ReturnType<typeof vi.mocked<IDriverRepository>>;
   let logger: ReturnType<typeof vi.mocked<Logger>>;
 
@@ -102,17 +107,11 @@ describe('DriverService', () => {
         activeCount: 1,
       };
 
-      const mockPresenter = {
-        viewModel: mockViewModel,
-      };
-
-      getDriversLeaderboardUseCase.execute.mockImplementation(async (input, presenter) => {
-        Object.assign(presenter, mockPresenter);
-      });
+      getDriversLeaderboardUseCase.execute.mockResolvedValue(Result.ok(mockViewModel));
 
       const result = await service.getDriversLeaderboard();
 
-      expect(getDriversLeaderboardUseCase.execute).toHaveBeenCalledWith(undefined, expect.any(Object));
+      expect(getDriversLeaderboardUseCase.execute).toHaveBeenCalledWith();
       expect(logger.debug).toHaveBeenCalledWith('[DriverService] Fetching drivers leaderboard.');
       expect(result).toEqual(mockViewModel);
     });
@@ -120,26 +119,20 @@ describe('DriverService', () => {
 
   describe('getTotalDrivers', () => {
     it('should call GetTotalDriversUseCase and return the view model', async () => {
-      const mockViewModel = { totalDrivers: 5 };
+      const mockOutput = { totalDrivers: 5 };
 
-      const mockPresenter = {
-        viewModel: mockViewModel,
-      };
-
-      getTotalDriversUseCase.execute.mockImplementation(async (input, presenter) => {
-        Object.assign(presenter, mockPresenter);
-      });
+      getTotalDriversUseCase.execute.mockResolvedValue(Result.ok(mockOutput));
 
       const result = await service.getTotalDrivers();
 
-      expect(getTotalDriversUseCase.execute).toHaveBeenCalledWith(undefined, expect.any(Object));
+      expect(getTotalDriversUseCase.execute).toHaveBeenCalledWith();
       expect(logger.debug).toHaveBeenCalledWith('[DriverService] Fetching total drivers count.');
-      expect(result).toEqual(mockViewModel);
+      expect(result).toEqual(mockOutput);
     });
   });
 
   describe('completeOnboarding', () => {
-    it('should call CompleteDriverOnboardingUseCase and return the view model', async () => {
+    it('should call CompleteDriverOnboardingUseCase and return success', async () => {
       const input = {
         firstName: 'John',
         lastName: 'Doe',
@@ -149,30 +142,43 @@ describe('DriverService', () => {
         bio: 'Racing enthusiast',
       };
 
-      const mockViewModel = {
-        success: true,
-        driverId: 'user-123',
-      };
-
-      const mockPresenter = {
-        viewModel: mockViewModel,
-      };
-
-      completeDriverOnboardingUseCase.execute.mockImplementation(async (input, presenter) => {
-        Object.assign(presenter, mockPresenter);
-      });
+      completeDriverOnboardingUseCase.execute.mockResolvedValue(
+        Result.ok<CompleteDriverOnboardingOutputPort, ApplicationErrorCode<string>>({ driverId: 'user-123' })
+      );
 
       const result = await service.completeOnboarding('user-123', input);
 
-      expect(completeDriverOnboardingUseCase.execute).toHaveBeenCalledWith(
-        {
-          userId: 'user-123',
-          ...input,
-        },
-        expect.any(Object)
-      );
+      expect(completeDriverOnboardingUseCase.execute).toHaveBeenCalledWith({
+        userId: 'user-123',
+        ...input,
+      });
       expect(logger.debug).toHaveBeenCalledWith('Completing onboarding for user:', 'user-123');
-      expect(result).toEqual(mockViewModel);
+      expect(result).toEqual({
+        success: true,
+        driverId: 'user-123',
+      });
+    });
+
+    it('should handle error from use case', async () => {
+      const input = {
+        firstName: 'John',
+        lastName: 'Doe',
+        displayName: 'John Doe',
+        country: 'US',
+        timezone: 'America/New_York',
+        bio: 'Racing enthusiast',
+      };
+
+      completeDriverOnboardingUseCase.execute.mockResolvedValue(
+        Result.err<CompleteDriverOnboardingOutputPort, ApplicationErrorCode<string>>({ code: 'DRIVER_ALREADY_EXISTS' })
+      );
+
+      const result = await service.completeOnboarding('user-123', input);
+
+      expect(result).toEqual({
+        success: false,
+        errorMessage: 'DRIVER_ALREADY_EXISTS',
+      });
     });
   });
 
@@ -183,25 +189,19 @@ describe('DriverService', () => {
         raceId: 'race-1',
       };
 
-      const mockViewModel = {
+      const mockOutput = {
         isRegistered: true,
         raceId: 'race-1',
         driverId: 'driver-1',
       };
 
-      const mockPresenter = {
-        viewModel: mockViewModel,
-      };
-
-      isDriverRegisteredForRaceUseCase.execute.mockImplementation(async (params, presenter) => {
-        Object.assign(presenter, mockPresenter);
-      });
+      isDriverRegisteredForRaceUseCase.execute.mockResolvedValue(Result.ok(mockOutput));
 
       const result = await service.getDriverRegistrationStatus(query);
 
-      expect(isDriverRegisteredForRaceUseCase.execute).toHaveBeenCalledWith(query, expect.any(Object));
+      expect(isDriverRegisteredForRaceUseCase.execute).toHaveBeenCalledWith(query);
       expect(logger.debug).toHaveBeenCalledWith('Checking driver registration status:', query);
-      expect(result).toEqual(mockViewModel);
+      expect(result).toEqual(mockOutput);
     });
   });
 });