refactor racing use cases

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

@@ -1,9 +1,17 @@
-import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { GetTeamJoinRequestsUseCase } from './GetTeamJoinRequestsUseCase';
+import { describe, it, expect, beforeEach, vi, type Mock } from 'vitest';
+import {
+  GetTeamJoinRequestsUseCase,
+  type GetTeamJoinRequestsInput,
+  type GetTeamJoinRequestsResult,
+  type GetTeamJoinRequestsErrorCode,
+} from './GetTeamJoinRequestsUseCase';
 import { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
 import { IDriverRepository } from '../../domain/repositories/IDriverRepository';
+import { ITeamRepository } from '../../domain/repositories/ITeamRepository';
 import { Driver } from '../../domain/entities/Driver';
-import type { Logger } from '@core/shared/application';
+import { Team } from '../../domain/entities/Team';
+import type { UseCaseOutputPort } from '@core/shared/application';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('GetTeamJoinRequestsUseCase', () => {
   let useCase: GetTeamJoinRequestsUseCase;
@@ -13,13 +21,10 @@ describe('GetTeamJoinRequestsUseCase', () => {
   let driverRepository: {
     findById: Mock;
   };
-  let getDriverAvatar: Mock;
-  let logger: {
-    debug: Mock;
-    info: Mock;
-    warn: Mock;
-    error: Mock;
+  let teamRepository: {
+    findById: Mock;
   };
+  let output: UseCaseOutputPort<GetTeamJoinRequestsResult> & { present: Mock };
 
   beforeEach(() => {
     membershipRepository = {
@@ -28,102 +33,106 @@ describe('GetTeamJoinRequestsUseCase', () => {
     driverRepository = {
       findById: vi.fn(),
     };
-    getDriverAvatar = vi.fn();
-    logger = {
-      debug: vi.fn(),
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
+    teamRepository = {
+      findById: vi.fn(),
     };
+    output = {
+      present: vi.fn(),
+    };
+
     useCase = new GetTeamJoinRequestsUseCase(
       membershipRepository as unknown as ITeamMembershipRepository,
       driverRepository as unknown as IDriverRepository,
-      getDriverAvatar,
-      logger as unknown as Logger,
+      teamRepository as unknown as ITeamRepository,
+      output,
     );
   });
 
-  it('should return join requests with driver names and avatar urls', async () => {
+  it('should return join requests with drivers when team exists', async () => {
     const teamId = 'team-1';
+    const input: GetTeamJoinRequestsInput = { teamId };
+
     const joinRequests = [
       { id: 'req-1', teamId, driverId: 'driver-1', requestedAt: new Date(), message: 'msg' },
-      { id: 'req-2', teamId, driverId: 'driver-2', requestedAt: new Date() },
     ];
-    const driver1 = Driver.create({
+
+    const driver = Driver.create({
       id: 'driver-1',
       iracingId: '123',
       name: 'Driver 1',
       country: 'US',
     });
-    const driver2 = Driver.create({
-      id: 'driver-2',
-      iracingId: '456',
-      name: 'Driver 2',
-      country: 'UK',
+
+    const team = Team.create({
+      id: teamId,
+      name: 'Team 1',
+      tag: 'T1',
+      description: 'Description',
+      ownerId: 'owner-1',
+      leagues: [],
     });
 
+    teamRepository.findById.mockResolvedValue(team);
     membershipRepository.getJoinRequests.mockResolvedValue(joinRequests);
-    driverRepository.findById.mockImplementation((id: string) => {
-      if (id === 'driver-1') return Promise.resolve(driver1);
-      if (id === 'driver-2') return Promise.resolve(driver2);
-      return Promise.resolve(null);
-    });
-    getDriverAvatar.mockImplementation((input) => {
-      if (input.driverId === 'driver-1') return Promise.resolve({ avatarUrl: 'avatar-driver-1' });
-      if (input.driverId === 'driver-2') return Promise.resolve({ avatarUrl: 'avatar-driver-2' });
-      return Promise.resolve({ avatarUrl: 'avatar-default' });
-    });
+    driverRepository.findById.mockResolvedValue(driver);
 
-    const result = await useCase.execute({ teamId });
+    const result = await useCase.execute(input);
 
     expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({
-      requests: joinRequests,
-      driverNames: {
-        'driver-1': 'Driver 1',
-        'driver-2': 'Driver 2',
-      },
-      avatarUrls: {
-        'driver-1': 'avatar-driver-1',
-        'driver-2': 'avatar-driver-2',
-      },
+    expect(result.unwrap()).toBeUndefined();
+
+    expect(output.present).toHaveBeenCalledTimes(1);
+    const presented = output.present.mock.calls[0][0] as GetTeamJoinRequestsResult;
+
+    expect(presented.team).toBe(team);
+    expect(presented.joinRequests).toHaveLength(1);
+    expect(presented.joinRequests[0]).toMatchObject({
+      id: 'req-1',
+      teamId,
+      driverId: 'driver-1',
+      message: 'msg',
     });
+    expect(presented.joinRequests[0].driver).toBe(driver);
   });
 
-  it('should handle driver not found', async () => {
-    const teamId = 'team-1';
-    const joinRequests = [
-      { id: 'req-1', teamId, driverId: 'driver-1', requestedAt: new Date() },
-    ];
+  it('should return TEAM_NOT_FOUND error when team does not exist', async () => {
+    const teamId = 'missing-team';
+    const input: GetTeamJoinRequestsInput = { teamId };
 
-    membershipRepository.getJoinRequests.mockResolvedValue(joinRequests);
-    driverRepository.findById.mockResolvedValue(null);
-    getDriverAvatar.mockResolvedValue({ avatarUrl: 'avatar-driver-1' });
+    teamRepository.findById.mockResolvedValue(null);
 
-    const result = await useCase.execute({ teamId });
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({
-      requests: joinRequests,
-      driverNames: {},
-      avatarUrls: {
-        'driver-1': 'avatar-driver-1',
-      },
-    });
-  });
-
-  it('should return error on repository failure', async () => {
-    const teamId = 'team-1';
-    const error = new Error('Repository error');
-
-    membershipRepository.getJoinRequests.mockRejectedValue(error);
-
-    const result = await useCase.execute({ teamId });
+    const result = await useCase.execute(input);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'REPOSITORY_ERROR',
-      details: { message: 'Failed to retrieve team join requests' },
-    });
+
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      GetTeamJoinRequestsErrorCode,
+      { message: string }
+    >;
+
+    expect(err.code).toBe('TEAM_NOT_FOUND');
+    expect(err.details.message).toBe('Team not found');
+    expect(output.present).not.toHaveBeenCalled();
   });
-});
+
+  it('should return REPOSITORY_ERROR when repository throws', async () => {
+    const teamId = 'team-1';
+    const input: GetTeamJoinRequestsInput = { teamId };
+    const error = new Error('Repository failure');
+
+    teamRepository.findById.mockRejectedValue(error);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      GetTeamJoinRequestsErrorCode,
+      { message: string }
+    >;
+
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(err.details.message).toBe('Repository failure');
+    expect(output.present).not.toHaveBeenCalled();
+  });
+});