Question

我正在使用JUnit为测试数据库上运行的某些方法编写测试。

我需要在每个@Test之后将数据库重置为原始状态。我想知道最好的方法是什么。

EntityManager中有哪些方法？或者我应该手动删除所有内容还是使用SQL语句？删除并重新创建整个数据库会更好吗？

Answer 1

最简单的方法是在每次测试后简单地回滚所有更改。这需要一个事务性RDBMS和一个自定义测试运行器或类似程序，它将每个测试包装到它自己的事务中。 Spring的AbstractTransactionalJUnit4SpringContextTests就是这么做的。

Answer 2

我过去使用过的一种技术是从头开始重新创建数据库，只需从标准的“测试数据库”中复制数据库，然后在测试中使用它。

此技术适用于：

你的架构没有太大变化（否则很难保持一致）
你正在使用像hibernate这样合理的数据库独立的东西。

这具有以下优点：

它适用于管理自己的事务的代码。我的集成测试在junit下运行。例如，当我测试批处理时，我从junit调用Batch.main（），并测试之前和之后的内容。我不想更改被测代码中的事务处理。
速度相当快。如果文件足够小，那么速度不是问题。
它使ci服务器上的运行集成测试变得容易。使用代码签入数据库文件。无需启动和运行真正的数据库。

以下缺点：

测试数据库文件需要与真实数据库一起维护。如果你一直在添加列，这可能很痛苦。
有管理jdbc网址的代码，因为它们会针对每个测试进行更改。

我将其用作Oracle作为生产/集成数据库，将hsqldb用作测试数据库。它工作得很好。 hsqldb是一个文件，因此很容易复制。

因此，在 @Before 中，使用hsqldb，将文件复制到target / it / database / name_of_test.script等位置。这在测试中被选中。

在 @After 中，您删除了该文件（或者只是留下它，谁在乎）。使用hsqldb，您还需要执行SHUTDOWN，以便删除该文件。

您还可以使用从 ExternalResource 扩展的 @Rule ，这是管理资源的更好方式。

另一个提示是，如果你正在使用maven或类似的东西，你可以在目标中创建数据库。我使用target / it。这样，当我这样做并清除mvn时，数据库的副本就会被删除。对于我的批次，我实际上将所有其他属性文件等复制到此目录中，因此我也不会在奇怪的地方出现任何文件。

Answer 3

DBUnit可以在测试之间重置数据库，甚至可以使用预定义的测试数据填充它。

Answer 4

我正在回答这个问题，供我自己参考，但是这里有。答案假定每个开发人员SQL Server数据库。

基本方法

使用DBUnit存储已知状态的XML文件。您可以在设置数据库后提取此文件，也可以从头开始创建。将此文件与调用DBUnit的脚本一起放入版本控制中，以便用它填充数据库。
在测试中，使用@Before调用上述脚本。

加速1

一旦这项工作正常，请调整方法以加快速度。这是SQL Server数据库的一种方法。

在DBUnit之前，完全消灭了数据库：

EXEC sp_msforeachtable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL';
EXEC sp_MSforeachtable 'ALTER TABLE ? DISABLE TRIGGER ALL';
EXEC sp_MSForEachTable 'SET QUOTED_IDENTIFIER ON SET ANSI_NULLS ON DELETE FROM ?';

在DBUnit之后，恢复约束

EXEC sp_MSforeachtable 'ALTER TABLE ? CHECK CONSTRAINT ALL';
EXEC sp_MSforeachtable 'ALTER TABLE ? ENABLE TRIGGER ALL';

加速2

使用SQL Server的RESTORE功能。在我的测试中，这比DBUnit占用的时间长25％。如果（并且仅当）这是您测试持续时间的主要因素，则值得研究这种方法。

以下类显示了使用Spring JDBC，JTDS和CDI注入的实现。这适用于容器内测试，容器可能与DB建立自己的连接，需要停止

import java.io.File;
import java.sql.SQLException;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * Allows the DB to be reset quickly using SQL restore, at the price of
 * additional complexity. Recommended to vanilla DBUnit unless speed is
 * necessary.
 * 
 * @author aocathain
 * 
 */
@SuppressWarnings({ "PMD.SignatureDeclareThrowsException" })
public abstract class DbResetterSO {

    protected final Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * Deliberately created in the target dir, so that on mvn clean, it is
     * deleted and will be recreated.
     */
    private final File backupFile = new File(
            "target\\test-classes\\db-backup.bak");

    @Inject
    private OtherDbConnections otherDbConnections;

    /**
     * Backs up the database, if a backup doesn't exist.
     * 
     * @param masterDataSource
     *            a datasource with sufficient rights to do RESTORE DATABASE. It
     *            must not be connected to the database being restored, so
     *            should have db master as its default db.
     */
    public void backup(final DataSource masterDataSource) throws Exception {

        final JdbcTemplate masterJdbcTemplate = new JdbcTemplate(
                masterDataSource);

        if (backupFile.exists()) {
            logger.debug("File {} already exists, not backing up", backupFile);
        } else {
            otherDbConnections.start();

            setupDbWithDbUnit();

            otherDbConnections.stop();
            logger.debug("Backing up");
            masterJdbcTemplate.execute("BACKUP DATABASE [" + getDbName()
                    + "] TO DISK ='" + backupFile.getAbsolutePath() + "'");
            logger.debug("Finished backing up");
            otherDbConnections.start();
        }

    }

    /**
     * Restores the database
     * 
     * @param masterDataSource
     *            a datasource with sufficient rights to do RESTORE DATABASE. It
     *            must not be connected to the database being restored, so
     *            should have db master as its default db.
     */
    public void restore(final DataSource masterDataSource) throws SQLException {
        final JdbcTemplate masterJdbcTemplate = new JdbcTemplate(
                masterDataSource);

        if (!backupFile.exists()) {
            throw new IllegalStateException(backupFile.getAbsolutePath()
                    + " must have been created already");
        }
        otherDbConnections.stop();

        logger.debug("Setting to single user");

        masterJdbcTemplate.execute("ALTER DATABASE [" + getDbName()
                + "] SET SINGLE_USER WITH ROLLBACK IMMEDIATE;");

        logger.info("Restoring");

        masterJdbcTemplate.execute("RESTORE DATABASE [" + getDbName()
                + "] FROM DISK ='" + backupFile.getAbsolutePath()
                + "' WITH REPLACE");

        logger.debug("Setting to multi user");

        masterJdbcTemplate.execute("ALTER DATABASE [" + getDbName()
                + "] SET MULTI_USER;");

        otherDbConnections.start();
    }

    /**
     * @return Name of the DB on the SQL server instance
     */
    protected abstract String getDbName();

    /**
     * Sets up the DB to the required known state. Can be slow, since it's only
     * run once, during the initial backup. Can use the DB connections from otherDbConnections.
     */
    protected abstract void setupDbWithDbUnit() throws Exception;
}


import java.sql.SQLException;

/**
 * To SQL RESTORE the db, all other connections to that DB must be stopped. Implementations of this interface must
 * have control of all other connections.
 * 
 * @author aocathain
 * 
 */
public interface OtherDbConnections
{

    /**
     * Restarts all connections
     */
    void start() throws SQLException;

    /**
     * Stops all connections
     */
    void stop() throws SQLException;

}



import java.sql.Connection;
import java.sql.SQLException;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.enterprise.inject.Produces;
import javax.inject.Named;
import javax.inject.Singleton;
import javax.sql.DataSource;

import net.sourceforge.jtds.jdbcx.JtdsDataSource;

import org.springframework.jdbc.datasource.DelegatingDataSource;
import org.springframework.jdbc.datasource.SingleConnectionDataSource;

/**
 * Implements OtherDbConnections for the DbResetter and provides the DataSource during in-container tests.
 * 
 * @author aocathain
 * 
 */
@Singleton
@SuppressWarnings({ "PMD.AvoidUsingVolatile" })
public abstract class ResettableDataSourceProviderSO implements OtherDbConnections
{

    private volatile Connection connection;
    private volatile SingleConnectionDataSource scds;
    private final DelegatingDataSource dgds = new DelegatingDataSource();

    @Produces
    @Named("in-container-ds")
    public DataSource resettableDatasource() throws SQLException
    {
        return dgds;
    }

    @Override
    @PostConstruct
    public void start() throws SQLException
    {
        final JtdsDataSource ds = new JtdsDataSource();

        ds.setServerName("localhost");
        ds.setDatabaseName(dbName());
        connection = ds.getConnection(username(), password());

        scds = new SingleConnectionDataSource(connection, true);
        dgds.setTargetDataSource(scds);

    }

    protected abstract String password();

    protected abstract String username();

    protected abstract String dbName();

    @Override
    @PreDestroy
    public void stop() throws SQLException
    {
        if (null != connection)
        {
            scds.destroy();
            connection.close();
        }

    }
}

在测试数据库操作时，将数据库重置为已知状态的最佳方法是什么？

4 个答案:

基本方法

加速1

加速2