refactor

core/racing/application/use-cases/CloseRaceEventStewardingUseCase.test.ts

@@ -0,0 +1,94 @@
+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);
+  });
+});