JUnit 5 @BeforeEach — 3-Minute CI Pipeline from Setup

package io.thecodeforge.payment;

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

class PaymentServiceTest {

    // Shared across ALL tests in this class — initialised once
    private static EmbeddedPostgres embeddedDb;
    private static DataSource dataSource;

    // Fresh instance per test — guarantees test isolation
    private PaymentService paymentService;

    @BeforeAll
    static void setUpDatabase() {
        // Expensive — do this ONCE, not before every test
        embeddedDb = EmbeddedPostgres.start();
        dataSource = embeddedDb.getPostgresDatabase();
        System.out.println("Embedded DB started — shared across all tests");
    }

    @BeforeEach
    void setUpService() {
        // Cheap — fresh PaymentService instance per test
        paymentService = new PaymentService(dataSource);
    }

    @Test
    @DisplayName("processPayment should return SUCCESS for valid payment request")
    void processPayment_validRequest_returnsSuccess() {
        PaymentRequest request = new PaymentRequest("customer-42", 100_00, "GBP");
        PaymentResult result = paymentService.processPayment(request);
        assertEquals(PaymentStatus.SUCCESS, result.getStatus());
    }

    @Test
    @DisplayName("processPayment should throw for null payment reference")
    void processPayment_nullReference_throwsIllegalArgument() {
        assertThrows(IllegalArgumentException.class,
            () -> paymentService.processPayment(null),
            "Expected exception for null payment request");
    }

    @AfterEach
    void cleanUpTestData() {
        // Clean only data created during THIS test
        paymentService.deleteTestPayments("customer-42");
    }

    @AfterAll
    static void tearDownDatabase() {
        embeddedDb.close();
        System.out.println("Embedded DB stopped");
    }
}

package io.thecodeforge.payment;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;
import static org.junit.jupiter.api.Assertions.*;

class PaymentValidatorTest {

    private final PaymentValidator validator = new PaymentValidator();

    @ParameterizedTest(name = "amount {0} should be valid")
    @ValueSource(ints = {1, 100, 999_99, 1_000_00})
    void validate_validAmounts_pass(int amountInPence) {
        assertTrue(validator.isValidAmount(amountInPence));
    }

    @ParameterizedTest(name = "amount={0} currency={1} should {2}")
    @CsvSource({
        "100,   GBP, true",
        "100,   USD, true",
        "0,     GBP, false",   // zero amount invalid
        "-100,  GBP, false",   // negative amount invalid
        "100,   XYZ, false"    // unknown currency invalid
    })
    void validate_amountAndCurrency(int amount, String currency, boolean expected) {
        assertEquals(expected, validator.isValid(amount, currency));
    }

    @ParameterizedTest
    @EnumSource(value = PaymentMethod.class, names = {"CARD", "BANK_TRANSFER"})
    void validate_supportedPaymentMethods_pass(PaymentMethod method) {
        assertTrue(validator.isSupportedMethod(method));
    }

    // @MethodSource for complex objects
    @ParameterizedTest
    @MethodSource("invalidPaymentRequests")
    void validate_invalidRequests_fail(PaymentRequest request, String reason) {
        assertFalse(validator.isValid(request), "Expected invalid: " + reason);
    }

    static Stream<Arguments> invalidPaymentRequests() {
        return Stream.of(
            Arguments.of(new PaymentRequest(null, 100, "GBP"), "null customer"),
            Arguments.of(new PaymentRequest("c1", -1, "GBP"), "negative amount"),
            Arguments.of(new PaymentRequest("c1", 100, null), "null currency")
        );
    }
}

package io.thecodeforge.order;

import org.junit.jupiter.api.*;
import java.time.Duration;

class OrderServiceTest {

    @Test
    @Disabled("Disabled until JIRA-1234 is resolved — payment gateway sandbox is down")
    @DisplayName("processOrder should trigger payment")
    void processOrder_triggersPayment() {
        // Will be skipped with the reason logged
    }

    @Test
    @Timeout(2)  // Fails if this test takes more than 2 seconds
    @DisplayName("fetchOrder should return within SLA")
    void fetchOrder_returnsWithinSla() {
        OrderService service = new OrderService();
        Order result = service.fetchOrder("order-123");
        assertNotNull(result);
    }

    @Nested
    @DisplayName("When order is in PENDING state")
    class WhenPending {

        private Order pendingOrder;

        @BeforeEach
        void setUp() {
            pendingOrder = Order.builder().status(OrderStatus.PENDING).build();
        }

        @Test
        @DisplayName("can be cancelled")
        void canBeCancelled() {
            assertTrue(pendingOrder.canBeCancelled());
        }

        @Test
        @DisplayName("cannot be refunded")
        void cannotBeRefunded() {
            assertFalse(pendingOrder.canBeRefunded());
        }
    }
}

package io.thecodeforge.order;

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

@TestMethodOrder(MethodName.class)
class OrderedTestSuite {

    private static int counter = 0;

    @Test
    void testB() {
        assertEquals(1, ++counter);  // Runs first: testA -> testB -> testC
    }

    @Test
    void testA() {
        assertEquals(0, ++counter);  // Actually runs before testB alphabetically
    }

    @Test
    void testC() {
        // some test
    }
}

// Alternative with @Order annotation
@TestMethodOrder(OrderAnnotation.class)
class ExplicitOrderTest {

    private static int counter = 0;

    @Test
    @Order(1)
    void first() {
        assertEquals(1, ++counter);
    }

    @Test
    @Order(2)
    void second() {
        assertEquals(2, ++counter);
    }

    @Test
    @Order(3)
    void third() {
        assertEquals(3, ++counter);
    }
}

package io.thecodeforge.retry;

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

class RetryServiceTest {

    @RepeatedTest(value = 5, name = "Attempt {currentRepetition} of {totalRepetitions}")
    @Tag("fast")
    @DisplayName("Idempotent retry should always succeed")
    void testIdempotentRetry(RepetitionInfo info) {
        int attempt = info.getCurrentRepetition();
        assertTrue(attempt >= 1 && attempt <= 5);
    }

    @Test
    @Tag("slow")
    @DisplayName("Payment gateway call times out after 3 retries")
    void testGatewayRetry() {
        // Simulate external call
        assertTrue(true);
    }
}

// In build.gradle or pom.xml you can filter:
// mvn test -Dgroups="fast"  (excludes @Tag("slow") tests)