Test-Driven Development (TDD) Explained — Red, Green, Refactor in Practice

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

/**
 * STEP 1 — RED: We write this test BEFORE ShoppingCart exists.
 * It describes exactly what we want: a cart that totals item prices
 * and applies a 10% discount when the total exceeds $100.
 *
 * Run this now and it won't even compile — that IS the red phase.
 */
class ShoppingCartTest {

    private ShoppingCart cart;

    @BeforeEach
    void setUp() {
        // Fresh cart before every test — tests must never share state
        cart = new ShoppingCart();
    }

    @Test
    void emptyCartHasZeroTotal() {
        // Simplest possible case — always start here
        assertEquals(0.0, cart.getTotal(), 0.001,
            "A brand new cart should have a total of exactly zero");
    }

    @Test
    void addingSingleItemUpdatesTotalCorrectly() {
        cart.addItem("Keyboard", 49.99);

        // We expect the total to equal the single item price — no tricks yet
        assertEquals(49.99, cart.getTotal(), 0.001,
            "Total should equal the price of the one item added");
    }

    @Test
    void addingMultipleItemsSumsAllPrices() {
        cart.addItem("Keyboard", 49.99);
        cart.addItem("Mouse",    29.99);
        cart.addItem("Monitor", 249.99);

        // 49.99 + 29.99 + 249.99 = 329.97
        assertEquals(329.97, cart.getTotal(), 0.001,
            "Total should be the sum of all added item prices");
    }

    @Test
    void totalAboveOneHundredDollarsReceivesTenPercentDiscount() {
        cart.addItem("Keyboard",  49.99);
        cart.addItem("Mouse",     29.99);
        cart.addItem("WebCam",    39.99);  // total = 119.97, triggers discount

        // 119.97 * 0.90 = 107.973
        assertEquals(107.973, cart.getTotal(), 0.001,
            "Orders over $100 should receive a 10% discount on the total");
    }

    @Test
    void cannotAddItemWithNegativePrice() {
        // Edge case: guard against bad data — the test documents this rule
        assertThrows(IllegalArgumentException.class,
            () -> cart.addItem("Broken Item", -5.00),
            "Adding an item with a negative price should throw IllegalArgumentException");
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * STEP 2 — GREEN: Minimum implementation to pass all five tests.
 * Then STEP 3 — REFACTOR: Clean it up with the tests as a safety net.
 */
public class ShoppingCart {

    // Each item is a small record: name + price. No over-engineering.
    private record CartItem(String name, double price) {}

    private final List<CartItem> items = new ArrayList<>();

    // Discount constants are named — magic numbers are a maintenance nightmare
    private static final double DISCOUNT_THRESHOLD  = 100.00;
    private static final double DISCOUNT_MULTIPLIER = 0.90;   // 10% off

    /**
     * Adds an item to the cart.
     * @throws IllegalArgumentException if price is negative (test 5 requires this)
     */
    public void addItem(String name, double price) {
        if (price < 0) {
            // Guard clause: fail fast and loud rather than silently corrupt the total
            throw new IllegalArgumentException(
                "Item price cannot be negative. Received: " + price
            );
        }
        items.add(new CartItem(name, price));
    }

    /**
     * Returns the cart total, with a 10% discount applied if the raw
     * sum exceeds $100. This is the core business rule our tests define.
     */
    public double getTotal() {
        // Stream the items and sum their prices — readable and concise
        double rawTotal = items.stream()
                               .mapToDouble(CartItem::price)
                               .sum();

        // REFACTOR: the discount decision is now in a named private method,
        // making getTotal() read like a sentence, not a maths puzzle
        return applyBulkDiscountIfEligible(rawTotal);
    }

    /**
     * Private helper extracted during the Refactor step.
     * The name describes the INTENT — not the mechanics.
     */
    private double applyBulkDiscountIfEligible(double rawTotal) {
        if (rawTotal > DISCOUNT_THRESHOLD) {
            return rawTotal * DISCOUNT_MULTIPLIER;
        }
        return rawTotal;
    }
}

// ─── Now re-run the test suite ───────────────────────────────────────────────

/**
 * STEP 3 — RUN THE TESTS AGAIN TO CONFIRM REFACTOR DIDN'T BREAK ANYTHING
 *
 * Run: mvn test   OR   gradlew test   OR use your IDE's test runner
 */

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

/**
 * Parameterized TDD example — password validation rules.
 *
 * Business rules defined BEFORE PasswordValidator is written:
 *   1. Must be at least 8 characters
 *   2. Must contain at least one uppercase letter
 *   3. Must contain at least one digit
 *   4. Must not contain spaces
 *
 * @CsvSource lets us test many cases with one test method —
 * ideal when the same rule applies to many different inputs.
 */
class PasswordValidatorTest {

    private final PasswordValidator validator = new PasswordValidator();

    @ParameterizedTest(name = "''{0}'' should be valid={1} because: {2}")
    @CsvSource({
        // password,          expectedValid, reason
        "Secure99,            true,  meets all four rules",
        "short1A,             false, only 7 characters — fails length rule",
        "alllowercase1,       false, no uppercase — fails case rule",
        "ALLUPPERCASE1,       false, no lowercase — but wait, do we require lowercase?",
        "NoDigitsHere,        false, missing a digit",
        "Has Space1A,         false, contains a space",
        "ExactlyEight1A,      true,  exactly 8 chars with all required types"
    })
    void passwordMeetsAllValidationRules(
            String password, boolean expectedValid, String reason) {

        boolean actualResult = validator.isValid(password.trim());

        // The failure message uses 'reason' so a failing test self-documents
        assertEquals(expectedValid, actualResult,
            "Password '" + password.trim() + "' — " + reason);
    }
}

// ─── Minimal Green implementation ────────────────────────────────────────────

// PasswordValidator.java
class PasswordValidator {

    private static final int    MINIMUM_LENGTH    = 8;
    private static final String UPPERCASE_PATTERN = ".*[A-Z].*";
    private static final String DIGIT_PATTERN     = ".*[0-9].*";

    public boolean isValid(String password) {
        if (password == null)             return false;
        if (password.length() < MINIMUM_LENGTH) return false;
        if (password.contains(" "))       return false;  // no spaces
        if (!password.matches(UPPERCASE_PATTERN)) return false;
        if (!password.matches(DIGIT_PATTERN))     return false;
        return true;
    }
}