refactor racing use cases

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

@@ -1,12 +1,19 @@
-import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { GetProfileOverviewUseCase } from './GetProfileOverviewUseCase';
+import { describe, it, expect, beforeEach, vi, type Mock } from 'vitest';
+import {
+  GetProfileOverviewUseCase,
+  type GetProfileOverviewInput,
+  type GetProfileOverviewResult,
+  type GetProfileOverviewErrorCode,
+} from './GetProfileOverviewUseCase';
 import { IDriverRepository } from '../../domain/repositories/IDriverRepository';
 import { ITeamRepository } from '../../domain/repositories/ITeamRepository';
 import { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
 import { ISocialGraphRepository } from '@core/social/domain/repositories/ISocialGraphRepository';
-import { IImageServicePort } from '../ports/IImageServicePort';
+import type { IImageServicePort } from '../ports/IImageServicePort';
 import { Driver } from '../../domain/entities/Driver';
 import { Team } from '../../domain/entities/Team';
+import type { UseCaseOutputPort } from '@core/shared/application';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('GetProfileOverviewUseCase', () => {
   let useCase: GetProfileOverviewUseCase;
@@ -27,6 +34,10 @@ describe('GetProfileOverviewUseCase', () => {
   };
   let getDriverStats: Mock;
   let getAllDriverRankings: Mock;
+  let driverExtendedProfileProvider: {
+    getExtendedProfile: Mock;
+  };
+  let output: UseCaseOutputPort<GetProfileOverviewResult> & { present: Mock };
 
   beforeEach(() => {
     driverRepository = {
@@ -46,14 +57,23 @@ describe('GetProfileOverviewUseCase', () => {
     };
     getDriverStats = vi.fn();
     getAllDriverRankings = vi.fn();
+    driverExtendedProfileProvider = {
+      getExtendedProfile: vi.fn(),
+    };
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<GetProfileOverviewResult> & { present: Mock };
+
     useCase = new GetProfileOverviewUseCase(
       driverRepository as unknown as IDriverRepository,
       teamRepository as unknown as ITeamRepository,
       teamMembershipRepository as unknown as ITeamMembershipRepository,
       socialRepository as unknown as ISocialGraphRepository,
       imageService as unknown as IImageServicePort,
+      driverExtendedProfileProvider,
       getDriverStats,
       getAllDriverRankings,
+      output,
     );
   });
 
@@ -65,15 +85,33 @@ describe('GetProfileOverviewUseCase', () => {
       name: 'Test Driver',
       country: 'US',
     });
-    const teams = [Team.create({ id: 'team-1', name: 'Test Team', tag: 'TT', description: 'Test', ownerId: 'owner-1', leagues: [] })];
-    const friends = [Driver.create({ id: 'friend-1', iracingId: '456', name: 'Friend', country: 'US' })];
+    const teams = [
+      Team.create({
+        id: 'team-1',
+        name: 'Test Team',
+        tag: 'TT',
+        description: 'Test',
+        ownerId: 'owner-1',
+        leagues: [],
+      }),
+    ];
+    const friends = [
+      Driver.create({ id: 'friend-1', iracingId: '456', name: 'Friend', country: 'US' }),
+    ];
     const statsAdapter = {
       rating: 1500,
       wins: 5,
+      podiums: 2,
+      dnfs: 1,
       totalRaces: 10,
       avgFinish: 3.5,
+      bestFinish: 1,
+      worstFinish: 10,
+      overallRank: 10,
+      consistency: 90,
+      percentile: 75,
     };
-    const rankings = [{ driverId, rating: 1500, overallRank: 1 }];
+    const rankings = [{ driverId, rating: 1500, overallRank: 10 }];
 
     driverRepository.findById.mockResolvedValue(driver);
     teamRepository.findAll.mockResolvedValue(teams);
@@ -82,38 +120,48 @@ describe('GetProfileOverviewUseCase', () => {
     imageService.getDriverAvatar.mockReturnValue('avatar-url');
     getDriverStats.mockReturnValue(statsAdapter);
     getAllDriverRankings.mockReturnValue(rankings);
+    driverExtendedProfileProvider.getExtendedProfile.mockReturnValue(null);
 
-    const result = await useCase.execute({ driverId });
+    const result = await useCase.execute({ driverId } as GetProfileOverviewInput);
 
     expect(result.isOk()).toBe(true);
-    const viewModel = result.unwrap();
-    expect(viewModel.currentDriver?.id).toBe(driverId);
-    expect(viewModel.extendedProfile).toBe(null);
+    expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+    const presented = (output.present as unknown as Mock).mock
+      .calls[0][0] as GetProfileOverviewResult;
+    expect(presented.driverInfo.driver.id).toBe(driverId);
+    expect(presented.extendedProfile).toBeNull();
   });
 
   it('should return error for non-existing driver', async () => {
     const driverId = 'driver-1';
     driverRepository.findById.mockResolvedValue(null);
 
-    const result = await useCase.execute({ driverId });
-
+    const result = await useCase.execute({ driverId } as GetProfileOverviewInput);
+ 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'DRIVER_NOT_FOUND',
-      message: 'Driver not found',
-    });
+    const error = result.unwrapErr() as ApplicationErrorCode<
+      GetProfileOverviewErrorCode,
+      { message: string }
+    >;
+    expect(error.code).toBe('DRIVER_NOT_FOUND');
+    expect(error.details.message).toBe('Driver not found');
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('should return error on repository failure', async () => {
     const driverId = 'driver-1';
     driverRepository.findById.mockRejectedValue(new Error('DB error'));
 
-    const result = await useCase.execute({ driverId });
-
+    const result = await useCase.execute({ driverId } as GetProfileOverviewInput);
+ 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'REPOSITORY_ERROR',
-      message: 'Failed to fetch profile overview',
-    });
+    const error = result.unwrapErr() as ApplicationErrorCode<
+      GetProfileOverviewErrorCode,
+      { message: string }
+    >;
+    expect(error.code).toBe('REPOSITORY_ERROR');
+    expect(error.details.message).toBe('DB error');
+    expect(output.present).not.toHaveBeenCalled();
   });
-});
+});