mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor use cases

Browse Source
This commit is contained in:
Marc Mintel
2026-01-08 15:34:51 +01:00
parent d984ab24a8
commit 52e9a2f6a7
362 changed files with 5192 additions and 8409 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
core/payments/application/use-cases/UpdatePaymentStatusUseCase.test.ts
View File

@@ -1,19 +1,13 @@
import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
import { describe, it, expect, vi, type Mock } from 'vitest';
import { UpdatePaymentStatusUseCase, type UpdatePaymentStatusInput } from './UpdatePaymentStatusUseCase';
import type { IPaymentRepository } from '../../domain/repositories/IPaymentRepository';
import { PaymentStatus, PaymentType, PayerType, type Payment } from '../../domain/entities/Payment';
import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
import { PaymentStatus, PaymentType, PayerType } from '../../domain/entities/Payment';
describe('UpdatePaymentStatusUseCase', () => {
let paymentRepository: {
findById: Mock;
update: Mock;
};
let output: {
present: Mock;
};
let useCase: UpdatePaymentStatusUseCase;
beforeEach(() => {
@@ -22,133 +16,63 @@ describe('UpdatePaymentStatusUseCase', () => {
update: vi.fn(),
};
output = {
present: vi.fn(),
};
useCase = new UpdatePaymentStatusUseCase(
paymentRepository as unknown as IPaymentRepository,
output as unknown as UseCaseOutputPort<unknown>,
);
});
it('returns PAYMENT_NOT_FOUND when payment does not exist', async () => {
it('updates payment status and returns result', async () => {
const input: UpdatePaymentStatusInput = {
paymentId: 'payment-1',
status: PaymentStatus.COMPLETED,
};
const existingPayment = {
id: 'payment-1',
type: PaymentType.SPONSORSHIP,
amount: 100,
platformFee: 5,
netAmount: 95,
payerId: 'payer-1',
payerType: PayerType.SPONSOR,
leagueId: 'league-1',
status: PaymentStatus.PENDING,
createdAt: new Date(),
};
const updatedPayment = {
...existingPayment,
status: PaymentStatus.COMPLETED,
completedAt: new Date(),
};
paymentRepository.findById.mockResolvedValue(existingPayment);
paymentRepository.update.mockResolvedValue(updatedPayment);
const result = await useCase.execute(input);
expect(result.isOk()).toBe(true);
expect(paymentRepository.findById).toHaveBeenCalledWith('payment-1');
expect(paymentRepository.update).toHaveBeenCalled();
if (result.isOk()) {
expect(result.value.payment).toEqual(updatedPayment);
}
});
it('returns error when payment not found', async () => {
const input: UpdatePaymentStatusInput = {
paymentId: 'non-existent',
status: PaymentStatus.COMPLETED,
};
paymentRepository.findById.mockResolvedValue(null);
const result = await useCase.execute(input);
expect(result.isErr()).toBe(true);
expect(result.unwrapErr().code).toBe('PAYMENT_NOT_FOUND');
expect(paymentRepository.update).not.toHaveBeenCalled();
expect(output.present).not.toHaveBeenCalled();
});
it('sets completedAt when status becomes COMPLETED', async () => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2025-01-01T00:00:00.000Z'));
try {
const input: UpdatePaymentStatusInput = {
paymentId: 'payment-1',
status: PaymentStatus.COMPLETED,
};
const existingPayment: Payment = {
id: 'payment-1',
type: PaymentType.SPONSORSHIP,
amount: 100,
platformFee: 5,
netAmount: 95,
payerId: 'payer-1',
payerType: PayerType.SPONSOR,
leagueId: 'league-1',
status: PaymentStatus.PENDING,
createdAt: new Date('2024-12-31T00:00:00.000Z'),
};
paymentRepository.findById.mockResolvedValue(existingPayment);
paymentRepository.update.mockImplementation(async (p: Payment) => ({ ...p }));
const result = await useCase.execute(input);
expect(result.isOk()).toBe(true);
expect(paymentRepository.update).toHaveBeenCalledWith(
expect.objectContaining({
id: 'payment-1',
status: PaymentStatus.COMPLETED,
completedAt: new Date('2025-01-01T00:00:00.000Z'),
}),
);
const savedPayment = paymentRepository.update.mock.results[0]?.value;
await expect(savedPayment).resolves.toEqual(
expect.objectContaining({
id: 'payment-1',
status: PaymentStatus.COMPLETED,
completedAt: new Date('2025-01-01T00:00:00.000Z'),
}),
);
const presentedPayment = (output.present.mock.calls[0]?.[0] as { payment: Payment }).payment;
expect(presentedPayment.status).toBe(PaymentStatus.COMPLETED);
expect(presentedPayment.completedAt).toEqual(new Date('2025-01-01T00:00:00.000Z'));
} finally {
vi.useRealTimers();
}
});
it('preserves completedAt when status is not COMPLETED', async () => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
try {
const input: UpdatePaymentStatusInput = {
paymentId: 'payment-1',
status: PaymentStatus.FAILED,
};
const existingCompletedAt = new Date('2025-01-01T00:00:00.000Z');
const existingPayment: Payment = {
id: 'payment-1',
type: PaymentType.SPONSORSHIP,
amount: 100,
platformFee: 5,
netAmount: 95,
payerId: 'payer-1',
payerType: PayerType.SPONSOR,
leagueId: 'league-1',
status: PaymentStatus.COMPLETED,
createdAt: new Date('2024-12-31T00:00:00.000Z'),
completedAt: existingCompletedAt,
};
paymentRepository.findById.mockResolvedValue(existingPayment);
paymentRepository.update.mockImplementation(async (p: Payment) => ({ ...p }));
const result = await useCase.execute(input);
expect(result.isOk()).toBe(true);
expect(paymentRepository.update).toHaveBeenCalledWith(
expect.objectContaining({
id: 'payment-1',
status: PaymentStatus.FAILED,
completedAt: existingCompletedAt,
}),
);
const presentedPayment = (output.present.mock.calls[0]?.[0] as { payment: Payment }).payment;
expect(presentedPayment.status).toBe(PaymentStatus.FAILED);
expect(presentedPayment.completedAt).toEqual(existingCompletedAt);
} finally {
vi.useRealTimers();
if (result.isErr()) {
expect(result.error.code).toBe('PAYMENT_NOT_FOUND');
}
});
});