refactor racing use cases

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

@@ -1,7 +1,9 @@
 import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { JoinLeagueUseCase } from './JoinLeagueUseCase';
+import { JoinLeagueUseCase, type JoinLeagueResult, type JoinLeagueInput, type JoinLeagueErrorCode } from './JoinLeagueUseCase';
 import { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
 import type { Logger } from '@core/shared/application';
+import type { UseCaseOutputPort } from '@core/shared/application';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('JoinLeagueUseCase', () => {
   let useCase: JoinLeagueUseCase;
@@ -15,6 +17,7 @@ describe('JoinLeagueUseCase', () => {
     warn: Mock;
     error: Mock;
   };
+  let output: UseCaseOutputPort<JoinLeagueResult> & { present: Mock };
 
   beforeEach(() => {
     membershipRepository = {
@@ -27,37 +30,56 @@ describe('JoinLeagueUseCase', () => {
       warn: vi.fn(),
       error: vi.fn(),
     };
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<JoinLeagueResult> & { present: Mock };
+
     useCase = new JoinLeagueUseCase(
       membershipRepository as unknown as ILeagueMembershipRepository,
       logger as unknown as Logger,
+      output,
     );
   });
 
   it('should join league successfully', async () => {
-    const command = { leagueId: 'league-1', driverId: 'driver-1' };
+    const command: JoinLeagueInput = { leagueId: 'league-1', driverId: 'driver-1' };
 
     membershipRepository.getMembership.mockResolvedValue(null);
     membershipRepository.saveMembership.mockResolvedValue({
       id: 'membership-1',
-      leagueId: 'league-1',
-      driverId: 'driver-1',
-      role: 'member',
-      status: 'active',
-      joinedAt: new Date(),
+      leagueId: {
+        value: 'league-1',
+      },
+      driverId: {
+        value: 'driver-1',
+      },
+      role: {
+        value: 'member',
+      },
+      status: {
+        value: 'active',
+      },
+      joinedAt: {
+        value: expect.any(Date),
+      },
     });
 
     const result = await useCase.execute(command);
 
     expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({
-      membershipId: 'membership-1',
-      leagueId: 'league-1',
-      status: 'active',
-    });
+    expect(result.unwrap()).toBeUndefined();
+
+    expect(output.present).toHaveBeenCalledTimes(1);
+    const presented = output.present.mock.calls[0]![0] as JoinLeagueResult;
+    expect(presented.membership.id).toBe('membership-1');
+    expect(presented.membership.leagueId.toString()).toBe('league-1');
+    expect(presented.membership.driverId.toString()).toBe('driver-1');
+    expect(presented.membership.role.toString()).toBe('member');
+    expect(presented.membership.status.toString()).toBe('active');
   });
 
   it('should return error when already a member', async () => {
-    const command = { leagueId: 'league-1', driverId: 'driver-1' };
+    const command: JoinLeagueInput = { leagueId: 'league-1', driverId: 'driver-1' };
 
     membershipRepository.getMembership.mockResolvedValue({
       id: 'membership-1',
@@ -71,13 +93,14 @@ describe('JoinLeagueUseCase', () => {
     const result = await useCase.execute(command);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'ALREADY_MEMBER',
-    });
+    const err = result.unwrapErr() as ApplicationErrorCode<JoinLeagueErrorCode, { message: string }>;
+    expect(err.code).toBe('ALREADY_MEMBER');
+    expect(err.details?.message).toBe('Driver is already a member of this league or has a pending membership.');
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('should return error on repository failure', async () => {
-    const command = { leagueId: 'league-1', driverId: 'driver-1' };
+    const command: JoinLeagueInput = { leagueId: 'league-1', driverId: 'driver-1' };
     const error = new Error('Repository error');
 
     membershipRepository.getMembership.mockRejectedValue(error);
@@ -85,8 +108,9 @@ describe('JoinLeagueUseCase', () => {
     const result = await useCase.execute(command);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'REPOSITORY_ERROR',
-    });
+    const err = result.unwrapErr() as ApplicationErrorCode<JoinLeagueErrorCode, { message: string }>;
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(err.details?.message).toBe('Repository error');
+    expect(output.present).not.toHaveBeenCalled();
   });
 });