refactor racing use cases

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

@@ -1,8 +1,14 @@
-import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { JoinTeamUseCase } from './JoinTeamUseCase';
-import { ITeamRepository } from '../../domain/repositories/ITeamRepository';
-import { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
-import type { Logger } from '@core/shared/application';
+import { describe, it, expect, beforeEach, vi, type Mock } from 'vitest';
+import {
+  JoinTeamUseCase,
+  type JoinTeamInput,
+  type JoinTeamResult,
+  type JoinTeamErrorCode,
+} from './JoinTeamUseCase';
+import type { ITeamRepository } from '../../domain/repositories/ITeamRepository';
+import type { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('JoinTeamUseCase', () => {
   let useCase: JoinTeamUseCase;
@@ -20,6 +26,7 @@ describe('JoinTeamUseCase', () => {
     warn: Mock;
     error: Mock;
   };
+  let output: UseCaseOutputPort<JoinTeamResult> & { present: Mock };
 
   beforeEach(() => {
     teamRepository = {
@@ -36,29 +43,48 @@ describe('JoinTeamUseCase', () => {
       warn: vi.fn(),
       error: vi.fn(),
     };
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<JoinTeamResult> & { present: Mock };
+
     useCase = new JoinTeamUseCase(
       teamRepository as unknown as ITeamRepository,
       membershipRepository as unknown as ITeamMembershipRepository,
       logger as unknown as Logger,
+      output,
     );
   });
 
   it('should join team successfully', async () => {
-    const command = { teamId: 'team-1', driverId: 'driver-1' };
+    const input: JoinTeamInput = { teamId: 'team-1', driverId: 'driver-1' };
 
     membershipRepository.getActiveMembershipForDriver.mockResolvedValue(null);
     membershipRepository.getMembership.mockResolvedValue(null);
     teamRepository.findById.mockResolvedValue({ id: 'team-1' });
-    membershipRepository.saveMembership.mockResolvedValue(undefined);
+    membershipRepository.saveMembership.mockResolvedValue({
+      teamId: 'team-1',
+      driverId: 'driver-1',
+      role: 'driver',
+      status: 'active',
+      joinedAt: new Date(),
+    });
 
-    const result = await useCase.execute(command);
+    const result = await useCase.execute(input);
 
     expect(result.isOk()).toBe(true);
     expect(result.unwrap()).toBeUndefined();
+    expect(output.present).toHaveBeenCalledTimes(1);
+
+    const presented = output.present.mock.calls[0]![0] as JoinTeamResult;
+    expect(presented.team.id).toBe('team-1');
+    expect(presented.membership.teamId).toBe('team-1');
+    expect(presented.membership.driverId).toBe('driver-1');
+    expect(presented.membership.role).toBe('driver');
+    expect(presented.membership.status).toBe('active');
   });
 
   it('should return error when driver already in a team', async () => {
-    const command = { teamId: 'team-1', driverId: 'driver-1' };
+    const input: JoinTeamInput = { teamId: 'team-1', driverId: 'driver-1' };
 
     membershipRepository.getActiveMembershipForDriver.mockResolvedValue({
       teamId: 'team-2',
@@ -68,17 +94,20 @@ describe('JoinTeamUseCase', () => {
       joinedAt: new Date(),
     });
 
-    const result = await useCase.execute(command);
+    const result = await useCase.execute(input);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'ALREADY_IN_TEAM',
-      details: { message: 'Driver already belongs to a team' },
-    });
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      JoinTeamErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('ALREADY_IN_TEAM');
+    expect(err.details.message).toBe('Driver already belongs to a team');
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('should return error when already a member', async () => {
-    const command = { teamId: 'team-1', driverId: 'driver-1' };
+    const input: JoinTeamInput = { teamId: 'team-1', driverId: 'driver-1' };
 
     membershipRepository.getActiveMembershipForDriver.mockResolvedValue(null);
     membershipRepository.getMembership.mockResolvedValue({
@@ -89,43 +118,54 @@ describe('JoinTeamUseCase', () => {
       joinedAt: new Date(),
     });
 
-    const result = await useCase.execute(command);
+    const result = await useCase.execute(input);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'ALREADY_MEMBER',
-      details: { message: 'Already a member or have a pending request' },
-    });
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      JoinTeamErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('ALREADY_MEMBER');
+    expect(err.details.message).toBe(
+      'Already a member or have a pending request',
+    );
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('should return error when team not found', async () => {
-    const command = { teamId: 'team-1', driverId: 'driver-1' };
+    const input: JoinTeamInput = { teamId: 'team-1', driverId: 'driver-1' };
 
     membershipRepository.getActiveMembershipForDriver.mockResolvedValue(null);
     membershipRepository.getMembership.mockResolvedValue(null);
     teamRepository.findById.mockResolvedValue(null);
 
-    const result = await useCase.execute(command);
+    const result = await useCase.execute(input);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'TEAM_NOT_FOUND',
-      details: { message: 'Team team-1 not found' },
-    });
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      JoinTeamErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('TEAM_NOT_FOUND');
+    expect(err.details.message).toBe('Team team-1 not found');
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('should return error on repository failure', async () => {
-    const command = { teamId: 'team-1', driverId: 'driver-1' };
+    const input: JoinTeamInput = { teamId: 'team-1', driverId: 'driver-1' };
     const error = new Error('Repository error');
 
     membershipRepository.getActiveMembershipForDriver.mockRejectedValue(error);
 
-    const result = await useCase.execute(command);
+    const result = await useCase.execute(input);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'REPOSITORY_ERROR',
-      details: { message: 'Repository error' },
-    });
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      JoinTeamErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(err.details.message).toBe('Repository error');
+    expect(output.present).not.toHaveBeenCalled();
   });
 });