refactor racing use cases

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

@@ -1,10 +1,17 @@
 import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
-import { GetPendingSponsorshipRequestsUseCase } from './GetPendingSponsorshipRequestsUseCase';
+import {
+  GetPendingSponsorshipRequestsUseCase,
+  type GetPendingSponsorshipRequestsResult,
+  type GetPendingSponsorshipRequestsInput,
+  type GetPendingSponsorshipRequestsErrorCode,
+} from './GetPendingSponsorshipRequestsUseCase';
 import { ISponsorshipRequestRepository } from '../../domain/repositories/ISponsorshipRequestRepository';
 import { ISponsorRepository } from '../../domain/repositories/ISponsorRepository';
 import { SponsorshipRequest } from '../../domain/entities/SponsorshipRequest';
 import { Sponsor } from '../../domain/entities/Sponsor';
 import { Money } from '../../domain/value-objects/Money';
+import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 describe('GetPendingSponsorshipRequestsUseCase', () => {
   let useCase: GetPendingSponsorshipRequestsUseCase;
@@ -14,6 +21,9 @@ describe('GetPendingSponsorshipRequestsUseCase', () => {
   let sponsorRepo: {
     findById: Mock;
   };
+  let output: UseCaseOutputPort<GetPendingSponsorshipRequestsResult> & {
+    present: Mock;
+  };
 
   beforeEach(() => {
     sponsorshipRequestRepo = {
@@ -22,14 +32,21 @@ describe('GetPendingSponsorshipRequestsUseCase', () => {
     sponsorRepo = {
       findById: vi.fn(),
     };
+    output = {
+      present: vi.fn(),
+    } as unknown as typeof output;
     useCase = new GetPendingSponsorshipRequestsUseCase(
       sponsorshipRequestRepo as unknown as ISponsorshipRequestRepository,
       sponsorRepo as unknown as ISponsorRepository,
+      output,
     );
   });
 
-  it('should return pending sponsorship requests', async () => {
-    const dto = { entityType: 'season' as const, entityId: 'entity-1' };
+  it('should present pending sponsorship requests', async () => {
+    const input: GetPendingSponsorshipRequestsInput = {
+      entityType: 'season',
+      entityId: 'entity-1',
+    };
     const request = SponsorshipRequest.create({
       id: 'req-1',
       sponsorId: 'sponsor-1',
@@ -49,42 +66,41 @@ describe('GetPendingSponsorshipRequestsUseCase', () => {
     sponsorshipRequestRepo.findPendingByEntity.mockResolvedValue([request]);
     sponsorRepo.findById.mockResolvedValue(sponsor);
 
-    const result = await useCase.execute(dto);
+    const result = await useCase.execute(input);
 
     expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({
-      entityType: 'season',
-      entityId: 'entity-1',
-      requests: [
-        {
-          id: 'req-1',
-          sponsorId: 'sponsor-1',
-          sponsorName: 'Test Sponsor',
-          sponsorLogo: 'logo.png',
-          tier: 'main',
-          offeredAmount: 10000,
-          currency: 'USD',
-          formattedAmount: '$100.00',
-          message: 'Test message',
-          createdAt: expect.any(Date),
-          platformFee: 1000,
-          netAmount: 9000,
-        },
-      ],
-      totalCount: 1,
-    });
+    expect(result.unwrap()).toBeUndefined();
+
+    expect(output.present).toHaveBeenCalledTimes(1);
+    const presented = (output.present as Mock).mock.calls[0][0] as GetPendingSponsorshipRequestsResult;
+
+    expect(presented.entityType).toBe('season');
+    expect(presented.entityId).toBe('entity-1');
+    expect(presented.totalCount).toBe(1);
+    expect(presented.requests).toHaveLength(1);
+    const summary = presented.requests[0];
+    expect(summary.sponsor?.name).toBe('Test Sponsor');
+    expect(summary.financials.offeredAmount.amount).toBe(10000);
+    expect(summary.financials.offeredAmount.currency).toBe('USD');
   });
 
   it('should return error when repository fails', async () => {
-    const dto = { entityType: 'season' as const, entityId: 'entity-1' };
-    sponsorshipRequestRepo.findPendingByEntity.mockRejectedValue(new Error('DB error'));
+    const input: GetPendingSponsorshipRequestsInput = {
+      entityType: 'season',
+      entityId: 'entity-1',
+    };
+    const error = new Error('DB error');
+    sponsorshipRequestRepo.findPendingByEntity.mockRejectedValue(error);
 
-    const result = await useCase.execute(dto);
+    const result = await useCase.execute(input);
 
     expect(result.isErr()).toBe(true);
-    expect(result.unwrapErr()).toEqual({
-      code: 'REPOSITORY_ERROR',
-      message: 'Failed to fetch pending sponsorship requests',
-    });
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      GetPendingSponsorshipRequestsErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(err.details.message).toBe('DB error');
+    expect(output.present).not.toHaveBeenCalled();
   });
-});
+});