测试用例后回滚种子数据：Ktor+JPA+Hibernate测试性能优化咨询

嘿，我完全懂你现在的困扰——每次测试都重建EntityManagerFactory确实会拖慢整个测试套件的速度，毕竟初始化ORM框架的开销不小。针对你需要在测试后回滚种子数据、保持数据库干净的需求，我给你几个实用的替代方案：

方案一：用事务包裹每个测试，结束后自动回滚 #

这是最直接高效的方案，核心思路是：只初始化一次EntityManagerFactory，每个测试在独立的事务中运行，测试结束后回滚事务，这样所有测试操作（包括种子数据的插入）都会被撤销，数据库回到初始干净状态。

具体实现步骤：

1. 在测试类的@BeforeAll中初始化EntityManagerFactory，所有测试共用这个实例。
2. 每个测试方法开始前，从工厂获取新的EntityManager并开启事务。
3. 执行测试逻辑（包括插入种子数据、业务操作）。
4. 测试结束后，回滚事务并关闭EntityManager。

代码示例：

import org.junit.jupiter.api.*
import javax.persistence.EntityManagerFactory
import javax.persistence.Persistence

class UserRepositoryTest {
    companion object {
        // 全局只初始化一次EntityManagerFactory
        private lateinit var emf: EntityManagerFactory

        @BeforeAll
        @JvmStatic
        fun initEmf() {
            emf = Persistence.createEntityManagerFactory("test-pu")
        }

        @AfterAll
        @JvmStatic
        fun closeEmf() {
            emf.close()
        }
    }

    private lateinit var em: javax.persistence.EntityManager
    private lateinit var transaction: javax.persistence.EntityTransaction

    @BeforeEach
    fun setupTest() {
        em = emf.createEntityManager()
        transaction = em.transaction
        transaction.begin()

        // 在这里插入测试需要的种子数据，比如：
        // val testUser = User(id = 1, name = "Test User")
        // em.persist(testUser)
    }

    @AfterEach
    fun teardownTest() {
        // 无论测试成功失败，都回滚事务
        if (transaction.isActive) {
            transaction.rollback()
        }
        em.close()
    }

    @Test
    fun `should find user by id`() {
        // 执行测试逻辑，比如查询用户
        val foundUser = em.find(User::class.java, 1L)
        assert(foundUser?.name == "Test User")

        // 不需要提交事务，AfterEach会自动回滚
    }
}

这个方案的优势是完全利用JPA的事务机制，不需要额外依赖，速度提升非常明显——毕竟EntityManagerFactory只初始化一次，避免了重复的ORM启动开销。

方案二：利用H2数据库的快照功能 #

如果你的测试中有一些无法通过事务回滚的操作（比如DDL语句），可以试试H2的快照功能：在所有测试开始前创建数据库快照，每个测试前恢复快照，保证数据库状态一致。

代码示例：

import org.junit.jupiter.api.*
import javax.persistence.EntityManagerFactory
import javax.persistence.Persistence

class ProductServiceTest {
    companion object {
        private lateinit var emf: EntityManagerFactory

        @BeforeAll
        @JvmStatic
        fun initDatabase() {
            emf = Persistence.createEntityManagerFactory("test-pu")
            val em = emf.createEntityManager()

            // 初始化基础种子数据（所有测试共用的基础数据）
            em.transaction.begin()
            em.persist(ProductCategory(name = "Electronics"))
            em.transaction.commit()
            em.close()

            // 创建H2数据库快照
            val connection = emf.createEntityManager().connection
            connection.createStatement().execute("CREATE SNAPSHOT test_snapshot")
            connection.close()
        }

        @AfterAll
        @JvmStatic
        fun cleanUp() {
            emf.close()
        }
    }

    @BeforeEach
    fun restoreSnapshot() {
        // 每个测试前恢复快照，回到初始状态
        val connection = emf.createEntityManager().connection
        connection.createStatement().execute("RESTORE SNAPSHOT test_snapshot")
        connection.close()
    }

    @Test
    fun `should add new product`() {
        val em = emf.createEntityManager()
        em.transaction.begin()
        val newProduct = Product(name = "Laptop", categoryId = 1)
        em.persist(newProduct)
        em.transaction.commit()
        em.close()

        // 验证测试结果
        val verifyEm = emf.createEntityManager()
        val product = verifyEm.find(Product::class.java, newProduct.id)
        assert(product != null)
        verifyEm.close()
    }
}

注意：使用H2快照需要在数据库URL中开启相关支持，比如jdbc:h2:mem:testdb;AUTO_SERVER=TRUE;DB_CLOSE_DELAY=-1，具体可以参考H2官方文档的快照说明。

方案三：自定义测试扩展实现自动事务回滚 #

如果你用Koin这类DI框架管理EntityManager，可以写一个JUnit 5扩展，通过注解来自动管理事务的开启和回滚，让代码更简洁。

示例扩展代码：

import org.junit.jupiter.api.extension.*
import javax.persistence.EntityManager
import javax.persistence.EntityTransaction
import org.koin.core.context.GlobalContext
import org.koin.core.parameter.parametersOf

class RollbackExtension : BeforeTestExecutionCallback, AfterTestExecutionCallback {
    override fun beforeTestExecution(context: ExtensionContext) {
        // 从Koin容器获取EntityManager
        val em = GlobalContext.get().get<EntityManager> { parametersOf("test") }
        val transaction = em.transaction
        transaction.begin()

        // 把事务和EntityManager存到测试上下文，方便后续回滚
        context.store.put("transaction", transaction)
        context.store.put("entityManager", em)
    }

    override fun afterTestExecution(context: ExtensionContext) {
        val transaction = context.store.get<EntityTransaction>("transaction")
        val em = context.store.get<EntityManager>("entityManager")

        if (transaction?.isActive == true) {
            transaction.rollback()
        }
        em?.close()
    }
}

然后在测试类上标记扩展：

@ExtendWith(RollbackExtension::class)
class OrderServiceTest {
    // 注入EntityManager
    private val em: EntityManager by inject { parametersOf("test") }

    @Test
    fun `should create order`() {
        // 测试逻辑，无需手动管理事务
        val order = Order(customerId = 1)
        em.persist(order)
        assert(order.id != null)
    }
}

关于你提到的Transactional注解，在非Spring环境下确实没有原生支持，但上面的扩展可以模拟类似的效果——标记了扩展的测试方法都会自动在事务中运行并回滚。

总结一下，方案一是最推荐的，它既符合JPA的设计理念，又能最大程度提升测试速度，同时保证数据库状态的干净。

内容的提问来源于stack exchange，提问作者Jakob Nielsen