TDD 与 BDD 实战：从 Red-Green-Refactor 到行为驱动开发

┌──────────────────────────────────────────────────────────────────────┐
│                        TDD 三大法则                                   │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  法则一：在编写任何产品代码之前，先写一个失败的单元测试。              │
│                                                                      │
│  法则二：只编写足够让测试通过的代码，不要多写。                        │
│                                                                      │
│  法则三：只重构在产品代码和测试都通过的情况下进行。                    │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

     ┌─────────────┐
     │    Red      │ ◄── 写一个失败的测试（编译错误也算失败）
     │   (测试)     │     测试描述了尚未实现的功能期望
     └──────┬──────┘
            │
            ▼
     ┌─────────────┐
     │   Green     │ ◄── 写最少代码让测试通过（允许丑陋/取巧）
     │  (通过)      │     目标：让绿灯亮起，不管实现多烂
     └──────┬──────┘
            │
            ▼
     ┌─────────────┐
     │   Refactor  │ ◄── 重构代码，消除重复，提升设计质量
     │  (重构)      │     测试保持绿色，验证重构安全性
     └──────┬──────┘
            │
            └─────────► 回到 Red，开始下一个循环

# test_password_validator.py
import pytest
from password_validator import validate_password

def test_password_too_short():
    """密码少于 8 个字符应该返回 False。"""
    assert validate_password("Short1!") is False

# password_validator.py
def validate_password(password: str) -> bool:
    return False  # 最简单实现——让所有测试通过（目前只有一个）

def test_valid_password():
    """符合所有规则的密码应该返回 True。"""
    assert validate_password("Valid1@Pass") is True

def validate_password(password: str) -> bool:
    if len(password) < 8:
        return False
    if not any(c.isupper() for c in password):
        return False
    if not any(c.islower() for c in password):
        return False
    if not any(c.isdigit() for c in password):
        return False
    if not any(c in "!@#$%^&*" for c in password):
        return False
    return True

import re

def validate_password(password: str) -> bool:
    """验证密码是否满足安全强度要求。"""
    return all([
        len(password) >= 8,
        re.search(r'[A-Z]', password),
        re.search(r'[a-z]', password),
        re.search(r'\d', password),
        re.search(r'[!@#$%^&*]', password),
    ])

@pytest.mark.parametrize("password,expected", [
    ("", False),                    # 空密码
    ("a" * 100, False),            # 超长但只有小写
    ("UPPERCASE1!", False),        # 没有小写
    ("lowercase1!", False),        # 没有大写
    ("NoDigit!abc", False),        # 没有数字
    ("NoSpecial123", False),       # 没有特殊字符
    ("Valid1@", True),             # 刚好 8 位，满足所有
    ("Valid1@Pass", True),         # 正常情况
    ("Valid1@Pass!", True),        # 更多特殊字符
])
def test_password_validation_cases(password, expected):
    assert validate_password(password) == expected

TDD ──────────────────────────────────────►
     关注：代码正确性（单元级）
     受众：开发者自己

BDD ──────────────────────────────────────►
     关注：业务行为正确性（系统级）
     受众：开发者 + 产品 + 测试 + 业务

关系：BDD 是 TDD 的扩展，用自然语言描述行为，用测试验证行为

Feature: 用户登录
  作为注册用户
  我希望能够使用邮箱和密码登录
  以便访问我的个人中心

  Background:
    Given 系统中存在以下用户
      | email              | password   | role  |
      | user@example.com   | Pass123!   | user  |
      | admin@example.com  | Admin456!  | admin |

  Scenario: 使用正确凭据登录成功
    Given 用户在登录页面
    When 用户输入邮箱 "user@example.com"
    And 用户输入密码 "Pass123!"
    And 用户点击登录按钮
    Then 用户应被重定向到个人中心
    And 页面应显示欢迎消息 "欢迎回来，user@example.com"

  Scenario: 使用错误密码登录失败
    Given 用户在登录页面
    When 用户输入邮箱 "user@example.com"
    And 用户输入密码 "wrongpassword"
    And 用户点击登录按钮
    Then 页面应显示错误消息 "邮箱或密码错误"
    And 用户仍停留在登录页面

  Scenario Outline: 多种无效输入
    Given 用户在登录页面
    When 用户输入邮箱 "<email>"
    And 用户输入密码 "<password>"
    And 用户点击登录按钮
    Then 页面应显示错误消息 "<error_message>"

    Examples:
      | email              | password   | error_message         |
      |                    | Pass123!   | 请输入邮箱地址        |
      | user@example.com   |            | 请输入密码            |
      | invalid-email      | Pass123!   | 邮箱格式不正确        |
      | notexist@test.com  | Pass123!   | 邮箱或密码错误        |

# features/login.feature
# （上面的 Gherkin 内容保存于此）

# test_login_bdd.py
import pytest
from pytest_bdd import scenarios, given, when, then, parsers
from playwright.sync_api import Page, expect

scenarios('login.feature')

# Step 定义
@given('用户在登录页面')
def user_on_login_page(page: Page):
    page.goto('/login')

@given(parsers.parse('系统中存在以下用户\n{users_table}'))
def setup_users(users_table):
    # 解析表数据并创建用户
    from testing.db import create_user
    for row in users_table:
        create_user(email=row['email'], password=row['password'], role=row['role'])

@when(parsers.parse('用户输入邮箱 "{email}"'))
def enter_email(page: Page, email: str):
    page.get_by_test_id('login-email').fill(email)

@when(parsers.parse('用户输入密码 "{password}"'))
def enter_password(page: Page, password: str):
    page.get_by_test_id('login-password').fill(password)

@when('用户点击登录按钮')
def click_login(page: Page):
    page.get_by_test_id('login-submit').click()

@then(parsers.parse('用户应被重定向到 "{path}"'))
def redirect_to(page: Page, path: str):
    expect(page).to_have_url(path)

@then(parsers.parse('页面应显示错误消息 "{message}"'))
def show_error(page: Page, message: str):
    expect(page.get_by_test_id('login-error')).to_have_text(message)

// src/test/resources/features/checkout.feature
Feature: 购物车结算

  Scenario: 成功提交订单
    Given 用户已登录
    And 购物车中有以下商品
      | productId | name     | quantity | price |
      | p1        | iPhone   | 1        | 999   |
      | p2        | AirPods  | 2        | 199   |
    When 用户前往结算页面
    And 用户填写收货地址
      | name   | street      | city     | zip   |
      | 张三   | 中山路 100 号 | 上海     | 200000|
    And 用户选择支付方式 "信用卡"
    And 用户确认订单
    Then 订单应创建成功
    And 订单总金额应为 1397.00
    And 用户应收到订单确认邮件

// src/test/java/steps/CheckoutSteps.java
public class CheckoutSteps {

    @Given("用户已登录")
    public void userIsLoggedIn() {
        authService.login("test@example.com", "password");
    }

    @Given("购物车中有以下商品")
    public void cartContainsProducts(DataTable dataTable) {
        List<Map<String, String>> products = dataTable.asMaps();
        for (Map<String, String> product : products) {
            cartService.addItem(
                product.get("productId"),
                Integer.parseInt(product.get("quantity"))
            );
        }
    }

    @When("用户前往结算页面")
    public void userGoesToCheckout() {
        checkoutPage.navigate();
    }

    @When("用户填写收货地址")
    public void userFillsAddress(DataTable dataTable) {
        Map<String, String> address = dataTable.asMaps().get(0);
        checkoutPage.fillAddress(
            address.get("name"),
            address.get("street"),
            address.get("city"),
            address.get("zip")
        );
    }

    @Then("订单应创建成功")
    public void orderShouldBeCreated() {
        Order order = orderRepository.findLatest();
        assertThat(order).isNotNull();
        assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING);
    }

    @Then("订单总金额应为 {bigdecimal}")
    public void orderTotalShouldBe(BigDecimal expectedTotal) {
        Order order = orderRepository.findLatest();
        assertThat(order.getTotalAmount()).isEqualByComparingTo(expectedTotal);
    }
}

# 不是什么神秘的 BDD 框架——只是参数化测试 + 好命名
import pytest

@pytest.mark.parametrize("amount,balance,expected_result,expected_balance", [
    # 正常取款
    (100, 500, "SUCCESS", 400),
    # 余额刚好
    (500, 500, "SUCCESS", 0),
    # 余额不足
    (600, 500, "INSUFFICIENT_FUNDS", 500),
    # 零值边界
    (0, 500, "INVALID_AMOUNT", 500),
    # 负数
    (-100, 500, "INVALID_AMOUNT", 500),
    # 超额上限
    (10000, 500, "EXCEEDS_LIMIT", 500),
])
def test_withdrawal_scenarios(amount, balance, expected_result, expected_balance):
    account = Account(initial_balance=balance)
    result = account.withdraw(amount)
    assert result.status == expected_result
    assert account.balance == expected_balance