PaymentGateWayInterface.java

package org.codewithtee;

public interface PaymentGateWayInterface {
    public String[] validaAccountNumber = {"101012345678", "101098765432", "101034567890"};
    public String[] validaCardNumbers = {"4439123456789012", "4439987654321098", "4439765432109876"};
    public boolean makeCardPayment(String cardNumber, double amount );
    public boolean validateCard(String cardNumber);
    public boolean validateAccountNumber(String cardNumber);
    public boolean makeBankTransfer(String accountNumber,  double amount);
    public String generateAccountNumber(String username);
    public String generateCardNumber(String username);
}

PaymentService.java

package org.codewithtee;

import java.util.Objects;
import java.util.Random;

public class PaymentService implements PaymentGateWayInterface {
    public enum TransactionType {CREDIT_CARD, BANK_TRANSFER, DIGITAL_WALLET}
    String testUsername = "test";
    public String processPayment(TransactionType transactionType, double amount, String username) {
        boolean response = false;
        switch (transactionType) {
            case CREDIT_CARD:
                response = this.makeCardPayment(generateCardNumber(username), amount);
                break;
            case BANK_TRANSFER:
                response = this.makeBankTransfer(generateAccountNumber(username), amount);
                break;
            case DIGITAL_WALLET:
                response = this.makeWalletPayment(testUsername, amount);
        }
        if (response) {
            return "Success";
        }
        return "Failure";
    }

    public boolean makeWalletPayment(String userName, double amount) {
        if (amount <= 0 || !Objects.equals(userName, "test")) {
            return false;
        }
        return true;
    }

    @Override
    public boolean makeCardPayment(String cardNumber, double amount) {
        return validateCard(cardNumber);
    }

    @Override
    public boolean makeBankTransfer(String accountNumber, double amount) {
        return !(amount <= 0) && validateAccountNumber(accountNumber);
    }

    @Override
    public String generateAccountNumber(String username) {

        if (username.startsWith("test")) {
            return validaAccountNumber[new Random().nextInt(validaAccountNumber.length)];
        }
        return "101189012345";
    }

    @Override
    public String generateCardNumber(String username) {
        if (username.startsWith("test")) {
            return validaCardNumbers[new Random().nextInt(validaCardNumbers.length)];
        }
        return "8888567812345678";
    }

    @Override
    public boolean validateCard(String cardNumber) {
        return cardNumber.startsWith("4439") && cardNumber.length() == 16;
    }

    @Override
    public boolean validateAccountNumber(String accountNumber) {
        return accountNumber.startsWith("1010") && !(accountNumber.length() < 10);
    }

    public static void main(String[] args) {
        PaymentService paymentService = new PaymentService();
        System.out.println(paymentService.processPayment(TransactionType.CREDIT_CARD, 150.00, paymentService.testUsername));
        System.out.println(paymentService.processPayment(TransactionType.BANK_TRANSFER, 200.50, paymentService.testUsername));
        System.out.println(paymentService.processPayment(TransactionType.DIGITAL_WALLET, 75.75, paymentService.testUsername));
    }
}

PaymentServiceTest.java

import org.codewithtee.PaymentService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class PaymentServiceTest {
    private PaymentService paymentService;

    @BeforeEach
    void setUp() {
        paymentService = new PaymentService();
    }

    @Test
    void testMakeCardPayment_ValidCardNumber() {
        String validCard = "4439123456789012";
        double amount = 150.00;

        boolean result = paymentService.makeCardPayment(validCard, amount);

        assertTrue(result, "Valid card payment should return true");
    }

    @Test
    void testMakeCardPayment_InvalidCardNumber() {
        String invalidCard = "1234567812345678";
        double amount = 150.00;

        boolean result = paymentService.makeCardPayment(invalidCard, amount);

        assertFalse(result, "Invalid card payment should return false");
    }

    @Test
    void testValidateCard_ValidCardNumber() {
        String validCard = "4439123456789012";

        assertTrue(paymentService.validateCard(validCard), "Valid card number should return true");
    }

    @Test
    void testValidateCard_InvalidCardNumber() {
        String invalidCard = "1234567812345678";

        assertFalse(paymentService.validateCard(invalidCard), "Invalid card number should return false");
    }

    @Test
    void testMakeBankTransfer_ValidAccountNumber() {
        String validAccount = "101012345678";
        double amount = 200.00;

        boolean result = paymentService.makeBankTransfer(validAccount, amount);

        assertTrue(result, "Valid bank transfer should return true");
    }

    @Test
    void testMakeBankTransfer_InvalidAccountNumber() {
        String invalidAccount = "999912345678";
        double amount = 200.00;

        boolean result = paymentService.makeBankTransfer(invalidAccount, amount);

        assertFalse(result, "Invalid bank transfer should return false");
    }

    @Test
    void testGenerateAccountNumber_ValidUser() {
        String username = "testUser";

        String accountNumber = paymentService.generateAccountNumber(username);

        assertNotNull(accountNumber, "Generated account number should not be null");
        assertTrue(accountNumber.startsWith("1010"), "Generated account number should start with 1010");
    }

    @Test
    void testGenerateCardNumber_ValidUser() {
        String username = "testUser";

        String cardNumber = paymentService.generateCardNumber(username);

        assertNotNull(cardNumber, "Generated card number should not be null");
        assertTrue(cardNumber.startsWith("4439"), "Generated card number should start with 4439");
    }

    @Test
    void testMakeWalletPayment_ValidUser() {
        String username = "test";
        double amount = 100.00;

        boolean result = paymentService.makeWalletPayment(username, amount);

        assertTrue(result, "Valid wallet payment should return true");
    }

    @Test
    void testMakeWalletPayment_InvalidUser() {
        String username = "invalidUser";
        double amount = 100.00;

        boolean result = paymentService.makeWalletPayment(username, amount);

        assertFalse(result, "Invalid wallet payment should return false");
    }

    @Test
    void testProcessPayment_CreditCardSuccess() {
        String username = "test";
        double amount = 150.00;

        String result = paymentService.processPayment(PaymentService.TransactionType.CREDIT_CARD, amount, username);

        assertEquals("Success", result, "Credit card payment should return Success");
    }

    @Test
    void testProcessPayment_BankTransferSuccess() {
        String username = "test";
        double amount = 200.00;

        String result = paymentService.processPayment(PaymentService.TransactionType.BANK_TRANSFER, amount, username);

        assertEquals("Success", result, "Bank transfer payment should return Success");
    }

    @Test
    void testProcessPayment_DigitalWalletSuccess() {
        String username = "test";
        double amount = 75.75;

        String result = paymentService.processPayment(PaymentService.TransactionType.DIGITAL_WALLET, amount, username);

        assertEquals("Success", result, "Digital wallet payment should return Success");
    }

    @Test
    void testProcessPayment_InvalidAmount() {
        String username = "test";
        double amount = -10.00;

        String result = paymentService.processPayment(PaymentService.TransactionType.DIGITAL_WALLET, amount, username);

        assertEquals("Failure", result, "Payment with invalid amount should return Failure");
    }
}