refactor racing use cases

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { CloseRaceEventStewardingUseCase } from './CloseRaceEventStewardingUseCase';
+import { CloseRaceEventStewardingUseCase, type CloseRaceEventStewardingResult } from './CloseRaceEventStewardingUseCase';
 import type { IRaceEventRepository } from '../../domain/repositories/IRaceEventRepository';
 import type { IRaceRegistrationRepository } from '../../domain/repositories/IRaceRegistrationRepository';
 import type { IPenaltyRepository } from '../../domain/repositories/IPenaltyRepository';
@@ -8,6 +8,7 @@ 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 type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
 
 describe('CloseRaceEventStewardingUseCase', () => {
   let useCase: CloseRaceEventStewardingUseCase;
@@ -27,6 +28,7 @@ describe('CloseRaceEventStewardingUseCase', () => {
   let logger: {
     error: Mock;
   };
+  let output: UseCaseOutputPort<CloseRaceEventStewardingResult> & { present: Mock };
 
   beforeEach(() => {
     raceEventRepository = {
@@ -45,12 +47,14 @@ describe('CloseRaceEventStewardingUseCase', () => {
     logger = {
       error: vi.fn(),
     };
+    output = { present: vi.fn() } as unknown as UseCaseOutputPort<CloseRaceEventStewardingResult> & { present: Mock };
     useCase = new CloseRaceEventStewardingUseCase(
       logger as unknown as Logger,
       raceEventRepository as unknown as IRaceEventRepository,
       raceRegistrationRepository as unknown as IRaceRegistrationRepository,
       penaltyRepository as unknown as IPenaltyRepository,
       domainEventPublisher as unknown as DomainEventPublisher,
+      output,
     );
   });
 
@@ -80,32 +84,41 @@ describe('CloseRaceEventStewardingUseCase', () => {
     penaltyRepository.findByRaceId.mockResolvedValue([]);
     domainEventPublisher.publish.mockResolvedValue(undefined);
 
-    const result = await useCase.execute({});
+    const result = await useCase.execute({ raceId: 'event-1', closedById: 'admin-1' });
 
     expect(result.isOk()).toBe(true);
+    expect(result.unwrap()).toBeUndefined();
     expect(raceEventRepository.findAwaitingStewardingClose).toHaveBeenCalled();
     expect(raceEventRepository.update).toHaveBeenCalledWith(
       expect.objectContaining({ id: 'event-1', status: 'closed' })
     );
     expect(domainEventPublisher.publish).toHaveBeenCalled();
+    expect(output.present).toHaveBeenCalledTimes(1);
+    expect(output.present).toHaveBeenCalledWith({
+      race: expect.objectContaining({ id: 'event-1', status: 'closed' })
+    });
   });
 
   it('should handle no expired events', async () => {
     raceEventRepository.findAwaitingStewardingClose.mockResolvedValue([]);
 
-    const result = await useCase.execute({});
+    const result = await useCase.execute({ raceId: 'event-1', closedById: 'admin-1' });
 
     expect(result.isOk()).toBe(true);
+    expect(result.unwrap()).toBeUndefined();
     expect(raceEventRepository.update).not.toHaveBeenCalled();
     expect(domainEventPublisher.publish).not.toHaveBeenCalled();
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('should return error when repository throws', async () => {
     raceEventRepository.findAwaitingStewardingClose.mockRejectedValue(new Error('DB error'));
 
-    const result = await useCase.execute({});
+    const result = await useCase.execute({ raceId: 'event-1', closedById: 'admin-1' });
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr().code).toBe('FAILED_TO_CLOSE_STEWARDING');
+    expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
+    expect(result.unwrapErr().details?.message).toContain('DB error');
+    expect(output.present).not.toHaveBeenCalled();
   });
 });