gridpilot.gg/core/racing/application/use-cases/RejectLeagueJoinRequestUseCase.test.ts

import { describe, it, expect, vi, type Mock, beforeEach } from 'vitest';
import {
  RejectLeagueJoinRequestUseCase,
  type RejectLeagueJoinRequestInput,
  type RejectLeagueJoinRequestResult,
  type RejectLeagueJoinRequestErrorCode,
} from './RejectLeagueJoinRequestUseCase';
import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
import type { Logger, UseCaseOutputPort } from '@core/shared/application';
import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
import { Result } from '@core/shared/application/Result';

interface LeagueRepositoryMock {
  findById: Mock;
}

interface LeagueMembershipRepositoryMock {
  getMembership: Mock;
  getJoinRequests: Mock;
  removeJoinRequest: Mock;
}

describe('RejectLeagueJoinRequestUseCase', () => {
  let leagueRepository: LeagueRepositoryMock;
  let leagueMembershipRepository: LeagueMembershipRepositoryMock;
  let logger: Logger & { info: Mock; warn: Mock; error: Mock; debug: Mock };
  let output: UseCaseOutputPort<RejectLeagueJoinRequestResult> & { present: Mock };
  let useCase: RejectLeagueJoinRequestUseCase;

  beforeEach(() => {
    leagueRepository = {
      findById: vi.fn(),
    } as unknown as ILeagueRepository as any;

    leagueMembershipRepository = {
      getMembership: vi.fn(),
      getJoinRequests: vi.fn(),
      removeJoinRequest: vi.fn(),
    } as unknown as ILeagueMembershipRepository 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<RejectLeagueJoinRequestResult> & { present: Mock };

    useCase = new RejectLeagueJoinRequestUseCase(
      leagueRepository as unknown as ILeagueRepository,
      leagueMembershipRepository as unknown as ILeagueMembershipRepository,
      logger,
      output,
    );
  });

  it('rejects a pending join request successfully and presents result', async () => {
    const input: RejectLeagueJoinRequestInput = {
      leagueId: 'league-1',
      adminId: 'admin-1',
      requestId: 'req-1',
    };

    leagueRepository.findById.mockResolvedValue({ id: 'league-1' });
    leagueMembershipRepository.getMembership.mockResolvedValue({
      leagueId: 'league-1',
      driverId: 'admin-1',
      role: { toString: () => 'owner' },
      status: { toString: () => 'active' },
    });
    leagueMembershipRepository.getJoinRequests.mockResolvedValue([
      {
        id: 'req-1',
        leagueId: 'league-1',
        driverId: 'driver-1',
        status: 'pending',
      },
    ]);
    leagueMembershipRepository.removeJoinRequest.mockResolvedValue(undefined);

    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 RejectLeagueJoinRequestResult;
    expect(presented.leagueId).toBe('league-1');
    expect(presented.requestId).toBe('req-1');
    expect(presented.status).toBe('rejected');
    expect(leagueMembershipRepository.removeJoinRequest).toHaveBeenCalledWith('req-1');
  });

  it('returns LEAGUE_NOT_FOUND when league does not exist', async () => {
    const input: RejectLeagueJoinRequestInput = {
      leagueId: 'missing-league',
      adminId: 'admin-1',
      requestId: 'req-1',
    };

    leagueRepository.findById.mockResolvedValue(null);

    const result = await useCase.execute(input);

    expect(result.isErr()).toBe(true);
    const err = result.unwrapErr() as ApplicationErrorCode<
      RejectLeagueJoinRequestErrorCode,
      { message: string }
    >;
    expect(err.code).toBe('LEAGUE_NOT_FOUND');
    expect(output.present).not.toHaveBeenCalled();
    expect(leagueMembershipRepository.removeJoinRequest).not.toHaveBeenCalled();
  });

  it('returns UNAUTHORIZED when admin is not authorized', async () => {
    const input: RejectLeagueJoinRequestInput = {
      leagueId: 'league-1',
      adminId: 'user-1',
      requestId: 'req-1',
    };

    leagueRepository.findById.mockResolvedValue({ id: 'league-1' });
    leagueMembershipRepository.getMembership.mockResolvedValue(null);

    const result = await useCase.execute(input);

    expect(result.isErr()).toBe(true);
    const err = result.unwrapErr() as ApplicationErrorCode<
      RejectLeagueJoinRequestErrorCode,
      { message: string }
    >;
    expect(err.code).toBe('UNAUTHORIZED');
    expect(output.present).not.toHaveBeenCalled();
    expect(leagueMembershipRepository.removeJoinRequest).not.toHaveBeenCalled();
  });

  it('returns REQUEST_NOT_FOUND when join request does not exist', async () => {
    const input: RejectLeagueJoinRequestInput = {
      leagueId: 'league-1',
      adminId: 'admin-1',
      requestId: 'missing-req',
    };

    leagueRepository.findById.mockResolvedValue({ id: 'league-1' });
    leagueMembershipRepository.getMembership.mockResolvedValue({
      leagueId: 'league-1',
      driverId: 'admin-1',
      role: { toString: () => 'owner' },
      status: { toString: () => 'active' },
    });
    leagueMembershipRepository.getJoinRequests.mockResolvedValue([]);

    const result = await useCase.execute(input);

    expect(result.isErr()).toBe(true);
    const err = result.unwrapErr() as ApplicationErrorCode<
      RejectLeagueJoinRequestErrorCode,
      { message: string }
    >;
    expect(err.code).toBe('REQUEST_NOT_FOUND');
    expect(output.present).not.toHaveBeenCalled();
    expect(leagueMembershipRepository.removeJoinRequest).not.toHaveBeenCalled();
  });

  it('returns INVALID_REQUEST_STATE when join request is not pending', async () => {
    const input: RejectLeagueJoinRequestInput = {
      leagueId: 'league-1',
      adminId: 'admin-1',
      requestId: 'req-1',
    };

    leagueRepository.findById.mockResolvedValue({ id: 'league-1' });
    leagueMembershipRepository.getMembership.mockResolvedValue({
      leagueId: 'league-1',
      driverId: 'admin-1',
      role: { toString: () => 'owner' },
      status: { toString: () => 'active' },
    });
    leagueMembershipRepository.getJoinRequests.mockResolvedValue([
      {
        id: 'req-1',
        leagueId: 'league-1',
        driverId: 'driver-1',
        status: 'approved',
      },
    ]);

    const result = await useCase.execute(input);

    expect(result.isErr()).toBe(true);
    const err = result.unwrapErr() as ApplicationErrorCode<
      RejectLeagueJoinRequestErrorCode,
      { message: string }
    >;
    expect(err.code).toBe('INVALID_REQUEST_STATE');
    expect(output.present).not.toHaveBeenCalled();
    expect(leagueMembershipRepository.removeJoinRequest).not.toHaveBeenCalled();
  });

  it('returns REPOSITORY_ERROR when repository throws', async () => {
    const input: RejectLeagueJoinRequestInput = {
      leagueId: 'league-1',
      adminId: 'admin-1',
      requestId: 'req-1',
    };

    const repoError = new Error('Repository failure');
    leagueRepository.findById.mockRejectedValue(repoError);

    const result = await useCase.execute(input);

    expect(result.isErr()).toBe(true);
    const err = result.unwrapErr() as ApplicationErrorCode<
      RejectLeagueJoinRequestErrorCode,
      { message: string }
    >;
    expect(err.code).toBe('REPOSITORY_ERROR');
    expect(err.details.message).toBe('Repository failure');
    expect(output.present).not.toHaveBeenCalled();
    expect(leagueMembershipRepository.removeJoinRequest).not.toHaveBeenCalled();
  });
});