Java开发中的测试驱动开发（TDD）JUnit与Mockito的应用指南

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

// CalculatorTest.java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {

    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(1, 2);
        assertEquals(3, result);
    }
}

mvn test

// UserRepository.java
public class UserRepository {
    public User getUserById(int id) {
        // 假设这里是从数据库中查询用户
        return new User(id, "John Doe");
    }
}

// UserService.java
public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public String getUserName(int id) {
        User user = userRepository.getUserById(id);
        return user.getName();
    }
}

// UserServiceTest.java
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class UserServiceTest {

    @Test
    public void testGetUserName() {
        // 创建UserRepository的模拟对象
        UserRepository mockRepository = mock(UserRepository.class);
        
        // 设置模拟对象的行为
        when(mockRepository.getUserById(1)).thenReturn(new User(1, "Alice"));

        // 创建UserService对象，传入模拟的UserRepository
        UserService userService = new UserService(mockRepository);
        
        // 测试UserService的getUserName方法
        String userName = userService.getUserName(1);
        
        // 验证返回结果
        assertEquals("Alice", userName);
        
        // 验证mockRepository的getUserById方法是否被调用
        verify(mockRepository).getUserById(1);
    }
}

mvn test

// BankAccount.java
public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
        }
    }

    public double getBalance() {
        return balance;
    }
}

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

public class BankAccountTest {

    private BankAccount account;

    @BeforeEach
    public void setup() {
        // 每次测试之前都创建一个新的BankAccount对象，初始余额为100
        account = new BankAccount(100.0);
    }

    @Test
    public void testDepositValidAmount() {
        account.deposit(50.0);
        assertEquals(150.0, account.getBalance(), "存款后余额应该增加");
    }

    @Test
    public void testDepositInvalidAmount() {
        account.deposit(-10.0);  // 存入负数金额
        assertEquals(100.0, account.getBalance(), "存入负数金额时余额不应发生变化");
    }

    @Test
    public void testWithdrawValidAmount() {
        account.withdraw(30.0);
        assertEquals(70.0, account.getBalance(), "取款后余额应该减少");
    }

    @Test
    public void testWithdrawInvalidAmount() {
        account.withdraw(200.0);  // 取款金额超过余额
        assertEquals(100.0, account.getBalance(), "取款金额超过余额时，余额不应改变");
    }

    @Test
    public void testWithdrawNegativeAmount() {
        account.withdraw(-50.0);  // 取款负数金额
        assertEquals(100.0, account.getBalance(), "取款负数金额时，余额不应改变");
    }
}

// PaymentService.java
public class PaymentService {
    public boolean processPayment(double amount) {
        // 假设这是一个复杂的支付处理逻辑
        return true;
    }
}

// OrderService.java
public class OrderService {
    private PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public boolean placeOrder(double amount) {
        boolean paymentSuccess = paymentService.processPayment(amount);
        return paymentSuccess;
    }
}

// OrderServiceTest.java
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

public class OrderServiceTest {

    @Test
    public void testPlaceOrder() {
        // 创建PaymentService的模拟对象
        PaymentService mockPaymentService = mock(PaymentService.class);
        
        // 设置模拟对象的行为
        when(mockPaymentService.processPayment(100.0)).thenReturn(true);
        
        // 创建OrderService对象，传入模拟的PaymentService
        OrderService orderService = new OrderService(mockPaymentService);
        
        // 测试placeOrder方法
        boolean result = orderService.placeOrder(100.0);
        
        // 验证结果
        assertTrue(result, "订单支付成功，应该返回true");
        
        // 验证PaymentService的processPayment方法是否被调用
        verify(mockPaymentService).processPayment(100.0);
    }
}

@Test
public void testPlaceOrderFailure() {
    PaymentService mockPaymentService = mock(PaymentService.class);
    when(mockPaymentService.processPayment(100.0)).thenThrow(new RuntimeException("支付失败"));

    OrderService orderService = new OrderService(mockPaymentService);

    // 测试支付失败时，订单是否正确处理
    assertThrows(RuntimeException.class, () -> orderService.placeOrder(100.0));
}

name: Java CI with Maven

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up JDK
        uses: actions/setup-java@v2
        with:
          java-version: '11'

      - name: Build with Maven
        run: mvn clean install

      - name: Run tests
        run: mvn test