refactor racing use cases

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

@@ -1,8 +1,13 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { GetAllRacesPageDataUseCase } from './GetAllRacesPageDataUseCase';
+import {
+  GetAllRacesPageDataUseCase,
+  type GetAllRacesPageDataResult,
+  type GetAllRacesPageDataInput,
+} from './GetAllRacesPageDataUseCase';
 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('GetAllRacesPageDataUseCase', () => {
   const mockRaceFindAll = vi.fn();
@@ -39,15 +44,21 @@ describe('GetAllRacesPageDataUseCase', () => {
     error: vi.fn(),
   };
 
+  let output: UseCaseOutputPort<GetAllRacesPageDataResult> & { present: ReturnType<typeof vi.fn> };
+
   beforeEach(() => {
     vi.clearAllMocks();
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<GetAllRacesPageDataResult> & { present: ReturnType<typeof vi.fn> };
   });
 
-  it('should return races and filters data', async () => {
+  it('should present races and filters data', async () => {
     const useCase = new GetAllRacesPageDataUseCase(
       mockRaceRepo,
       mockLeagueRepo,
       mockLogger,
+      output,
     );
 
     const race1 = {
@@ -58,7 +69,7 @@ describe('GetAllRacesPageDataUseCase', () => {
       status: 'scheduled' as const,
       leagueId: 'league1',
       strengthOfField: 5,
-    };
+    } as any;
     const race2 = {
       id: 'race2',
       track: 'Track B',
@@ -67,97 +78,110 @@ describe('GetAllRacesPageDataUseCase', () => {
       status: 'completed' as const,
       leagueId: 'league2',
       strengthOfField: null,
-    };
-    const league1 = { id: 'league1', name: 'League One' };
-    const league2 = { id: 'league2', name: 'League Two' };
+    } as any;
+    const league1 = { id: 'league1', name: 'League One' } as any;
+    const league2 = { id: 'league2', name: 'League Two' } as any;
 
     mockRaceFindAll.mockResolvedValue([race1, race2]);
     mockLeagueFindAll.mockResolvedValue([league1, league2]);
 
-    const result = await useCase.execute();
+    const input: GetAllRacesPageDataInput = {};
+
+    const result = await useCase.execute(input);
 
     expect(result.isOk()).toBe(true);
-    expect(result.value).toEqual({
-      races: [
-        {
-          id: 'race2',
-          track: 'Track B',
-          car: 'Car B',
-          scheduledAt: '2023-01-02T10:00:00.000Z',
-          status: 'completed',
-          leagueId: 'league2',
-          leagueName: 'League Two',
-          strengthOfField: null,
-        },
-        {
-          id: 'race1',
-          track: 'Track A',
-          car: 'Car A',
-          scheduledAt: '2023-01-01T10:00:00.000Z',
-          status: 'scheduled',
-          leagueId: 'league1',
-          leagueName: 'League One',
-          strengthOfField: 5,
-        },
-      ],
-      filters: {
-        statuses: [
-          { value: 'all', label: 'All Statuses' },
-          { value: 'scheduled', label: 'Scheduled' },
-          { value: 'running', label: 'Live' },
-          { value: 'completed', label: 'Completed' },
-          { value: 'cancelled', label: 'Cancelled' },
-        ],
-        leagues: [
-          { id: 'league1', name: 'League One' },
-          { id: 'league2', name: 'League Two' },
-        ],
+    expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+
+    const presented = output.present.mock.calls[0][0] as GetAllRacesPageDataResult;
+
+    expect(presented.races).toEqual([
+      {
+        id: 'race2',
+        track: 'Track B',
+        car: 'Car B',
+        scheduledAt: '2023-01-02T10:00:00.000Z',
+        status: 'completed',
+        leagueId: 'league2',
+        leagueName: 'League Two',
+        strengthOfField: null,
       },
+      {
+        id: 'race1',
+        track: 'Track A',
+        car: 'Car A',
+        scheduledAt: '2023-01-01T10:00:00.000Z',
+        status: 'scheduled',
+        leagueId: 'league1',
+        leagueName: 'League One',
+        strengthOfField: 5,
+      },
+    ]);
+
+    expect(presented.filters).toEqual({
+      statuses: [
+        { value: 'all', label: 'All Statuses' },
+        { value: 'scheduled', label: 'Scheduled' },
+        { value: 'running', label: 'Live' },
+        { value: 'completed', label: 'Completed' },
+        { value: 'cancelled', label: 'Cancelled' },
+      ],
+      leagues: [
+        { id: 'league1', name: 'League One' },
+        { id: 'league2', name: 'League Two' },
+      ],
     });
   });
 
-  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 GetAllRacesPageDataUseCase(
       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: [],
-      filters: {
-        statuses: [
-          { value: 'all', label: 'All Statuses' },
-          { value: 'scheduled', label: 'Scheduled' },
-          { value: 'running', label: 'Live' },
-          { value: 'completed', label: 'Completed' },
-          { value: 'cancelled', label: 'Cancelled' },
-        ],
-        leagues: [],
-      },
+    expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+
+    const presented = output.present.mock.calls[0][0] as GetAllRacesPageDataResult;
+
+    expect(presented.races).toEqual([]);
+    expect(presented.filters).toEqual({
+      statuses: [
+        { value: 'all', label: 'All Statuses' },
+        { value: 'scheduled', label: 'Scheduled' },
+        { value: 'running', label: 'Live' },
+        { value: 'completed', label: 'Completed' },
+        { value: 'cancelled', label: 'Cancelled' },
+      ],
+      leagues: [],
     });
   });
 
-  it('should return error when repository throws', async () => {
+  it('should return error when repository throws and not present data', async () => {
     const useCase = new GetAllRacesPageDataUseCase(
       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();
   });
-});
+});