refactor racing use cases

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

@@ -1,47 +1,106 @@
 import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { RemoveLeagueMemberUseCase } from './RemoveLeagueMemberUseCase';
+import {
+  RemoveLeagueMemberUseCase,
+  type RemoveLeagueMemberInput,
+  type RemoveLeagueMemberResult,
+  type RemoveLeagueMemberErrorCode,
+} from './RemoveLeagueMemberUseCase';
 import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
+import { UseCaseOutputPort } from '@core/shared/application';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('RemoveLeagueMemberUseCase', () => {
   let useCase: RemoveLeagueMemberUseCase;
-  let leagueMembershipRepository: { getLeagueMembers: Mock; saveMembership: Mock };
+  let leagueMembershipRepository: { getMembership: Mock; saveMembership: Mock };
+  let output: UseCaseOutputPort<RemoveLeagueMemberResult> & { present: Mock };
 
   beforeEach(() => {
     leagueMembershipRepository = {
-      getLeagueMembers: vi.fn(),
+      getMembership: vi.fn(),
       saveMembership: vi.fn(),
     };
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<RemoveLeagueMemberResult> & { present: Mock };
     useCase = new RemoveLeagueMemberUseCase(
       leagueMembershipRepository as unknown as ILeagueMembershipRepository,
+      output,
     );
   });
 
   it('should remove league member by setting status to inactive', async () => {
     const leagueId = 'league-1';
     const targetDriverId = 'driver-1';
-    const memberships = [{ leagueId, driverId: targetDriverId, role: 'member', status: 'active', joinedAt: new Date() }];
+    const membership = {
+      id: `${leagueId}:${targetDriverId}`,
+      leagueId: { toString: () => leagueId },
+      driverId: { toString: () => targetDriverId },
+      role: { toString: () => 'member' },
+      status: { toString: () => 'active' },
+      joinedAt: { toDate: () => new Date() },
+    };
 
-    leagueMembershipRepository.getLeagueMembers.mockResolvedValue(memberships);
+    leagueMembershipRepository.getMembership.mockResolvedValue(membership);
 
-    const result = await useCase.execute({ leagueId, targetDriverId });
+    const input: RemoveLeagueMemberInput = { leagueId, targetDriverId };
+
+    const result = await useCase.execute(input);
 
     expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ success: true });
-    expect(leagueMembershipRepository.saveMembership).toHaveBeenCalledWith({
+    expect(result.unwrap()).toBeUndefined();
+
+    expect(leagueMembershipRepository.saveMembership).toHaveBeenCalledTimes(1);
+    const savedMembership = leagueMembershipRepository.saveMembership.mock.calls[0][0];
+    expect(savedMembership.status.toString()).toBe('inactive');
+
+    expect(output.present).toHaveBeenCalledTimes(1);
+    expect(output.present).toHaveBeenCalledWith({
       leagueId,
-      driverId: targetDriverId,
-      role: 'member',
-      status: 'inactive',
-      joinedAt: expect.any(Date),
-    });
+      memberId: targetDriverId,
+      removedRole: 'member',
+    } satisfies RemoveLeagueMemberResult);
   });
 
   it('should return error if membership not found', async () => {
-    leagueMembershipRepository.getLeagueMembers.mockResolvedValue([]);
+    leagueMembershipRepository.getMembership.mockResolvedValue(null);
 
-    const result = await useCase.execute({ leagueId: 'league-1', targetDriverId: 'driver-1' });
+    const input: RemoveLeagueMemberInput = { leagueId: 'league-1', targetDriverId: 'driver-1' };
+
+    const result = await useCase.execute(input);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({ code: 'MEMBERSHIP_NOT_FOUND' });
+
+    const error = result.unwrapErr() as ApplicationErrorCode<
+      RemoveLeagueMemberErrorCode,
+      { message: string }
+    >;
+
+    expect(error.code).toBe('MEMBERSHIP_NOT_FOUND');
+    expect(error.details.message).toBe('Membership not found for given league and driver');
+
+    expect(output.present).not.toHaveBeenCalled();
+  });
+
+  it('should return repository error when an exception occurs', async () => {
+    const leagueId = 'league-1';
+    const targetDriverId = 'driver-1';
+
+    leagueMembershipRepository.getMembership.mockRejectedValue(new Error('DB error'));
+
+    const input: RemoveLeagueMemberInput = { leagueId, targetDriverId };
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+
+    const error = result.unwrapErr() as ApplicationErrorCode<
+      RemoveLeagueMemberErrorCode,
+      { message: string }
+    >;
+
+    expect(error.code).toBe('REPOSITORY_ERROR');
+    expect(error.details.message).toBe('DB error');
+
+    expect(output.present).not.toHaveBeenCalled();
   });
 });