TDD — A $0.01 Floating-Point Error Cost $4,200 in Revenue

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;
    }
}

// ─── Trap 1: All-or-nothing — carve a TDD zone ──────────────

// Antipattern: Try to test a legacy class with 500 lines and 8 dependencies
// @Test void testLegacyMonster() { ... }  // This will be painful

// Pattern: Write a characterisation test first (capture current behaviour)
// Then refactor with the safety net of that test
// Only apply TDD to new code paths

// ─── Trap 2: Tests as a checkbox — assert something meaningful ─

// Antipattern: Test that doesn't assert
// @Test void testGetTotal() {
//     ShoppingCart cart = new ShoppingCart();
//     cart.addItem("test", 10);
//     cart.getTotal();  // no assertion!
// }

// Pattern: Every test must have at least one assertion
// @Test void testGetTotal() {
//     assertEquals(10, cart.getTotal());
// }

// ─── Trap 3: Skipping Refactor ────────────────────────────────

// After Green, look for:
// - Magic numbers: DISCOUNT_THRESHOLD = 100.00 instead of hardcoded 100
// - Duplicated logic: extract to private method
// - Unclear names: `applyBulkDiscountIfEligible` vs `x`
// Run tests after every rename or extract

// ─── Trap 4: Tests that are too big ────────────────────────────

// Antipattern: One test for the whole workflow
// @Test void testFullCheckout() { ... }  // 50 lines, 6 assertions

// Pattern: One test per behaviour
// @Test void testCartTotalForOneItem() { ... }
// @Test void testCartTotalForMultipleItems() { ... }
// @Test void testDiscountAppliedWhenOverThreshold() { ... }

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

/**
 * Characterisation test — captures current behaviour of a legacy class
 * that has no tests. We run the actual method and assert what it returns NOW.
 * This test becomes the safety net for future refactoring.
 */
class LegacyDiscountCalculatorTest {

    private final LegacyDiscountCalculator calc = new LegacyDiscountCalculator();

    @Test
    void appliesDiscountForAmountAbove100() {
        // We run the legacy code and capture the actual output
        double result = calc.calculate(150.00);
        // Based on observing the output, we assert the current behaviour
        assertEquals(135.00, result, 0.001,
            "Legacy behaviour: 10% discount on amounts over $100");
    }

    @Test
    void doesNotApplyDiscountAtExactly100() {
        double result = calc.calculate(100.00);
        assertEquals(100.00, result, 0.001,
            "Legacy behaviour: exactly $100 gets no discount? Let's verify");
    }

    // Once these characterisation tests pass, we can refactor the implementation
    // with confidence — and then write new features using TDD on the refactored code
}