refactor racing use cases

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

@@ -1,7 +1,13 @@
 import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { IsDriverRegisteredForRaceUseCase } from './IsDriverRegisteredForRaceUseCase';
+import {
+  IsDriverRegisteredForRaceUseCase,
+  type IsDriverRegisteredForRaceInput,
+  type IsDriverRegisteredForRaceResult,
+  type IsDriverRegisteredForRaceErrorCode,
+} from './IsDriverRegisteredForRaceUseCase';
 import { IRaceRegistrationRepository } from '../../domain/repositories/IRaceRegistrationRepository';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('IsDriverRegisteredForRaceUseCase', () => {
   let useCase: IsDriverRegisteredForRaceUseCase;
@@ -14,6 +20,9 @@ describe('IsDriverRegisteredForRaceUseCase', () => {
     warn: Mock;
     error: Mock;
   };
+  let output: UseCaseOutputPort<IsDriverRegisteredForRaceResult> & {
+    present: Mock;
+  };
 
   beforeEach(() => {
     registrationRepository = {
@@ -25,36 +34,54 @@ describe('IsDriverRegisteredForRaceUseCase', () => {
       warn: vi.fn(),
       error: vi.fn(),
     };
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<IsDriverRegisteredForRaceResult> & { present: Mock };
     useCase = new IsDriverRegisteredForRaceUseCase(
       registrationRepository as unknown as IRaceRegistrationRepository,
       logger as unknown as Logger,
+      output as UseCaseOutputPort<IsDriverRegisteredForRaceResult>,
     );
   });
 
   it('should return true when driver is registered', async () => {
-    const params = { raceId: 'race-1', driverId: 'driver-1' };
+    const params: IsDriverRegisteredForRaceInput = { raceId: 'race-1', driverId: 'driver-1' };
 
     registrationRepository.isRegistered.mockResolvedValue(true);
 
     const result = await useCase.execute(params);
 
     expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(true);
+    expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+    const [[presented]] = (output.present as Mock).mock.calls as [[IsDriverRegisteredForRaceResult]];
+    expect(presented).toEqual({
+      raceId: params.raceId,
+      driverId: params.driverId,
+      isRegistered: true,
+    });
   });
 
   it('should return false when driver is not registered', async () => {
-    const params = { raceId: 'race-1', driverId: 'driver-1' };
+    const params: IsDriverRegisteredForRaceInput = { raceId: 'race-1', driverId: 'driver-1' };
 
     registrationRepository.isRegistered.mockResolvedValue(false);
 
     const result = await useCase.execute(params);
 
     expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(false);
+    expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+    const [[presented]] = (output.present as Mock).mock.calls as [[IsDriverRegisteredForRaceResult]];
+    expect(presented).toEqual({
+      raceId: params.raceId,
+      driverId: params.driverId,
+      isRegistered: false,
+    });
   });
 
   it('should return error on repository failure', async () => {
-    const params = { raceId: 'race-1', driverId: 'driver-1' };
+    const params: IsDriverRegisteredForRaceInput = { raceId: 'race-1', driverId: 'driver-1' };
     const error = new Error('Repository error');
 
     registrationRepository.isRegistered.mockRejectedValue(error);
@@ -62,9 +89,12 @@ describe('IsDriverRegisteredForRaceUseCase', () => {
     const result = await useCase.execute(params);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'REPOSITORY_ERROR',
-      details: { message: 'Repository error' },
-    });
+    const errorResult = result.unwrapErr() as ApplicationErrorCode<
+      IsDriverRegisteredForRaceErrorCode,
+      { message: string }
+    >;
+    expect(errorResult.code).toBe('REPOSITORY_ERROR');
+    expect(errorResult.details?.message).toBe('Repository error');
+    expect(output.present).not.toHaveBeenCalled();
   });
 });