Spring JPA 服务层集成测试中优雅处理实体ID冲突

private static final OrderDTO VALID_ORDER = OrderDTO.builder()
    .withId(1L) // 硬编码主键ID
    .withOrderId("orderId")
    // ... 其他字段
    .build();

@Test
void shouldSaveNewOrder() {
    OrderDTO order = orderService.saveNewOrder(VALID_ORDER);
    assertThat(orderService.findByOrderId("orderId")).isEqualTo(order);
}

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

// 假设 OrderDTO 结构如下 (使用 Lombok 或手动实现 getter)
// public class OrderDTO {
//     private Long id;
//     private String orderId;
//     private String address;
//     private String status;
//     // ... 构造器, builder, getter, setter
// }

// 模拟 OrderService 和 OrderDTO
class OrderDTO {
    private Long id;
    private String orderId;
    private String address;
    private String status;

    public OrderDTO(Long id, String orderId, String address, String status) {
        this.id = id;
        this.orderId = orderId;
        this.address = address;
        this.status = status;
    }

    public static OrderDTOBuilder builder() {
        return new OrderDTOBuilder();
    }

    // Getters
    public Long getId() { return id; }
    public String getOrderId() { return orderId; }
    public String getAddress() { return address; }
    public String getStatus() { return status; }

    // 模拟 Builder 模式
    public static class OrderDTOBuilder {
        private Long id;
        private String orderId;
        private String address;
        private String status;

        public OrderDTOBuilder withId(Long id) { this.id = id; return this; }
        public OrderDTOBuilder withOrderId(String orderId) { this.orderId = orderId; return this; }
        public OrderDTOBuilder withAddress(String address) { this.address = address; return this; }
        public OrderDTOBuilder withStatus(String status) { this.status = status; return this; }
        public OrderDTO build() { return new OrderDTO(id, orderId, address, status); }
    }

    @Override
    public boolean equals(Object o) { // 仅为示例，实际应包含所有字段
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        OrderDTO orderDTO = (OrderDTO) o;
        return java.util.Objects.equals(id, orderDTO.id) &&
               java.util.Objects.equals(orderId, orderDTO.orderId) &&
               java.util.Objects.equals(address, orderDTO.address) &&
               java.util.Objects.equals(status, orderDTO.status);
    }

    @Override
    public int hashCode() { // 仅为示例
        return java.util.Objects.hash(id, orderId, address, status);
    }
}

// 模拟 OrderService
class OrderService {
    private long nextId = 1L; // 模拟数据库自增ID
    private java.util.Map<String, OrderDTO> orders = new java.util.HashMap<>();

    public OrderDTO saveNewOrder(OrderDTO order) {
        // 模拟数据库生成ID
        Long generatedId = nextId++;
        OrderDTO savedOrder = OrderDTO.builder()
            .withId(generatedId)
            .withOrderId(order.getOrderId())
            .withAddress(order.getAddress())
            .withStatus(order.getStatus())
            .build();
        orders.put(savedOrder.getOrderId(), savedOrder);
        return savedOrder;
    }

    public OrderDTO findByOrderId(String orderId) {
        return orders.get(orderId);
    }
}

public class OrderServiceIntegrationTest {

    private final OrderService orderService = new OrderService();

    @Test
    void shouldSaveNewOrderAndIgnoreId() {
        // 输入的订单DTO，可以不设置ID，或者设置一个临时ID，因为会被数据库覆盖
        OrderDTO inputOrder = OrderDTO.builder()
            .withOrderId("testOrderId_ABC")
            .withAddress("北京市朝阳区")
            .withStatus("PENDING")
            .build();

        // 服务保存订单，会返回一个带有数据库生成ID的OrderDTO
        OrderDTO savedOrder = orderService.saveNewOrder(inputOrder);

        // 从服务中再次查询该订单，确保其存在且业务字段正确
        OrderDTO fetchedOrder = orderService.findByOrderId("testOrderId_ABC");

        // 使用 AssertJ 的 extracting 提取业务字段进行断言
        Assertions.assertThat(fetchedOrder)
            .extracting(OrderDTO::getOrderId, OrderDTO::getAddress, OrderDTO::getStatus)
            .containsExactly("testOrderId_ABC", "北京市朝阳区", "PENDING"); // 使用 containsExactly 确保顺序和值匹配
    }
}

import org.assertj.core.api.InstanceOfAssertFactories;
import static org.assertj.core.api.Assertions.as;

// 定义一个只包含业务字段的Record
record OrderBusinessDetails(String orderId, String address, String status) {}

public class OrderServiceIntegrationTest {

    private final OrderService orderService = new OrderService();

    @Test
    void shouldSaveNewOrderAndMapToBusinessDetails() {
        OrderDTO inputOrder = OrderDTO.builder()
            .withOrderId("testOrderId_XYZ")
            .withAddress("上海市浦东新区")
            .withStatus("PROCESSING")
            .build();

        orderService.saveNewOrder(inputOrder);
        OrderDTO fetchedOrder = orderService.findByOrderId("testOrderId_XYZ");

        // 构建预期的业务详情对象
        OrderBusinessDetails expectedDetails = new OrderBusinessDetails("testOrderId_XYZ", "上海市浦东新区", "PROCESSING");

        // 使用 extracting 结合 lambda 表达式和 as() 映射到自定义 Record 进行断言
        Assertions.assertThat(fetchedOrder)
            .extracting(
                o -> new OrderBusinessDetails(o.getOrderId(), o.getAddress(), o.getStatus()),
                as(InstanceOfAssertFactories.type(OrderBusinessDetails.class))
            )
            .isEqualTo(expectedDetails);
    }
}