league service

tests/application/CompleteDriverOnboardingUseCase.spec.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { CompleteDriverOnboardingUseCase } from '../../core/racing/application/use-cases/CompleteDriverOnboardingUseCase';
+import { IDriverRepository } from '../../core/racing/domain/repositories/IDriverRepository';
+import { CompleteOnboardingPresenter } from '../../apps/api/src/modules/driver/presenters/CompleteOnboardingPresenter';
+
+describe('CompleteDriverOnboardingUseCase', () => {
+  let useCase: CompleteDriverOnboardingUseCase;
+  let driverRepository: { findById: any; save: any };
+
+  beforeEach(() => {
+    driverRepository = {
+      findById: vi.fn(),
+      save: vi.fn(),
+    };
+    useCase = new CompleteDriverOnboardingUseCase(driverRepository as IDriverRepository);
+  });
+
+  describe('execute', () => {
+    it('should create a new driver and return success', async () => {
+      const input = {
+        userId: 'user-123',
+        firstName: 'John',
+        lastName: 'Doe',
+        displayName: 'John Doe',
+        country: 'US',
+        timezone: 'America/New_York',
+        bio: 'Racing enthusiast',
+      };
+
+      driverRepository.findById.mockResolvedValue(null); // Driver doesn't exist
+      driverRepository.save.mockResolvedValue(undefined);
+
+      const presenter = new CompleteOnboardingPresenter();
+
+      await useCase.execute(input, presenter);
+
+      expect(driverRepository.findById).toHaveBeenCalledWith('user-123');
+      expect(driverRepository.save).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: 'user-123',
+          iracingId: 'user-123',
+          name: 'John Doe',
+          country: 'US',
+          bio: 'Racing enthusiast',
+        })
+      );
+      expect(presenter.viewModel).toEqual({
+        success: true,
+        driverId: 'user-123',
+        errorMessage: undefined,
+      });
+    });
+
+    it('should return error if driver already exists', async () => {
+      const input = {
+        userId: 'user-123',
+        firstName: 'John',
+        lastName: 'Doe',
+        displayName: 'John Doe',
+        country: 'US',
+      };
+
+      const existingDriver = {
+        id: 'user-123',
+        name: 'Existing Driver',
+      };
+
+      driverRepository.findById.mockResolvedValue(existingDriver);
+
+      const presenter = new CompleteOnboardingPresenter();
+
+      await useCase.execute(input, presenter);
+
+      expect(driverRepository.findById).toHaveBeenCalledWith('user-123');
+      expect(driverRepository.save).not.toHaveBeenCalled();
+      expect(presenter.viewModel).toEqual({
+        success: false,
+        driverId: undefined,
+        errorMessage: 'Driver already exists',
+      });
+    });
+
+    it('should handle domain validation errors', async () => {
+      const input = {
+        userId: 'user-123',
+        firstName: 'John',
+        lastName: 'Doe',
+        displayName: 'John Doe',
+        country: 'INVALID', // Invalid country code
+      };
+
+      driverRepository.findById.mockResolvedValue(null);
+
+      const presenter = new CompleteOnboardingPresenter();
+
+      await useCase.execute(input, presenter);
+
+      expect(presenter.viewModel.success).toBe(false);
+      expect(presenter.viewModel.errorMessage).toContain('Country must be a valid ISO code');
+    });
+  });
+});

tests/application/GetTotalDriversUseCase.spec.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { GetTotalDriversUseCase } from '../../core/racing/application/use-cases/GetTotalDriversUseCase';
+import { IDriverRepository } from '../../core/racing/domain/repositories/IDriverRepository';
+import { DriverStatsPresenter } from '../../apps/api/src/modules/driver/presenters/DriverStatsPresenter';
+
+describe('GetTotalDriversUseCase', () => {
+  let useCase: GetTotalDriversUseCase;
+  let driverRepository: { findAll: any };
+
+  beforeEach(() => {
+    driverRepository = {
+      findAll: vi.fn(),
+    };
+    useCase = new GetTotalDriversUseCase(driverRepository as IDriverRepository);
+  });
+
+  it('should return total drivers count', async () => {
+    // Arrange
+    const mockDrivers = [
+      { id: '1', name: 'Driver 1' },
+      { id: '2', name: 'Driver 2' },
+    ];
+    driverRepository.findAll.mockResolvedValue(mockDrivers);
+    const presenter = new DriverStatsPresenter();
+
+    // Act
+    await useCase.execute(undefined, presenter);
+
+    // Assert
+    expect(driverRepository.findAll).toHaveBeenCalled();
+    expect(presenter.viewModel).toEqual({ totalDrivers: 2 });
+  });
+});

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');
+  });
+});