94 lines
3.1 KiB
TypeScript
94 lines
3.1 KiB
TypeScript
import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
|
|
import { CloseRaceEventStewardingUseCase } from './CloseRaceEventStewardingUseCase';
|
|
import type { IRaceEventRepository } from '../../domain/repositories/IRaceEventRepository';
|
|
import type { IDomainEventPublisher } from '@core/shared/domain/IDomainEvent';
|
|
import type { Logger } from '@core/shared/application';
|
|
import { RaceEvent } from '../../domain/entities/RaceEvent';
|
|
import { Session } from '../../domain/entities/Session';
|
|
import { SessionType } from '../../domain/value-objects/SessionType';
|
|
import { RacingDomainValidationError } from '../../domain/errors/RacingDomainError';
|
|
|
|
describe('CloseRaceEventStewardingUseCase', () => {
|
|
let useCase: CloseRaceEventStewardingUseCase;
|
|
let raceEventRepository: {
|
|
findAwaitingStewardingClose: Mock;
|
|
update: Mock;
|
|
};
|
|
let domainEventPublisher: {
|
|
publish: Mock;
|
|
};
|
|
let logger: {
|
|
error: Mock;
|
|
};
|
|
|
|
beforeEach(() => {
|
|
raceEventRepository = {
|
|
findAwaitingStewardingClose: vi.fn(),
|
|
update: vi.fn(),
|
|
};
|
|
domainEventPublisher = {
|
|
publish: vi.fn(),
|
|
};
|
|
logger = {
|
|
error: vi.fn(),
|
|
};
|
|
useCase = new CloseRaceEventStewardingUseCase(
|
|
logger as unknown as Logger,
|
|
raceEventRepository as unknown as IRaceEventRepository,
|
|
domainEventPublisher as unknown as IDomainEventPublisher,
|
|
);
|
|
});
|
|
|
|
it('should close stewarding for expired events successfully', async () => {
|
|
const raceEvent = RaceEvent.create({
|
|
id: 'event-1',
|
|
seasonId: 'season-1',
|
|
leagueId: 'league-1',
|
|
name: 'Test Event',
|
|
sessions: [
|
|
Session.create({
|
|
id: 'session-1',
|
|
raceEventId: 'event-1',
|
|
sessionType: SessionType.main(),
|
|
scheduledAt: new Date(),
|
|
track: 'Test Track',
|
|
car: 'Test Car',
|
|
status: 'completed',
|
|
}),
|
|
],
|
|
status: 'awaiting_stewarding',
|
|
stewardingClosesAt: new Date(Date.now() - 1000), // expired
|
|
});
|
|
|
|
raceEventRepository.findAwaitingStewardingClose.mockResolvedValue([raceEvent]);
|
|
domainEventPublisher.publish.mockResolvedValue(undefined);
|
|
|
|
const result = await useCase.execute({});
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(raceEventRepository.findAwaitingStewardingClose).toHaveBeenCalled();
|
|
expect(raceEventRepository.update).toHaveBeenCalledWith(
|
|
expect.objectContaining({ id: 'event-1', status: 'closed' })
|
|
);
|
|
expect(domainEventPublisher.publish).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should handle no expired events', async () => {
|
|
raceEventRepository.findAwaitingStewardingClose.mockResolvedValue([]);
|
|
|
|
const result = await useCase.execute({});
|
|
|
|
expect(result.isOk()).toBe(true);
|
|
expect(raceEventRepository.update).not.toHaveBeenCalled();
|
|
expect(domainEventPublisher.publish).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should return error when repository throws', async () => {
|
|
raceEventRepository.findAwaitingStewardingClose.mockRejectedValue(new Error('DB error'));
|
|
|
|
const result = await useCase.execute({});
|
|
|
|
expect(result.isErr()).toBe(true);
|
|
expect(result.unwrapErr()).toBeInstanceOf(RacingDomainValidationError);
|
|
});
|
|
}); |