668 lines
23 KiB
TypeScript
668 lines
23 KiB
TypeScript
/**
|
|
* Integration Test: Global Leaderboards Use Case Orchestration
|
|
*
|
|
* Tests the orchestration logic of global leaderboards-related Use Cases:
|
|
* - GetGlobalLeaderboardsUseCase: Retrieves top drivers and teams for the main leaderboards page
|
|
* - 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 { InMemoryLeaderboardsRepository } from '../../../adapters/leaderboards/persistence/inmemory/InMemoryLeaderboardsRepository';
|
|
import { InMemoryLeaderboardsEventPublisher } from '../../../adapters/leaderboards/events/InMemoryLeaderboardsEventPublisher';
|
|
import { GetGlobalLeaderboardsUseCase } from '../../../core/leaderboards/application/use-cases/GetGlobalLeaderboardsUseCase';
|
|
|
|
describe('Global Leaderboards Use Case Orchestration', () => {
|
|
let leaderboardsRepository: InMemoryLeaderboardsRepository;
|
|
let eventPublisher: InMemoryLeaderboardsEventPublisher;
|
|
let getGlobalLeaderboardsUseCase: GetGlobalLeaderboardsUseCase;
|
|
|
|
beforeAll(() => {
|
|
leaderboardsRepository = new InMemoryLeaderboardsRepository();
|
|
eventPublisher = new InMemoryLeaderboardsEventPublisher();
|
|
getGlobalLeaderboardsUseCase = new GetGlobalLeaderboardsUseCase({
|
|
leaderboardsRepository,
|
|
eventPublisher,
|
|
});
|
|
});
|
|
|
|
beforeEach(() => {
|
|
leaderboardsRepository.clear();
|
|
eventPublisher.clear();
|
|
});
|
|
|
|
describe('GetGlobalLeaderboardsUseCase - Success Path', () => {
|
|
it('should retrieve top drivers and teams with complete data', async () => {
|
|
// Scenario: System has multiple drivers and teams with complete data
|
|
// Given: Multiple drivers exist with various ratings and team affiliations
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-1',
|
|
name: 'John Smith',
|
|
rating: 5.0,
|
|
teamId: 'team-1',
|
|
teamName: 'Racing Team A',
|
|
raceCount: 50,
|
|
});
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-2',
|
|
name: 'Jane Doe',
|
|
rating: 4.8,
|
|
teamId: 'team-2',
|
|
teamName: 'Speed Squad',
|
|
raceCount: 45,
|
|
});
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-3',
|
|
name: 'Bob Johnson',
|
|
rating: 4.5,
|
|
teamId: 'team-1',
|
|
teamName: 'Racing Team A',
|
|
raceCount: 40,
|
|
});
|
|
|
|
// And: Multiple teams exist with various ratings and member counts
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-1',
|
|
name: 'Racing Team A',
|
|
rating: 4.9,
|
|
memberCount: 5,
|
|
raceCount: 100,
|
|
});
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-2',
|
|
name: 'Speed Squad',
|
|
rating: 4.7,
|
|
memberCount: 3,
|
|
raceCount: 80,
|
|
});
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-3',
|
|
name: 'Champions League',
|
|
rating: 4.3,
|
|
memberCount: 4,
|
|
raceCount: 60,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: The result should contain top 10 drivers (but we only have 3)
|
|
expect(result.drivers).toHaveLength(3);
|
|
|
|
// And: The result should contain top 10 teams (but we only have 3)
|
|
expect(result.teams).toHaveLength(3);
|
|
|
|
// And: Driver entries should include rank, name, rating, and team affiliation
|
|
expect(result.drivers[0]).toMatchObject({
|
|
rank: 1,
|
|
id: 'driver-1',
|
|
name: 'John Smith',
|
|
rating: 5.0,
|
|
teamId: 'team-1',
|
|
teamName: 'Racing Team A',
|
|
raceCount: 50,
|
|
});
|
|
|
|
// And: Team entries should include rank, name, rating, and member count
|
|
expect(result.teams[0]).toMatchObject({
|
|
rank: 1,
|
|
id: 'team-1',
|
|
name: 'Racing Team A',
|
|
rating: 4.9,
|
|
memberCount: 5,
|
|
raceCount: 100,
|
|
});
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should retrieve top drivers and teams with minimal data', async () => {
|
|
// Scenario: System has minimal data
|
|
// Given: Only a few drivers exist
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-1',
|
|
name: 'John Smith',
|
|
rating: 5.0,
|
|
raceCount: 10,
|
|
});
|
|
|
|
// And: Only a few teams exist
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-1',
|
|
name: 'Racing Team A',
|
|
rating: 4.9,
|
|
memberCount: 2,
|
|
raceCount: 20,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: The result should contain all available drivers
|
|
expect(result.drivers).toHaveLength(1);
|
|
expect(result.drivers[0].name).toBe('John Smith');
|
|
|
|
// And: The result should contain all available teams
|
|
expect(result.teams).toHaveLength(1);
|
|
expect(result.teams[0].name).toBe('Racing Team A');
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should retrieve top drivers and teams when there are many', async () => {
|
|
// Scenario: System has many drivers and teams
|
|
// Given: More than 10 drivers exist
|
|
for (let i = 1; i <= 15; i++) {
|
|
leaderboardsRepository.addDriver({
|
|
id: `driver-${i}`,
|
|
name: `Driver ${i}`,
|
|
rating: 5.0 - i * 0.1,
|
|
raceCount: 10 + i,
|
|
});
|
|
}
|
|
|
|
// And: More than 10 teams exist
|
|
for (let i = 1; i <= 15; i++) {
|
|
leaderboardsRepository.addTeam({
|
|
id: `team-${i}`,
|
|
name: `Team ${i}`,
|
|
rating: 5.0 - i * 0.1,
|
|
memberCount: 2 + i,
|
|
raceCount: 20 + i,
|
|
});
|
|
}
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: The result should contain only top 10 drivers
|
|
expect(result.drivers).toHaveLength(10);
|
|
|
|
// And: The result should contain only top 10 teams
|
|
expect(result.teams).toHaveLength(10);
|
|
|
|
// And: Drivers should be sorted by rating (highest first)
|
|
expect(result.drivers[0].rating).toBe(4.9); // Driver 1
|
|
expect(result.drivers[9].rating).toBe(4.0); // Driver 10
|
|
|
|
// And: Teams should be sorted by rating (highest first)
|
|
expect(result.teams[0].rating).toBe(4.9); // Team 1
|
|
expect(result.teams[9].rating).toBe(4.0); // Team 10
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should retrieve top drivers and teams with consistent ranking order', async () => {
|
|
// Scenario: Verify ranking consistency
|
|
// Given: Multiple drivers exist with various ratings
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-1',
|
|
name: 'Driver A',
|
|
rating: 5.0,
|
|
raceCount: 10,
|
|
});
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-2',
|
|
name: 'Driver B',
|
|
rating: 4.8,
|
|
raceCount: 10,
|
|
});
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-3',
|
|
name: 'Driver C',
|
|
rating: 4.5,
|
|
raceCount: 10,
|
|
});
|
|
|
|
// And: Multiple teams exist with various ratings
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-1',
|
|
name: 'Team A',
|
|
rating: 4.9,
|
|
memberCount: 2,
|
|
raceCount: 20,
|
|
});
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-2',
|
|
name: 'Team B',
|
|
rating: 4.7,
|
|
memberCount: 2,
|
|
raceCount: 20,
|
|
});
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-3',
|
|
name: 'Team C',
|
|
rating: 4.3,
|
|
memberCount: 2,
|
|
raceCount: 20,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Driver ranks should be sequential (1, 2, 3...)
|
|
expect(result.drivers[0].rank).toBe(1);
|
|
expect(result.drivers[1].rank).toBe(2);
|
|
expect(result.drivers[2].rank).toBe(3);
|
|
|
|
// And: Team ranks should be sequential (1, 2, 3...)
|
|
expect(result.teams[0].rank).toBe(1);
|
|
expect(result.teams[1].rank).toBe(2);
|
|
expect(result.teams[2].rank).toBe(3);
|
|
|
|
// And: No duplicate ranks should appear
|
|
const driverRanks = result.drivers.map((d) => d.rank);
|
|
const teamRanks = result.teams.map((t) => t.rank);
|
|
expect(new Set(driverRanks).size).toBe(driverRanks.length);
|
|
expect(new Set(teamRanks).size).toBe(teamRanks.length);
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should retrieve top drivers and teams with accurate data', async () => {
|
|
// Scenario: Verify data accuracy
|
|
// Given: Drivers exist with valid ratings and names
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-1',
|
|
name: 'John Smith',
|
|
rating: 5.0,
|
|
raceCount: 50,
|
|
});
|
|
|
|
// And: Teams exist with valid ratings and member counts
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-1',
|
|
name: 'Racing Team A',
|
|
rating: 4.9,
|
|
memberCount: 5,
|
|
raceCount: 100,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: All driver ratings should be valid numbers
|
|
expect(result.drivers[0].rating).toBeGreaterThan(0);
|
|
expect(typeof result.drivers[0].rating).toBe('number');
|
|
|
|
// And: All team ratings should be valid numbers
|
|
expect(result.teams[0].rating).toBeGreaterThan(0);
|
|
expect(typeof result.teams[0].rating).toBe('number');
|
|
|
|
// And: All team member counts should be valid numbers
|
|
expect(result.teams[0].memberCount).toBeGreaterThan(0);
|
|
expect(typeof result.teams[0].memberCount).toBe('number');
|
|
|
|
// And: All names should be non-empty strings
|
|
expect(result.drivers[0].name).toBeTruthy();
|
|
expect(typeof result.drivers[0].name).toBe('string');
|
|
expect(result.teams[0].name).toBeTruthy();
|
|
expect(typeof result.teams[0].name).toBe('string');
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('GetGlobalLeaderboardsUseCase - Edge Cases', () => {
|
|
it('should handle system with no drivers', async () => {
|
|
// Scenario: System has no drivers
|
|
// Given: No drivers exist in the system
|
|
// And: Teams exist
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-1',
|
|
name: 'Racing Team A',
|
|
rating: 4.9,
|
|
memberCount: 5,
|
|
raceCount: 100,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: The result should contain empty drivers list
|
|
expect(result.drivers).toHaveLength(0);
|
|
|
|
// And: The result should contain top teams
|
|
expect(result.teams).toHaveLength(1);
|
|
expect(result.teams[0].name).toBe('Racing Team A');
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should handle system with no teams', async () => {
|
|
// Scenario: System has no teams
|
|
// Given: Drivers exist
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-1',
|
|
name: 'John Smith',
|
|
rating: 5.0,
|
|
raceCount: 50,
|
|
});
|
|
|
|
// And: No teams exist in the system
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: The result should contain top drivers
|
|
expect(result.drivers).toHaveLength(1);
|
|
expect(result.drivers[0].name).toBe('John Smith');
|
|
|
|
// And: The result should contain empty teams list
|
|
expect(result.teams).toHaveLength(0);
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should handle system with no data at all', async () => {
|
|
// Scenario: System has absolutely no data
|
|
// Given: No drivers exist
|
|
// And: No teams exist
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: The result should contain empty drivers list
|
|
expect(result.drivers).toHaveLength(0);
|
|
|
|
// And: The result should contain empty teams list
|
|
expect(result.teams).toHaveLength(0);
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should handle drivers with same rating', async () => {
|
|
// Scenario: Multiple drivers with identical ratings
|
|
// Given: Multiple drivers exist with the same rating
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-1',
|
|
name: 'Zoe',
|
|
rating: 5.0,
|
|
raceCount: 50,
|
|
});
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-2',
|
|
name: 'Alice',
|
|
rating: 5.0,
|
|
raceCount: 45,
|
|
});
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-3',
|
|
name: 'Bob',
|
|
rating: 5.0,
|
|
raceCount: 40,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Drivers should be sorted by rating
|
|
expect(result.drivers[0].rating).toBe(5.0);
|
|
expect(result.drivers[1].rating).toBe(5.0);
|
|
expect(result.drivers[2].rating).toBe(5.0);
|
|
|
|
// And: Drivers with same rating should have consistent ordering (by name)
|
|
expect(result.drivers[0].name).toBe('Alice');
|
|
expect(result.drivers[1].name).toBe('Bob');
|
|
expect(result.drivers[2].name).toBe('Zoe');
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
|
|
it('should handle teams with same rating', async () => {
|
|
// Scenario: Multiple teams with identical ratings
|
|
// Given: Multiple teams exist with the same rating
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-1',
|
|
name: 'Zeta Team',
|
|
rating: 4.9,
|
|
memberCount: 5,
|
|
raceCount: 100,
|
|
});
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-2',
|
|
name: 'Alpha Team',
|
|
rating: 4.9,
|
|
memberCount: 3,
|
|
raceCount: 80,
|
|
});
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-3',
|
|
name: 'Beta Team',
|
|
rating: 4.9,
|
|
memberCount: 4,
|
|
raceCount: 60,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Teams should be sorted by rating
|
|
expect(result.teams[0].rating).toBe(4.9);
|
|
expect(result.teams[1].rating).toBe(4.9);
|
|
expect(result.teams[2].rating).toBe(4.9);
|
|
|
|
// And: Teams with same rating should have consistent ordering (by name)
|
|
expect(result.teams[0].name).toBe('Alpha Team');
|
|
expect(result.teams[1].name).toBe('Beta Team');
|
|
expect(result.teams[2].name).toBe('Zeta Team');
|
|
|
|
// And: EventPublisher should emit GlobalLeaderboardsAccessedEvent
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('GetGlobalLeaderboardsUseCase - Error Handling', () => {
|
|
it('should handle repository errors gracefully', async () => {
|
|
// Scenario: Repository throws error
|
|
// Given: LeaderboardsRepository throws an error during query
|
|
const originalFindAllDrivers = leaderboardsRepository.findAllDrivers.bind(leaderboardsRepository);
|
|
leaderboardsRepository.findAllDrivers = async () => {
|
|
throw new Error('Repository error');
|
|
};
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
try {
|
|
await getGlobalLeaderboardsUseCase.execute();
|
|
// Should not reach here
|
|
expect(true).toBe(false);
|
|
} catch (error) {
|
|
// Then: Should propagate the error appropriately
|
|
expect(error).toBeInstanceOf(Error);
|
|
expect((error as Error).message).toBe('Repository error');
|
|
}
|
|
|
|
// And: EventPublisher should NOT emit any events
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(0);
|
|
|
|
// Restore original method
|
|
leaderboardsRepository.findAllDrivers = originalFindAllDrivers;
|
|
});
|
|
|
|
it('should handle team repository errors gracefully', async () => {
|
|
// Scenario: Team repository throws error
|
|
// Given: LeaderboardsRepository throws an error during query
|
|
const originalFindAllTeams = leaderboardsRepository.findAllTeams.bind(leaderboardsRepository);
|
|
leaderboardsRepository.findAllTeams = async () => {
|
|
throw new Error('Team repository error');
|
|
};
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
try {
|
|
await getGlobalLeaderboardsUseCase.execute();
|
|
// Should not reach here
|
|
expect(true).toBe(false);
|
|
} catch (error) {
|
|
// Then: Should propagate the error appropriately
|
|
expect(error).toBeInstanceOf(Error);
|
|
expect((error as Error).message).toBe('Team repository error');
|
|
}
|
|
|
|
// And: EventPublisher should NOT emit any events
|
|
expect(eventPublisher.getGlobalLeaderboardsAccessedEventCount()).toBe(0);
|
|
|
|
// Restore original method
|
|
leaderboardsRepository.findAllTeams = originalFindAllTeams;
|
|
});
|
|
});
|
|
|
|
describe('Global Leaderboards Data Orchestration', () => {
|
|
it('should correctly calculate driver rankings based on rating', async () => {
|
|
// Scenario: Driver ranking calculation
|
|
// Given: Drivers exist with ratings: 5.0, 4.8, 4.5, 4.2, 4.0
|
|
const ratings = [5.0, 4.8, 4.5, 4.2, 4.0];
|
|
ratings.forEach((rating, index) => {
|
|
leaderboardsRepository.addDriver({
|
|
id: `driver-${index}`,
|
|
name: `Driver ${index}`,
|
|
rating,
|
|
raceCount: 10 + index,
|
|
});
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Driver rankings should be correct
|
|
expect(result.drivers[0].rank).toBe(1);
|
|
expect(result.drivers[0].rating).toBe(5.0);
|
|
expect(result.drivers[1].rank).toBe(2);
|
|
expect(result.drivers[1].rating).toBe(4.8);
|
|
expect(result.drivers[2].rank).toBe(3);
|
|
expect(result.drivers[2].rating).toBe(4.5);
|
|
expect(result.drivers[3].rank).toBe(4);
|
|
expect(result.drivers[3].rating).toBe(4.2);
|
|
expect(result.drivers[4].rank).toBe(5);
|
|
expect(result.drivers[4].rating).toBe(4.0);
|
|
});
|
|
|
|
it('should correctly calculate team rankings based on rating', async () => {
|
|
// Scenario: Team ranking calculation
|
|
// Given: Teams exist with ratings: 4.9, 4.7, 4.6, 4.3, 4.1
|
|
const ratings = [4.9, 4.7, 4.6, 4.3, 4.1];
|
|
ratings.forEach((rating, index) => {
|
|
leaderboardsRepository.addTeam({
|
|
id: `team-${index}`,
|
|
name: `Team ${index}`,
|
|
rating,
|
|
memberCount: 2 + index,
|
|
raceCount: 20 + index,
|
|
});
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Team rankings should be correct
|
|
expect(result.teams[0].rank).toBe(1);
|
|
expect(result.teams[0].rating).toBe(4.9);
|
|
expect(result.teams[1].rank).toBe(2);
|
|
expect(result.teams[1].rating).toBe(4.7);
|
|
expect(result.teams[2].rank).toBe(3);
|
|
expect(result.teams[2].rating).toBe(4.6);
|
|
expect(result.teams[3].rank).toBe(4);
|
|
expect(result.teams[3].rating).toBe(4.3);
|
|
expect(result.teams[4].rank).toBe(5);
|
|
expect(result.teams[4].rating).toBe(4.1);
|
|
});
|
|
|
|
it('should correctly format driver entries with team affiliation', async () => {
|
|
// Scenario: Driver entry formatting
|
|
// Given: A driver exists with team affiliation
|
|
leaderboardsRepository.addDriver({
|
|
id: 'driver-1',
|
|
name: 'John Smith',
|
|
rating: 5.0,
|
|
teamId: 'team-1',
|
|
teamName: 'Racing Team A',
|
|
raceCount: 50,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Driver entry should include all required fields
|
|
const driver = result.drivers[0];
|
|
expect(driver.rank).toBe(1);
|
|
expect(driver.id).toBe('driver-1');
|
|
expect(driver.name).toBe('John Smith');
|
|
expect(driver.rating).toBe(5.0);
|
|
expect(driver.teamId).toBe('team-1');
|
|
expect(driver.teamName).toBe('Racing Team A');
|
|
expect(driver.raceCount).toBe(50);
|
|
});
|
|
|
|
it('should correctly format team entries with member count', async () => {
|
|
// Scenario: Team entry formatting
|
|
// Given: A team exists with members
|
|
leaderboardsRepository.addTeam({
|
|
id: 'team-1',
|
|
name: 'Racing Team A',
|
|
rating: 4.9,
|
|
memberCount: 5,
|
|
raceCount: 100,
|
|
});
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Team entry should include all required fields
|
|
const team = result.teams[0];
|
|
expect(team.rank).toBe(1);
|
|
expect(team.id).toBe('team-1');
|
|
expect(team.name).toBe('Racing Team A');
|
|
expect(team.rating).toBe(4.9);
|
|
expect(team.memberCount).toBe(5);
|
|
expect(team.raceCount).toBe(100);
|
|
});
|
|
|
|
it('should limit results to top 10 drivers and teams', async () => {
|
|
// Scenario: Result limiting
|
|
// Given: More than 10 drivers exist
|
|
for (let i = 1; i <= 15; i++) {
|
|
leaderboardsRepository.addDriver({
|
|
id: `driver-${i}`,
|
|
name: `Driver ${i}`,
|
|
rating: 5.0 - i * 0.1,
|
|
raceCount: 10 + i,
|
|
});
|
|
}
|
|
|
|
// And: More than 10 teams exist
|
|
for (let i = 1; i <= 15; i++) {
|
|
leaderboardsRepository.addTeam({
|
|
id: `team-${i}`,
|
|
name: `Team ${i}`,
|
|
rating: 5.0 - i * 0.1,
|
|
memberCount: 2 + i,
|
|
raceCount: 20 + i,
|
|
});
|
|
}
|
|
|
|
// When: GetGlobalLeaderboardsUseCase.execute() is called
|
|
const result = await getGlobalLeaderboardsUseCase.execute();
|
|
|
|
// Then: Only top 10 drivers should be returned
|
|
expect(result.drivers).toHaveLength(10);
|
|
|
|
// And: Only top 10 teams should be returned
|
|
expect(result.teams).toHaveLength(10);
|
|
|
|
// And: Results should be sorted by rating (highest first)
|
|
expect(result.drivers[0].rating).toBe(4.9); // Driver 1
|
|
expect(result.drivers[9].rating).toBe(4.0); // Driver 10
|
|
expect(result.teams[0].rating).toBe(4.9); // Team 1
|
|
expect(result.teams[9].rating).toBe(4.0); // Team 10
|
|
});
|
|
});
|
|
});
|