TDD Spring Boot — CultivaPay API

@ExtendWith(MockitoExtension.class)
class PaymentServiceTest {

    @Mock MerchantRepository merchantRepository;
    @Mock TransactionRepository transactionRepository;
    @Mock RedisEventPublisher   eventPublisher;
    @InjectMocks PaymentService service;

    @Test
    void processPayment_whenValidRequest_createsTransactionPending() {
        // Arrange
        var merchant = new Merchant("mer_123", "CULTIVA Store", MerchantStatus.ACTIVE);
        var req      = new PaymentRequest("mer_123", 4999L, "EUR", "Suscripción CULTIVA IA");
        when(merchantRepository.findById("mer_123")).thenReturn(Optional.of(merchant));
        when(transactionRepository.save(any())).thenAnswer(inv -> {
            Transaction t = inv.getArgument(0);
            t.setId("txn_abc789");
            return t;
        });

        // Act
        PaymentResult result = service.processPayment(req);

        // Assert
        assertThat(result.transactionId()).isEqualTo("txn_abc789");
        assertThat(result.status()).isEqualTo(TransactionStatus.PENDING);
        verify(transactionRepository).save(argThat(t ->
            t.getAmount() == 4999L && t.getStatus() == TransactionStatus.PENDING
        ));
        verify(eventPublisher).publish("payment.created", any());
    }

    @Test
    void processPayment_whenMerchantNotFound_throwsMerchantNotFoundException() {
        when(merchantRepository.findById(any())).thenReturn(Optional.empty());
        assertThatThrownBy(() -> service.processPayment(
            new PaymentRequest("mer_unknown", 100L, "EUR", "Test")
        )).isInstanceOf(MerchantNotFoundException.class);
    }

    @ParameterizedTest
    @ValueSource(longs = {0L, -1L, 100_001L})
    void processPayment_whenAmountInvalid_throwsInvalidAmountException(long amount) {
        when(merchantRepository.findById(any())).thenReturn(Optional.of(activeMerchant()));
        assertThatThrownBy(() -> service.processPayment(
            new PaymentRequest("mer_123", amount, "EUR", "Test")
        )).isInstanceOf(InvalidAmountException.class);
    }
}

@Service
@Transactional
public class PaymentService {

    private static final long MIN_AMOUNT = 1L;
    private static final long MAX_AMOUNT = 100_000L;

    private final MerchantRepository    merchantRepository;
    private final TransactionRepository  transactionRepository;
    private final RedisEventPublisher    eventPublisher;

    public PaymentResult processPayment(PaymentRequest req) {
        // Guard: montante válido
        if (req.amount() < MIN_AMOUNT || req.amount() > MAX_AMOUNT) {
            throw new InvalidAmountException(req.amount());
        }
        // Guard: comerciante activo
        Merchant merchant = merchantRepository
            .findById(req.merchantId())
            .orElseThrow(() -> new MerchantNotFoundException(req.merchantId()));
        if (merchant.status() != MerchantStatus.ACTIVE) {
            throw new InactiveMerchantException(req.merchantId());
        }
        // Persistir transacción PENDING
        Transaction txn = transactionRepository.save(
            Transaction.builder()
                .merchantId(req.merchantId())
                .amount(req.amount())
                .currency(req.currency())
                .description(req.description())
                .status(TransactionStatus.PENDING)
                .createdAt(Instant.now())
                .build()
        );
        // Publicar evento Redis
        eventPublisher.publish("payment.created", new PaymentCreatedEvent(txn));
        return new PaymentResult(txn.getId(), TransactionStatus.PENDING);
    }
}