Spring JPA集成测试中优雅地忽略实体ID进行断言

private static final OrderDTO VALID_ORDER = OrderDTO.builder()
    .withId(1L) // 硬编码主键ID
    .withOrderId("orderId") // 从外部API获取的业务ID
    .withAddress(validAddress)
    .build();

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

import java.util.Objects;

public class Order {
    private Long id;
    private String orderId; // 业务ID
    private String address;
    // ... 其他字段

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

    // Builder模式（简化版）
    public static OrderBuilder builder() {
        return new OrderBuilder();
    }

    public static class OrderBuilder {
        private Long id;
        private String orderId;
        private String address;

        public OrderBuilder withId(Long id) {
            this.id = id;
            return this;
        }

        public OrderBuilder withOrderId(String orderId) {
            this.orderId = orderId;
            return this;
        }

        public OrderBuilder withAddress(String address) {
            this.address = address;
            return this;
        }

        public Order build() {
            return new Order(id, orderId, address);
        }
    }

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

    // Setters (如果需要)
    public void setId(Long id) { this.id = id; }
    public void setOrderId(String orderId) { this.orderId = orderId; }
    public void setAddress(String address) { this.address = address; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Order order = (Order) o;
        return Objects.equals(id, order.id) && Objects.equals(orderId, order.orderId) && Objects.equals(address, order.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, orderId, address);
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

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

// 假设有一个OrderService
interface OrderService {
    Order saveNewOrder(Order order);
    Order findByOrderId(String orderId);
}

// 这是一个简化的OrderService实现，用于示例
class MockOrderService implements OrderService {
    private Long nextId = 1L;
    private java.util.Map<String, Order> orders = new java.util.HashMap<>();

    @Override
    public Order saveNewOrder(Order order) {
        // 模拟数据库自动生成ID
        order.setId(nextId++);
        orders.put(order.getOrderId(), order);
        return order;
    }

    @Override
    public Order findByOrderId(String orderId) {
        return orders.get(orderId);
    }
}


@Testcontainers
@SpringBootTest(classes = MockOrderService.class) // 使用MockOrderService进行测试
class OrderServiceIntegrationTest {

    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
            .withDatabaseName("testdb")
            .withUsername("testuser")
            .withPassword("testpass");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
        // ... 其他JPA/Hibernate配置
    }

    @Autowired
    private OrderService orderService; // 注入实际的OrderService，这里用Mock代替

    @Test
    void shouldSaveNewOrderAndAssertRelevantFields() {
        // 1. 准备数据：不指定ID，让数据库自动生成
        Order newOrder = Order.builder()
                              .withOrderId("order_abc_123")
                              .withAddress("Some Street 123")
                              .build();

        // 2. 执行服务层操作
        Order savedOrder = orderService.saveNewOrder(newOrder);

        // 3. 断言：只比较业务相关的字段
        assertThat(savedOrder)
            .extracting(Order::getOrderId, Order::getAddress) // 提取订单号和地址
            .containsExactly("order_abc_123", "Some Street 123"); // 严格按顺序匹配

        // 4. (可选) 验证ID是否被成功生成
        assertThat(savedOrder.getId()).isNotNull();
        assertThat(savedOrder.getId()).isPositive();

        // 5. 进一步验证通过业务ID查询到的对象是否一致 (依然忽略ID)
        Order foundOrder = orderService.findByOrderId("order_abc_123");
        assertThat(foundOrder)
            .extracting(Order::getOrderId, Order::getAddress)
            .containsExactly("order_abc_123", "Some Street 123");

        // 还可以通过映射到新的Record/DTO进行比较，这在需要比较复杂结构时非常有用
        record OrderDetails(String orderId, String address) {}
        OrderDetails expectedDetails = new OrderDetails("order_abc_123", "Some Street 123");

        assertThat(savedOrder)
            .extracting(o -> new OrderDetails(o.getOrderId(), o.getAddress()),
                        as(type(OrderDetails.class))) // 提取并映射为OrderDetails类型
            .isEqualTo(expectedDetails); // 比较映射后的对象
    }
}