@Test
public void testAddTwoNumbers() {
    Calculator calculator = new Calculator();
    int result = calculator.add(2, 3);
    assertEquals(5, result); // 此時會失敗,因為 add() 方法尚未實作
}

public class Calculator {
    public int add(int a, int b) {
        return a + b; // 最簡單的實作
    }
}

@Test
public void testCalculateDiscount_WithVIPMember_ShouldGet20PercentOff() {
    // Arrange
    Product product = new Product("Laptop", 1000);
    Customer vipCustomer = new Customer("VIP");
    
    // Act
    double finalPrice = product.calculateDiscount(vipCustomer);
    
    // Assert
    assertEquals(800, finalPrice, 0.01);
}

@Test
public void testSaveOrder_ShouldPersistToDatabase() {
    // Arrange
    Order order = new Order("ORD-001", 1500);
    OrderRepository repository = new OrderRepository(testDatabase);
    
    // Act
    repository.save(order);
    
    // Assert
    Order savedOrder = repository.findById("ORD-001");
    assertNotNull(savedOrder);
    assertEquals(1500, savedOrder.getAmount());
}

@Test
public void testUserPurchaseFlow() {
    // 使用者登入
    loginPage.login("user@example.com", "password");
    
    // 搜尋商品
    searchPage.search("Laptop");
    
    // 加入購物車
    productPage.addToCart();
    
    // 結帳
    checkoutPage.checkout();
    
    // 驗證訂單建立
    assertTrue(orderPage.isOrderCreated());
}

需求範例:
「實作一個購物車系統,當使用者加入商品時,需要計算總金額」

// 範例:購物車測試 (Java + JUnit)
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class ShoppingCartTest {
    
    @Test
    public void testAddSingleItem_ShouldCalculateCorrectTotal() {
        // Arrange (準備測試資料)
        ShoppingCart cart = new ShoppingCart();
        Product laptop = new Product("Laptop", 30000);
        
        // Act (執行測試動作)
        cart.addItem(laptop, 1);
        
        // Assert (驗證結果)
        assertEquals(30000, cart.getTotal());
    }
}

# 執行測試
mvn test

# 預期輸出(紅燈)
[ERROR] testAddSingleItem_ShouldCalculateCorrectTotal()
java.lang.NoSuchMethodError: ShoppingCart.addItem()

// ❌ 錯誤範例
@Test
public void testAddition() {
    assertEquals(5, 2 + 3); // 這不是在測試你的程式碼!
}

// ❌ 錯誤範例:一次測試太多事情
@Test
public void testComplexScenario() {
    cart.addItem(item1, 2);
    cart.addItem(item2, 3);
    cart.applyDiscount(0.1);
    cart.checkout();
    cart.generateInvoice();
    // 太多行為混在一起!
}

// ✅ 正確範例:一次只測試一個行為
@Test
public void testAddMultipleItems_ShouldSumTotal() {
    ShoppingCart cart = new ShoppingCart();
    cart.addItem(new Product("A", 100), 2);
    cart.addItem(new Product("B", 200), 1);
    
    assertEquals(400, cart.getTotal());
}

// ❌ 不好的命名
@Test
public void test1() { }

@Test
public void testCart() { }

// ✅ 好的命名
@Test
public void testAddItem_WithNegativeQuantity_ShouldThrowException() { }

@Test
public void testCalculateTotal_WithEmptyCart_ShouldReturnZero() { }

test[方法名]_[測試條件]_[預期結果]

// 第一個測試:最基本的情況
@Test
public void testAddSingleItem_ShouldUpdateTotal() { }

// 第二個測試:多個商品
@Test
public void testAddMultipleItems_ShouldSumTotal() { }

// 第三個測試:邊界條件
@Test
public void testAddItem_WithZeroQuantity_ShouldNotChangeTotal() { }

// 第四個測試:異常情況
@Test
public void testAddItem_WithNullProduct_ShouldThrowException() { }

// 使用建構器簡化測試資料準備
public class ProductBuilder {
    private String name = "Default Product";
    private int price = 100;
    
    public ProductBuilder withName(String name) {
        this.name = name;
        return this;
    }
    
    public ProductBuilder withPrice(int price) {
        this.price = price;
        return this;
    }
    
    public Product build() {
        return new Product(name, price);
    }
}

// 測試中使用
@Test
public void testExpensiveProduct() {
    Product product = new ProductBuilder()
        .withName("MacBook Pro")
        .withPrice(80000)
        .build();
    
    cart.addItem(product, 1);
    assertEquals(80000, cart.getTotal());
}

// 第一版:讓測試通過的最簡實作
public class ShoppingCart {
    private int total = 0;
    
    public void addItem(Product product, int quantity) {
        total = product.getPrice() * quantity;
    }
    
    public int getTotal() {
        return total;
    }
}

public class Product {
    private String name;
    private int price;
    
    public Product(String name, int price) {
        this.name = name;
        this.price = price;
    }
    
    public int getPrice() {
        return price;
    }
}

mvn test

# 預期輸出(綠燈)
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS

// ❌ 過度設計
public class ShoppingCart {
    private List<CartItem> items = new ArrayList<>();
    private DiscountStrategy discountStrategy;
    private TaxCalculator taxCalculator;
    // ... 太多不必要的設計
}

// ✅ 簡單實作
public class ShoppingCart {
    private int total = 0;
    
    public void addItem(Product product, int quantity) {
        total += product.getPrice() * quantity;
    }
}

// 第一個測試
@Test
public void testGetDiscount_ForVIP_ShouldReturn20Percent() {
    Customer vip = new Customer("VIP");
    assertEquals(0.2, vip.getDiscount(), 0.01);
}

// 假實作(硬編碼)
public class Customer {
    public double getDiscount() {
        return 0.2; // 先硬編碼通過測試
    }
}

// 當有第二個測試時,再改為真實邏輯
@Test
public void testGetDiscount_ForRegular_ShouldReturn0() {
    Customer regular = new Customer("REGULAR");
    assertEquals(0.0, regular.getDiscount(), 0.01);
}

// 現在需要真實實作
public class Customer {
    private String type;
    
    public Customer(String type) {
        this.type = type;
    }
    
    public double getDiscount() {
        if ("VIP".equals(type)) {
            return 0.2;
        }
        return 0.0;
    }
}

// 測試 1
@Test
public void testFizzBuzz_With3_ShouldReturnFizz() {
    assertEquals("Fizz", fizzBuzz(3));
}

// 第一版實作(假實作)
public String fizzBuzz(int number) {
    return "Fizz";
}

// 測試 2
@Test
public void testFizzBuzz_With5_ShouldReturnBuzz() {
    assertEquals("Buzz", fizzBuzz(5));
}

// 第二版實作
public String fizzBuzz(int number) {
    if (number % 3 == 0) return "Fizz";
    if (number % 5 == 0) return "Buzz";
    return String.valueOf(number);
}

// 測試 3
@Test
public void testFizzBuzz_With15_ShouldReturnFizzBuzz() {
    assertEquals("FizzBuzz", fizzBuzz(15));
}

// 第三版實作(完整邏輯)
public String fizzBuzz(int number) {
    if (number % 15 == 0) return "FizzBuzz";
    if (number % 3 == 0) return "Fizz";
    if (number % 5 == 0) return "Buzz";
    return String.valueOf(number);
}

// 可以先用 TODO 標記待實作的複雜邏輯
public void processPayment(Payment payment) {
    // TODO: 實作複雜的支付邏輯
    if (payment.getAmount() > 0) {
        // 簡單版本先通過測試
    }
}

# 確保新實作不會破壞既有測試
mvn test

# 或使用 IDE 的快捷鍵
# IntelliJ: Ctrl+Shift+F10 (Windows) / Cmd+Shift+R (Mac)
# VS Code: Ctrl+; A (Windows) / Cmd+; A (Mac)

// 重構前:有重複邏輯
public class ShoppingCart {
    public int calculateTotalForVIP(List<Product> products) {
        int total = 0;
        for (Product p : products) {
            total += p.getPrice();
        }
        return (int)(total * 0.8); // VIP 8折
    }
    
    public int calculateTotalForRegular(List<Product> products) {
        int total = 0;
        for (Product p : products) {
            total += p.getPrice();
        }
        return total;
    }
}

// 重構後:消除重複
public class ShoppingCart {
    public int calculateTotal(List<Product> products, double discount) {
        int total = products.stream()
            .mapToInt(Product::getPrice)
            .sum();
        return (int)(total * (1 - discount));
    }
}

# 每次小改動後都要測試
git add .
mvn test && git commit -m "Refactor: extract method"

// 重構前
public void processOrder(Order order) {
    // 驗證訂單
    if (order.getItems().isEmpty()) {
        throw new IllegalArgumentException("Empty order");
    }
    if (order.getTotal() < 0) {
        throw new IllegalArgumentException("Invalid total");
    }
    
    // 計算折扣
    double discount = 0;
    if (order.getCustomer().isVIP()) {
        discount = 0.2;
    }
    double finalPrice = order.getTotal() * (1 - discount);
    
    // 儲存訂單
    database.save(order);
}

// 重構後:提取獨立方法
public void processOrder(Order order) {
    validateOrder(order);
    double finalPrice = calculateFinalPrice(order);
    saveOrder(order);
}

private void validateOrder(Order order) {
    if (order.getItems().isEmpty()) {
        throw new IllegalArgumentException("Empty order");
    }
    if (order.getTotal() < 0) {
        throw new IllegalArgumentException("Invalid total");
    }
}

private double calculateFinalPrice(Order order) {
    double discount = order.getCustomer().isVIP() ? 0.2 : 0.0;
    return order.getTotal() * (1 - discount);
}

private void saveOrder(Order order) {
    database.save(order);
}

// 重構前:職責過多
public class Customer {
    private String name;
    private String email;
    private String phone;
    private String street;
    private String city;
    private String zipCode;
    
    // 太多欄位與職責
}

// 重構後:分離地址類別
public class Customer {
    private String name;
    private String email;
    private String phone;
    private Address address; // 提取為獨立類別
}

public class Address {
    private String street;
    private String city;
    private String zipCode;
    
    public String getFullAddress() {
        return street + ", " + city + " " + zipCode;
    }
}

// 重構前
public double calculateDiscount(Customer customer) {
    if (customer.isVIP()) {
        return total * 0.8; // 魔術數字
    }
    return total * 0.95; // 魔術數字
}

// 重構後
private static final double VIP_DISCOUNT_RATE = 0.2;
private static final double REGULAR_DISCOUNT_RATE = 0.05;

public double calculateDiscount(Customer customer) {
    if (customer.isVIP()) {
        return total * (1 - VIP_DISCOUNT_RATE);
    }
    return total * (1 - REGULAR_DISCOUNT_RATE);
}

// 重構前
public double calculateShippingCost(String shippingType, double weight) {
    if ("STANDARD".equals(shippingType)) {
        return weight * 10;
    } else if ("EXPRESS".equals(shippingType)) {
        return weight * 20 + 50;
    } else if ("OVERNIGHT".equals(shippingType)) {
        return weight * 30 + 100;
    }
    return 0;
}

// 重構後:使用策略模式
public interface ShippingStrategy {
    double calculateCost(double weight);
}

public class StandardShipping implements ShippingStrategy {
    public double calculateCost(double weight) {
        return weight * 10;
    }
}

public class ExpressShipping implements ShippingStrategy {
    public double calculateCost(double weight) {
        return weight * 20 + 50;
    }
}

// 使用
public double calculateShippingCost(ShippingStrategy strategy, double weight) {
    return strategy.calculateCost(weight);
}

❌ 同時重構:改命名 + 提取方法 + 調整架構
✅ 循序漸進:先改命名 → 測試 → 提取方法 → 測試 → 調整架構 → 測試

// ❌ 錯誤:重構時加入新功能
public double calculateTotal() {
    // 重構:提取方法
    double subtotal = calculateSubtotal();
    
    // 同時加入新功能(稅金計算) - 不好!
    double tax = subtotal * 0.05;
    return subtotal + tax;
}

// ✅ 正確:先重構,再加新功能
// 步驟1:重構
public double calculateTotal() {
    return calculateSubtotal();
}

private double calculateSubtotal() {
    // 提取的邏輯
}

// 步驟2:寫新測試
@Test
public void testCalculateTotal_ShouldIncludeTax() {
    // 新功能的測試
}

// 步驟3:實作新功能
public double calculateTotal() {
    double subtotal = calculateSubtotal();
    double tax = calculateTax(subtotal);
    return subtotal + tax;
}

# 每次重構後提交
git add .
git commit -m "Refactor: extract calculateDiscount method"

# 如果重構失敗可快速復原
git reset --hard HEAD

IntelliJ IDEA 常用快捷鍵:

- Ctrl+Alt+M: 提取方法

- Ctrl+Alt+V: 提取變數

- Ctrl+Alt+C: 提取常數

- Ctrl+Alt+F: 提取欄位

- F6: 移動類別/方法

- Shift+F6: 重新命名

// 測試程式碼也會有重複,需要重構
@Test
public void testVIPDiscount() {
    Customer vip = new Customer("John", "VIP");
    ShoppingCart cart = new ShoppingCart(vip);
    cart.addItem(new Product("A", 1000), 1);
    assertEquals(800, cart.getTotal());
}

@Test
public void testRegularCustomer() {
    Customer regular = new Customer("Jane", "REGULAR");
    ShoppingCart cart = new ShoppingCart(regular);
    cart.addItem(new Product("A", 1000), 1);
    assertEquals(1000, cart.getTotal());
}

// 重構測試:提取共用設定
private ShoppingCart createCartWith Product(Customer customer, int price) {
    ShoppingCart cart = new ShoppingCart(customer);
    cart.addItem(new Product("TestProduct", price), 1);
    return cart;
}

@Test
public void testVIPDiscount() {
    Customer vip = new Customer("John", "VIP");
    ShoppingCart cart = createCartWithProduct(vip, 1000);
    assertEquals(800, cart.getTotal());
}

@Test
public void testRegularCustomer() {
    Customer regular = new Customer("Jane", "REGULAR");
    ShoppingCart cart = createCartWithProduct(regular, 1000);
    assertEquals(1000, cart.getTotal());
}

// Iteration 1: Red - 寫測試
@Test
public void testVIPCustomer_ShouldGet20PercentDiscount() {
    Order order = new Order(new Customer("VIP"), 1000);
    assertEquals(800, order.getFinalPrice());
}

// Iteration 1: Green - 最簡實作
public class Order {
    private Customer customer;
    private double amount;
    
    public Order(Customer customer, double amount) {
        this.customer = customer;
        this.amount = amount;
    }
    
    public double getFinalPrice() {
        if (customer.isVIP()) {
            return amount * 0.8;
        }
        return amount;
    }
}

// Iteration 1: Refactor - 提取常數
private static final double VIP_DISCOUNT = 0.2;

public double getFinalPrice() {
    if (customer.isVIP()) {
        return amount * (1 - VIP_DISCOUNT);
    }
    return amount;
}

// Iteration 2: Red - 新測試
@Test
public void testRegularCustomer_ShouldHaveNoDiscount() {
    Order order = new Order(new Customer("REGULAR"), 1000);
    assertEquals(1000, order.getFinalPrice());
}

// Iteration 2: Green - 程式碼已經支援,測試直接通過!

// Iteration 2: Refactor - 簡化邏輯
public double getFinalPrice() {
    double discount = customer.isVIP() ? VIP_DISCOUNT : 0;
    return amount * (1 - discount);
}

// Iteration 3: Red - 新測試
@Test
public void testLargeOrder_ShouldGetAdditional5PercentDiscount() {
    Order order = new Order(new Customer("REGULAR"), 1500);
    assertEquals(1425, order.getFinalPrice()); // 1500 * 0.95
}

// Iteration 3: Green - 加入邏輯
private static final double LARGE_ORDER_THRESHOLD = 1000;
private static final double LARGE_ORDER_DISCOUNT = 0.05;

public double getFinalPrice() {
    double discount = customer.isVIP() ? VIP_DISCOUNT : 0;
    
    if (amount > LARGE_ORDER_THRESHOLD) {
        discount += LARGE_ORDER_DISCOUNT;
    }
    
    return amount * (1 - discount);
}

// Iteration 3: Refactor - 提取方法
public double getFinalPrice() {
    double totalDiscount = calculateTotalDiscount();
    return amount * (1 - totalDiscount);
}

private double calculateTotalDiscount() {
    double discount = customer.isVIP() ? VIP_DISCOUNT : 0;
    
    if (amount > LARGE_ORDER_THRESHOLD) {
        discount += LARGE_ORDER_DISCOUNT;
    }
    
    return discount;
}

// Iteration 4: Red - 組合測試
@Test
public void testVIPWithLargeOrder_ShouldGetBothDiscounts() {
    Order order = new Order(new Customer("VIP"), 1500);
    // VIP 20% + 大額訂單 5% = 25% 折扣
    assertEquals(1125, order.getFinalPrice()); // 1500 * 0.75
}

// Iteration 4: Green - 程式碼已支援,測試通過!

// Iteration 4: Refactor - 進一步重構
public double getFinalPrice() {
    DiscountCalculator calculator = new DiscountCalculator(customer, amount);
    return calculator.calculateFinalPrice();
}

// 提取為獨立的折扣計算類別
public class DiscountCalculator {
    private static final double VIP_DISCOUNT = 0.2;
    private static final double LARGE_ORDER_DISCOUNT = 0.05;
    private static final double LARGE_ORDER_THRESHOLD = 1000;
    
    private Customer customer;
    private double amount;
    
    public DiscountCalculator(Customer customer, double amount) {
        this.customer = customer;
        this.amount = amount;
    }
    
    public double calculateFinalPrice() {
        double totalDiscount = calculateTotalDiscount();
        return amount * (1 - totalDiscount);
    }
    
    private double calculateTotalDiscount() {
        double discount = 0;
        
        if (customer.isVIP()) {
            discount += VIP_DISCOUNT;
        }
        
        if (amount > LARGE_ORDER_THRESHOLD) {
            discount += LARGE_ORDER_DISCOUNT;
        }
        
        return discount;
    }
}

## 訂單折扣系統開發任務

### 已完成

- [x] VIP 客戶 20% 折扣

- [x] 一般客戶無折扣

- [x] 訂單金額 > 1000 享 5% 折扣

- [x] VIP + 大額訂單折扣累加


### 進行中

- [ ] 會員等級分級(金、銀、銅)


### 待辦

- [ ] 季節性促銷折扣

- [ ] 優惠券折扣

- [ ] 折扣上限設定

❌ 大迭代:一次實作完整的折扣系統(需要3小時)
✅ 小迭代:每個折扣類型獨立開發(每個15分鐘)

## 購物車測試清單

### 基本功能

- [ ] 加入單一商品

- [ ] 加入多個不同商品

- [ ] 計算總金額


### 邊界條件

- [ ] 加入數量為 0 的商品

- [ ] 加入負數數量的商品

- [ ] 空購物車的總金額


### 異常處理

- [ ] 加入 null 商品

- [ ] 移除不存在的商品


### 進階功能

- [ ] 更新商品數量

- [ ] 清空購物車

- [ ] 套用折扣碼

<!-- Maven: 使用 JaCoCo -->
<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.10</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
        </execution>
        <execution>
            <id>jacoco-check</id>
            <goals>
                <goal>check</goal>
            </goals>
            <configuration>
                <rules>
                    <rule>
                        <element>PACKAGE</element>
                        <limits>
                            <limit>
                                <counter>LINE</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.80</minimum>
                            </limit>
                        </limits>
                    </rule>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

# 執行並生成覆蓋率報告
mvn clean test jacoco:report

# 查看報告
open target/site/jacoco/index.html

-------------------------------------------------------
JaCoCo Coverage Report
-------------------------------------------------------
Package         Line Coverage   Branch Coverage
-------------------------------------------------------
com.example
  ├─ service    87.5% (35/40)  75.0% (6/8)
  ├─ model      95.0% (19/20)  N/A
  └─ util       82.3% (28/34)  80.0% (8/10)
-------------------------------------------------------
Total           88.3% (82/94)  77.8% (14/18)

// 範例:100% 覆蓋率但測試品質差
@Test
public void testCalculate() {
    Calculator calc = new Calculator();
    calc.add(2, 3);
    calc.subtract(5, 2);
    calc.multiply(3, 4);
    // 沒有任何 assert,但程式碼都執行了!
}

@Test
public void testAdd_ShouldReturnCorrectSum() {
    Calculator calc = new Calculator();
    int result = calc.add(2, 3);
    assertEquals(5, result); // 有驗證!
}

@Test
public void testSubtract_ShouldReturnCorrectDifference() {
    Calculator calc = new Calculator();
    int result = calc.subtract(5, 2);
    assertEquals(3, result);
}

✅ 高覆蓋率優先:

- 核心業務邏輯(100%)

- 複雜演算法(100%)

- 錯誤處理(90%+)


⚠️ 可較低覆蓋率:

- 簡單的 Getter/Setter

- 框架生成的程式碼

- UI 元件程式碼

# .gitlab-ci.yml 範例
test:
  script:
    - mvn clean test jacoco:report
  coverage: '/Total.*?([0-9]{1,3})%/'
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: target/site/jacoco/jacoco.xml
  # 設定最低覆蓋率要求
  allow_failure:
    exit_codes:
      - 1  # 如果覆蓋率低於門檻則失敗

## 功能開發完成檢查清單

### 測試相關

- [ ] 所有測試案例通過(綠燈)

- [ ] 測試覆蓋率達到 80% 以上

- [ ] 包含邊界條件測試

- [ ] 包含異常處理測試

- [ ] 測試命名清晰易懂


### 程式碼品質

- [ ] 無重複程式碼

- [ ] 無程式碼異味(Code Smells)

- [ ] 命名清晰有意義

- [ ] 符合 SOLID 原則

- [ ] 通過靜態分析工具檢查


### 文件與審查

- [ ] 程式碼已提交並推送

- [ ] 通過 Code Review

- [ ] API 文件已更新

- [ ] Commit 訊息清晰


### CI/CD

- [ ] CI Pipeline 執行成功

- [ ] 無安全性漏洞警告

- [ ] 效能測試通過(如適用)


### 簽核

- [ ] 開發者簽核: ___________

- [ ] 審查者簽核: ___________

- [ ] 日期: ___________

<!-- pom.xml -->
<dependencies>
    <!-- JUnit 5 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>
    
    <!-- Mockito (Mock 工具) -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>5.5.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

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

class CalculatorTest {
    
    private Calculator calculator;
    
    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }
    
    @Test
    @DisplayName("測試加法:2 + 3 應該等於 5")
    void testAdd() {
        int result = calculator.add(2, 3);
        assertEquals(5, result);
    }
    
    @Test
    void testDivide_ByZero_ShouldThrowException() {
        assertThrows(ArithmeticException.class, () -> {
            calculator.divide(10, 0);
        });
    }
    
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 5, 8})
    void testIsPositive(int number) {
        assertTrue(calculator.isPositive(number));
    }
}

@Test                  // 標記測試方法
@DisplayName("...")    // 測試顯示名稱
@BeforeEach           // 每個測試前執行
@AfterEach            // 每個測試後執行
@BeforeAll            // 所有測試前執行一次(static)
@AfterAll             // 所有測試後執行一次(static)
@Disabled             // 暫時停用測試
@RepeatedTest(5)      // 重複執行測試
@ParameterizedTest    // 參數化測試
@Timeout(5)           // 測試逾時限制(秒)

pip install pytest pytest-cov

# calculator.py
class Calculator:
    def add(self, a, b):
        return a + b
    
    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

# test_calculator.py
import pytest
from calculator import Calculator

class TestCalculator:
    
    def setup_method(self):
        """每個測試前執行"""
        self.calc = Calculator()
    
    def test_add(self):
        """測試加法功能"""
        result = self.calc.add(2, 3)
        assert result == 5
    
    def test_divide_by_zero_should_raise_exception(self):
        """測試除以零應拋出例外"""
        with pytest.raises(ValueError, match="Cannot divide by zero"):
            self.calc.divide(10, 0)
    
    @pytest.mark.parametrize("a,b,expected", [
        (2, 3, 5),
        (0, 0, 0),
        (-1, 1, 0),
        (100, 200, 300),
    ])
    def test_add_with_multiple_inputs(self, a, b, expected):
        """參數化測試"""
        assert self.calc.add(a, b) == expected

# 執行所有測試
pytest

# 顯示詳細輸出
pytest -v

# 生成覆蓋率報告
pytest --cov=calculator --cov-report=html

# 只執行特定測試
pytest test_calculator.py::TestCalculator::test_add

# 執行標記的測試
pytest -m slow

@pytest.fixture          # 定義測試夾具(共用資源)
@pytest.mark.parametrize # 參數化測試
@pytest.mark.skip       # 跳過測試
@pytest.mark.skipif     # 條件式跳過
@pytest.mark.xfail      # 預期失敗
@pytest.mark.slow       # 自定義標記

npm install --save-dev jest

{
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage"
  },
  "jest": {
    "testEnvironment": "node",
    "coverageThreshold": {
      "global": {
        "branches": 80,
        "functions": 80,
        "lines": 80
      }
    }
  }
}

// calculator.js
class Calculator {
  add(a, b) {
    return a + b;
  }
  
  divide(a, b) {
    if (b === 0) {
      throw new Error('Cannot divide by zero');
    }
    return a / b;
  }
}

module.exports = Calculator;

// calculator.test.js
const Calculator = require('./calculator');

describe('Calculator', () => {
  let calculator;
  
  beforeEach(() => {
    calculator = new Calculator();
  });
  
  test('should add two numbers correctly', () => {
    const result = calculator.add(2, 3);
    expect(result).toBe(5);
  });
  
  test('should throw error when dividing by zero', () => {
    expect(() => {
      calculator.divide(10, 0);
    }).toThrow('Cannot divide by zero');
  });
  
  test.each([
    [1, 2, 3],
    [0, 0, 0],
    [-1, 1, 0],
  ])('add(%i, %i) should return %i', (a, b, expected) => {
    expect(calculator.add(a, b)).toBe(expected);
  });
});

// 斷言
expect(value).toBe(expected)              // 嚴格相等
expect(value).toEqual(expected)           // 深度相等
expect(value).toBeTruthy()                // 真值
expect(value).toBeFalsy()                 // 假值
expect(array).toContain(item)             // 包含元素
expect(fn).toThrow()                      // 拋出例外
expect(fn).toHaveBeenCalled()             // 被呼叫

// 生命週期
beforeAll(() => {})      // 所有測試前
beforeEach(() => {})     // 每個測試前
afterEach(() => {})      // 每個測試後
afterAll(() => {})       // 所有測試後

// 測試組織
describe('group', () => {})  // 測試群組
test('name', () => {})       // 測試案例
it('name', () => {})         // test 的別名

1. Run → Edit Configurations

2. Add New Configuration → JUnit

3. 設定:
   - Test kind: All in package
   - Package: com.example
   - VM options: -ea (啟用 assertions)
   - Working directory: $MODULE_WORKING_DIR$

Ctrl+Shift+F10 (Win) / Cmd+Shift+R (Mac)  - 執行當前測試
Ctrl+Shift+F9 (Win) / Cmd+Shift+D (Mac)   - Debug 當前測試
Alt+Insert (Win) / Cmd+N (Mac)            - 生成測試方法
Ctrl+Shift+T (Win) / Cmd+Shift+T (Mac)    - 在測試與實作間切換

<!-- 安裝 Infinitest 插件 -->
Settings → Plugins → Marketplace → 搜尋 "Infinitest"

{
  "java.test.config": {
    "workingDirectory": "${workspaceFolder}"
  },
  "java.test.defaultConfig": "default",
  "python.testing.pytestEnabled": true,
  "python.testing.unittestEnabled": false,
  "coverage-gutters.coverageFileNames": [
    "coverage/lcov.info",
    "coverage/coverage.xml"
  ],
  "editor.codeActionsOnSave": {
    "source.organizeImports": true
  }
}

Ctrl+; A (Win) / Cmd+; A (Mac)  - 執行所有測試
Ctrl+; C (Win) / Cmd+; C (Mac)  - 執行當前測試
Ctrl+; L (Win) / Cmd+; L (Mac)  - 執行上次測試

右鍵點擊測試類別或方法
→ Run As → JUnit Test

Alt+Shift+X, T  - 執行 JUnit 測試
Alt+Shift+D, T  - Debug JUnit 測試
Ctrl+0          - 快速切換至測試

# .gitlab-ci.yml
image: maven:3.8-openjdk-17

stages:
  - test
  - report

variables:
  MAVEN_OPTS: "-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository"

cache:
  paths:
    - .m2/repository
    - target/

test:
  stage: test
  script:
    - mvn clean test
  coverage: '/Total.*?([0-9]{1,3})%/'
  artifacts:
    when: always
    reports:
      junit:
        - target/surefire-reports/TEST-*.xml
    paths:
      - target/surefire-reports/
      - target/site/jacoco/
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
    - if: '$CI_COMMIT_BRANCH == "main"'

coverage:
  stage: report
  script:
    - mvn jacoco:report
  coverage: '/Total.*?([0-9]{1,3})%/'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: target/site/jacoco/jacoco.xml
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'

# 加入通知階段
notify_failure:
  stage: .post
  script:
    - 'curl -X POST -H "Content-Type: application/json" 
       -d "{\"text\":\"Test Failed in ${CI_PROJECT_NAME}\"}" 
       $SLACK_WEBHOOK_URL'
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
      when: on_failure

name: Run Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up JDK 17
      uses: actions/setup-java@v3
      with:
        java-version: '17'
        distribution: 'temurin'
        cache: maven
    
    - name: Run tests
      run: mvn clean test
    
    - name: Generate coverage report
      run: mvn jacoco:report
    
    - name: Upload coverage to Codecov
      uses: codecov/codecov-action@v3
      with:
        files: ./target/site/jacoco/jacoco.xml
        flags: unittests
        name: codecov-umbrella
    
    - name: Publish test results
      uses: EnricoMi/publish-unit-test-result-action@v2
      if: always()
      with:
        files: target/surefire-reports/*.xml
    
    - name: Comment PR with coverage
      uses: romeovs/lcov-reporter-action@v0.3.1
      if: github.event_name == 'pull_request'
      with:
        lcov-file: ./target/site/jacoco/jacoco.xml
        github-token: ${{ secrets.GITHUB_TOKEN }}

name: Python Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.8', '3.9', '3.10', '3.11']
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}
    
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install pytest pytest-cov
        pip install -r requirements.txt
    
    - name: Run tests with coverage
      run: |
        pytest --cov=. --cov-report=xml --cov-report=html
    
    - name: Upload coverage
      uses: codecov/codecov-action@v3
      with:
        files: ./coverage.xml

pipeline {
    agent any
    
    tools {
        maven 'Maven 3.8'
        jdk 'JDK 17'
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Test') {
            steps {
                sh 'mvn clean test'
            }
        }
        
        stage('Coverage') {
            steps {
                sh 'mvn jacoco:report'
                jacoco(
                    execPattern: 'target/*.exec',
                    classPattern: 'target/classes',
                    sourcePattern: 'src/main/java',
                    inclusionPattern: '**/*.class'
                )
            }
        }
        
        stage('Quality Gate') {
            steps {
                script {
                    def coverage = sh(
                        script: 'mvn jacoco:check',
                        returnStatus: true
                    )
                    if (coverage != 0) {
                        error("Coverage below threshold!")
                    }
                }
            }
        }
    }
    
    post {
        always {
            junit 'target/surefire-reports/*.xml'
            publishHTML([
                reportDir: 'target/site/jacoco',
                reportFiles: 'index.html',
                reportName: 'Coverage Report'
            ])
        }
        failure {
            mail to: 'team@example.com',
                 subject: "Test Failed: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
                 body: "Check ${env.BUILD_URL}"
        }
    }
}

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.10</version>
    <executions>
        <execution>
            <id>prepare-agent</id>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
        </execution>
        <execution>
            <id>jacoco-check</id>
            <goals>
                <goal>check</goal>
            </goals>
            <configuration>
                <rules>
                    <rule>
                        <element>PACKAGE</element>
                        <limits>
                            <limit>
                                <counter>LINE</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.80</minimum>
                            </limit>
                            <limit>
                                <counter>BRANCH</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.70</minimum>
                            </limit>
                        </limits>
                    </rule>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

mvn clean test jacoco:report

# 查看報告
open target/site/jacoco/index.html

# 安裝
pip install coverage pytest-cov

# 執行測試並收集覆蓋率
coverage run -m pytest

# 生成報告
coverage report

# 生成 HTML 報告
coverage html
open htmlcov/index.html

# 與 pytest 整合
pytest --cov=mypackage --cov-report=html --cov-report=term

[run]
source = src/
omit = 
    */tests/*
    */migrations/*
    */__pycache__/*

[report]
precision = 2
exclude_lines =
    pragma: no cover
    def __repr__
    raise AssertionError
    raise NotImplementedError
    if __name__ == .__main__.:

[html]
directory = htmlcov

npm install --save-dev nyc

{
  "scripts": {
    "test": "jest",
    "test:coverage": "jest --coverage",
    "coverage": "nyc --reporter=html --reporter=text npm test"
  },
  "nyc": {
    "check-coverage": true,
    "lines": 80,
    "statements": 80,
    "functions": 80,
    "branches": 75,
    "include": [
      "src/**/*.js"
    ],
    "exclude": [
      "src/**/*.test.js",
      "src/**/*.spec.js"
    ]
  }
}

npm run test:coverage
open coverage/index.html

import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;

public class OrderServiceTest {
    
    @Test
    public void testPlaceOrder_ShouldCallRepository() {
        // 建立 Mock 物件
        OrderRepository mockRepository = mock(OrderRepository.class);
        PaymentService mockPayment = mock(PaymentService.class);
        
        OrderService service = new OrderService(mockRepository, mockPayment);
        
        // 設定 Mock 行為
        when(mockPayment.process(any(Order.class))).thenReturn(true);
        when(mockRepository.save(any(Order.class))).thenReturn(new Order("123"));
        
        // 執行測試
        Order order = new Order("ORD-001", 1000);
        service.placeOrder(order);
        
        // 驗證互動
        verify(mockPayment).process(order);
        verify(mockRepository).save(order);
        verify(mockRepository, times(1)).save(any(Order.class));
    }
    
    @Test
    public void testGetOrder_WhenNotFound_ShouldThrowException() {
        OrderRepository mockRepository = mock(OrderRepository.class);
        
        // Mock 拋出例外
        when(mockRepository.findById("999"))
            .thenThrow(new OrderNotFoundException("Order not found"));
        
        OrderService service = new OrderService(mockRepository, null);
        
        assertThrows(OrderNotFoundException.class, () -> {
            service.getOrder("999");
        });
    }
}

// 使用 @Mock 註解
@ExtendWith(MockitoExtension.class)
public class OrderServiceTest {
    
    @Mock
    private OrderRepository repository;
    
    @Mock
    private PaymentService payment;
    
    @InjectMocks  // 自動注入 Mock
    private OrderService service;
    
    @Test
    public void testWithAnnotations() {
        when(payment.process(any())).thenReturn(true);
        
        service.placeOrder(new Order("001", 1000));
        
        verify(repository).save(any());
    }
    
    // ArgumentCaptor: 捕捉參數
    @Test
    public void testCaptureArgument() {
        ArgumentCaptor<Order> captor = ArgumentCaptor.forClass(Order.class);
        
        service.placeOrder(new Order("001", 1500));
        
        verify(repository).save(captor.capture());
        Order captured = captor.getValue();
        assertEquals(1500, captured.getAmount());
    }
    
    // Spy: 部分 Mock
    @Test
    public void testSpyObject() {
        OrderService spy = spy(new OrderService(repository, payment));
        
        doReturn(true).when(spy).isValidOrder(any());
        
        spy.placeOrder(new Order("001", 1000));
    }
}

from unittest.mock import Mock, patch, MagicMock
import pytest

class TestOrderService:
    
    def test_place_order_should_call_repository(self):
        # 建立 Mock
        mock_repository = Mock()
        mock_payment = Mock()
        
        service = OrderService(mock_repository, mock_payment)
        
        # 設定回傳值
        mock_payment.process.return_value = True
        mock_repository.save.return_value = Order("123")
        
        # 執行
        order = Order("ORD-001", 1000)
        service.place_order(order)
        
        # 驗證呼叫
        mock_payment.process.assert_called_once_with(order)
        mock_repository.save.assert_called_once()
    
    @patch('order_service.PaymentService')
    @patch('order_service.OrderRepository')
    def test_with_patch_decorator(self, mock_repo_class, mock_payment_class):
        # 使用 @patch 裝飾器
        mock_repo = mock_repo_class.return_value
        mock_payment = mock_payment_class.return_value
        
        mock_payment.process.return_value = True
        
        service = OrderService(mock_repo, mock_payment)
        service.place_order(Order("001", 1000))
        
        assert mock_payment.process.called
    
    def test_mock_side_effect(self):
        # 設定副作用
        mock = Mock()
        mock.get_discount.side_effect = [0.1, 0.2, 0.3]
        
        assert mock.get_discount() == 0.1
        assert mock.get_discount() == 0.2
        assert mock.get_discount() == 0.3
    
    def test_mock_exception(self):
        mock_repo = Mock()
        mock_repo.find_by_id.side_effect = NotFoundException("Not found")
        
        service = OrderService(mock_repo, None)
        
        with pytest.raises(NotFoundException):
            service.get_order("999")

// orderService.test.js
const OrderService = require('./orderService');

describe('OrderService', () => {
  let mockRepository;
  let mockPayment;
  let service;
  
  beforeEach(() => {
    // 建立 Mock 函式
    mockRepository = {
      save: jest.fn(),
      findById: jest.fn()
    };
    
    mockPayment = {
      process: jest.fn()
    };
    
    service = new OrderService(mockRepository, mockPayment);
  });
  
  test('should call payment and repository', async () => {
    // 設定 Mock 回傳值
    mockPayment.process.mockResolvedValue(true);
    mockRepository.save.mockResolvedValue({ id: '123' });
    
    const order = { id: 'ORD-001', amount: 1000 };
    await service.placeOrder(order);
    
    // 驗證呼叫
    expect(mockPayment.process).toHaveBeenCalledWith(order);
    expect(mockRepository.save).toHaveBeenCalledTimes(1);
  });
  
  test('should handle payment failure', async () => {
    // Mock 拋出錯誤
    mockPayment.process.mockRejectedValue(new Error('Payment failed'));
    
    const order = { id: 'ORD-001', amount: 1000 };
    
    await expect(service.placeOrder(order))
      .rejects
      .toThrow('Payment failed');
  });
  
  test('should mock implementation', () => {
    mockRepository.findById.mockImplementation((id) => {
      if (id === '123') {
        return { id: '123', amount: 1000 };
      }
      throw new Error('Not found');
    });
    
    const order = mockRepository.findById('123');
    expect(order.amount).toBe(1000);
    
    expect(() => mockRepository.findById('999')).toThrow('Not found');
  });
});

import com.github.javafaker.Faker;

public class TestDataBuilder {
    private static Faker faker = new Faker();
    
    public static Customer createRandomCustomer() {
        return new Customer(
            faker.name().fullName(),
            faker.internet().emailAddress(),
            faker.phoneNumber().phoneNumber(),
            faker.address().fullAddress()
        );
    }
    
    public static Product createRandomProduct() {
        return new Product(
            faker.commerce().productName(),
            faker.number().numberBetween(100, 10000)
        );
    }
}

// 使用
@Test
public void testWithRandomData() {
    Customer customer = TestDataBuilder.createRandomCustomer();
    Product product = TestDataBuilder.createRandomProduct();
    
    Order order = new Order(customer);
    order.addItem(product, 1);
    
    assertTrue(order.getTotal() > 0);
}

from faker import Faker

fake = Faker(['zh_TW'])  # 使用繁體中文

class TestDataBuilder:
    
    @staticmethod
    def create_customer():
        return Customer(
            name=fake.name(),
            email=fake.email(),
            phone=fake.phone_number(),
            address=fake.address()
        )
    
    @staticmethod
    def create_product():
        return Product(
            name=fake.catch_phrase(),
            price=fake.random_int(min=100, max=10000)
        )

# 使用
def test_with_random_data():
    customer = TestDataBuilder.create_customer()
    product = TestDataBuilder.create_product()
    
    order = Order(customer)
    order.add_item(product, 1)
    
    assert order.get_total() > 0

// ✅ 清楚的命名
@Test
public void calculateDiscount_WithVIPCustomer_ShouldReturn20Percent() { }

@Test
public void processPayment_WhenBalanceInsufficient_ShouldThrowException() { }

@Test
public void addItem_WithNegativeQuantity_ShouldRejectAndReturnFalse() { }

// ❌ 不好的命名
@Test
public void test1() { }

@Test
public void testDiscount() { }

@Test
public void testPayment() { }

@Test
public void givenVIPCustomer_whenCalculateDiscount_thenReturn20Percent() {
    // Given (準備)
    Customer vip = new Customer("VIP");
    DiscountCalculator calculator = new DiscountCalculator();
    
    // When (執行)
    double discount = calculator.calculate(vip);
    
    // Then (驗證)
    assertEquals(0.20, discount, 0.01);
}

@Test
public void givenEmptyCart_whenCheckout_thenThrowEmptyCartException() {
    ShoppingCart cart = new ShoppingCart();
    
    assertThrows(EmptyCartException.class, () -> {
        cart.checkout();
    });
}

@Test
public void shouldCalculate20PercentDiscountForVIPCustomer() { }

@Test
public void shouldThrowExceptionWhenPaymentFails() { }

@Test
public void shouldReturnEmptyListWhenNoOrdersFound() { }

@Test
@DisplayName("VIP 客戶應該獲得 20% 折扣")
public void calculateDiscount_WithVIPCustomer_ShouldReturn20Percent() {
    // 測試邏輯
}

@Test
@DisplayName("當購物車為空時,結帳應該拋出例外")
public void checkout_WithEmptyCart_ShouldThrowException() {
    // 測試邏輯
}

// Python pytest
def test_vip客戶應該獲得20%折扣():
    # 測試邏輯
    pass

// JavaScript Jest
test('VIP 客戶應該獲得 20% 折扣', () => {
  // 測試邏輯
});

@DisplayName("訂單服務測試")
class OrderServiceTest {
    
    @Nested
    @DisplayName("建立訂單")
    class CreateOrder {
        
        @Test
        @DisplayName("成功建立訂單")
        void shouldCreateOrderSuccessfully() { }
        
        @Test
        @DisplayName("訂單金額為負數時應拋出例外")
        void shouldThrowException_WhenAmountIsNegative() { }
    }
    
    @Nested
    @DisplayName("取消訂單")
    class CancelOrder {
        
        @Test
        @DisplayName("成功取消訂單")
        void shouldCancelOrderSuccessfully() { }
        
        @Test
        @DisplayName("已出貨訂單無法取消")
        void shouldNotCancelShippedOrder() { }
    }
}

OrderServiceTest
├─ CreateOrder
│  ├─ ✓ 成功建立訂單
│  └─ ✓ 訂單金額為負數時應拋出例外
└─ CancelOrder
   ├─ ✓ 成功取消訂單
   └─ ✓ 已出貨訂單無法取消

Arrange (準備) → Act (執行) → Assert (驗證)

@Test
public void testTransferMoney() {
    // === Arrange (準備測試資料與環境) ===
    Account fromAccount = new Account("A001", 1000);
    Account toAccount = new Account("A002", 500);
    BankService service = new BankService();
    
    // === Act (執行要測試的動作) ===
    service.transfer(fromAccount, toAccount, 300);
    
    // === Assert (驗證結果) ===
    assertEquals(700, fromAccount.getBalance());
    assertEquals(800, toAccount.getBalance());
}

@Test
public void testApplyDiscount() {
    // Arrange - 清楚區分準備階段
    // 1. 建立測試資料
    Customer vipCustomer = new Customer("John", CustomerType.VIP);
    Product product = new Product("Laptop", 30000);
    ShoppingCart cart = new ShoppingCart(vipCustomer);
    
    // 2. 設定初始狀態
    cart.addItem(product, 1);
    
    // 3. 準備相依物件(Mock)
    PaymentService mockPayment = mock(PaymentService.class);
    when(mockPayment.isAvailable()).thenReturn(true);
    
    OrderService service = new OrderService(mockPayment);
    
    // Act & Assert ...
}

// 測試資料建構器
public class CustomerBuilder {
    private String name = "Default Name";
    private CustomerType type = CustomerType.REGULAR;
    private int points = 0;
    
    public CustomerBuilder withName(String name) {
        this.name = name;
        return this;
    }
    
    public CustomerBuilder asVIP() {
        this.type = CustomerType.VIP;
        return this;
    }
    
    public CustomerBuilder withPoints(int points) {
        this.points = points;
        return this;
    }
    
    public Customer build() {
        return new Customer(name, type, points);
    }
}

// 使用
@Test
public void testVIPDiscount() {
    // Arrange - 使用 Builder 讓準備更清晰
    Customer vip = new CustomerBuilder()
        .withName("Alice")
        .asVIP()
        .withPoints(1000)
        .build();
    
    // Act
    double discount = vip.getDiscount();
    
    // Assert
    assertEquals(0.20, discount, 0.01);
}

@Test
public void testCheckout() {
    // Arrange
    ShoppingCart cart = createCartWithItems();
    
    // Act - 通常只有一行,清楚標示要測試的動作
    CheckoutResult result = cart.checkout();
    
    // Assert
    assertTrue(result.isSuccess());
}

@Test
public void testInvalidPayment_ShouldThrowException() {
    // Arrange
    PaymentService service = new PaymentService();
    Payment invalidPayment = new Payment(-100);
    
    // Act & Assert - 例外情況合併處理
    assertThrows(InvalidPaymentException.class, () -> {
        service.process(invalidPayment); // Act
    });
}

@Test
public void testAsyncOperation() throws Exception {
    // Arrange
    AsyncService service = new AsyncService();
    
    // Act
    CompletableFuture<String> future = service.processAsync("data");
    String result = future.get(5, TimeUnit.SECONDS);
    
    // Assert
    assertEquals("processed: data", result);
}

// ✅ 好的做法 - 每個測試只驗證一個概念
@Test
public void testCalculateTotal_ShouldSumAllItemPrices() {
    ShoppingCart cart = new ShoppingCart();
    cart.addItem(new Product("A", 100), 2);
    cart.addItem(new Product("B", 200), 1);
    
    int total = cart.calculateTotal();
    
    assertEquals(400, total); // 只驗證總金額計算
}

@Test
public void testAddItem_ShouldIncreaseItemCount() {
    ShoppingCart cart = new ShoppingCart();
    
    cart.addItem(new Product("A", 100), 1);
    
    assertEquals(1, cart.getItemCount()); // 只驗證數量增加
}

// ❌ 不好的做法 - 在一個測試中驗證太多事情
@Test
public void testShoppingCart() {
    ShoppingCart cart = new ShoppingCart();
    cart.addItem(new Product("A", 100), 2);
    
    assertEquals(2, cart.getItemCount());         // 驗證數量
    assertEquals(200, cart.calculateTotal());     // 驗證總額
    assertTrue(cart.hasItem("A"));                // 驗證包含商品
    assertEquals("A", cart.getItems().get(0).getName()); // 驗證商品名稱
    // 太多驗證!測試失敗時難以定位問題
}

// 數值比較
assertEquals(expected, actual);
assertEquals(expected, actual, delta); // 浮點數比較
assertNotEquals(unexpected, actual);

// 布林值
assertTrue(condition);
assertFalse(condition);

// Null 檢查
assertNull(object);
assertNotNull(object);

// 物件比較
assertSame(expected, actual);        // 同一物件
assertNotSame(unexpected, actual);

// 陣列/集合
assertArrayEquals(expectedArray, actualArray);
assertIterableEquals(expectedList, actualList);

// 例外
assertThrows(ExceptionClass.class, () -> {
    // 會拋出例外的程式碼
});

// 綜合驗證
assertAll(
    () -> assertEquals(expected1, actual1),
    () -> assertEquals(expected2, actual2),
    () -> assertTrue(condition)
);

// ❌ 沒有訊息
assertEquals(800, cart.getTotal());

// ✅ 提供清晰的錯誤訊息
assertEquals(800, cart.getTotal(), 
    "VIP 客戶購買 1000 元商品應獲得 20% 折扣,總額應為 800");

// ✅ 使用 assertAll 提供完整資訊
assertAll("訂單驗證",
    () -> assertEquals(3, order.getItemCount(), "商品數量不正確"),
    () -> assertEquals(1500, order.getTotal(), "訂單總額不正確"),
    () -> assertEquals("PENDING", order.getStatus(), "訂單狀態不正確")
);

@Test
public void testTransferWithInsufficientBalance() {
    // Arrange
    Account from = new Account(100);
    Account to = new Account(200);
    BankService service = new BankService();
    
    // Act
    TransferResult result = service.transfer(from, to, 150);
    
    // Assert
    assertFalse(result.isSuccess());
    assertEquals("Insufficient balance", result.getMessage());
}

public class OrderServiceTest {
    
    private OrderService service;
    private OrderRepository mockRepository;
    
    @BeforeEach
    public void setUp() {
        // 共用的 Arrange 邏輯
        mockRepository = mock(OrderRepository.class);
        service = new OrderService(mockRepository);
    }
    
    @Test
    public void testCreateOrder() {
        // Arrange - 只需準備此測試特有的資料
        Order order = new Order("001", 1000);
        when(mockRepository.save(any())).thenReturn(order);
        
        // Act
        Order created = service.createOrder(order);
        
        // Assert
        assertNotNull(created);
        assertEquals("001", created.getId());
    }
}

@Test
public void testApplyPromoCode() {
    // Given: VIP 客戶與有效的促銷碼
    Customer vip = new CustomerBuilder().asVIP().build();
    PromoCode code = new PromoCode("SUMMER2024", 0.15);
    Order order = new Order(vip, 1000);
    
    // When: 套用促銷碼
    order.applyPromoCode(code);
    
    // Then: 應該獲得 VIP 折扣 20% + 促銷碼 15% = 35% 折扣
    assertEquals(650, order.getFinalPrice());
}

@Test
public void testUserRegistrationAndLogin() {
    // 測試了兩件事:註冊 + 登入
    UserService service = new UserService();
    
    // 測試註冊
    User user = service.register("john@example.com", "password123");
    assertNotNull(user);
    assertEquals("john@example.com", user.getEmail());
    
    // 測試登入
    boolean loginSuccess = service.login("john@example.com", "password123");
    assertTrue(loginSuccess);
    
    // 測試登入失敗
    boolean loginFail = service.login("john@example.com", "wrongpassword");
    assertFalse(loginFail);
    
    // 太多職責!
}

@Test
public void testRegister_WithValidData_ShouldCreateUser() {
    // 只測試註冊功能
    UserService service = new UserService();
    
    User user = service.register("john@example.com", "password123");
    
    assertNotNull(user);
    assertEquals("john@example.com", user.getEmail());
}

@Test
public void testLogin_WithCorrectPassword_ShouldReturnTrue() {
    // 只測試成功登入
    UserService service = new UserService();
    service.register("john@example.com", "password123");
    
    boolean result = service.login("john@example.com", "password123");
    
    assertTrue(result);
}

@Test
public void testLogin_WithWrongPassword_ShouldReturnFalse() {
    // 只測試登入失敗
    UserService service = new UserService();
    service.register("john@example.com", "password123");
    
    boolean result = service.login("john@example.com", "wrongpassword");
    
    assertFalse(result);
}

```text

#### 🔍 識別多職責測試

**警訊:**

- 測試名稱包含"And"、"Or"

- 有多個 Act 階段

- 有多個不相關的 Assert

- 測試程式碼超過 15 行

- 註解說明"然後測試..."、"接著驗證..."


**重構範例:**


```java
// ❌ 多職責測試
@Test
public void testOrderProcessing() {
    Order order = new Order(1000);
    
    // 驗證訂單建立
    assertNotNull(order);
    
    // 加入商品
    order.addItem(new Product("A", 500), 2);
    assertEquals(1000, order.getTotal());
    
    // 套用折扣
    order.applyDiscount(0.1);
    assertEquals(900, order.getTotal());
    
    // 結帳
    order.checkout();
    assertEquals("PAID", order.getStatus());
}

// ✅ 拆分為多個單一職責測試
@Test
public void testAddItem_ShouldUpdateTotal() {
    Order order = new Order();
    
    order.addItem(new Product("A", 500), 2);
    
    assertEquals(1000, order.getTotal());
}

@Test
public void testApplyDiscount_ShouldReduceTotal() {
    Order order = new Order();
    order.addItem(new Product("A", 1000), 1);
    
    order.applyDiscount(0.1);
    
    assertEquals(900, order.getTotal());
}

@Test
public void testCheckout_ShouldChangeStatusToPaid() {
    Order order = new Order();
    order.addItem(new Product("A", 1000), 1);
    
    order.checkout();
    
    assertEquals("PAID", order.getStatus());
}

@Test
public void testSendEmail() {
    EmailService service = new EmailService();
    User dummyUser = null; // Dummy,不會被使用
    
    // 只測試郵件發送,不關心使用者物件
    service.sendEmail("test@example.com", "Subject", "Body", dummyUser);
    
    // 驗證郵件發送行為
}

// Stub 實作
public class StubPaymentService implements PaymentService {
    @Override
    public boolean process(Payment payment) {
        return true; // 總是回傳成功
    }
    
    @Override
    public PaymentStatus getStatus(String transactionId) {
        return new PaymentStatus("SUCCESS"); // 固定回應
    }
}

@Test
public void testOrderWithPaymentStub() {
    // Arrange
    PaymentService stubPayment = new StubPaymentService();
    OrderService service = new OrderService(stubPayment);
    Order order = new Order(1000);
    
    // Act
    boolean result = service.processOrder(order);
    
    // Assert
    assertTrue(result);
}

// 使用 Mockito 建立 Stub
@Test
public void testWithMockitoStub() {
    PaymentService stubPayment = mock(PaymentService.class);
    when(stubPayment.process(any())).thenReturn(true); // Stub 行為
    
    OrderService service = new OrderService(stubPayment);
    
    assertTrue(service.processOrder(new Order(1000)));
}

@Test
public void testOrderShouldCallPaymentService() {
    // Arrange
    PaymentService mockPayment = mock(PaymentService.class);
    when(mockPayment.process(any())).thenReturn(true);
    
    OrderService service = new OrderService(mockPayment);
    Order order = new Order(1000);
    
    // Act
    service.processOrder(order);
    
    // Assert - 驗證互動行為
    verify(mockPayment).process(any(Payment.class)); // 驗證被呼叫
    verify(mockPayment, times(1)).process(any());    // 驗證呼叫次數
    verify(mockPayment, never()).refund(any());      // 驗證未被呼叫
}

@Test
public void testOrderShouldPassCorrectAmount() {
    PaymentService mockPayment = mock(PaymentService.class);
    OrderService service = new OrderService(mockPayment);
    
    service.processOrder(new Order(1500));
    
    // 使用 ArgumentCaptor 捕捉傳遞的參數
    ArgumentCaptor<Payment> captor = ArgumentCaptor.forClass(Payment.class);
    verify(mockPayment).process(captor.capture());
    
    Payment captured = captor.getValue();
    assertEquals(1500, captured.getAmount());
}

// Stub: 只提供回應,不驗證行為
@Test
public void testWithStub() {
    PaymentService stub = mock(PaymentService.class);
    when(stub.process(any())).thenReturn(true);
    
    service.processOrder(order);
    
    // 不關心 process 是否被呼叫
}

// Mock: 提供回應 + 驗證行為
@Test
public void testWithMock() {
    PaymentService mock = mock(PaymentService.class);
    when(mock.process(any())).thenReturn(true);
    
    service.processOrder(order);
    
    verify(mock).process(any()); // 驗證互動
}

@Test
public void testWithSpy() {
    // 使用真實物件建立 Spy
    OrderService realService = new OrderService(realRepository, realPayment);
    OrderService spyService = spy(realService);
    
    // 只覆寫特定方法
    doReturn(true).when(spyService).isValidOrder(any());
    
    // 其他方法使用真實實作
    spyService.processOrder(order);
    
    // 可以驗證真實方法的呼叫
    verify(spyService).sendConfirmationEmail(any());
}

@Test
public void testPartialMock() {
    List<String> list = new ArrayList<>();
    List<String> spyList = spy(list);
    
    // 真實行為
    spyList.add("item1");
    assertEquals(1, spyList.size()); // 真實的 size()
    
    // 覆寫特定方法
    when(spyList.size()).thenReturn(100);
    assertEquals(100, spyList.size()); // 使用模擬的 size()
}

// ❌ 錯誤:會真的呼叫方法
when(spyList.get(0)).thenReturn("mocked");

// ✅ 正確:使用 doReturn
doReturn("mocked").when(spyList).get(0);

// Fake 實作:記憶體版本的 Repository
public class FakeOrderRepository implements OrderRepository {
    private Map<String, Order> storage = new HashMap<>();
    private int idCounter = 1;
    
    @Override
    public Order save(Order order) {
        if (order.getId() == null) {
            order.setId(String.valueOf(idCounter++));
        }
        storage.put(order.getId(), order);
        return order;
    }
    
    @Override
    public Order findById(String id) {
        Order order = storage.get(id);
        if (order == null) {
            throw new OrderNotFoundException();
        }
        return order;
    }
    
    @Override
    public List<Order> findAll() {
        return new ArrayList<>(storage.values());
    }
}

@Test
public void testWithFakeRepository() {
    // 使用 Fake 替代真實資料庫
    OrderRepository fakeRepo = new FakeOrderRepository();
    OrderService service = new OrderService(fakeRepo);
    
    Order order = new Order(1000);
    Order saved = service.createOrder(order);
    
    assertNotNull(saved.getId());
    assertEquals(order.getAmount(), saved.getAmount());
    
    // Fake 有真實的行為,可以查詢
    Order found = fakeRepo.findById(saved.getId());
    assertEquals(saved.getId(), found.getId());
}

// ✅ 優先使用真實物件
@Test
public void testOrderCalculation() {
    Order order = new Order(); // 真實物件
    order.addItem(new Product("A", 100), 2);
    
    assertEquals(200, order.getTotal());
}

// ⚠️ 只在必要時使用 Mock
@Test
public void testOrderWithExternalService() {
    PaymentService mockPayment = mock(PaymentService.class); // 外部服務才 Mock
    Order order = new Order(); // 內部邏輯用真實物件
    
    OrderService service = new OrderService(mockPayment);
    service.processOrder(order);
}

// ❌ 過度 Mock
@Test
public void testBadExample() {
    Product mockProduct = mock(Product.class);
    when(mockProduct.getPrice()).thenReturn(100);
    when(mockProduct.getName()).thenReturn("Product");
    
    Customer mockCustomer = mock(Customer.class);
    when(mockCustomer.getName()).thenReturn("John");
    
    // 所有東西都 Mock,失去測試意義!
}

// ✅ 適度使用
@Test
public void testGoodExample() {
    Product product = new Product("Product", 100); // 真實物件
    Customer customer = new Customer("John");      // 真實物件
    
    PaymentService mockPayment = mock(PaymentService.class); // 只 Mock 外部依賴
    when(mockPayment.process(any())).thenReturn(true);
}

✅ 應該 Mock:

- 資料庫

- 外部 API

- 檔案系統

- 網路服務

- 時間/日期

- 隨機數生成器


❌ 不要 Mock:

- 值物件(Value Objects)

- 資料傳輸物件(DTOs)

- 簡單的業務邏輯

- 被測試的類別本身

// ❌ 錯誤:測試間有相依性
public class UserServiceTest {
    private static User createdUser; // 共享狀態!
    
    @Test
    public void test1_CreateUser() {
        UserService service = new UserService();
        createdUser = service.create("john@example.com");
        assertNotNull(createdUser);
    }
    
    @Test
    public void test2_UpdateUser() {
        // 依賴 test1 的結果
        createdUser.setName("John Doe");
        service.update(createdUser);
    }
}

// ✅ 正確:每個測試獨立
public class UserServiceTest {
    
    @Test
    public void testCreateUser() {
        UserService service = new UserService();
        User user = service.create("john@example.com");
        assertNotNull(user);
    }
    
    @Test
    public void testUpdateUser() {
        UserService service = new UserService();
        // 自行準備測試資料,不依賴其他測試
        User user = service.create("john@example.com");
        user.setName("John Doe");
        
        User updated = service.update(user);
        assertEquals("John Doe", updated.getName());
    }
}

// ❌ 錯誤:測試實作細節
@Test
public void testCalculateDiscount() {
    Order order = new Order(1000);
    
    // 測試內部欄位(實作細節)
    Field field = Order.class.getDeclaredField("discountRate");
    field.setAccessible(true);
    assertEquals(0.1, field.get(order));
    
    // 測試私有方法(實作細節)
    Method method = Order.class.getDeclaredMethod("calculateDiscountAmount");
    method.setAccessible(true);
    assertEquals(100, method.invoke(order));
}

// ✅ 正確:測試外部行為
@Test
public void testCalculateDiscount() {
    Order order = new Order(1000);
    order.applyDiscount(0.1);
    
    // 只測試公開 API 的行為
    assertEquals(900, order.getFinalPrice());
}

// ❌ 脆弱:硬編碼順序與格式
@Test
public void testGetUserList() {
    List<User> users = service.getAllUsers();
    
    assertEquals("John", users.get(0).getName());
    assertEquals("Jane", users.get(1).getName());
    assertEquals("Bob", users.get(2).getName());
    // 新增使用者或改變順序就會失敗
}

// ✅ 穩定:測試業務邏輯而非實作細節
@Test
public void testGetUserList_ShouldContainAllUsers() {
    List<User> users = service.getAllUsers();
    
    assertEquals(3, users.size());
    assertTrue(users.stream().anyMatch(u -> "John".equals(u.getName())));
    assertTrue(users.stream().anyMatch(u -> "Jane".equals(u.getName())));
    assertTrue(users.stream().anyMatch(u -> "Bob".equals(u.getName())));
}

// ❌ 不完整:只測試正常情況
@Test
public void testDivide() {
    Calculator calc = new Calculator();
    assertEquals(5, calc.divide(10, 2));
}

// ✅ 完整:涵蓋邊界條件
@Test
public void testDivide_NormalCase() {
    Calculator calc = new Calculator();
    assertEquals(5, calc.divide(10, 2));
}

@Test
public void testDivide_ByZero_ShouldThrowException() {
    Calculator calc = new Calculator();
    assertThrows(ArithmeticException.class, () -> {
        calc.divide(10, 0);
    });
}

@Test
public void testDivide_WithNegativeNumbers() {
    Calculator calc = new Calculator();
    assertEquals(-5, calc.divide(-10, 2));
    assertEquals(-5, calc.divide(10, -2));
    assertEquals(5, calc.divide(-10, -2));
}

@Test
public void testDivide_WithZeroDividend() {
    Calculator calc = new Calculator();
    assertEquals(0, calc.divide(0, 5));
}

// ❌ 重複的測試準備
@Test
public void testVIPDiscount() {
    Customer customer = new Customer("John");
    customer.setType(CustomerType.VIP);
    customer.setPoints(1000);
    Product product = new Product("Laptop", 30000);
    ShoppingCart cart = new ShoppingCart(customer);
    cart.addItem(product, 1);
    
    assertEquals(24000, cart.getTotal());
}

@Test
public void testRegularCustomer() {
    Customer customer = new Customer("Jane");
    customer.setType(CustomerType.REGULAR);
    customer.setPoints(0);
    Product product = new Product("Laptop", 30000);
    ShoppingCart cart = new ShoppingCart(customer);
    cart.addItem(product, 1);
    
    assertEquals(30000, cart.getTotal());
}

// ✅ 提取共用邏輯
public class ShoppingCartTest {
    
    private Product laptop;
    
    @BeforeEach
    public void setUp() {
        laptop = new Product("Laptop", 30000);
    }
    
    private ShoppingCart createCartWithCustomer(CustomerType type) {
        Customer customer = new Customer("Test User");
        customer.setType(type);
        ShoppingCart cart = new ShoppingCart(customer);
        cart.addItem(laptop, 1);
        return cart;
    }
    
    @Test
    public void testVIPDiscount() {
        ShoppingCart cart = createCartWithCustomer(CustomerType.VIP);
        assertEquals(24000, cart.getTotal());
    }
    
    @Test
    public void testRegularCustomer() {
        ShoppingCart cart = createCartWithCustomer(CustomerType.REGULAR);
        assertEquals(30000, cart.getTotal());
    }
}

// ❌ 無效測試:沒有 assert
@Test
public void testProcessOrder() {
    OrderService service = new OrderService();
    Order order = new Order(1000);
    service.processOrder(order); // 沒有驗證!
}

// ✅ 有效測試:明確驗證結果
@Test
public void testProcessOrder_ShouldChangeStatus() {
    OrderService service = new OrderService();
    Order order = new Order(1000);
    
    service.processOrder(order);
    
    assertEquals("PROCESSED", order.getStatus());
}

// ❌ 不可靠:使用 sleep
@Test
public void testAsyncOperation() throws Exception {
    service.processAsync();
    Thread.sleep(1000); // 不可靠!
    assertTrue(service.isCompleted());
}

// ✅ 可靠:使用適當的同步機制
@Test
public void testAsyncOperation() throws Exception {
    CompletableFuture<Void> future = service.processAsync();
    future.get(5, TimeUnit.SECONDS); // 最多等待 5 秒
    assertTrue(service.isCompleted());
}

// ✅ 或使用 Awaitility 庫
@Test
public void testAsyncWithAwaitility() {
    service.processAsync();
    
    await().atMost(5, SECONDS)
           .until(() -> service.isCompleted());
}

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

public class CalculatorTest {
    
    @Test
    public void testAdd_TwoPositiveNumbers_ShouldReturnSum() {
        // Arrange
        Calculator calculator = new Calculator();
        
        // Act
        int result = calculator.add(2, 3);
        
        // Assert
        assertEquals(5, result);
    }
}

# 測試失敗:Calculator 類別不存在
Error: Cannot resolve symbol 'Calculator'

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

# 測試通過 ✅
Tests run: 1, Failures: 0, Errors: 0

@Test
public void testAdd_WithNegativeNumbers_ShouldReturnCorrectSum() {
    Calculator calculator = new Calculator();
    
    assertEquals(-1, calculator.add(-2, 1));
    assertEquals(-5, calculator.add(-2, -3));
}

@Test
public void testAdd_WithZero_ShouldReturnOtherNumber() {
    Calculator calculator = new Calculator();
    
    assertEquals(5, calculator.add(0, 5));
    assertEquals(5, calculator.add(5, 0));
    assertEquals(0, calculator.add(0, 0));
}

@Test
public void testAdd_WithLargeNumbers_ShouldNotOverflow() {
    Calculator calculator = new Calculator();
    
    // 使用 long 避免溢位
    assertEquals(3000000000L, calculator.addLong(2000000000L, 1000000000L));
}

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public long addLong(long a, long b) {
        return a + b;
    }
}

public class CalculatorTest {
    
    private Calculator calculator;
    
    @BeforeEach
    public void setUp() {
        calculator = new Calculator();
    }
    
    @Test
    public void testAdd_TwoPositiveNumbers_ShouldReturnSum() {
        assertEquals(5, calculator.add(2, 3));
    }
    
    @Test
    public void testAdd_WithNegativeNumbers_ShouldReturnCorrectSum() {
        assertEquals(-1, calculator.add(-2, 1));
        assertEquals(-5, calculator.add(-2, -3));
    }
    
    // ... 其他測試
}

@Test
public void testSubtract_TwoPositiveNumbers_ShouldReturnDifference() {
    assertEquals(2, calculator.subtract(5, 3));
}

@Test
public void testSubtract_ResultIsNegative_ShouldReturnNegativeNumber() {
    assertEquals(-2, calculator.subtract(3, 5));
}

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int subtract(int a, int b) {
        return a - b;
    }
    
    public long addLong(long a, long b) {
        return a + b;
    }
}

@Test
public void testMultiply_TwoPositiveNumbers_ShouldReturnProduct() {
    assertEquals(15, calculator.multiply(3, 5));
}

@Test
public void testMultiply_WithZero_ShouldReturnZero() {
    assertEquals(0, calculator.multiply(5, 0));
    assertEquals(0, calculator.multiply(0, 5));
}

@Test
public void testMultiply_WithNegativeNumber_ShouldReturnNegativeProduct() {
    assertEquals(-15, calculator.multiply(-3, 5));
    assertEquals(-15, calculator.multiply(3, -5));
    assertEquals(15, calculator.multiply(-3, -5));
}

@Test
public void testDivide_TwoPositiveNumbers_ShouldReturnQuotient() {
    assertEquals(3, calculator.divide(15, 5));
}

@Test
public void testDivide_WithRemainder_ShouldReturnIntegerPart() {
    assertEquals(3, calculator.divide(10, 3));
}

@Test
public void testDivide_ByZero_ShouldThrowArithmeticException() {
    assertThrows(ArithmeticException.class, () -> {
        calculator.divide(10, 0);
    });
}

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int subtract(int a, int b) {
        return a - b;
    }
    
    public int multiply(int a, int b) {
        return a * b;
    }
    
    public int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return a / b;
    }
    
    public long addLong(long a, long b) {
        return a + b;
    }
}

public class Calculator {
    
    public int add(int a, int b) {
        return a + b;
    }
    
    public long addLong(long a, long b) {
        return a + b;
    }
    
    public int subtract(int a, int b) {
        return a - b;
    }
    
    public int multiply(int a, int b) {
        return a * b;
    }
    
    public int divide(int a, int b) {
        validateDivisor(b);
        return a / b;
    }
    
    public double divideAsDouble(int a, int b) {
        validateDivisor(b);
        return (double) a / b;
    }
    
    private void validateDivisor(int divisor) {
        if (divisor == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
    }
}

mvn clean test jacoco:report

-------------------------------------------------------
Calculator Coverage Report
-------------------------------------------------------
Class           Line Coverage   Branch Coverage
-------------------------------------------------------
Calculator      100% (15/15)    100% (4/4)
-------------------------------------------------------

{
  "id": "ORD-001",
  "customerId": "CUST-001",
  "items": [
    {"productId": "P001", "quantity": 2, "price": 100}
  ],
  "totalAmount": 200,
  "status": "PENDING"
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(OrderController.class)
public class OrderControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private OrderService orderService;
    
    @Test
    public void testCreateOrder_WithValidData_ShouldReturn201Created() throws Exception {
        // Arrange
        String requestBody = """
            {
                "customerId": "CUST-001",
                "items": [
                    {"productId": "P001", "quantity": 2, "price": 100}
                ]
            }
            """;
        
        Order createdOrder = new Order("ORD-001", "CUST-001", 200, "PENDING");
        when(orderService.createOrder(any(OrderRequest.class)))
            .thenReturn(createdOrder);
        
        // Act & Assert
        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(requestBody))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").value("ORD-001"))
            .andExpect(jsonPath("$.customerId").value("CUST-001"))
            .andExpect(jsonPath("$.totalAmount").value(200))
            .andExpect(jsonPath("$.status").value("PENDING"));
    }
    
    @Test
    public void testCreateOrder_WithInvalidData_ShouldReturn400BadRequest() throws Exception {
        // Arrange
        String invalidRequest = """
            {
                "customerId": "",
                "items": []
            }
            """;
        
        // Act & Assert
        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(invalidRequest))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.error").exists());
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    
    private final OrderService orderService;
    
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
            @Valid @RequestBody OrderRequest request) {
        
        Order order = orderService.createOrder(request);
        OrderResponse response = OrderResponse.from(order);
        
        return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(response);
    }
}

public class OrderRequest {
    @NotBlank(message = "Customer ID is required")
    private String customerId;
    
    @NotEmpty(message = "Items cannot be empty")
    private List<OrderItemRequest> items;
    
    // Getters and Setters
}

public class OrderItemRequest {
    @NotBlank
    private String productId;
    
    @Min(1)
    private int quantity;
    
    @Min(0)
    private double price;
    
    // Getters and Setters
}

public record OrderResponse(
    String id,
    String customerId,
    double totalAmount,
    String status
) {
    public static OrderResponse from(Order order) {
        return new OrderResponse(
            order.getId(),
            order.getCustomerId(),
            order.getTotalAmount(),
            order.getStatus()
        );
    }
}

@ExtendWith(MockitoExtension.class)
public class OrderServiceTest {
    
    @Mock
    private OrderRepository orderRepository;
    
    @Mock
    private InventoryService inventoryService;
    
    @InjectMocks
    private OrderService orderService;
    
    @Test
    public void testCreateOrder_ShouldGenerateOrderIdAndSave() {
        // Arrange
        OrderRequest request = createValidOrderRequest();
        Order expectedOrder = new Order("ORD-001", "CUST-001", 200, "PENDING");
        
        when(inventoryService.checkAvailability(anyString(), anyInt()))
            .thenReturn(true);
        when(orderRepository.save(any(Order.class)))
            .thenReturn(expectedOrder);
        
        // Act
        Order result = orderService.createOrder(request);
        
        // Assert
        assertNotNull(result.getId());
        assertEquals("CUST-001", result.getCustomerId());
        assertEquals(200, result.getTotalAmount());
        assertEquals("PENDING", result.getStatus());
        
        verify(orderRepository).save(any(Order.class));
    }
    
    @Test
    public void testCreateOrder_WhenInventoryInsufficient_ShouldThrowException() {
        // Arrange
        OrderRequest request = createValidOrderRequest();
        
        when(inventoryService.checkAvailability(anyString(), anyInt()))
            .thenReturn(false);
        
        // Act & Assert
        assertThrows(InsufficientInventoryException.class, () -> {
            orderService.createOrder(request);
        });
        
        verify(orderRepository, never()).save(any());
    }
    
    private OrderRequest createValidOrderRequest() {
        OrderRequest request = new OrderRequest();
        request.setCustomerId("CUST-001");
        
        OrderItemRequest item = new OrderItemRequest();
        item.setProductId("P001");
        item.setQuantity(2);
        item.setPrice(100);
        
        request.setItems(List.of(item));
        return request;
    }
}

@Service
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    
    public OrderService(OrderRepository orderRepository, 
                       InventoryService inventoryService) {
        this.orderRepository = orderRepository;
        this.inventoryService = inventoryService;
    }
    
    @Transactional
    public Order createOrder(OrderRequest request) {
        // 驗證庫存
        validateInventory(request);
        
        // 計算總額
        double totalAmount = calculateTotalAmount(request.getItems());
        
        // 建立訂單
        Order order = new Order(
            generateOrderId(),
            request.getCustomerId(),
            totalAmount,
            "PENDING"
        );
        
        // 儲存訂單
        return orderRepository.save(order);
    }
    
    private void validateInventory(OrderRequest request) {
        for (OrderItemRequest item : request.getItems()) {
            boolean available = inventoryService.checkAvailability(
                item.getProductId(),
                item.getQuantity()
            );
            
            if (!available) {
                throw new InsufficientInventoryException(
                    "Product " + item.getProductId() + " is not available"
                );
            }
        }
    }
    
    private double calculateTotalAmount(List<OrderItemRequest> items) {
        return items.stream()
            .mapToDouble(item -> item.getPrice() * item.getQuantity())
            .sum();
    }
    
    private String generateOrderId() {
        return "ORD-" + UUID.randomUUID().toString().substring(0, 8).toUpperCase();
    }
}

@Test
public void testGetOrder_WithValidId_ShouldReturn200AndOrder() throws Exception {
    // Arrange
    Order order = new Order("ORD-001", "CUST-001", 200, "PENDING");
    when(orderService.getOrderById("ORD-001")).thenReturn(order);
    
    // Act & Assert
    mockMvc.perform(get("/api/orders/ORD-001"))
        .andExpect(status().isOk())
        .andExpect(jsonPath("$.id").value("ORD-001"))
        .andExpect(jsonPath("$.customerId").value("CUST-001"));
}

@Test
public void testGetOrder_WithInvalidId_ShouldReturn404NotFound() throws Exception {
    // Arrange
    when(orderService.getOrderById("INVALID"))
        .thenThrow(new OrderNotFoundException("Order not found"));
    
    // Act & Assert
    mockMvc.perform(get("/api/orders/INVALID"))
        .andExpect(status().isNotFound())
        .andExpect(jsonPath("$.error").value("Order not found"));
}

@Test
public void testGetAllOrders_ShouldReturnOrderList() throws Exception {
    // Arrange
    List<Order> orders = List.of(
        new Order("ORD-001", "CUST-001", 200, "PENDING"),
        new Order("ORD-002", "CUST-002", 300, "COMPLETED")
    );
    when(orderService.getAllOrders()).thenReturn(orders);
    
    // Act & Assert
    mockMvc.perform(get("/api/orders"))
        .andExpect(status().isOk())
        .andExpect(jsonPath("$").isArray())
        .andExpect(jsonPath("$.length()").value(2))
        .andExpect(jsonPath("$[0].id").value("ORD-001"))
        .andExpect(jsonPath("$[1].id").value("ORD-002"));
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    
    private final OrderService orderService;
    
    // ... constructor
    
    @GetMapping("/{id}")
    public ResponseEntity<OrderResponse> getOrder(@PathVariable String id) {
        Order order = orderService.getOrderById(id);
        return ResponseEntity.ok(OrderResponse.from(order));
    }
    
    @GetMapping
    public ResponseEntity<List<OrderResponse>> getAllOrders() {
        List<Order> orders = orderService.getAllOrders();
        List<OrderResponse> responses = orders.stream()
            .map(OrderResponse::from)
            .toList();
        return ResponseEntity.ok(responses);
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(OrderNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleOrderNotFound(
            OrderNotFoundException ex) {
        
        ErrorResponse error = new ErrorResponse(
            "NOT_FOUND",
            ex.getMessage()
        );
        
        return ResponseEntity
            .status(HttpStatus.NOT_FOUND)
            .body(error);
    }
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationError(
            MethodArgumentNotValidException ex) {
        
        String message = ex.getBindingResult()
            .getFieldErrors()
            .stream()
            .map(FieldError::getDefaultMessage)
            .collect(Collectors.joining(", "));
        
        ErrorResponse error = new ErrorResponse(
            "VALIDATION_ERROR",
            message
        );
        
        return ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(error);
    }
}

public record ErrorResponse(String code, String message) {}

@Test
public void testCancelOrder_WithPendingOrder_ShouldReturn200() throws Exception {
    // Arrange
    Order cancelledOrder = new Order("ORD-001", "CUST-001", 200, "CANCELLED");
    when(orderService.cancelOrder("ORD-001")).thenReturn(cancelledOrder);
    
    // Act & Assert
    mockMvc.perform(put("/api/orders/ORD-001/cancel"))
        .andExpect(status().isOk())
        .andExpect(jsonPath("$.status").value("CANCELLED"));
}

@Test
public void testCancelOrder_WithCompletedOrder_ShouldReturn400() throws Exception {
    // Arrange
    when(orderService.cancelOrder("ORD-001"))
        .thenThrow(new IllegalOrderStateException("Cannot cancel completed order"));
    
    // Act & Assert
    mockMvc.perform(put("/api/orders/ORD-001/cancel"))
        .andExpect(status().isBadRequest())
        .andExpect(jsonPath("$.error").exists());
}

@PutMapping("/{id}/cancel")
public ResponseEntity<OrderResponse> cancelOrder(@PathVariable String id) {
    Order order = orderService.cancelOrder(id);
    return ResponseEntity.ok(OrderResponse.from(order));
}

```text

**Service 層實作:**


```java
@Transactional
public Order cancelOrder(String orderId) {
    Order order = getOrderById(orderId);
    
    if (!order.canBeCancelled()) {
        throw new IllegalOrderStateException(
            "Order in status " + order.getStatus() + " cannot be cancelled"
        );
    }
    
    order.cancel();
    return orderRepository.save(order);
}

@Entity
public class Order {
    @Id
    private String id;
    private String customerId;
    private double totalAmount;
    private String status;
    
    // ... constructors, getters, setters
    
    public boolean canBeCancelled() {
        return "PENDING".equals(status) || "CONFIRMED".equals(status);
    }
    
    public void cancel() {
        if (!canBeCancelled()) {
            throw new IllegalOrderStateException("Cannot cancel order");
        }
        this.status = "CANCELLED";
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Sql(scripts = "/test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
@Sql(scripts = "/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
public class OrderIntegrationTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    public void testCompleteOrderWorkflow() {
        // 1. 建立訂單
        OrderRequest request = createOrderRequest();
        ResponseEntity<OrderResponse> createResponse = restTemplate.postForEntity(
            "/api/orders",
            request,
            OrderResponse.class
        );
        
        assertEquals(HttpStatus.CREATED, createResponse.getStatusCode());
        String orderId = createResponse.getBody().id();
        assertNotNull(orderId);
        
        // 2. 查詢訂單
        ResponseEntity<OrderResponse> getResponse = restTemplate.getForEntity(
            "/api/orders/" + orderId,
            OrderResponse.class
        );
        
        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
        assertEquals("PENDING", getResponse.getBody().status());
        
        // 3. 取消訂單
        ResponseEntity<OrderResponse> cancelResponse = restTemplate.exchange(
            "/api/orders/" + orderId + "/cancel",
            HttpMethod.PUT,
            null,
            OrderResponse.class
        );
        
        assertEquals(HttpStatus.OK, cancelResponse.getStatusCode());
        assertEquals("CANCELLED", cancelResponse.getBody().status());
    }
}

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
public class CustomerRepositoryTest {
    
    @Autowired
    private CustomerRepository customerRepository;
    
    @Autowired
    private TestEntityManager entityManager;
    
    @BeforeEach
    public void setUp() {
        customerRepository.deleteAll();
    }
    
    // ... 測試方法
}

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
  h2:
    console:
      enabled: true

@Test
public void testSave_NewCustomer_ShouldGenerateIdAndSave() {
    // Arrange
    Customer customer = new Customer(
        null,
        "John Doe",
        "john@example.com",
        "0912345678",
        true
    );
    
    // Act
    Customer saved = customerRepository.save(customer);
    
    // Assert
    assertNotNull(saved.getId());
    assertEquals("John Doe", saved.getName());
    assertEquals("john@example.com", saved.getEmail());
    assertTrue(saved.isActive());
}

@Test
public void testFindById_WithExistingId_ShouldReturnCustomer() {
    // Arrange
    Customer customer = createAndSaveCustomer("John Doe", "john@example.com");
    
    // Act
    Optional<Customer> found = customerRepository.findById(customer.getId());
    
    // Assert
    assertTrue(found.isPresent());
    assertEquals("John Doe", found.get().getName());
}

@Test
public void testFindById_WithNonExistingId_ShouldReturnEmpty() {
    // Act
    Optional<Customer> found = customerRepository.findById(999L);
    
    // Assert
    assertFalse(found.isPresent());
}

@Entity
@Table(name = "customers")
public class Customer {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    private String phone;
    
    @Column(nullable = false)
    private boolean active = true;
    
    @CreatedDate
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    private LocalDateTime updatedAt;
    
    // Constructors, Getters, Setters
}

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    // 基本方法由 JpaRepository 提供
}

@Test
public void testFindByEmail_WithExistingEmail_ShouldReturnCustomer() {
    // Arrange
    Customer customer = createAndSaveCustomer("John Doe", "john@example.com");
    
    // Act
    Optional<Customer> found = customerRepository.findByEmail("john@example.com");
    
    // Assert
    assertTrue(found.isPresent());
    assertEquals("John Doe", found.get().getName());
}

@Test
public void testFindByEmail_WithNonExistingEmail_ShouldReturnEmpty() {
    // Act
    Optional<Customer> found = customerRepository.findByEmail("nonexist@example.com");
    
    // Assert
    assertFalse(found.isPresent());
}

@Test
public void testFindAllByActiveTrue_ShouldReturnOnlyActiveCustomers() {
    // Arrange
    Customer active1 = createAndSaveCustomer("John", "john@example.com");
    Customer active2 = createAndSaveCustomer("Jane", "jane@example.com");
    Customer inactive = createAndSaveCustomer("Bob", "bob@example.com");
    inactive.setActive(false);
    customerRepository.save(inactive);
    
    // Act
    List<Customer> activeCustomers = customerRepository.findAllByActiveTrue();
    
    // Assert
    assertEquals(2, activeCustomers.size());
    assertTrue(activeCustomers.stream()
        .allMatch(Customer::isActive));
}

@Test
public void testFindByNameContaining_ShouldReturnMatchingCustomers() {
    // Arrange
    createAndSaveCustomer("John Doe", "john@example.com");
    createAndSaveCustomer("Jane Doe", "jane@example.com");
    createAndSaveCustomer("Bob Smith", "bob@example.com");
    
    // Act
    List<Customer> results = customerRepository.findByNameContaining("Doe");
    
    // Assert
    assertEquals(2, results.size());
    assertTrue(results.stream()
        .allMatch(c -> c.getName().contains("Doe")));
}

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    
    Optional<Customer> findByEmail(String email);
    
    List<Customer> findAllByActiveTrue();
    
    List<Customer> findByNameContaining(String name);
}

@Test
public void testFindActiveCustomersWithRecentActivity_ShouldReturnCorrectList() {
    // Arrange
    LocalDateTime thirtyDaysAgo = LocalDateTime.now().minusDays(30);
    
    Customer recent = createAndSaveCustomer("Recent User", "recent@example.com");
    recent.setLastActivityDate(LocalDateTime.now().minusDays(5));
    customerRepository.save(recent);
    
    Customer old = createAndSaveCustomer("Old User", "old@example.com");
    old.setLastActivityDate(LocalDateTime.now().minusDays(60));
    customerRepository.save(old);
    
    Customer inactive = createAndSaveCustomer("Inactive User", "inactive@example.com");
    inactive.setActive(false);
    inactive.setLastActivityDate(LocalDateTime.now().minusDays(5));
    customerRepository.save(inactive);
    
    // Act
    List<Customer> results = customerRepository
        .findActiveCustomersWithRecentActivity(thirtyDaysAgo);
    
    // Assert
    assertEquals(1, results.size());
    assertEquals("Recent User", results.get(0).getName());
}

@Test
public void testCountByActiveTrue_ShouldReturnActiveCustomerCount() {
    // Arrange
    createAndSaveCustomer("User1", "user1@example.com");
    createAndSaveCustomer("User2", "user2@example.com");
    
    Customer inactive = createAndSaveCustomer("User3", "user3@example.com");
    inactive.setActive(false);
    customerRepository.save(inactive);
    
    // Act
    long count = customerRepository.countByActiveTrue();
    
    // Assert
    assertEquals(2, count);
}

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    
    Optional<Customer> findByEmail(String email);
    
    List<Customer> findAllByActiveTrue();
    
    List<Customer> findByNameContaining(String name);
    
    @Query("SELECT c FROM Customer c WHERE c.active = true " +
           "AND c.lastActivityDate >= :since")
    List<Customer> findActiveCustomersWithRecentActivity(
        @Param("since") LocalDateTime since);
    
    long countByActiveTrue();
    
    @Query("SELECT c FROM Customer c WHERE c.email LIKE %:domain")
    List<Customer> findByEmailDomain(@Param("domain") String domain);
}

@Test
public void testUpdateCustomerEmail_ShouldUpdateAndPersist() {
    // Arrange
    Customer customer = createAndSaveCustomer("John Doe", "old@example.com");
    Long customerId = customer.getId();
    
    // Act
    customer.setEmail("new@example.com");
    customerRepository.save(customer);
    entityManager.flush();
    entityManager.clear(); // 清除快取,強制重新查詢
    
    // Assert
    Customer updated = customerRepository.findById(customerId).orElseThrow();
    assertEquals("new@example.com", updated.getEmail());
}

@Test
public void testDeleteCustomer_ShouldRemoveFromDatabase() {
    // Arrange
    Customer customer = createAndSaveCustomer("John Doe", "john@example.com");
    Long customerId = customer.getId();
    
    // Act
    customerRepository.delete(customer);
    entityManager.flush();
    
    // Assert
    Optional<Customer> found = customerRepository.findById(customerId);
    assertFalse(found.isPresent());
}

@Test
public void testSoftDelete_ShouldSetActiveToFalse() {
    // Arrange
    Customer customer = createAndSaveCustomer("John Doe", "john@example.com");
    Long customerId = customer.getId();
    
    // Act
    customerRepository.softDelete(customerId);
    entityManager.flush();
    entityManager.clear();
    
    // Assert
    Customer found = customerRepository.findById(customerId).orElseThrow();
    assertFalse(found.isActive());
}

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    
    // ... 其他方法
    
    @Modifying
    @Query("UPDATE Customer c SET c.active = false WHERE c.id = :id")
    void softDelete(@Param("id") Long id);
}

@Service
public class CustomerService {
    
    private final CustomerRepository customerRepository;
    
    public CustomerService(CustomerRepository customerRepository) {
        this.customerRepository = customerRepository;
    }
    
    @Transactional
    public void softDeleteCustomer(Long customerId) {
        customerRepository.softDelete(customerId);
    }
}

@DataJpaTest
public class CustomerRepositoryTest {
    
    @Autowired
    private CustomerRepository customerRepository;
    
    @Autowired
    private TestEntityManager entityManager;
    
    // 輔助方法:建立並儲存客戶
    private Customer createAndSaveCustomer(String name, String email) {
        Customer customer = new Customer();
        customer.setName(name);
        customer.setEmail(email);
        customer.setPhone("0912345678");
        customer.setActive(true);
        customer.setLastActivityDate(LocalDateTime.now());
        return customerRepository.save(customer);
    }
    
    // 輔助方法:建立客戶建構器
    private CustomerBuilder aCustomer() {
        return new CustomerBuilder();
    }
    
    private static class CustomerBuilder {
        private String name = "Default Name";
        private String email = "default@example.com";
        private String phone = "0912345678";
        private boolean active = true;
        
        public CustomerBuilder withName(String name) {
            this.name = name;
            return this;
        }
        
        public CustomerBuilder withEmail(String email) {
            this.email = email;
            return this;
        }
        
        public CustomerBuilder inactive() {
            this.active = false;
            return this;
        }
        
        public Customer build() {
            Customer customer = new Customer();
            customer.setName(name);
            customer.setEmail(email);
            customer.setPhone(phone);
            customer.setActive(active);
            customer.setLastActivityDate(LocalDateTime.now());
            return customer;
        }
    }
    
    // 使用建構器的測試
    @Test
    public void testWithBuilder() {
        // Arrange
        Customer customer = aCustomer()
            .withName("John Doe")
            .withEmail("john@example.com")
            .inactive()
            .build();
        
        // Act
        Customer saved = customerRepository.save(customer);
        
        // Assert
        assertFalse(saved.isActive());
    }
}

## Definition of Done


- [ ] 程式碼已完成

- [ ] 單元測試已撰寫且通過(覆蓋率 > 80%)

- [ ] 整合測試已通過

- [ ] Code Review 已完成

- [ ] CI/CD Pipeline 執行成功

- [ ] 文件已更新

- [ ] 已合併至主分支

// 開發者 A 寫測試
@Test
public void testCalculateShippingCost_ForStandardDelivery() {
    Order order = new Order(1000);
    assertEquals(50, order.calculateShippingCost("STANDARD"));
}

// 開發者 B 實作
public class Order {
    private double amount;
    
    public double calculateShippingCost(String type) {
        if ("STANDARD".equals(type)) {
            return 50;
        }
        return 0;
    }
}

// 兩人一起重構
public class Order {
    private static final Map<String, Double> SHIPPING_COSTS = Map.of(
        "STANDARD", 50.0,
        "EXPRESS", 100.0
    );
    
    public double calculateShippingCost(String type) {
        return SHIPPING_COSTS.getOrDefault(type, 0.0);
    }
}

## 測試審查檢查清單

### 測試品質

- [ ] 測試命名清晰描述測試意圖

- [ ] 使用 AAA 模式組織測試

- [ ] 每個測試只驗證一個概念

- [ ] 測試彼此獨立,無相依性


### 測試覆蓋

- [ ] 涵蓋正常流程

- [ ] 涵蓋邊界條件

- [ ] 涵蓋異常情況

- [ ] 覆蓋率達到團隊標準(80%+)


### 測試可維護性

- [ ] 沒有重複的測試邏輯

- [ ] 使用測試輔助方法或 Builder

- [ ] Mock 使用適當(不過度)

- [ ] 測試資料清晰易懂


### 測試執行

- [ ] 測試執行速度合理(<5 秒)

- [ ] 測試在 CI 中穩定通過

- [ ] 沒有使用 Thread.sleep()

- [ ] 沒有依賴外部環境

// ❌ 待審查的程式碼
@Test
public void testCreateOrder() {
    Product mockProduct = mock(Product.class);
    when(mockProduct.getPrice()).thenReturn(100);
    when(mockProduct.getName()).thenReturn("Product");
    
    Customer mockCustomer = mock(Customer.class);
    when(mockCustomer.getName()).thenReturn("John");
    
    // 過度 Mock
}

// 💬 Code Review 意見
@Reviewer: "這個測試過度使用 Mock,Product 和 Customer 
是簡單的值物件,建議使用真實物件。"

// ✅ 改進後
@Test
public void testCreateOrder() {
    Product product = new Product("Product", 100);
    Customer customer = new Customer("John");
    
    // 更簡潔,更真實
}

pipeline {
    agent any
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Build') {
            steps {
                sh 'mvn clean compile'
            }
        }
        
        stage('Unit Tests') {
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    junit 'target/surefire-reports/*.xml'
                    jacoco(
                        execPattern: 'target/*.exec',
                        classPattern: 'target/classes',
                        sourcePattern: 'src/main/java'
                    )
                }
            }
        }
        
        stage('Quality Gate') {
            steps {
                script {
                    def coverage = sh(
                        script: "mvn jacoco:check",
                        returnStatus: true
                    )
                    if (coverage != 0) {
                        error("Coverage below 80%")
                    }
                }
            }
        }
        
        stage('Integration Tests') {
            steps {
                sh 'mvn verify -P integration-tests'
            }
        }
        
        stage('Deploy to Staging') {
            when {
                branch 'develop'
            }
            steps {
                sh './deploy-staging.sh'
            }
        }
        
        stage('E2E Tests') {
            when {
                branch 'develop'
            }
            steps {
                sh 'npm run test:e2e'
            }
        }
    }
    
    post {
        failure {
            mail to: 'team@example.com',
                 subject: "Build Failed: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
                 body: "Check ${env.BUILD_URL}"
        }
        success {
            echo 'All tests passed!'
        }
    }
}

## TDD 培訓計畫(4 週)

### Week 1: 基礎概念

- TDD 原理與好處

- Red-Green-Refactor 循環

- 測試框架入門(JUnit/pytest)

- 實作:計算機類別


### Week 2: 進階技巧

- AAA 模式

- Mock 與 Stub

- 測試替身使用時機

- 實作:訂單服務


### Week 3: 實務應用

- API 測試

- 資料庫測試

- CI/CD 整合

- 實作:完整功能模組


### Week 4: 團隊實踐

- Pair Programming

- Code Review 技巧

- Legacy Code 重構

- 實際專案練習

// 一次寫完所有測試
testAdd()
testSubtract()
testMultiply()
testDivide()

// 然後一次實作所有功能

// 一次一個測試 + 實作循環
testAdd() → implement add() → refactor
testSubtract() → implement subtract() → refactor

Product mockProduct = mock(Product.class);
Customer mockCustomer = mock(Customer.class);
// 連簡單的值物件都 Mock

Product product = new Product("Item", 100); // 真實物件
Customer customer = new Customer("John");    // 真實物件
PaymentService mockPayment = mock(PaymentService.class); // 只 Mock 外部依賴

@Test
public void testPrivateMethod() {
    Method method = MyClass.class.getDeclaredMethod("privateMethod");
    method.setAccessible(true);
    // 不應該測試私有方法
}

@Test
public void testPublicBehavior() {
    MyClass obj = new MyClass();
    int result = obj.publicMethod(); // 透過公開 API 測試
    assertEquals(expected, result);
}

核心業務邏輯:    95-100%
服務層:          85-95%
控制器層:        80-90%
工具類別:        90-100%
配置類別:        50-70%

// 先為現有行為寫測試(即使不知道正確結果)
@Test
public void testLegacyBehavior() {
    LegacyClass legacy = new LegacyClass();
    int result = legacy.complexMethod(input);
    
    // 記錄當前行為(即使不確定是否正確)
    assertEquals(currentBehavior, result);
}

// 提取小方法
public int complexMethod(Input input) {
    validateInput(input); // 提取出來的方法可以寫測試
    int result = calculate(input);
    return result;
}

@Test
public void testValidateInput() {
    // 可以單獨測試提取出來的方法
}

// Legacy Code(難以測試)
public class OrderService {
    public void process() {
        Database db = new Database(); // 緊耦合
        db.save(order);
    }
}

// 重構後(可測試)
public class OrderService {
    private final Database database;
    
    public OrderService(Database database) { // 依賴注入
        this.database = database;
    }
    
    public void process() {
        database.save(order);
    }
}

// 現在可以 Mock
@Test
public void testProcess() {
    Database mockDb = mock(Database.class);
    OrderService service = new OrderService(mockDb);
    service.process();
    verify(mockDb).save(any());
}

Feature: 購物車結帳
  
  Scenario: VIP 客戶結帳享有折扣
    Given 我是 VIP 客戶
    And 購物車有總價 1000 元的商品
    When 我進行結帳
    Then 我應該支付 800 元
    And 折扣為 200 元

@Given("我是 VIP 客戶")
public void 我是VIP客戶() {
    customer = new Customer(CustomerType.VIP);
}

@Given("購物車有總價 {int} 元的商品")
public void 購物車有總價元的商品(int amount) {
    cart = new ShoppingCart(customer);
    cart.addItem(new Product("商品", amount), 1);
}

@When("我進行結帳")
public void 我進行結帳() {
    result = cart.checkout();
}

@Then("我應該支付 {int} 元")
public void 我應該支付元(int expectedAmount) {
    assertEquals(expectedAmount, result.getFinalAmount());
}

@Property
boolean absoluteValueIsAlwaysPositive(@ForAll int number) {
    return Math.abs(number) >= 0;
}

@Property
boolean reverseTwiceGivesOriginal(@ForAll List<Integer> list) {
    List<Integer> reversed = reverse(reverse(list));
    return list.equals(reversed);
}

@Property
boolean sortedListIsOrdered(@ForAll List<Integer> list) {
    List<Integer> sorted = list.stream()
        .sorted()
        .collect(Collectors.toList());
    
    for (int i = 0; i < sorted.size() - 1; i++) {
        if (sorted.get(i) > sorted.get(i + 1)) {
            return false;
        }
    }
    return true;
}

// 第一版:簡單實作
public class OrderService {
    public void process(Order order) {
        Database.save(order);
    }
}

// 為了測試,重構為可注入
public class OrderService {
    private final OrderRepository repository;
    
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
    
    public void process(Order order) {
        repository.save(order);
    }
}

// 測試驅動出介面設計
public interface OrderRepository {
    void save(Order order);
    Order findById(String id);
}

<dependency>
    <groupId>io.qameta.allure</groupId>
    <artifactId>allure-junit5</artifactId>
    <version>2.24.0</version>
</dependency>

@Epic("訂單管理")
@Feature("訂單建立")
public class OrderCreationTest {
    
    @Test
    @Story("VIP 客戶訂單")
    @Severity(SeverityLevel.CRITICAL)
    @Description("測試 VIP 客戶建立訂單時自動套用折扣")
    public void testVIPOrderDiscount() {
        // 測試實作
    }
}