integration tests

tests/integration/leagues/roster/league-roster-actions.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaguesTestContext } from '../LeaguesTestContext';
+
+describe('League Roster - Actions', () => {
+  let context: LeaguesTestContext;
+
+  beforeEach(() => {
+    context = new LeaguesTestContext();
+    context.clear();
+  });
+
+  it('should allow a driver to join a public league without approval', async () => {
+    const league = await context.createLeague({ approvalRequired: false });
+    const driverId = 'driver-joiner';
+    
+    context.driverRepository.addDriver({ 
+      id: driverId, 
+      name: 'Joiner Driver', 
+      rating: 1500, 
+      rank: 100, 
+      avatar: undefined,
+      starts: 0,
+      wins: 0,
+      podiums: 0,
+      leagues: 0
+    });
+    
+    await context.joinLeagueUseCase.execute({ leagueId: league.id, driverId });
+    
+    const members = await context.leagueRepository.getLeagueMembers(league.id);
+    expect(members.some(m => m.driverId === driverId)).toBe(true);
+  });
+
+  it('should create a pending request when joining a league requiring approval', async () => {
+    const league = await context.createLeague({ approvalRequired: true });
+    const driverId = 'driver-requester';
+    
+    context.driverRepository.addDriver({ 
+      id: driverId, 
+      name: 'Requester Driver', 
+      rating: 1500, 
+      rank: 100, 
+      avatar: undefined,
+      starts: 0,
+      wins: 0,
+      podiums: 0,
+      leagues: 0
+    });
+    
+    await context.joinLeagueUseCase.execute({ leagueId: league.id, driverId });
+    
+    const requests = await context.leagueRepository.getPendingRequests(league.id);
+    expect(requests.some(r => r.driverId === driverId)).toBe(true);
+  });
+
+  it('should allow an admin to approve a membership request', async () => {
+    const ownerId = 'driver-owner';
+    const league = await context.createLeague({ ownerId, approvalRequired: true });
+    const driverId = 'driver-requester';
+    
+    context.driverRepository.addDriver({ 
+      id: driverId, 
+      name: 'Requester Driver', 
+      rating: 1500, 
+      rank: 100, 
+      avatar: undefined,
+      starts: 0,
+      wins: 0,
+      podiums: 0,
+      leagues: 0
+    });
+    await context.joinLeagueUseCase.execute({ leagueId: league.id, driverId });
+    
+    const requests = await context.leagueRepository.getPendingRequests(league.id);
+    const requestId = requests[0].id;
+    
+    await context.approveMembershipRequestUseCase.execute({ leagueId: league.id, requestId });
+    
+    const members = await context.leagueRepository.getLeagueMembers(league.id);
+    expect(members.some(m => m.driverId === driverId)).toBe(true);
+    
+    const updatedRequests = await context.leagueRepository.getPendingRequests(league.id);
+    expect(updatedRequests).toHaveLength(0);
+  });
+
+  it('should allow an admin to reject a membership request', async () => {
+    const ownerId = 'driver-owner';
+    const league = await context.createLeague({ ownerId, approvalRequired: true });
+    const driverId = 'driver-requester';
+    
+    context.driverRepository.addDriver({ 
+      id: driverId, 
+      name: 'Requester Driver', 
+      rating: 1500, 
+      rank: 100, 
+      avatar: undefined,
+      starts: 0,
+      wins: 0,
+      podiums: 0,
+      leagues: 0
+    });
+    await context.joinLeagueUseCase.execute({ leagueId: league.id, driverId });
+    
+    const requests = await context.leagueRepository.getPendingRequests(league.id);
+    const requestId = requests[0].id;
+    
+    await context.rejectMembershipRequestUseCase.execute({ leagueId: league.id, requestId });
+    
+    const members = await context.leagueRepository.getLeagueMembers(league.id);
+    expect(members.some(m => m.driverId === driverId)).toBe(false);
+    
+    const updatedRequests = await context.leagueRepository.getPendingRequests(league.id);
+    expect(updatedRequests).toHaveLength(0);
+  });
+
+  it('should allow a driver to leave a league', async () => {
+    const league = await context.createLeague();
+    const driverId = 'driver-leaver';
+    
+    context.leagueRepository.addLeagueMembers(league.id, [
+      { driverId, name: 'Leaver', role: 'member', joinDate: new Date() }
+    ]);
+    
+    await context.leaveLeagueUseCase.execute({ leagueId: league.id, driverId });
+    
+    const members = await context.leagueRepository.getLeagueMembers(league.id);
+    expect(members.some(m => m.driverId === driverId)).toBe(false);
+  });
+});

tests/integration/leagues/roster/league-roster-management.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaguesTestContext } from '../LeaguesTestContext';
+
+describe('League Roster - Member Management', () => {
+  let context: LeaguesTestContext;
+
+  beforeEach(() => {
+    context = new LeaguesTestContext();
+    context.clear();
+  });
+
+  it('should allow an admin to promote a member to admin', async () => {
+    const ownerId = 'driver-owner';
+    const league = await context.createLeague({ ownerId });
+    const driverId = 'driver-member';
+    
+    context.leagueRepository.addLeagueMembers(league.id, [
+      { driverId: ownerId, name: 'Owner', role: 'owner', joinDate: new Date() },
+      { driverId: driverId, name: 'Member', role: 'member', joinDate: new Date() },
+    ]);
+    
+    await context.promoteMemberUseCase.execute({ leagueId: league.id, targetDriverId: driverId });
+    
+    const members = await context.leagueRepository.getLeagueMembers(league.id);
+    const promotedMember = members.find(m => m.driverId === driverId);
+    expect(promotedMember?.role).toBe('admin');
+  });
+
+  it('should allow an admin to demote an admin to member', async () => {
+    const ownerId = 'driver-owner';
+    const league = await context.createLeague({ ownerId });
+    const adminId = 'driver-admin';
+    
+    context.leagueRepository.addLeagueMembers(league.id, [
+      { driverId: ownerId, name: 'Owner', role: 'owner', joinDate: new Date() },
+      { driverId: adminId, name: 'Admin', role: 'admin', joinDate: new Date() },
+    ]);
+    
+    await context.demoteAdminUseCase.execute({ leagueId: league.id, targetDriverId: adminId });
+    
+    const members = await context.leagueRepository.getLeagueMembers(league.id);
+    const demotedAdmin = members.find(m => m.driverId === adminId);
+    expect(demotedAdmin?.role).toBe('member');
+  });
+
+  it('should allow an admin to remove a member', async () => {
+    const ownerId = 'driver-owner';
+    const league = await context.createLeague({ ownerId });
+    const driverId = 'driver-member';
+    
+    context.leagueRepository.addLeagueMembers(league.id, [
+      { driverId: ownerId, name: 'Owner', role: 'owner', joinDate: new Date() },
+      { driverId: driverId, name: 'Member', role: 'member', joinDate: new Date() },
+    ]);
+    
+    await context.removeMemberUseCase.execute({ leagueId: league.id, targetDriverId: driverId });
+    
+    const members = await context.leagueRepository.getLeagueMembers(league.id);
+    expect(members.some(m => m.driverId === driverId)).toBe(false);
+  });
+});

tests/integration/leagues/roster/league-roster-success.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaguesTestContext } from '../LeaguesTestContext';
+
+describe('League Roster - Success Path', () => {
+  let context: LeaguesTestContext;
+
+  beforeEach(() => {
+    context = new LeaguesTestContext();
+    context.clear();
+  });
+
+  it('should retrieve complete league roster with all members', async () => {
+    const leagueId = 'league-123';
+    const ownerId = 'driver-1';
+    const adminId = 'driver-2';
+    const driverId = 'driver-3';
+    
+    await context.leagueRepository.create({
+      id: leagueId,
+      name: 'Test League',
+      description: null,
+      visibility: 'public',
+      ownerId,
+      status: 'active',
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      maxDrivers: null,
+      approvalRequired: true,
+      lateJoinAllowed: true,
+      raceFrequency: null,
+      raceDay: null,
+      raceTime: null,
+      tracks: null,
+      scoringSystem: null,
+      bonusPointsEnabled: true,
+      penaltiesEnabled: true,
+      protestsEnabled: true,
+      appealsEnabled: true,
+      stewardTeam: null,
+      gameType: null,
+      skillLevel: null,
+      category: null,
+      tags: null,
+    });
+    
+    context.leagueRepository.addLeagueMembers(leagueId, [
+      { driverId: ownerId, name: 'Owner Driver', role: 'owner', joinDate: new Date('2024-01-01') },
+      { driverId: adminId, name: 'Admin Driver', role: 'admin', joinDate: new Date('2024-01-15') },
+      { driverId: driverId, name: 'Regular Driver', role: 'member', joinDate: new Date('2024-02-01') },
+    ]);
+    
+    context.leagueRepository.addPendingRequests(leagueId, [
+      { id: 'request-1', driverId: 'driver-4', name: 'Pending Driver', requestDate: new Date('2024-02-15') },
+    ]);
+    
+    const result = await context.getLeagueRosterUseCase.execute({ leagueId });
+    
+    expect(result).toBeDefined();
+    expect(result.members).toHaveLength(3);
+    expect(result.pendingRequests).toHaveLength(1);
+    expect(result.stats.adminCount).toBe(2);
+    expect(result.stats.driverCount).toBe(1);
+    expect(context.eventPublisher.getLeagueRosterAccessedEventCount()).toBe(1);
+  });
+
+  it('should retrieve league roster with minimal members', async () => {
+    const ownerId = 'driver-owner';
+    const league = await context.createLeague({ ownerId });
+    
+    context.leagueRepository.addLeagueMembers(league.id, [
+      { driverId: ownerId, name: 'Owner Driver', role: 'owner', joinDate: new Date('2024-01-01') },
+    ]);
+    
+    const result = await context.getLeagueRosterUseCase.execute({ leagueId: league.id });
+    
+    expect(result.members).toHaveLength(1);
+    expect(result.members[0].role).toBe('owner');
+    expect(result.stats.adminCount).toBe(1);
+  });
+});