841 lines
34 KiB
TypeScript
841 lines
34 KiB
TypeScript
/**
|
|
* Integration Test: League Creation Use Case Orchestration
|
|
*
|
|
* Tests the orchestration logic of league creation-related Use Cases:
|
|
* - CreateLeagueUseCase: Creates a new league with basic information, structure, schedule, scoring, and stewarding configuration
|
|
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
|
|
* - Uses In-Memory adapters for fast, deterministic testing
|
|
*
|
|
* Focus: Business logic orchestration, NOT UI rendering
|
|
*/
|
|
|
|
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
|
|
import { InMemoryLeagueRepository } from '../../../adapters/leagues/persistence/inmemory/InMemoryLeagueRepository';
|
|
import { InMemoryLeagueEventPublisher } from '../../../adapters/leagues/events/InMemoryLeagueEventPublisher';
|
|
import { CreateLeagueUseCase } from '../../../core/leagues/application/use-cases/CreateLeagueUseCase';
|
|
import { LeagueCreateCommand } from '../../../core/leagues/application/ports/LeagueCreateCommand';
|
|
|
|
describe('League Creation Use Case Orchestration', () => {
|
|
let leagueRepository: InMemoryLeagueRepository;
|
|
let eventPublisher: InMemoryLeagueEventPublisher;
|
|
let createLeagueUseCase: CreateLeagueUseCase;
|
|
|
|
beforeAll(() => {
|
|
leagueRepository = new InMemoryLeagueRepository();
|
|
eventPublisher = new InMemoryLeagueEventPublisher();
|
|
createLeagueUseCase = new CreateLeagueUseCase(leagueRepository, eventPublisher);
|
|
});
|
|
|
|
beforeEach(() => {
|
|
leagueRepository.clear();
|
|
eventPublisher.clear();
|
|
});
|
|
|
|
describe('CreateLeagueUseCase - Success Path', () => {
|
|
it('should create a league with complete configuration', async () => {
|
|
// Scenario: Driver creates a league with complete configuration
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with complete league configuration
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Test League',
|
|
description: 'A test league for integration testing',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
maxDrivers: 20,
|
|
approvalRequired: true,
|
|
lateJoinAllowed: true,
|
|
raceFrequency: 'weekly',
|
|
raceDay: 'Saturday',
|
|
raceTime: '18:00',
|
|
tracks: ['Monza', 'Spa', 'Nürburgring'],
|
|
scoringSystem: { points: [25, 18, 15, 12, 10, 8, 6, 4, 2, 1] },
|
|
bonusPointsEnabled: true,
|
|
penaltiesEnabled: true,
|
|
protestsEnabled: true,
|
|
appealsEnabled: true,
|
|
stewardTeam: ['steward-1', 'steward-2'],
|
|
gameType: 'iRacing',
|
|
skillLevel: 'Intermediate',
|
|
category: 'GT3',
|
|
tags: ['competitive', 'weekly-races'],
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created in the repository
|
|
expect(result).toBeDefined();
|
|
expect(result.id).toBeDefined();
|
|
expect(result.name).toBe('Test League');
|
|
expect(result.description).toBe('A test league for integration testing');
|
|
expect(result.visibility).toBe('public');
|
|
expect(result.ownerId).toBe(driverId);
|
|
expect(result.status).toBe('active');
|
|
|
|
// And: The league should have all configured properties
|
|
expect(result.maxDrivers).toBe(20);
|
|
expect(result.approvalRequired).toBe(true);
|
|
expect(result.lateJoinAllowed).toBe(true);
|
|
expect(result.raceFrequency).toBe('weekly');
|
|
expect(result.raceDay).toBe('Saturday');
|
|
expect(result.raceTime).toBe('18:00');
|
|
expect(result.tracks).toEqual(['Monza', 'Spa', 'Nürburgring']);
|
|
expect(result.scoringSystem).toEqual({ points: [25, 18, 15, 12, 10, 8, 6, 4, 2, 1] });
|
|
expect(result.bonusPointsEnabled).toBe(true);
|
|
expect(result.penaltiesEnabled).toBe(true);
|
|
expect(result.protestsEnabled).toBe(true);
|
|
expect(result.appealsEnabled).toBe(true);
|
|
expect(result.stewardTeam).toEqual(['steward-1', 'steward-2']);
|
|
expect(result.gameType).toBe('iRacing');
|
|
expect(result.skillLevel).toBe('Intermediate');
|
|
expect(result.category).toBe('GT3');
|
|
expect(result.tags).toEqual(['competitive', 'weekly-races']);
|
|
|
|
// And: The league should be associated with the creating driver as owner
|
|
const savedLeague = await leagueRepository.findById(result.id);
|
|
expect(savedLeague).toBeDefined();
|
|
expect(savedLeague?.ownerId).toBe(driverId);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
const events = eventPublisher.getLeagueCreatedEvents();
|
|
expect(events[0].leagueId).toBe(result.id);
|
|
expect(events[0].ownerId).toBe(driverId);
|
|
});
|
|
|
|
it('should create a league with minimal configuration', async () => {
|
|
// Scenario: Driver creates a league with minimal configuration
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with minimal league configuration
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Minimal League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created in the repository
|
|
expect(result).toBeDefined();
|
|
expect(result.id).toBeDefined();
|
|
expect(result.name).toBe('Minimal League');
|
|
expect(result.visibility).toBe('public');
|
|
expect(result.ownerId).toBe(driverId);
|
|
expect(result.status).toBe('active');
|
|
|
|
// And: The league should have default values for all properties
|
|
expect(result.description).toBeNull();
|
|
expect(result.maxDrivers).toBeNull();
|
|
expect(result.approvalRequired).toBe(false);
|
|
expect(result.lateJoinAllowed).toBe(false);
|
|
expect(result.raceFrequency).toBeNull();
|
|
expect(result.raceDay).toBeNull();
|
|
expect(result.raceTime).toBeNull();
|
|
expect(result.tracks).toBeNull();
|
|
expect(result.scoringSystem).toBeNull();
|
|
expect(result.bonusPointsEnabled).toBe(false);
|
|
expect(result.penaltiesEnabled).toBe(false);
|
|
expect(result.protestsEnabled).toBe(false);
|
|
expect(result.appealsEnabled).toBe(false);
|
|
expect(result.stewardTeam).toBeNull();
|
|
expect(result.gameType).toBeNull();
|
|
expect(result.skillLevel).toBeNull();
|
|
expect(result.category).toBeNull();
|
|
expect(result.tags).toBeNull();
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with public visibility', async () => {
|
|
// Scenario: Driver creates a public league
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with visibility set to "Public"
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Public League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with public visibility
|
|
expect(result).toBeDefined();
|
|
expect(result.visibility).toBe('public');
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with private visibility', async () => {
|
|
// Scenario: Driver creates a private league
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with visibility set to "Private"
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Private League',
|
|
visibility: 'private',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with private visibility
|
|
expect(result).toBeDefined();
|
|
expect(result.visibility).toBe('private');
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with approval required', async () => {
|
|
// Scenario: Driver creates a league requiring approval
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with approval required enabled
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Approval Required League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: true,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with approval required
|
|
expect(result).toBeDefined();
|
|
expect(result.approvalRequired).toBe(true);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with late join allowed', async () => {
|
|
// Scenario: Driver creates a league allowing late join
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with late join enabled
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Late Join League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: true,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with late join allowed
|
|
expect(result).toBeDefined();
|
|
expect(result.lateJoinAllowed).toBe(true);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with custom scoring system', async () => {
|
|
// Scenario: Driver creates a league with custom scoring
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with custom scoring configuration
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Custom Scoring League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
scoringSystem: { points: [25, 18, 15, 12, 10, 8, 6, 4, 2, 1] },
|
|
bonusPointsEnabled: true,
|
|
penaltiesEnabled: true,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with the custom scoring system
|
|
expect(result).toBeDefined();
|
|
expect(result.scoringSystem).toEqual({ points: [25, 18, 15, 12, 10, 8, 6, 4, 2, 1] });
|
|
expect(result.bonusPointsEnabled).toBe(true);
|
|
expect(result.penaltiesEnabled).toBe(true);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with stewarding configuration', async () => {
|
|
// Scenario: Driver creates a league with stewarding configuration
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with stewarding configuration
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Stewarding League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: true,
|
|
appealsEnabled: true,
|
|
stewardTeam: ['steward-1', 'steward-2'],
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with the stewarding configuration
|
|
expect(result).toBeDefined();
|
|
expect(result.protestsEnabled).toBe(true);
|
|
expect(result.appealsEnabled).toBe(true);
|
|
expect(result.stewardTeam).toEqual(['steward-1', 'steward-2']);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with schedule configuration', async () => {
|
|
// Scenario: Driver creates a league with schedule configuration
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with schedule configuration
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Schedule League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
raceFrequency: 'weekly',
|
|
raceDay: 'Saturday',
|
|
raceTime: '18:00',
|
|
tracks: ['Monza', 'Spa', 'Nürburgring'],
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with the schedule configuration
|
|
expect(result).toBeDefined();
|
|
expect(result.raceFrequency).toBe('weekly');
|
|
expect(result.raceDay).toBe('Saturday');
|
|
expect(result.raceTime).toBe('18:00');
|
|
expect(result.tracks).toEqual(['Monza', 'Spa', 'Nürburgring']);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with max drivers limit', async () => {
|
|
// Scenario: Driver creates a league with max drivers limit
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with max drivers set to 20
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Max Drivers League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
maxDrivers: 20,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with max drivers limit of 20
|
|
expect(result).toBeDefined();
|
|
expect(result.maxDrivers).toBe(20);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should create a league with no max drivers limit', async () => {
|
|
// Scenario: Driver creates a league with no max drivers limit
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called without max drivers
|
|
const command: LeagueCreateCommand = {
|
|
name: 'No Max Drivers League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
const result = await createLeagueUseCase.execute(command);
|
|
|
|
// Then: The league should be created with no max drivers limit
|
|
expect(result).toBeDefined();
|
|
expect(result.maxDrivers).toBeNull();
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('CreateLeagueUseCase - Edge Cases', () => {
|
|
it('should handle league with empty description', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with empty description
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with empty description
|
|
// Then: The league should be created with empty description
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with very long description', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with very long description
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with very long description
|
|
// Then: The league should be created with the long description
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with special characters in name', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with special characters in name
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with special characters in name
|
|
// Then: The league should be created with the special characters in name
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with max drivers set to 1', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with max drivers set to 1
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with max drivers set to 1
|
|
// Then: The league should be created with max drivers limit of 1
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with very large max drivers', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with very large max drivers
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with max drivers set to 1000
|
|
// Then: The league should be created with max drivers limit of 1000
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with empty track list', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with empty track list
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with empty track list
|
|
// Then: The league should be created with empty track list
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with very large track list', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with very large track list
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with very large track list
|
|
// Then: The league should be created with the large track list
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with custom scoring but no bonus points', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with custom scoring but no bonus points
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with custom scoring but bonus points disabled
|
|
// Then: The league should be created with custom scoring and no bonus points
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with stewarding but no protests', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with stewarding but no protests
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with stewarding but protests disabled
|
|
// Then: The league should be created with stewarding but no protests
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with stewarding but no appeals', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with stewarding but no appeals
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with stewarding but appeals disabled
|
|
// Then: The league should be created with stewarding but no appeals
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with stewarding but empty steward team', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with stewarding but empty steward team
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with stewarding but empty steward team
|
|
// Then: The league should be created with stewarding but empty steward team
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with schedule but no tracks', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with schedule but no tracks
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with schedule but no tracks
|
|
// Then: The league should be created with schedule but no tracks
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with schedule but no race frequency', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with schedule but no race frequency
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with schedule but no race frequency
|
|
// Then: The league should be created with schedule but no race frequency
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with schedule but no race day', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with schedule but no race day
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with schedule but no race day
|
|
// Then: The league should be created with schedule but no race day
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
|
|
it('should handle league with schedule but no race time', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver creates a league with schedule but no race time
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with schedule but no race time
|
|
// Then: The league should be created with schedule but no race time
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
});
|
|
});
|
|
|
|
describe('CreateLeagueUseCase - Error Handling', () => {
|
|
it('should create league even when driver does not exist', async () => {
|
|
// Scenario: Non-existent driver tries to create a league
|
|
// Given: No driver exists with the given ID
|
|
const driverId = 'non-existent-driver';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with non-existent driver ID
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Test League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
// Then: The league should be created (Use Case doesn't validate driver existence)
|
|
const result = await createLeagueUseCase.execute(command);
|
|
expect(result).toBeDefined();
|
|
expect(result.ownerId).toBe(driverId);
|
|
|
|
// And: EventPublisher should emit LeagueCreatedEvent
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should throw error when driver ID is invalid', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Invalid driver ID
|
|
// Given: An invalid driver ID (e.g., empty string, null, undefined)
|
|
// When: CreateLeagueUseCase.execute() is called with invalid driver ID
|
|
// Then: Should throw ValidationError
|
|
// And: EventPublisher should NOT emit any events
|
|
});
|
|
|
|
it('should throw error when league name is empty', async () => {
|
|
// Scenario: Empty league name
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with empty league name
|
|
const command: LeagueCreateCommand = {
|
|
name: '',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
// Then: Should throw error
|
|
await expect(createLeagueUseCase.execute(command)).rejects.toThrow();
|
|
|
|
// And: EventPublisher should NOT emit any events
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(0);
|
|
});
|
|
|
|
it('should throw error when league name is too long', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League name exceeds maximum length
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called with league name exceeding max length
|
|
// Then: Should throw ValidationError
|
|
// And: EventPublisher should NOT emit any events
|
|
});
|
|
|
|
it('should throw error when max drivers is invalid', async () => {
|
|
// Scenario: Invalid max drivers value
|
|
// Given: A driver exists with ID "driver-123"
|
|
const driverId = 'driver-123';
|
|
|
|
// When: CreateLeagueUseCase.execute() is called with invalid max drivers (negative number)
|
|
const command: LeagueCreateCommand = {
|
|
name: 'Test League',
|
|
visibility: 'public',
|
|
ownerId: driverId,
|
|
maxDrivers: -1,
|
|
approvalRequired: false,
|
|
lateJoinAllowed: false,
|
|
bonusPointsEnabled: false,
|
|
penaltiesEnabled: false,
|
|
protestsEnabled: false,
|
|
appealsEnabled: false,
|
|
};
|
|
|
|
// Then: Should throw error
|
|
await expect(createLeagueUseCase.execute(command)).rejects.toThrow();
|
|
|
|
// And: EventPublisher should NOT emit any events
|
|
expect(eventPublisher.getLeagueCreatedEventCount()).toBe(0);
|
|
});
|
|
|
|
it('should throw error when repository throws error', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Repository throws error during save
|
|
// Given: A driver exists with ID "driver-123"
|
|
// And: LeagueRepository throws an error during save
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: Should propagate the error appropriately
|
|
// And: EventPublisher should NOT emit any events
|
|
});
|
|
|
|
it('should throw error when event publisher throws error', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: Event publisher throws error during emit
|
|
// Given: A driver exists with ID "driver-123"
|
|
// And: EventPublisher throws an error during emit
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: Should propagate the error appropriately
|
|
// And: League should still be saved in repository
|
|
});
|
|
});
|
|
|
|
describe('League Creation Data Orchestration', () => {
|
|
it('should correctly associate league with creating driver as owner', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League ownership association
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have the driver as owner
|
|
// And: The driver should be listed in the league roster as owner
|
|
});
|
|
|
|
it('should correctly set league status to active', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League status initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have status "Active"
|
|
});
|
|
|
|
it('should correctly set league creation timestamp', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League creation timestamp
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have a creation timestamp
|
|
// And: The timestamp should be current or very recent
|
|
});
|
|
|
|
it('should correctly initialize league statistics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League statistics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized statistics
|
|
// - Member count: 1 (owner)
|
|
// - Race count: 0
|
|
// - Sponsor count: 0
|
|
// - Prize pool: 0
|
|
// - Rating: 0
|
|
// - Review count: 0
|
|
});
|
|
|
|
it('should correctly initialize league financials', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League financials initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized financials
|
|
// - Wallet balance: 0
|
|
// - Total revenue: 0
|
|
// - Total fees: 0
|
|
// - Pending payouts: 0
|
|
// - Net balance: 0
|
|
});
|
|
|
|
it('should correctly initialize league stewarding metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League stewarding metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized stewarding metrics
|
|
// - Average resolution time: 0
|
|
// - Average protest resolution time: 0
|
|
// - Average penalty appeal success rate: 0
|
|
// - Average protest success rate: 0
|
|
// - Average stewarding action success rate: 0
|
|
});
|
|
|
|
it('should correctly initialize league performance metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League performance metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized performance metrics
|
|
// - Average lap time: 0
|
|
// - Average field size: 0
|
|
// - Average incident count: 0
|
|
// - Average penalty count: 0
|
|
// - Average protest count: 0
|
|
// - Average stewarding action count: 0
|
|
});
|
|
|
|
it('should correctly initialize league rating metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League rating metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized rating metrics
|
|
// - Overall rating: 0
|
|
// - Rating trend: 0
|
|
// - Rank trend: 0
|
|
// - Points trend: 0
|
|
// - Win rate trend: 0
|
|
// - Podium rate trend: 0
|
|
// - DNF rate trend: 0
|
|
});
|
|
|
|
it('should correctly initialize league trend metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League trend metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized trend metrics
|
|
// - Incident rate trend: 0
|
|
// - Penalty rate trend: 0
|
|
// - Protest rate trend: 0
|
|
// - Stewarding action rate trend: 0
|
|
// - Stewarding time trend: 0
|
|
// - Protest resolution time trend: 0
|
|
});
|
|
|
|
it('should correctly initialize league success rate metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League success rate metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized success rate metrics
|
|
// - Penalty appeal success rate: 0
|
|
// - Protest success rate: 0
|
|
// - Stewarding action success rate: 0
|
|
// - Stewarding action appeal success rate: 0
|
|
// - Stewarding action penalty success rate: 0
|
|
// - Stewarding action protest success rate: 0
|
|
});
|
|
|
|
it('should correctly initialize league resolution time metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League resolution time metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized resolution time metrics
|
|
// - Average stewarding time: 0
|
|
// - Average protest resolution time: 0
|
|
// - Average stewarding action appeal penalty protest resolution time: 0
|
|
});
|
|
|
|
it('should correctly initialize league complex success rate metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League complex success rate metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized complex success rate metrics
|
|
// - Stewarding action appeal penalty protest success rate: 0
|
|
// - Stewarding action appeal protest success rate: 0
|
|
// - Stewarding action penalty protest success rate: 0
|
|
// - Stewarding action appeal penalty protest success rate: 0
|
|
});
|
|
|
|
it('should correctly initialize league complex resolution time metrics', async () => {
|
|
// TODO: Implement test
|
|
// Scenario: League complex resolution time metrics initialization
|
|
// Given: A driver exists with ID "driver-123"
|
|
// When: CreateLeagueUseCase.execute() is called
|
|
// Then: The created league should have initialized complex resolution time metrics
|
|
// - Stewarding action appeal penalty protest resolution time: 0
|
|
// - Stewarding action appeal protest resolution time: 0
|
|
// - Stewarding action penalty protest resolution time: 0
|
|
// - Stewarding action appeal penalty protest resolution time: 0
|
|
});
|
|
});
|
|
});
|