如何回滚向数据库写入数据的API HTTP请求（组件测试场景）

针对你的组件测试场景——不想直接操作数据库、希望Mock数据库访问同时保证测试数据能被清理，我整理了几个实用方案，结合你的现有代码来分析：

一、优先推荐：Mock数据访问层（彻底隔离数据库） #

组件测试的核心是隔离外部依赖，数据库属于典型的外部依赖，最优雅的方式是直接Mock掉你的数据访问层（Repository/DAO），完全不用碰真实数据库，自然也不用处理回滚。

比如用Mockito来Mock你的TripEventRepository：

import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

// 假设你的组件依赖TripEventRepository
@Mock
private TripEventRepository tripEventRepository;

@InjectMocks
private TripEventHandlerComponent componentUnderTest; // 你要测试的组件

@BeforeEach
void setup() {
    MockitoAnnotations.openMocks(this);
    // 模拟save方法，无需真实写入数据库
    when(tripEventRepository.save(any(TripEventEntity.class)))
        .thenReturn(mock(TripEventEntity.class));
}

@Test
void testTripEventProcessing() {
    // 调用组件的业务方法，内部会触发Repository的save，但已经被Mock
    componentUnderTest.processEvent(buildTestEvent(1L, "CHARGING_STATUS_CHANGE"));
    
    // 验证Repository的save方法是否按预期被调用
    verify(tripEventRepository, times(1)).save(any(TripEventEntity.class));
}

这种方式的优势：

• 测试速度极快，完全不依赖数据库环境
• 无需清理数据，因为根本没写入真实数据库
• 可以精准控制Repository的返回值和调用行为

二、如果需要真实数据库交互：用测试库+事务自动回滚 #

如果你需要验证ORM映射、查询语句这类和数据库强相关的逻辑，可以用内存测试数据库（比如H2），再借助Spring的事务注解自动回滚：

在测试类上添加@Transactional和@Rollback，每个测试方法结束后Spring会自动回滚事务，数据库不会留下测试数据：

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.test.annotation.Rollback;
import org.springframework.boot.test.web.client.TestRestTemplate;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Transactional
@Rollback(true) // 测试结束自动回滚事务
public class TripEventComponentTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @BeforeEach
    void setupTestData() {
        // 通过TestRestTemplate调用你的数据写入接口
        restTemplate.put("/db/save/tripevententity", buildTripEvent(1L, "CHARGING_STATUS_CHANGE"));
        restTemplate.put("/db/save/tripevententity", buildTripEvent(2L, "CHARGING_STATUS_CHANGE"));
        // ... 其他测试数据
    }

    @Test
    void testComponentBusinessLogic() {
        // 执行你的组件测试逻辑
        // 测试结束后，事务自动回滚，数据库数据被清空
    }
}

注意：需要在测试配置中指定H2内存数据库，确保和生产库的SQL语法兼容。

三、自定义内存Mock数据库（替代你的DbIntegrationMock） #

如果不想用Mockito，也可以自己实现一个基于内存的Mock Repository，在测试环境中替换真实的数据库访问实现：

// 自定义内存版Repository
public class InMemoryTripEventRepository implements TripEventRepository {
    private final Map<Long, TripEventEntity> dataStore = new HashMap<>();
    private long nextId = 1;

    @Override
    public TripEventEntity save(TripEventEntity entity) {
        if (entity.getId() == null) {
            entity.setId(nextId++);
        }
        dataStore.put(entity.getId(), entity);
        return entity;
    }

    // 按需实现其他查询方法，比如findById、findAll等
}

然后在测试配置中注入这个Mock实现：

import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;

@TestConfiguration
public class TestRepositoryConfig {
    @Bean
    public TripEventRepository tripEventRepository() {
        return new InMemoryTripEventRepository();
    }
}

这样你的组件在测试时会使用内存存储，完全不用访问真实数据库，测试结束后内存数据自动销毁，无需额外清理。

对你现有代码的改进建议 #

你当前通过调用/dev/db/save/tripevententity接口写入数据的方式，本质还是依赖真实数据库。如果要继续用这种方式实现数据清理，可以在@AfterEach中批量删除测试数据：

private List<Long> savedEventIds = new ArrayList<>();

private void setupTrips(long l, String triggerType) throws ExecutionException, InterruptedException {
    TripEventEntity tripEventEntity = buildTestEvent(l, triggerType);
    // 假设save接口会返回保存后的实体（带ID）
    TripEventEntity savedEntity = dbIntegrationMock.saveTripEventEntity(tripEventEntity);
    savedEventIds.add(savedEntity.getId());
}

@AfterEach
void cleanUpTestData() {
    for (Long id : savedEventIds) {
        HttpClient.forService(Service.withName("componentname"))
                .send(HttpRequest.forDelete("/dev/db/delete/tripevententity/" + id)
                        .withHeader(HttpHeaders.ACCEPT, "application/json"), HttpResponseType.of(Void.class, MediaType.of("application/json")))
                .toCompletableFuture()
                .join();
    }
}

但这种方式需要维护额外的清理逻辑，且测试失败时可能残留数据，不如前面的Mock或事务回滚方案优雅。

内容的提问来源于stack exchange，提问作者Marcin Retek