refactor racing use cases

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

@@ -1,27 +1,232 @@
-import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { RejectTeamJoinRequestUseCase } from './RejectTeamJoinRequestUseCase';
+import { describe, it, expect, beforeEach, vi, type Mock } from 'vitest';
+import {
+  RejectTeamJoinRequestUseCase,
+  type RejectTeamJoinRequestInput,
+  type RejectTeamJoinRequestResult,
+  type RejectTeamJoinRequestErrorCode,
+} from './RejectTeamJoinRequestUseCase';
 import type { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
+import type { ITeamRepository } from '../../domain/repositories/ITeamRepository';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
+import { Result } from '@core/shared/application/Result';
+
+interface TeamRepositoryMock {
+  findById: Mock;
+}
+
+interface TeamMembershipRepositoryMock {
+  getMembership: Mock;
+  getJoinRequests: Mock;
+  removeJoinRequest: Mock;
+}
 
 describe('RejectTeamJoinRequestUseCase', () => {
+  let teamRepository: TeamRepositoryMock;
+  let membershipRepository: TeamMembershipRepositoryMock;
+  let logger: Logger & { info: Mock; warn: Mock; error: Mock; debug: Mock };
+  let output: UseCaseOutputPort<RejectTeamJoinRequestResult> & { present: Mock };
   let useCase: RejectTeamJoinRequestUseCase;
-  let membershipRepository: { removeJoinRequest: Mock };
 
   beforeEach(() => {
-    membershipRepository = { removeJoinRequest: vi.fn() };
+    teamRepository = {
+      findById: vi.fn(),
+    } as unknown as ITeamRepository as any;
+
+    membershipRepository = {
+      getMembership: vi.fn(),
+      getJoinRequests: vi.fn(),
+      removeJoinRequest: vi.fn(),
+    } as unknown as ITeamMembershipRepository as any;
+
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger & { info: Mock; warn: Mock; error: Mock; debug: Mock };
+
+    output = {
+      present: vi.fn(),
+    } as unknown as UseCaseOutputPort<RejectTeamJoinRequestResult> & { present: Mock };
+
     useCase = new RejectTeamJoinRequestUseCase(
+      teamRepository as unknown as ITeamRepository,
       membershipRepository as unknown as ITeamMembershipRepository,
+      logger,
+      output,
     );
   });
 
-  it('should reject the join request successfully', async () => {
+  it('rejects a pending join request successfully and presents result', async () => {
+    const input: RejectTeamJoinRequestInput = {
+      teamId: 'team-1',
+      managerId: 'manager-1',
+      requestId: 'req-1',
+    };
+
+    teamRepository.findById.mockResolvedValue({ id: 'team-1' });
+    membershipRepository.getMembership.mockResolvedValue({
+      teamId: 'team-1',
+      driverId: 'manager-1',
+      role: 'owner',
+      status: 'active',
+      joinedAt: new Date(),
+    });
+    membershipRepository.getJoinRequests.mockResolvedValue([
+      {
+        id: 'req-1',
+        teamId: 'team-1',
+        driverId: 'driver-1',
+        requestedAt: new Date(),
+        message: 'please',
+        status: 'pending',
+      },
+    ]);
     membershipRepository.removeJoinRequest.mockResolvedValue(undefined);
 
-    const result = await useCase.execute({
-      requestId: 'request-1',
-    });
+    const result = await useCase.execute(input);
 
     expect(result.isOk()).toBe(true);
     expect(result.unwrap()).toBeUndefined();
-    expect(membershipRepository.removeJoinRequest).toHaveBeenCalledWith('request-1');
+    expect(output.present).toHaveBeenCalledTimes(1);
+    const presented = output.present.mock.calls[0]![0] as RejectTeamJoinRequestResult;
+    expect(presented.teamId).toBe('team-1');
+    expect(presented.requestId).toBe('req-1');
+    expect(presented.status).toBe('rejected');
+    expect(membershipRepository.removeJoinRequest).toHaveBeenCalledWith('req-1');
+  });
+
+  it('returns TEAM_NOT_FOUND when team does not exist', async () => {
+    const input: RejectTeamJoinRequestInput = {
+      teamId: 'missing-team',
+      managerId: 'manager-1',
+      requestId: 'req-1',
+    };
+
+    teamRepository.findById.mockResolvedValue(null);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      RejectTeamJoinRequestErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('TEAM_NOT_FOUND');
+    expect(output.present).not.toHaveBeenCalled();
+    expect(membershipRepository.removeJoinRequest).not.toHaveBeenCalled();
+  });
+
+  it('returns UNAUTHORIZED when manager is not authorized', async () => {
+    const input: RejectTeamJoinRequestInput = {
+      teamId: 'team-1',
+      managerId: 'user-1',
+      requestId: 'req-1',
+    };
+
+    teamRepository.findById.mockResolvedValue({ id: 'team-1' });
+    membershipRepository.getMembership.mockResolvedValue(null);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      RejectTeamJoinRequestErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('UNAUTHORIZED');
+    expect(output.present).not.toHaveBeenCalled();
+    expect(membershipRepository.removeJoinRequest).not.toHaveBeenCalled();
+  });
+
+  it('returns REQUEST_NOT_FOUND when join request does not exist', async () => {
+    const input: RejectTeamJoinRequestInput = {
+      teamId: 'team-1',
+      managerId: 'manager-1',
+      requestId: 'missing-req',
+    };
+
+    teamRepository.findById.mockResolvedValue({ id: 'team-1' });
+    membershipRepository.getMembership.mockResolvedValue({
+      teamId: 'team-1',
+      driverId: 'manager-1',
+      role: 'owner',
+      status: 'active',
+      joinedAt: new Date(),
+    });
+    membershipRepository.getJoinRequests.mockResolvedValue([]);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      RejectTeamJoinRequestErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('REQUEST_NOT_FOUND');
+    expect(output.present).not.toHaveBeenCalled();
+    expect(membershipRepository.removeJoinRequest).not.toHaveBeenCalled();
+  });
+
+  it('returns INVALID_REQUEST_STATE when join request is not pending', async () => {
+    const input: RejectTeamJoinRequestInput = {
+      teamId: 'team-1',
+      managerId: 'manager-1',
+      requestId: 'req-1',
+    };
+
+    teamRepository.findById.mockResolvedValue({ id: 'team-1' });
+    membershipRepository.getMembership.mockResolvedValue({
+      teamId: 'team-1',
+      driverId: 'manager-1',
+      role: 'owner',
+      status: 'active',
+      joinedAt: new Date(),
+    });
+    membershipRepository.getJoinRequests.mockResolvedValue([
+      {
+        id: 'req-1',
+        teamId: 'team-1',
+        driverId: 'driver-1',
+        requestedAt: new Date(),
+        message: 'please',
+        status: 'approved',
+      },
+    ]);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      RejectTeamJoinRequestErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('INVALID_REQUEST_STATE');
+    expect(output.present).not.toHaveBeenCalled();
+    expect(membershipRepository.removeJoinRequest).not.toHaveBeenCalled();
+  });
+
+  it('returns REPOSITORY_ERROR when repository throws', async () => {
+    const input: RejectTeamJoinRequestInput = {
+      teamId: 'team-1',
+      managerId: 'manager-1',
+      requestId: 'req-1',
+    };
+
+    const repoError = new Error('Repository failure');
+    teamRepository.findById.mockRejectedValue(repoError);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      RejectTeamJoinRequestErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(err.details.message).toBe('Repository failure');
+    expect(output.present).not.toHaveBeenCalled();
+    expect(membershipRepository.removeJoinRequest).not.toHaveBeenCalled();
   });
 });