╱╲
                 ╱  ╲          E2E / UI Tests
                ╱    ╲         Slow, brittle, expensive
               ╱──────╲       Few (5-10% of all tests)
              ╱        ╲
             ╱          ╲      Integration Tests
            ╱            ╲     Medium speed, test boundaries
           ╱──────────────╲    Some (15-25% of all tests)
          ╱                ╲
         ╱                  ╲   Unit Tests
        ╱                    ╲  Fast, focused, cheap
       ╱──────────────────────╲ Many (70-80% of all tests)

def test_applying_percentage_discount_reduces_total():
    # Arrange (Given)
    cart = Cart()
    cart.add_item(Item("Widget", price=100.00))
    cart.add_item(Item("Gadget", price=50.00))

    # Act (When)
    cart.apply_discount(percentage=10)

    # Assert (Then)
    assert cart.total == 135.00  # 150 - 15 = 135

test_<unit>_<scenario>_<expected_result>

test_cart_total_with_10_percent_discount_is_reduced_by_10_percent
test_user_login_with_wrong_password_returns_401
test_transfer_between_accounts_with_insufficient_funds_raises_error

// Testing pure logic — no dependencies, no setup
describe("PasswordValidator", () => {
  it("rejects passwords shorter than 8 characters", () => {
    expect(validatePassword("abc")).toEqual({
      valid: false,
      reason: "Password must be at least 8 characters",
    });
  });

  it("rejects passwords without uppercase letters", () => {
    expect(validatePassword("abcdefgh")).toEqual({
      valid: false,
      reason: "Password must contain at least one uppercase letter",
    });
  });

  it("accepts valid passwords", () => {
    expect(validatePassword("Abcdefgh1!")).toEqual({
      valid: true,
      reason: null,
    });
  });
});

# Stub — provides canned data
class StubPaymentGateway:
    def charge(self, amount, card):
        return PaymentResult(success=True, transaction_id="stub-123")

# Fake — simplified but functional
class FakeUserRepository:
    def __init__(self):
        self._users = {}

    def save(self, user):
        self._users[user.id] = user

    def find_by_id(self, user_id):
        return self._users.get(user_id)

# Using a fake in a test
def test_registration_saves_user():
    repo = FakeUserRepository()
    service = RegistrationService(repo)

    service.register("alice", "alice@example.com")

    saved = repo.find_by_id("alice")
    assert saved is not None
    assert saved.email == "alice@example.com"

# Integration test — uses a real database
class TestOrderRepository:
    def setup_method(self):
        self.db = create_test_database()  # Real DB, clean schema
        self.repo = PostgresOrderRepository(self.db)

    def teardown_method(self):
        self.db.rollback()  # Clean up after each test

    def test_save_and_retrieve_order(self):
        order = Order(id="123", items=[Item("Widget", 10.00)], total=10.00)
        self.repo.save(order)

        retrieved = self.repo.find_by_id("123")

        assert retrieved is not None
        assert retrieved.total == 10.00
        assert len(retrieved.items) == 1

    def test_find_by_id_returns_none_for_missing_order(self):
        result = self.repo.find_by_id("nonexistent")
        assert result is None

// Playwright E2E test
test("user can sign up, log in, and place an order", async ({ page }) => {
  // Sign up
  await page.goto("/signup");
  await page.fill('[name="email"]', "test@example.com");
  await page.fill('[name="password"]', "SecurePass123!");
  await page.click('button[type="submit"]');
  await expect(page).toHaveURL("/dashboard");

  // Add item to cart
  await page.goto("/products");
  await page.click('[data-testid="add-to-cart-widget"]');
  await expect(page.locator('[data-testid="cart-count"]')).toHaveText("1");

  // Checkout
  await page.click('[data-testid="checkout"]');
  await page.fill('[name="card"]', "4242424242424242");
  await page.click('[data-testid="place-order"]');
  await expect(page.locator('[data-testid="order-confirmation"]')).toBeVisible();
});

┌──────────────────┐
│ 1. RED           │  Write a failing test for the next piece of behaviour
├──────────────────┤
│ 2. GREEN         │  Write the simplest code that makes the test pass
├──────────────────┤
│ 3. REFACTOR      │  Clean up the code while keeping tests green
└──────────────────┘
       ↑___________________________________|

# RED: First behaviour — new stack is empty
def test_new_stack_is_empty():
    stack = Stack()
    assert stack.is_empty()

# GREEN: Simplest implementation
class Stack:
    def is_empty(self):
        return True

# RED: Push makes it non-empty
def test_stack_with_item_is_not_empty():
    stack = Stack()
    stack.push("a")
    assert not stack.is_empty()

# GREEN: Track items
class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def is_empty(self):
        return len(self._items) == 0

# RED: Pop returns last pushed item
def test_pop_returns_last_pushed_item():
    stack = Stack()
    stack.push("a")
    stack.push("b")
    assert stack.pop() == "b"

# GREEN
def pop(self):
    return self._items.pop()

# RED: Pop on empty stack raises
def test_pop_on_empty_stack_raises():
    stack = Stack()
    with pytest.raises(IndexError, match="pop from empty stack"):
        stack.pop()

# GREEN
def pop(self):
    if self.is_empty():
        raise IndexError("pop from empty stack")
    return self._items.pop()

from hypothesis import given
from hypothesis import strategies as st

@given(st.lists(st.integers()))
def test_sorting_preserves_length(xs):
    assert len(sorted(xs)) == len(xs)

@given(st.lists(st.integers()))
def test_sorting_produces_ordered_result(xs):
    result = sorted(xs)
    for i in range(len(result) - 1):
        assert result[i] <= result[i + 1]

@given(st.lists(st.integers()))
def test_sorting_preserves_elements(xs):
    assert sorted(sorted(xs)) == sorted(xs)

@given(st.text(), st.text())
def test_string_concatenation_length(a, b):
    assert len(a + b) == len(a) + len(b)

Library/Framework:  >90% unit coverage, few integration tests
Backend API:        70-80% unit, 15-20% integration, 5-10% E2E
Frontend:           50-70% unit/component, 10-20% integration, 5-10% E2E
Data Pipeline:      Focus on data quality checks, input/output validation

# Example CI configuration (GitHub Actions)
test:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with: { node-version: 20 }
    - run: npm ci
    - run: npm run test:unit        # Fast — runs every commit
    - run: npm run test:integration  # Medium — runs every commit
    - run: npm run test:e2e          # Slow — runs on PRs to main only
      if: github.event_name == 'pull_request'