refactor racing use cases

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

@@ -1,8 +1,13 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { GetAllRacesUseCase } from './GetAllRacesUseCase';
+import {
+  GetAllRacesUseCase,
+  type GetAllRacesResult,
+  type GetAllRacesInput,
+} from './GetAllRacesUseCase';
 import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
 import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
 import type { Logger } from '@core/shared/application';
+import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
 
 describe('GetAllRacesUseCase', () => {
   const mockRaceFindAll = vi.fn();
@@ -39,15 +44,21 @@ describe('GetAllRacesUseCase', () => {
     error: vi.fn(),
   };
 
+  let output: UseCaseOutputPort<GetAllRacesResult> & { present: ReturnType<typeof vi.fn> };
+
   beforeEach(() => {
     vi.clearAllMocks();
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<GetAllRacesResult> & { present: ReturnType<typeof vi.fn> };
   });
 
-  it('should return races data', async () => {
+  it('should present domain races and leagues data', async () => {
     const useCase = new GetAllRacesUseCase(
       mockRaceRepo,
       mockLeagueRepo,
       mockLogger,
+      output,
     );
 
     const race1 = {
@@ -56,75 +67,74 @@ describe('GetAllRacesUseCase', () => {
       car: 'Car A',
       scheduledAt: new Date('2023-01-01T10:00:00Z'),
       leagueId: 'league1',
-    };
+    } as any;
     const race2 = {
       id: 'race2',
       track: 'Track B',
       car: 'Car B',
       scheduledAt: new Date('2023-01-02T10:00:00Z'),
       leagueId: 'league2',
-    };
-    const league1 = { id: 'league1', name: 'League One' };
-    const league2 = { id: 'league2', name: 'League Two' };
+    } as any;
+    const league1 = { id: 'league1' } as any;
+    const league2 = { id: 'league2' } as any;
 
     mockRaceFindAll.mockResolvedValue([race1, race2]);
     mockLeagueFindAll.mockResolvedValue([league1, league2]);
 
-    const result = await useCase.execute();
+    const input: GetAllRacesInput = {};
+
+    const result = await useCase.execute(input);
 
     expect(result.isOk()).toBe(true);
-    expect(result.value).toEqual({
-      races: [
-        {
-          id: 'race1',
-          name: 'Track A - Car A',
-          date: '2023-01-01T10:00:00.000Z',
-          leagueName: 'League One',
-        },
-        {
-          id: 'race2',
-          name: 'Track B - Car B',
-          date: '2023-01-02T10:00:00.000Z',
-          leagueName: 'League Two',
-        },
-      ],
-      totalCount: 2,
-    });
+    expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+
+    const presented = output.present.mock.calls[0][0] as GetAllRacesResult;
+    expect(presented.totalCount).toBe(2);
+    expect(presented.races).toEqual([race1, race2]);
+    expect(presented.leagues).toEqual([league1, league2]);
   });
 
-  it('should return empty result when no races or leagues', async () => {
+  it('should present empty result when no races or leagues', async () => {
     const useCase = new GetAllRacesUseCase(
       mockRaceRepo,
       mockLeagueRepo,
       mockLogger,
+      output,
     );
 
     mockRaceFindAll.mockResolvedValue([]);
     mockLeagueFindAll.mockResolvedValue([]);
 
-    const result = await useCase.execute();
+    const result = await useCase.execute({});
 
     expect(result.isOk()).toBe(true);
-    expect(result.value).toEqual({
-      races: [],
-      totalCount: 0,
-    });
+    expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+
+    const presented = output.present.mock.calls[0][0] as GetAllRacesResult;
+    expect(presented.totalCount).toBe(0);
+    expect(presented.races).toEqual([]);
+    expect(presented.leagues).toEqual([]);
   });
 
-  it('should return error when repository throws', async () => {
+  it('should return error when repository throws and not present data', async () => {
     const useCase = new GetAllRacesUseCase(
       mockRaceRepo,
       mockLeagueRepo,
       mockLogger,
+      output,
     );
 
     const error = new Error('Repository error');
     mockRaceFindAll.mockRejectedValue(error);
 
-    const result = await useCase.execute();
+    const result = await useCase.execute({});
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
-    expect(result.unwrapErr().details.message).toBe('Repository error');
+    const err = result.unwrapErr();
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(err.details.message).toBe('Repository error');
+    expect(output.present).not.toHaveBeenCalled();
   });
-});
+});