224 lines
8.3 KiB
TypeScript
224 lines
8.3 KiB
TypeScript
import { Race, type RaceStatusValue } from '@core/racing/domain/entities/Race';
|
|
import type { Logger } from '@core/shared/domain/Logger';
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import { InMemoryRaceRepository } from './InMemoryRaceRepository';
|
|
|
|
describe('InMemoryRaceRepository', () => {
|
|
let repository: InMemoryRaceRepository;
|
|
let mockLogger: Logger;
|
|
|
|
beforeEach(() => {
|
|
mockLogger = {
|
|
debug: vi.fn(),
|
|
info: vi.fn(),
|
|
warn: vi.fn(),
|
|
error: vi.fn(),
|
|
};
|
|
repository = new InMemoryRaceRepository(mockLogger);
|
|
});
|
|
|
|
const createTestRace = (
|
|
id: string,
|
|
leagueId: string,
|
|
track: string,
|
|
car: string,
|
|
scheduledAt: Date,
|
|
status: RaceStatusValue = 'scheduled',
|
|
) => {
|
|
return Race.create({
|
|
id,
|
|
leagueId,
|
|
scheduledAt,
|
|
track,
|
|
car,
|
|
status,
|
|
});
|
|
};
|
|
|
|
describe('constructor', () => {
|
|
it('should initialize with a logger', () => {
|
|
expect(repository).toBeDefined();
|
|
expect(mockLogger.info).toHaveBeenCalledWith('InMemoryRaceRepository initialized.');
|
|
});
|
|
});
|
|
|
|
describe('findById', () => {
|
|
it('should return null if race not found', async () => {
|
|
const result = await repository.findById('nonexistent');
|
|
expect(result).toBeNull();
|
|
expect(mockLogger.debug).toHaveBeenCalledWith('[InMemoryRaceRepository] Finding race by ID: nonexistent');
|
|
expect(mockLogger.warn).toHaveBeenCalledWith('Race with ID nonexistent not found.');
|
|
});
|
|
|
|
it('should return the race if found', async () => {
|
|
const race = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
await repository.create(race);
|
|
|
|
const result = await repository.findById('1');
|
|
expect(result).toEqual(race);
|
|
expect(mockLogger.info).toHaveBeenCalledWith('Found race by ID: 1.');
|
|
});
|
|
});
|
|
|
|
describe('findAll', () => {
|
|
it('should return all races', async () => {
|
|
const race1 = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
const race2 = createTestRace('2', 'league2', 'Track2', 'Car2', new Date());
|
|
await repository.create(race1);
|
|
await repository.create(race2);
|
|
|
|
const result = await repository.findAll();
|
|
expect(result).toHaveLength(2);
|
|
expect(result).toContain(race1);
|
|
expect(result).toContain(race2);
|
|
});
|
|
});
|
|
|
|
describe('findByLeagueId', () => {
|
|
it('should return races filtered by league ID', async () => {
|
|
const race1 = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
const race2 = createTestRace('2', 'league2', 'Track2', 'Car2', new Date());
|
|
const race3 = createTestRace('3', 'league1', 'Track3', 'Car3', new Date());
|
|
await repository.create(race1);
|
|
await repository.create(race2);
|
|
await repository.create(race3);
|
|
|
|
const result = await repository.findByLeagueId('league1');
|
|
expect(result).toHaveLength(2);
|
|
expect(result).toContain(race1);
|
|
expect(result).toContain(race3);
|
|
});
|
|
});
|
|
|
|
describe('findUpcomingByLeagueId', () => {
|
|
it('should return upcoming races for league ID', async () => {
|
|
const pastDate = new Date(Date.now() - 1000 * 60 * 60); // 1 hour ago
|
|
const futureDate = new Date(Date.now() + 1000 * 60 * 60); // 1 hour from now
|
|
const race1 = createTestRace('1', 'league1', 'Track1', 'Car1', pastDate, 'scheduled');
|
|
const race2 = createTestRace('2', 'league1', 'Track2', 'Car2', futureDate, 'scheduled');
|
|
const race3 = createTestRace('3', 'league1', 'Track3', 'Car3', futureDate, 'completed');
|
|
await repository.create(race1);
|
|
await repository.create(race2);
|
|
await repository.create(race3);
|
|
|
|
const result = await repository.findUpcomingByLeagueId('league1');
|
|
expect(result).toHaveLength(1);
|
|
expect(result).toContain(race2);
|
|
});
|
|
});
|
|
|
|
describe('findCompletedByLeagueId', () => {
|
|
it('should return completed races for league ID', async () => {
|
|
const race1 = createTestRace('1', 'league1', 'Track1', 'Car1', new Date(), 'scheduled');
|
|
const race2 = createTestRace('2', 'league1', 'Track2', 'Car2', new Date(), 'completed');
|
|
const race3 = createTestRace('3', 'league1', 'Track3', 'Car3', new Date(), 'completed');
|
|
await repository.create(race1);
|
|
await repository.create(race2);
|
|
await repository.create(race3);
|
|
|
|
const result = await repository.findCompletedByLeagueId('league1');
|
|
expect(result).toHaveLength(2);
|
|
expect(result).toContain(race2);
|
|
expect(result).toContain(race3);
|
|
});
|
|
});
|
|
|
|
describe('findByStatus', () => {
|
|
it('should return races filtered by status', async () => {
|
|
const race1 = createTestRace('1', 'league1', 'Track1', 'Car1', new Date(), 'scheduled');
|
|
const race2 = createTestRace('2', 'league1', 'Track2', 'Car2', new Date(), 'completed');
|
|
const race3 = createTestRace('3', 'league1', 'Track3', 'Car3', new Date(), 'scheduled');
|
|
await repository.create(race1);
|
|
await repository.create(race2);
|
|
await repository.create(race3);
|
|
|
|
const result = await repository.findByStatus('scheduled');
|
|
expect(result).toHaveLength(2);
|
|
expect(result).toContain(race1);
|
|
expect(result).toContain(race3);
|
|
});
|
|
});
|
|
|
|
describe('findByDateRange', () => {
|
|
it('should return races within date range', async () => {
|
|
const date1 = new Date('2023-01-01');
|
|
const date2 = new Date('2023-01-02');
|
|
const date3 = new Date('2023-01-03');
|
|
const race1 = createTestRace('1', 'league1', 'Track1', 'Car1', date1);
|
|
const race2 = createTestRace('2', 'league1', 'Track2', 'Car2', date2);
|
|
const race3 = createTestRace('3', 'league1', 'Track3', 'Car3', date3);
|
|
await repository.create(race1);
|
|
await repository.create(race2);
|
|
await repository.create(race3);
|
|
|
|
const result = await repository.findByDateRange(date1, date2);
|
|
expect(result).toHaveLength(2);
|
|
expect(result).toContain(race1);
|
|
expect(result).toContain(race2);
|
|
});
|
|
});
|
|
|
|
describe('create', () => {
|
|
it('should create a new race', async () => {
|
|
const race = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
const result = await repository.create(race);
|
|
expect(result).toEqual(race);
|
|
expect(mockLogger.info).toHaveBeenCalledWith('Race 1 created successfully.');
|
|
});
|
|
|
|
it('should throw error if race already exists', async () => {
|
|
const race = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
await repository.create(race);
|
|
await expect(repository.create(race)).rejects.toThrow('Race already exists');
|
|
});
|
|
});
|
|
|
|
describe('update', () => {
|
|
it('should update an existing race', async () => {
|
|
const race = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
await repository.create(race);
|
|
|
|
const updatedRace = race.start().complete();
|
|
const result = await repository.update(updatedRace);
|
|
expect(result).toEqual(updatedRace);
|
|
expect(mockLogger.info).toHaveBeenCalledWith('Race 1 updated successfully.');
|
|
});
|
|
|
|
it('should throw error if race does not exist', async () => {
|
|
const race = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
await expect(repository.update(race)).rejects.toThrow('Race not found');
|
|
});
|
|
});
|
|
|
|
describe('delete', () => {
|
|
it('should delete an existing race', async () => {
|
|
const race = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
await repository.create(race);
|
|
|
|
await repository.delete('1');
|
|
expect(mockLogger.info).toHaveBeenCalledWith('Race 1 deleted successfully.');
|
|
const found = await repository.findById('1');
|
|
expect(found).toBeNull();
|
|
});
|
|
|
|
it('should not throw if race does not exist', async () => {
|
|
await repository.delete('nonexistent');
|
|
expect(mockLogger.warn).toHaveBeenCalledWith('Race with ID nonexistent not found for deletion.');
|
|
});
|
|
});
|
|
|
|
describe('exists', () => {
|
|
it('should return true if race exists', async () => {
|
|
const race = createTestRace('1', 'league1', 'Track1', 'Car1', new Date());
|
|
await repository.create(race);
|
|
|
|
const result = await repository.exists('1');
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('should return false if race does not exist', async () => {
|
|
const result = await repository.exists('nonexistent');
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
}); |