add tests to core

core/payments/application/use-cases/UpdateMemberPaymentUseCase.test.ts

@@ -0,0 +1,170 @@
+import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
+import { UpdateMemberPaymentUseCase, type UpdateMemberPaymentInput } from './UpdateMemberPaymentUseCase';
+import type { IMembershipFeeRepository, IMemberPaymentRepository } from '../../domain/repositories/IMembershipFeeRepository';
+import { MemberPaymentStatus, type MemberPayment } from '../../domain/entities/MemberPayment';
+import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
+
+describe('UpdateMemberPaymentUseCase', () => {
+  let membershipFeeRepository: {
+    findById: Mock;
+  };
+
+  let memberPaymentRepository: {
+    findByFeeIdAndDriverId: Mock;
+    create: Mock;
+    update: Mock;
+  };
+
+  let output: {
+    present: Mock;
+  };
+
+  let useCase: UpdateMemberPaymentUseCase;
+
+  beforeEach(() => {
+    membershipFeeRepository = {
+      findById: vi.fn(),
+    };
+
+    memberPaymentRepository = {
+      findByFeeIdAndDriverId: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+    };
+
+    output = {
+      present: vi.fn(),
+    };
+
+    useCase = new UpdateMemberPaymentUseCase(
+      membershipFeeRepository as unknown as IMembershipFeeRepository,
+      memberPaymentRepository as unknown as IMemberPaymentRepository,
+      output as unknown as UseCaseOutputPort<unknown>,
+    );
+  });
+
+  it('returns MEMBERSHIP_FEE_NOT_FOUND when fee does not exist', async () => {
+    const input: UpdateMemberPaymentInput = {
+      feeId: 'fee-1',
+      driverId: 'driver-1',
+    };
+
+    membershipFeeRepository.findById.mockResolvedValue(null);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('MEMBERSHIP_FEE_NOT_FOUND');
+    expect(memberPaymentRepository.findByFeeIdAndDriverId).not.toHaveBeenCalled();
+    expect(memberPaymentRepository.create).not.toHaveBeenCalled();
+    expect(memberPaymentRepository.update).not.toHaveBeenCalled();
+    expect(output.present).not.toHaveBeenCalled();
+  });
+
+  it('creates a new payment when missing, applies status and paidAt when PAID', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T00:00:00.000Z'));
+    vi.spyOn(Math, 'random').mockReturnValue(0.123456789);
+
+    try {
+      const input: UpdateMemberPaymentInput = {
+        feeId: 'fee-1',
+        driverId: 'driver-1',
+        status: MemberPaymentStatus.PAID,
+      };
+
+      const fee = {
+        id: 'fee-1',
+        leagueId: 'league-1',
+        type: 'season',
+        amount: 100,
+        enabled: true,
+        createdAt: new Date('2024-01-01T00:00:00.000Z'),
+        updatedAt: new Date('2024-01-02T00:00:00.000Z'),
+      };
+
+      membershipFeeRepository.findById.mockResolvedValue(fee);
+      memberPaymentRepository.findByFeeIdAndDriverId.mockResolvedValue(null);
+      memberPaymentRepository.create.mockImplementation(async (p: MemberPayment) => ({ ...p }));
+      memberPaymentRepository.update.mockImplementation(async (p: MemberPayment) => p);
+
+      const result = await useCase.execute(input);
+
+      expect(result.isOk()).toBe(true);
+
+      expect(memberPaymentRepository.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: expect.stringMatching(/^mp-1735689600000-[a-z0-9]{9}$/),
+          feeId: 'fee-1',
+          driverId: 'driver-1',
+          amount: 100,
+          platformFee: 10,
+          netAmount: 90,
+          status: MemberPaymentStatus.PENDING,
+          dueDate: new Date('2025-01-01T00:00:00.000Z'),
+        }),
+      );
+
+      expect(memberPaymentRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: MemberPaymentStatus.PAID,
+          paidAt: new Date('2025-01-01T00:00:00.000Z'),
+        }),
+      );
+
+      const updated = memberPaymentRepository.update.mock.calls[0]?.[0] as MemberPayment;
+      expect(output.present).toHaveBeenCalledWith({ payment: updated });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('updates existing payment status and parses paidAt string', async () => {
+    const input: UpdateMemberPaymentInput = {
+      feeId: 'fee-1',
+      driverId: 'driver-1',
+      status: MemberPaymentStatus.PAID,
+      paidAt: '2025-02-01T00:00:00.000Z',
+    };
+
+    const fee = {
+      id: 'fee-1',
+      leagueId: 'league-1',
+      type: 'season',
+      amount: 100,
+      enabled: true,
+      createdAt: new Date('2024-01-01T00:00:00.000Z'),
+      updatedAt: new Date('2024-01-02T00:00:00.000Z'),
+    };
+
+    const existingPayment: MemberPayment = {
+      id: 'mp-1',
+      feeId: 'fee-1',
+      driverId: 'driver-1',
+      amount: 100,
+      platformFee: 10,
+      netAmount: 90,
+      status: MemberPaymentStatus.PENDING,
+      dueDate: new Date('2025-01-01T00:00:00.000Z'),
+    };
+
+    membershipFeeRepository.findById.mockResolvedValue(fee);
+    memberPaymentRepository.findByFeeIdAndDriverId.mockResolvedValue(existingPayment);
+    memberPaymentRepository.update.mockImplementation(async (p: MemberPayment) => p);
+
+    const result = await useCase.execute(input);
+
+    expect(result.isOk()).toBe(true);
+
+    expect(memberPaymentRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: 'mp-1',
+        status: MemberPaymentStatus.PAID,
+        paidAt: new Date('2025-02-01T00:00:00.000Z'),
+      }),
+    );
+
+    const updated = memberPaymentRepository.update.mock.calls[0]?.[0] as MemberPayment;
+    expect(output.present).toHaveBeenCalledWith({ payment: updated });
+  });
+});