league service

tests/racing-application/ApproveLeagueJoinRequestUseCase.spec.ts

@@ -0,0 +1,45 @@
+import { ApproveLeagueJoinRequestUseCase } from '../../core/racing/application/use-cases/ApproveLeagueJoinRequestUseCase';
+import { ApproveLeagueJoinRequestPresenter } from '../../apps/api/src/modules/league/presenters/ApproveLeagueJoinRequestPresenter';
+import { ILeagueMembershipRepository } from '../../core/racing/domain/repositories/ILeagueMembershipRepository';
+
+describe('ApproveLeagueJoinRequestUseCase', () => {
+  let useCase: ApproveLeagueJoinRequestUseCase;
+  let leagueMembershipRepository: jest.Mocked<ILeagueMembershipRepository>;
+  let presenter: ApproveLeagueJoinRequestPresenter;
+
+  beforeEach(() => {
+    leagueMembershipRepository = {
+      getJoinRequests: jest.fn(),
+      removeJoinRequest: jest.fn(),
+      saveMembership: jest.fn(),
+    } as any;
+    presenter = new ApproveLeagueJoinRequestPresenter();
+    useCase = new ApproveLeagueJoinRequestUseCase(leagueMembershipRepository);
+  });
+
+  it('should approve join request and save membership', async () => {
+    const leagueId = 'league-1';
+    const requestId = 'req-1';
+    const joinRequests = [{ id: requestId, leagueId, driverId: 'driver-1', requestedAt: new Date(), message: 'msg' }];
+
+    leagueMembershipRepository.getJoinRequests.mockResolvedValue(joinRequests);
+
+    await useCase.execute({ leagueId, requestId }, presenter);
+
+    expect(leagueMembershipRepository.removeJoinRequest).toHaveBeenCalledWith(requestId);
+    expect(leagueMembershipRepository.saveMembership).toHaveBeenCalledWith({
+      leagueId,
+      driverId: 'driver-1',
+      role: 'member',
+      status: 'active',
+      joinedAt: expect.any(Date),
+    });
+    expect(presenter.viewModel).toEqual({ success: true, message: 'Join request approved.' });
+  });
+
+  it('should throw error if request not found', async () => {
+    leagueMembershipRepository.getJoinRequests.mockResolvedValue([]);
+
+    await expect(useCase.execute({ leagueId: 'league-1', requestId: 'req-1' }, presenter)).rejects.toThrow('Join request not found');
+  });
+});

tests/racing-application/GetLeagueJoinRequestsUseCase.spec.ts

@@ -0,0 +1,46 @@
+import { GetLeagueJoinRequestsUseCase } from '../../core/racing/application/use-cases/GetLeagueJoinRequestsUseCase';
+import { LeagueJoinRequestsPresenter } from '../../apps/api/src/modules/league/presenters/LeagueJoinRequestsPresenter';
+import { ILeagueMembershipRepository } from '../../core/racing/domain/repositories/ILeagueMembershipRepository';
+import { IDriverRepository } from '../../core/racing/domain/repositories/IDriverRepository';
+
+describe('GetLeagueJoinRequestsUseCase', () => {
+  let useCase: GetLeagueJoinRequestsUseCase;
+  let leagueMembershipRepository: jest.Mocked<ILeagueMembershipRepository>;
+  let driverRepository: jest.Mocked<IDriverRepository>;
+  let presenter: LeagueJoinRequestsPresenter;
+
+  beforeEach(() => {
+    leagueMembershipRepository = {
+      getJoinRequests: jest.fn(),
+    } as any;
+    driverRepository = {
+      findByIds: jest.fn(),
+    } as any;
+    presenter = new LeagueJoinRequestsPresenter();
+    useCase = new GetLeagueJoinRequestsUseCase(leagueMembershipRepository, driverRepository);
+  });
+
+  it('should return join requests with drivers', async () => {
+    const leagueId = 'league-1';
+    const joinRequests = [
+      { id: 'req-1', leagueId, driverId: 'driver-1', requestedAt: new Date(), message: 'msg' },
+    ];
+    const drivers = [{ id: 'driver-1', name: 'Driver 1' }];
+
+    leagueMembershipRepository.getJoinRequests.mockResolvedValue(joinRequests);
+    driverRepository.findByIds.mockResolvedValue(drivers);
+
+    await useCase.execute({ leagueId }, presenter);
+
+    expect(presenter.viewModel.joinRequests).toEqual([
+      {
+        id: 'req-1',
+        leagueId,
+        driverId: 'driver-1',
+        requestedAt: expect.any(Date),
+        message: 'msg',
+        driver: { id: 'driver-1', name: 'Driver 1' },
+      },
+    ]);
+  });
+});

tests/racing-application/RejectLeagueJoinRequestUseCase.spec.ts

@@ -0,0 +1,26 @@
+import { RejectLeagueJoinRequestUseCase } from '../../core/racing/application/use-cases/RejectLeagueJoinRequestUseCase';
+import { RejectLeagueJoinRequestPresenter } from '../../apps/api/src/modules/league/presenters/RejectLeagueJoinRequestPresenter';
+import { ILeagueMembershipRepository } from '../../core/racing/domain/repositories/ILeagueMembershipRepository';
+
+describe('RejectLeagueJoinRequestUseCase', () => {
+  let useCase: RejectLeagueJoinRequestUseCase;
+  let leagueMembershipRepository: jest.Mocked<ILeagueMembershipRepository>;
+  let presenter: RejectLeagueJoinRequestPresenter;
+
+  beforeEach(() => {
+    leagueMembershipRepository = {
+      removeJoinRequest: jest.fn(),
+    } as any;
+    presenter = new RejectLeagueJoinRequestPresenter();
+    useCase = new RejectLeagueJoinRequestUseCase(leagueMembershipRepository);
+  });
+
+  it('should reject join request', async () => {
+    const requestId = 'req-1';
+
+    await useCase.execute({ requestId }, presenter);
+
+    expect(leagueMembershipRepository.removeJoinRequest).toHaveBeenCalledWith(requestId);
+    expect(presenter.viewModel).toEqual({ success: true, message: 'Join request rejected.' });
+  });
+});

tests/racing-application/RemoveLeagueMemberUseCase.spec.ts

@@ -0,0 +1,43 @@
+import { RemoveLeagueMemberUseCase } from '../../core/racing/application/use-cases/RemoveLeagueMemberUseCase';
+import { RemoveLeagueMemberPresenter } from '../../apps/api/src/modules/league/presenters/RemoveLeagueMemberPresenter';
+import { ILeagueMembershipRepository } from '../../core/racing/domain/repositories/ILeagueMembershipRepository';
+
+describe('RemoveLeagueMemberUseCase', () => {
+  let useCase: RemoveLeagueMemberUseCase;
+  let leagueMembershipRepository: jest.Mocked<ILeagueMembershipRepository>;
+  let presenter: RemoveLeagueMemberPresenter;
+
+  beforeEach(() => {
+    leagueMembershipRepository = {
+      getLeagueMembers: jest.fn(),
+      saveMembership: jest.fn(),
+    } as any;
+    presenter = new RemoveLeagueMemberPresenter();
+    useCase = new RemoveLeagueMemberUseCase(leagueMembershipRepository);
+  });
+
+  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() }];
+
+    leagueMembershipRepository.getLeagueMembers.mockResolvedValue(memberships);
+
+    await useCase.execute({ leagueId, targetDriverId }, presenter);
+
+    expect(leagueMembershipRepository.saveMembership).toHaveBeenCalledWith({
+      leagueId,
+      driverId: targetDriverId,
+      role: 'member',
+      status: 'inactive',
+      joinedAt: expect.any(Date),
+    });
+    expect(presenter.viewModel).toEqual({ success: true });
+  });
+
+  it('should throw error if membership not found', async () => {
+    leagueMembershipRepository.getLeagueMembers.mockResolvedValue([]);
+
+    await expect(useCase.execute({ leagueId: 'league-1', targetDriverId: 'driver-1' }, presenter)).rejects.toThrow('Membership not found');
+  });
+});

tests/racing-application/UpdateLeagueMemberRoleUseCase.spec.ts

@@ -0,0 +1,44 @@
+import { UpdateLeagueMemberRoleUseCase } from '../../core/racing/application/use-cases/UpdateLeagueMemberRoleUseCase';
+import { UpdateLeagueMemberRolePresenter } from '../../apps/api/src/modules/league/presenters/UpdateLeagueMemberRolePresenter';
+import { ILeagueMembershipRepository } from '../../core/racing/domain/repositories/ILeagueMembershipRepository';
+
+describe('UpdateLeagueMemberRoleUseCase', () => {
+  let useCase: UpdateLeagueMemberRoleUseCase;
+  let leagueMembershipRepository: jest.Mocked<ILeagueMembershipRepository>;
+  let presenter: UpdateLeagueMemberRolePresenter;
+
+  beforeEach(() => {
+    leagueMembershipRepository = {
+      getLeagueMembers: jest.fn(),
+      saveMembership: jest.fn(),
+    } as any;
+    presenter = new UpdateLeagueMemberRolePresenter();
+    useCase = new UpdateLeagueMemberRoleUseCase(leagueMembershipRepository);
+  });
+
+  it('should update league member role', async () => {
+    const leagueId = 'league-1';
+    const targetDriverId = 'driver-1';
+    const newRole = 'admin';
+    const memberships = [{ leagueId, driverId: targetDriverId, role: 'member', status: 'active', joinedAt: new Date() }];
+
+    leagueMembershipRepository.getLeagueMembers.mockResolvedValue(memberships);
+
+    await useCase.execute({ leagueId, targetDriverId, newRole }, presenter);
+
+    expect(leagueMembershipRepository.saveMembership).toHaveBeenCalledWith({
+      leagueId,
+      driverId: targetDriverId,
+      role: 'admin',
+      status: 'active',
+      joinedAt: expect.any(Date),
+    });
+    expect(presenter.viewModel).toEqual({ success: true });
+  });
+
+  it('should throw error if membership not found', async () => {
+    leagueMembershipRepository.getLeagueMembers.mockResolvedValue([]);
+
+    await expect(useCase.execute({ leagueId: 'league-1', targetDriverId: 'driver-1', newRole: 'admin' }, presenter)).rejects.toThrow('Membership not found');
+  });
+});