website refactor

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

@@ -1,13 +1,9 @@
-import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { CloseRaceEventStewardingUseCase, type CloseRaceEventStewardingResult } from './CloseRaceEventStewardingUseCase';
-import type { RaceEventRepository } from '../../domain/repositories/RaceEventRepository';
-import type { RaceRegistrationRepository } from '../../domain/repositories/RaceRegistrationRepository';
-import type { PenaltyRepository } from '../../domain/repositories/PenaltyRepository';
-import type { DomainEventPublisher } from '@core/shared/domain/DomainEvent';
-import type { Logger } from '@core/shared/application';
+import { beforeEach, describe, expect, it, Mock, vi } from 'vitest';
 import { RaceEvent } from '../../domain/entities/RaceEvent';
 import { Session } from '../../domain/entities/Session';
 import { SessionType } from '../../domain/value-objects/SessionType';
+import { CloseRaceEventStewardingUseCase } from './CloseRaceEventStewardingUseCase';
+
 describe('CloseRaceEventStewardingUseCase', () => {
   let useCase: CloseRaceEventStewardingUseCase;
   let raceEventRepository: {
@@ -27,6 +23,7 @@ describe('CloseRaceEventStewardingUseCase', () => {
   let logger: {
     error: Mock;
   };
+
   beforeEach(() => {
     raceEventRepository = {
       findAwaitingStewardingClose: vi.fn(),
@@ -45,11 +42,11 @@ describe('CloseRaceEventStewardingUseCase', () => {
     logger = {
       error: vi.fn(),
     };
-    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);
+    useCase = new CloseRaceEventStewardingUseCase(logger as any,
+      raceEventRepository as any,
+      raceRegistrationRepository as any,
+      penaltyRepository as any,
+      domainEventPublisher as any);
   });
 
   it('should close stewarding for expired events successfully', async () => {
@@ -82,33 +79,27 @@ describe('CloseRaceEventStewardingUseCase', () => {
     const result = await useCase.execute({ raceId: 'event-1', closedById: 'admin-1' });
 
     expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBeUndefined();
+    const presented = result.unwrap();
     expect(raceEventRepository.findAwaitingStewardingClose).toHaveBeenCalled();
     expect(raceEventRepository.update).toHaveBeenCalledWith(
       expect.objectContaining({ status: 'closed' })
     );
     expect(domainEventPublisher.publish).toHaveBeenCalled();
-    const presentedRace = (status?: unknown;
-    };
-    const presentedId =
-      presentedRace?.id && typeof presentedRace.id === 'object' && typeof presentedRace.id.toString === 'function'
-        ? presentedRace.id.toString()
-        : presentedRace?.id;
 
-    expect(presentedId).toBe('event-1');
-    expect(presentedRace?.status).toBe('closed');
+    expect(presented.race.id).toBe('event-1');
+    expect(presented.race.status).toBe('closed');
   });
 
-  it('should handle no expired events', async () => {
+  it('should return error when no expired events', async () => {
     raceEventRepository.findAwaitingStewardingClose.mockResolvedValue([]);
 
     const result = await useCase.execute({ raceId: 'event-1', closedById: 'admin-1' });
 
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBeUndefined();
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('RACE_NOT_FOUND');
     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'));
@@ -121,5 +112,5 @@ describe('CloseRaceEventStewardingUseCase', () => {
     if ('details' in err && err.details && typeof err.details === 'object' && 'message' in err.details) {
       expect(err.details.message).toContain('DB error');
     }
-    });
-});
+  });
+});