全面单元测试生成

下面给出使用 JUnit 5 + Mockito 的完整、严格覆盖的单元测试类，放置路径建议为：src/test/java/app/order/OrderProcessorTest.java（与被测类在同一包 app.order 下，以便访问包级可见的类型）。

代码： // File: src/test/java/app/order/OrderProcessorTest.java package app.order;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.function.Executable; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension;

import java.util.Arrays; import java.util.List;

import static org.junit.jupiter.api.Assertions.; import static org.mockito.ArgumentMatchers.; import static org.mockito.Mockito.*; import org.junit.jupiter.api.extension.ExtendWith;

@ExtendWith(MockitoExtension.class) class OrderProcessorTest {

@Mock PaymentGateway paymentGateway;
@Mock InventoryService inventoryService;
@Mock OrderRepository orderRepository;
@Mock AuditLogger auditLogger;

OrderProcessor processor;

@BeforeEach
void setUp() {
    processor = new OrderProcessor(paymentGateway, inventoryService, orderRepository, auditLogger);
}

// 1) 正向：三明细成功，校验 reserve 调用、金额两位小数（四舍五入），markProcessed 与日志，返回 SUCCESS
@Test
void process_success_threeItems_reserveCalled_amountRounded_markProcessed_andLogged() {
    String orderId = "o-success";
    // 0.335 * 3 = 1.005，四舍五入到两位应为 1.01
    List<LineItem> items = Arrays.asList(
            new LineItem("SKU-A", 1, 0.335),
            new LineItem("SKU-B", 1, 0.335),
            new LineItem("SKU-C", 1, 0.335)
    );
    Order order = new Order(orderId, items);

    when(orderRepository.isProcessed(orderId)).thenReturn(false);
    when(paymentGateway.charge(eq(orderId), anyDouble()))
            .thenReturn(new ChargeResult(true, false, "TX123"));

    String result = processor.process(order);
    assertEquals("SUCCESS", result);

    // 交互顺序：reserve -> charge -> markProcessed -> log processed
    InOrder inOrder = inOrder(inventoryService, paymentGateway, orderRepository, auditLogger);
    inOrder.verify(inventoryService).reserve("SKU-A", 1);
    inOrder.verify(inventoryService).reserve("SKU-B", 1);
    inOrder.verify(inventoryService).reserve("SKU-C", 1);
    inOrder.verify(paymentGateway).charge(eq(orderId), argThat(a -> Math.abs(a - 1.01) < 1e-9));
    inOrder.verify(orderRepository).markProcessed(orderId);

    ArgumentCaptor<String> logCaptor = ArgumentCaptor.forClass(String.class);
    inOrder.verify(auditLogger).log(logCaptor.capture());
    String processedLog = logCaptor.getValue();
    assertTrue(processedLog.contains("processed:" + orderId + ":txn=TX123"));

    // 不应释放库存
    verify(inventoryService, never()).release(anyString(), anyInt());
    // 金额精度再断言（两位小数）
    verify(paymentGateway).charge(eq(orderId), argThat(a -> Math.abs(a - 1.01) < 1e-9));
}

// 2) 反向：支付失败时释放所有库存并抛 PaymentException
@Test
void process_paymentFails_releasesAllInventory_andThrowsPaymentException() {
    String orderId = "o-fail";
    List<LineItem> items = Arrays.asList(
            new LineItem("SKU-1", 2, 10.0),
            new LineItem("SKU-2", 1, 5.5),
            new LineItem("SKU-3", 3, 2.0)
    );
    Order order = new Order(orderId, items);

    when(orderRepository.isProcessed(orderId)).thenReturn(false);
    when(paymentGateway.charge(eq(orderId), anyDouble()))
            .thenReturn(new ChargeResult(false, false, null)); // 非 transient，直接失败

    Executable exec = () -> processor.process(order);
    PaymentException ex = assertThrows(PaymentException.class, exec);
    assertEquals("payment failed", ex.getMessage());

    // reserve 应被按明细调用
    verify(inventoryService).reserve("SKU-1", 2);
    verify(inventoryService).reserve("SKU-2", 1);
    verify(inventoryService).reserve("SKU-3", 3);

    // 交互顺序：reserve 全部 -> charge -> release 全部
    InOrder inOrder = inOrder(inventoryService, paymentGateway);
    inOrder.verify(inventoryService).reserve("SKU-1", 2);
    inOrder.verify(inventoryService).reserve("SKU-2", 1);
    inOrder.verify(inventoryService).reserve("SKU-3", 3);
    inOrder.verify(paymentGateway).charge(eq(orderId), anyDouble());
    inOrder.verify(inventoryService).release("SKU-1", 2);
    inOrder.verify(inventoryService).release("SKU-2", 1);
    inOrder.verify(inventoryService).release("SKU-3", 3);

    // 不应标记已处理
    verify(orderRepository, never()).markProcessed(anyString());
    // 支付仅调用一次
    verify(paymentGateway, times(1)).charge(eq(orderId), anyDouble());
}

// 2) 反向：非法明细（零数量）抛 IllegalArgumentException，且不调用库存与支付
@Test
void process_invalidItem_zeroQty_throwsIllegalArgumentException_andNoSideEffects() {
    String orderId = "o-bad-qty";
    List<LineItem> items = Arrays.asList(
            new LineItem("BAD-ZERO", 0, 1.0)
    );
    Order order = new Order(orderId, items);

    when(orderRepository.isProcessed(orderId)).thenReturn(false);

    assertThrows(IllegalArgumentException.class, () -> processor.process(order));

    verifyNoInteractions(paymentGateway);
    verifyNoInteractions(inventoryService);
    verify(orderRepository, never()).markProcessed(anyString());
}

// 2) 反向：非法明细（负价）抛 IllegalArgumentException，且不调用库存与支付
@Test
void process_invalidItem_negativePrice_throwsIllegalArgumentException_andNoSideEffects() {
    String orderId = "o-bad-price";
    List<LineItem> items = Arrays.asList(
            new LineItem("BAD-PRICE", 1, -0.01)
    );
    Order order = new Order(orderId, items);

    when(orderRepository.isProcessed(orderId)).thenReturn(false);

    assertThrows(IllegalArgumentException.class, () -> processor.process(order));

    verifyNoInteractions(paymentGateway);
    verifyNoInteractions(inventoryService);
    verify(orderRepository, never()).markProcessed(anyString());
}

// 3) 边界：幂等路径返回 ALREADY，且不触发支付与库存
@Test
void process_idempotentAlreadyProcessed_returnsAlready_noInventoryNoPayment() {
    String orderId = "o-idem";
    List<LineItem> items = Arrays.asList(
            new LineItem("SKU-X", 1, 2.0)
    );
    Order order = new Order(orderId, items);

    when(orderRepository.isProcessed(orderId)).thenReturn(true);

    String result = processor.process(order);
    assertEquals("ALREADY", result);

    verify(paymentGateway, never()).charge(anyString(), anyDouble());
    verify(inventoryService, never()).reserve(anyString(), anyInt());
    verify(inventoryService, never()).release(anyString(), anyInt());
    verify(orderRepository, never()).markProcessed(anyString());

    ArgumentCaptor<String> logCaptor = ArgumentCaptor.forClass(String.class);
    verify(auditLogger, times(1)).log(logCaptor.capture());
    assertTrue(logCaptor.getValue().contains("idempotent skip:" + orderId));
}

// 4) 重试：首次 transient 错误失败，二次成功；断言 charge 调用两次、日志包含 retry、无 release
@Test
void process_retryOnTransientPaymentError_thenSuccess() {
    String orderId = "o-retry";
    List<LineItem> items = Arrays.asList(
            new LineItem("SKU-R1", 2, 2.5), // 2 * 2.5 = 5.0
            new LineItem("SKU-R2", 1, 5.0)  // 总计 10.0
    );
    Order order = new Order(orderId, items);

    when(orderRepository.isProcessed(orderId)).thenReturn(false);
    when(paymentGateway.charge(eq(orderId), anyDouble()))
            .thenReturn(new ChargeResult(false, true, null)) // 第一次：transient 失败
            .thenReturn(new ChargeResult(true, false, "TXN-2")); // 第二次：成功

    String result = processor.process(order);
    assertEquals("SUCCESS", result);

    // 支付两次，金额一致且为 10.0（两位小数）
    ArgumentCaptor<Double> amountCaptor = ArgumentCaptor.forClass(Double.class);
    verify(paymentGateway, times(2)).charge(eq(orderId), amountCaptor.capture());
    List<Double> amounts = amountCaptor.getAllValues();
    assertEquals(2, amounts.size());
    assertEquals(10.0, amounts.get(0), 1e-9);
    assertEquals(10.0, amounts.get(1), 1e-9);

    // 日志包含 retry 与 processed
    ArgumentCaptor<String> logCaptor = ArgumentCaptor.forClass(String.class);
    verify(auditLogger, atLeastOnce()).log(logCaptor.capture());
    List<String> logs = logCaptor.getAllValues();
    assertTrue(logs.stream().anyMatch(m -> m.contains("retry payment:" + orderId)));
    assertTrue(logs.stream().anyMatch(m -> m.contains("processed:" + orderId + ":txn=TXN-2")));

    // 不应释放库存
    verify(inventoryService, never()).release(anyString(), anyInt());
    // markProcessed 必须调用一次
    verify(orderRepository, times(1)).markProcessed(orderId);

    // 交互顺序：reserve 全部 -> 第一次 charge -> log retry -> 第二次 charge -> markProcessed -> log processed
    InOrder inOrder = inOrder(inventoryService, paymentGateway, orderRepository, auditLogger);
    inOrder.verify(inventoryService).reserve("SKU-R1", 2);
    inOrder.verify(inventoryService).reserve("SKU-R2", 1);
    inOrder.verify(paymentGateway).charge(eq(orderId), anyDouble());
    inOrder.verify(auditLogger).log("retry payment:" + orderId);
    inOrder.verify(paymentGateway).charge(eq(orderId), anyDouble());
    inOrder.verify(orderRepository).markProcessed(orderId);
    // processed 日志最后
    inOrder.verify(auditLogger).log(argThat(s -> s.contains("processed:" + orderId + ":txn=TXN-2")));
}

}

Maven 运行指引

• 在 pom.xml 添加依赖：

  • junit-jupiter-api、junit-jupiter-engine（JUnit 5）
  • mockito-core、mockito-junit-jupiter（Mockito + JUnit5 扩展）

• 示例依赖与插件： org.junit.jupiter junit-jupiter-api 5.10.2 test org.junit.jupiter junit-jupiter-engine 5.10.2 test org.mockito mockito-core 5.12.0 test org.mockito mockito-junit-jupiter 5.12.0 test org.apache.maven.plugins maven-surefire-plugin 3.2.5 false

• 执行测试：

  • mvn test
  • 或仅运行本测试类：mvn -Dtest=app.order.OrderProcessorTest test

Gradle 运行指引（Kotlin 或 Groovy DSL 均可）

• 依赖（Groovy DSL）： dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.2' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.2' testImplementation 'org.mockito:mockito-core:5.12.0' testImplementation 'org.mockito:mockito-junit-jupiter:5.12.0' } test { useJUnitPlatform() }

• 执行测试：

  • ./gradlew test

说明

• 测试覆盖正向、反向、边界与重试场景，严格验证：
  • reserve/charge/release/markProcessed/log 的调用次数与顺序（InOrder）。
  • 支付金额四舍五入到两位小数。
  • 失败时释放所有已预留库存且抛 PaymentException。
  • 幂等路径返回 ALREADY 且不触发库存与支付。
  • transient 错误重试一次成功，日志包含 retry，且不额外释放库存。
• 使用 ArgumentCaptor 捕获并断言日志消息包含 txn 与 retry。