单元测试之DBUnit的使用以及原理剖析

最新推荐文章于 2024-08-22 10:02:04 发布
最新推荐文章于 2024-08-22 10:02:04 发布
阅读量3.4k 收藏 14
点赞数 2
分类专栏： 单元测试 文章标签： DBUnit
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35448165/article/details/109407775
版权

前面介绍了不少写单元测试的内容，比方说Mockito和PowerMockito, JUnit 5，经常写单元测试的想必对这些框架都比较熟悉。

这篇博客主要介绍下数据库驱动测试框架–DbUnit(http://dbunit.sourceforge.net/), 主要从DbUnit的设计原理和实际使用来展开，这里的使用我又分为三个部分:

  1. 基于spring-test-dbunit的使用
  2. 基于dbunit本身api的使用
  3. 在dbunit的基础上整合了公司自己的jdbc框架完成的工具类

DBUnit 设计原理

看过我之前关于单元测试的博客和熟悉单元测试的开发人员都知道，在写单元测试时最重要的一点就是单元测试是要求可以反复执行验证的。

那么在我们对数据库进行单元测试的时候，为了保证每次数据库的单元测试都可以得到一个相同的结果，我们就不能直接使用数据库里的数据来进行测试验证，说不定什么时候数据就被别人修改了，而且我们的单测执行最好也不要对数据库的数据有什么修改 — 很容易就想到的数据库的事务特性。

但是考虑到有的数据库本身并不支持事务，比如MyISAM引擎，而由dbunit本身实现事务是比较复杂的，所以dbunit框架本身是没有实现事务的

dbunit的设计原理就是在执行测试用例之前，先备份数据库，然后向数据库中插入我们需要的初始化数据(准备数据)，然后，在测试完毕后，清空表数据再将之前的备份的数据还原到数据库，从而回溯到测试前的状态。

乍一看是不是也像是实现了一个"事务" ？但还是有两个问题:

  1. 如果在单测执行过程中遇到问题, 导致执行中断，那么最后可能没有正常还原数据，这样的话就可能导致数据库的数据丢失(所以无论单测执行成功还是失败都记得一定要执行还原数据的代码)
  2. 单测执行过程中修改的数据在还原数据库的时候是会有丢失的，不过因为是测试环境的数据，影响也不是很大

DBUnit 基本概念和流程

基于DBUnit 单元测试的主要接口是IDataSet。IDataSet 数据集代表一个或多个表的数据。
dbunit可以将数据库的全部内容表示为IDataSet 实例。数据库表可以用ITable 实例来表示。

public interface IDataSet
{
    /**
     * 从IDataSet获取表名集合
     */
    public String[] getTableNames() throws DataSetException;

    /**
     * 获取数据库指定表的元数据
     */
    public ITableMetaData getTableMetaData(String tableName)
            throws DataSetException;

    /**
     * 获取指定表
     */
    public ITable getTable(String tableName) throws DataSetException;

    /**
     * 获取所有的表集合
     */
    public ITable[] getTables() throws DataSetException;
}

IDataSet 的实现有很多，每一个都对应一个不同的数据源或加载机制。最常用的几种 IDataSet实现为：
FlatXmlDataSet：数据的简单平面文件 XML 表示
QueryDataSet：用 SQL 查询获得的数据
DatabaseDataSet：数据库表本身内容的一种表示
XlsDataSet ：数据的excel表示

我们使用DbUnit进行数据库单元测试的流程如下：

  1. 备份数据库中的表数据
  2. 准备好测试使用的初始化数据和预期的结果数据，一般用xml文件表示
  3. 清空数据表并导入初始化数据。
  4. 执行对应的测试方法，比较实际执行的返回结果与预期结果是否匹配
  5. 使用备份文件还原表数据

DBUnit 使用

spring 结合dbunit完成db测试

dbunit本身并没有提供事务支持的功能，但是spring是可以提供事务支持的,包括声明式事务和程序控制事务。所以dbunit结合spring可以将上述单元测试的执行全都放在一个事务里，这样就可以解决我上面提到的两个问题

如果结合spring使用dbunit进行单元测试，就需要引入dbunit和spring-test-dbunit两个jar包

        <dependency>
            <groupId>com.github.springtestdbunit</groupId>
            <artifactId>spring-test-dbunit</artifactId>
            <version>1.2.0</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.dbunit</groupId>
            <artifactId>dbunit</artifactId>
            <version>2.5.0</version>
            <type>jar</type>
            <scope>test</scope>
        </dependency>

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ServiceInitializer.class)
@TestExecutionListeners({
        DependencyInjectionTestExecutionListener.class,
        DirtiesContextTestExecutionListener.class,
        TransactionalTestExecutionListener.class,
        DbUnitTestExecutionListener.class })
@DbUnitConfiguration(databaseConnection={"dataSource"})
@Transactional
public class BaseTest {、
}

因为我们使用@DbUnitConfiguration注解传入了dataSource, 这样在dbunit里获取连接的时候得到就是从spring管理的数据源获取的connection，这样事务管理也可以由spring的声明式事务托管。

public class UserMapperDBUnitTest extends BaseTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    @DatabaseSetup("/dbunit/sampleData_initdata.xml",type = DatabaseOperation.CLEAN_INSERT)
    @ExpectedDatabase(value = "/dbunit/sampleData_result_insert.xml", assertionMode = DatabaseAssertionMode.NON_STRICT)
    public void testInsertSelective(){
        User user = new User();
        user.setId("2");
        user.setUserName("Tom");
        user.setAge(28);
        user.setBirthday("1993-03-21");
        user.setAddress("上海市浦东新区");
        userMapper.insertSelective(user);

    }
 }

sampleData_initdata.xml :

 <?xml version="1.0" encoding="UTF-8"?>
<dataset>
    <user id="1" user_name="Bob" age = "20" birthday = "2000-01-02" address = "北京市大兴区" />
</dataset>

sampleData_result_insert.xml :

 <?xml version="1.0" encoding="UTF-8"?>
<dataset>
    <user id="1" user_name="Bob" age = "20" birthday = "2000-01-02" address = "北京市大兴区" />
    <user id="2" user_name="Tom" age = "28" birthday = "1993-03-21" address = "上海市浦东新区" />
</dataset>

@DatabaseSetup： 用于指定初始化数据库的xml文件，以及初始化方式。 默认使用的是CLEAN_INSERT方式，也就是先清除数据库的所有数据再插入准备的数据；如果表中的数据比较多，建议使用REFRESH方式，表示不会将原数据清空，而是直接对数据表中xml中存在的数据进行更新，不存在的就进行插入

@ExpectedDatabase 执行完测试方法后，将数据库中的数据查询出来和xml中的数据进行比较
注解参数query: 如果没有则查询所有的数据，否则按照指定的sql进行查询
参数 assertionMode: 支持两种数据验证方式：1）DatabaseAssertionMode.DEFAULT 要验证所有的字段 2）DatabaseAssertionMode.NON_STRICT则支持只验证部分字段(实际测试中NON_STRICT更为常用)

使用dbunit原生api完成db测试

上述spring-test-dbunit使用的前提是需要结合被spring管理的数据源, 因为公司有的旧项目是使用了自己开发的jdbc框架，其数据源无法直接获取，也没办法使用上面简单的注解方式

所以自己使用了dbunit的API来编写数据库的单元测试,具体代码如下:

public class DBUnitConnection {
    private static IDatabaseConnection CONNECTION_INSTANCE = null;
    //创建DBUnit Connection,先创建数据源, 再从数据源中获取到连接, 封装成MySQLConnection
    public static IDatabaseConnection getConnection() throws Exception {
        if (null == CONNECTION_INSTANCE) {
            //下面三行代码主要是为了获取数据库连接，可以根据你在项目中实际获取数据源和连接的方式调整
            XXDataSourceFactory factory = new XXDataSourceFactory();
            DataSource dataSource = factory.createDataSource();
            Connection connection = dataSource.getConnection();
            CONNECTION_INSTANCE = new MySqlConnection(connection,"userdb");
        }
        return CONNECTION_INSTANCE;
    }

    public void closeConnection() throws Exception {
        if (null != CONNECTION_INSTANCE) {
            if (!CONNECTION_INSTANCE.getConnection().isClosed()) {
                CONNECTION_INSTANCE.close();
            }
            CONNECTION_INSTANCE = null;
        }
    }
}

public class DbUnitUtil {
    //备份表数据
    public static void backupDatabase(String[] tables,File backupFile) throws Exception{
        QueryDataSet dataSet= new QueryDataSet(DBUnitConnection.getConnection());
        for(String _table:tables){
            dataSet.addTable(_table);
        }
        FlatXmlDataSet.write(dataSet, new FileOutputStream(backupFile));
    }

    //清空表数据，并导入测试数据
    public static void importTables(File dataFile) throws Exception{
        IDataSet dataSet=new FlatXmlDataSetBuilder().build(dataFile);
        DatabaseOperation.CLEAN_INSERT.execute(DBUnitConnection.getConnection(), dataSet);
    }

    //清空表数据，恢复备份数据
    public static void resumeDatabase(File backupFile) throws Exception{
        IDataSet dataSet= new FlatXmlDataSetBuilder().build(backupFile);
        DatabaseOperation.CLEAN_INSERT.execute(DBUnitConnection.getConnection(), dataSet);
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = {ServiceInitializer.class})
public class UserMapperDBUnitTest {

    @Autowired
    private UserMapper userMapper;

    private static final String TABLE_NAME = "user";

    private static String path = "";

    @Before
    public void init() throws Exception {
        path = UserMapperDBUnitTest .class.getClassLoader().getResource("").getPath()+"dbunit/backupAllData.xml";
        //备份数据表到path路径下的xml文件
        DbUnitUtil.backupDatabase(new String[]{TABLE_NAME},new File(path));
    }

    @After
    public void down() throws Exception {
        //还原表数据
        DbUnitUtil.resumeDatabase(new File(path));
    }

    @Test
    public void testInsertOneRecord() throws Exception {
        String path = getClass().getClassLoader().getResource("").getPath()+"dbunit/sampleData_initdata.xml";
        //清空并导入初始化数据
        DbUnitUtil.importTables(new File(path));
        User user = new User();
        user.setId("2");
        user.setUserName("Tom");
        user.setAge(28);
        user.setBirthday("1993-03-21");
        user.setAddress("上海市浦东新区");
        userMapper.insertSelective(user);
        String resultFile = getClass().getClassLoader().getResource("").getPath()+"dbunit/sampleData_result_insert.xml";
        IDataSet dataSet = new FlatXmlDataSetBuilder().build(new File(resultFile));
        assertDataSet(TABLE_NAME, "SELECT id, user_name, age, birthday, address FROM user", dataSet);

    }

虽然按照上面的方式可以实现数据库的单元测试，但是会出现最早提到的两个问题:

  1. 执行过程中更新的数据会丢失
  2. 执行失败可能会导致原来测试数据库的数据丢失

所以还是需要一个"事务"帮助我们来解决上述问题。

手动实现dbunit与事务的结合

查看了下我们的jdbc框架,它本身也是有事务支持的，既支持声明式事务，也支持编程式事务。我试着按照spring-test-dbunit和dbunit的使用方式来编写测试方法，但是在执行的时候会报错，提示使用事务注解的bean只能事务管理器来创建，所以最后我选择了使用编程式事务来解决上述问题

解决思路 :
我的目的是将dbunit对数据库的操作和应用代码里对数据库的操作放到一个事务里，那么首先二者需要处于一个连接中，我之前的代码中直接从数据源创建新连接的方法是需要修改的；其次就是需要将对数据库操作的代码都放在编程式事务里

为了方便使用，我将代码进一步封装，这样在编写测试用例的时候就可以只使用自定义注解和Rule来完成对数据库的清除，还原等操作。

修改后的代码如下:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DBUnitAnnotation {
    /**
     * Provides the locations of the datasets that will be used to reset the database.
     */
    String setupFile() ;
    /**
     * Provides the locations of the datasets that will be used to test the database.
     */
    String resultFile() default "";
}

public class DBUnitUtils {

    /**
     * clean table and input init data to table
     * */
    public static void importTables(File dataFile) throws Exception{
        IDataSet dataSet = new FlatXmlDataSetBuilder().build(dataFile);
        //通过反射获取项目中使用的connection实例
        DatabaseOperation.CLEAN_INSERT.execute(getConnectionInTransaction(), dataSet);
    }


    private static IDatabaseConnection CONNECTION_INSTANCE = null;

    /**
     * get the connection which is use in application
     * */
    public static IDatabaseConnection getConnectionInTransaction() throws Exception {
        // 这里是我根据公司的代码写的，你们可以按照自己项目的实际情况调整
        // 通过反射获取事务管理器的transactionHolder静态变量，从中获取项目中使用的connection实例(因为公司的框架并没有提供api让我们可以在项目中获取使用的连接实例)
        Field f = XXTransactionManager.class.getDeclaredField("transactionHolder");
        f.setAccessible(true);
        ThreadLocal<XXTransaction> transactionHolder = (ThreadLocal<XXTransaction>) f.get(null);
        XXTransaction transaction = transactionHolder.get();
        Connection connection = transaction.getConnection();
        CONNECTION_INSTANCE = new MySqlConnection(connection, "");
        return CONNECTION_INSTANCE;
    }

      /**
     *
     * compare the database data with the expectedDatabase
     * @param expectedDataSet
     * @throws Exception
     */
    public static void assertDataSet(IDataSet expectedDataSet) throws Exception {
        String[] tableNames = expectedDataSet.getTableNames();
        for (String tableName : tableNames) {
            //获取dataSet的表元数据，得到对应的Column集合
            Column[] columns = expectedDataSet.getTable(tableName).getTableMetaData().getColumns();
            String queryField = "";
            for (int i = 0 ; i < columns.length ; i++) {
                queryField += columns[i].getColumnName();
                if (i != columns.length - 1) {
                    queryField += " , ";
                }
            }
            String sql = "select " + queryField + " from " + tableName;
            QueryDataSet loadedDataSet = new QueryDataSet(DBUnitUtils.getConnectionInTransaction());
            loadedDataSet.addTable(tableName, sql);
            //从当前数据库中查询所有数据 并和预期的数据集进行比较
            ITable table1 = loadedDataSet.getTable(tableName);
            ITable table2 = expectedDataSet.getTable(tableName);

            Assert.assertEquals(table2.getRowCount(), table1.getRowCount());
            DefaultColumnFilter.includedColumnsTable(table1, table2.getTableMetaData().getColumns());
            Assertion.assertEquals(table2, table1);
        }
    }
}

public class DbUnitTransactionRule implements TestRule {

    @Override
    public Statement apply(final Statement base, Description description) {
        if (description.getAnnotation(DBUnitAnnotation.class) == null) {
            return new Statement() {
                @Override
                public void evaluate() throws Throwable {
                    base.evaluate();
                }
            };
        }
        final DBUnitAnnotation dbUnitAnnotation = description.getAnnotation(DBUnitAnnotation.class);
        //如果有DBUnitAnnotation注解
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                try {
                    //开启事务
                    String path = getClass().getClassLoader().getResource("").getPath() + dbUnitAnnotation.setupFile();
                    DBUnitUtils.importTables(new File(path));
                    base.evaluate();
                    if (StringUtils.isNotEmpty(dbUnitAnnotation.resultFile())) {
                        String resultFile = DBUnitUtils.class.getClassLoader().getResource("").getPath() + dbUnitAnnotation.resultFile();
                        IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File(resultFile));
                        DBUnitUtils.assertDataSet(expectedDataSet);
                    }
                } catch (Throwable e) {
                    e.printStackTrace();
                    //如果原来的单测有异常,则抛出断言失败也就是测试用例执行失败
                    throw new AssertionError();
                } finally {
                    //TODO 回滚，哪怕单测执行成功也要还原现场
                }
               
            }
        };
    }
}

使用的时候只需要加上DbUnitTransactionRule 和 @DBUnitAnnotation 注解就可以了，是不是很方便

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = {ServiceInitialier.class})
public class TRedPointRecordDaoDBUnitTest2 {

    @Autowired
    private UserMapper userMapper;

    @Rule
    public DbUnitTransactionRule rule = new DbUnitTransactionRule();

    @Test
    @DBUnitAnnotation(setupFile = "dbunit/sampleData_initdata.xml", resultFile = "dbunit/sampleData_result_insert.xml")
    public void testInsertOneRecord() throws Exception {
        User user = new User();
        user.setId("2");
        user.setUserName("Tom");
        user.setAge(28);
        user.setBirthday("1993-03-21");
        user.setAddress("上海市浦东新区");
        userMapper.insertSelective(user);
    }
}

封装的代码有一些考虑的还不是很完整，比如不支持多个xml文件；在校验数据的时候也没有对两个DataSet里的表做完全的相等判断

我本来是想写成两个注解，但是在测试的时候发现Rule的Description只能拿到两个注解，所以我就把两个注解定义成一个了 – 目前还没找到原因，如果有读者知道这个问题的答案欢迎在评论区分享下

总结

基本关于DBUnit的介绍就到这里了。

使用DBUnit进行数据库的单元测试，最好是可以结合事务来执行，这样可以避免出现测试数据没有被正常还原或者丢失执行过程中更新的数据的问题。

基本思路就是 开启事务 --> 清空表数据 --> 插入初始化数据 --> 执行测试方法 --> 查询表数据，比较预期结果和执行结果是否一致 --> 回滚事务(无论测试方法是否正确执行，最后都需要回滚)

最后的一部分是我基于工作中整合dbunit和内部的jdbc框架的需要，因为不同的jdbc框架获得connection的方式不一样(甚至有的框架可能也支持类似spring-test-dbunit的声明式事务的写法)，所以我只是写了自己项目中的代码实现，希望对有同样需求的开发者可以提供一些思路。

参考资料:

JUnit单元测试6—@Rule注解

dearfulan
关注
专栏目录
DBUnit 进行单元测试
03-01
一个很好的DBUnit的例子 博文链接：https://virgoooos.iteye.com/blog/186859
Springboot+DBunit单元测试，数据库隔离测试
Oumuv的博客
03-31 4541
关于DBunit 百度百科：dbunit是一个基于junit扩展的数据库测试框架。 简言之，dbunit是为了在单元测试中，通过备份数据库、导入测试数据、回滚恢复数据库的手段，在不污染数据库的前提下完成一系列单元测试工作。 DBunit关键知识点 IDataSet接口：用于操作表集合 ITable接口：用于操作表数据集合 DatabaseOperation类：对表数据执行一系列操作，比如刷新、删除...
Spring Test DbUnit 开源项目教程
最新发布
gitblog_00092的博客
08-22 687
Spring Test DbUnit 开源项目教程 spring-test-dbunitIntegration between the Spring testing framework and DBUnit项目地址:https://gitcode.com/gh_mirrors/sp/spring-test-dbunit 1. 项目的目录结构及介绍 Spring Test DbUnit 项目的目录...
DbUnit入门实战
wengyx的专栏
03-31 1359
欢迎交流：）  Msn   wengyx@hotmail.com相信做过单元测试的人都会对JUnit非常的熟悉了，今天要介绍的DbUnit(http://dbunit.sourceforge.net/)则是专门针对数据库测试的对JUnit的一个扩展，它可以将测试对象数据库置于一个测试轮回之间的状态。鉴于目前国内介绍DbUnit的系统教程比较少见，本文将分从理论和实例两个方面带你领略DbUnit
dbunit实践指南
热门推荐
pwlazy的专栏
05-08 1万+
什么是dbunit以及为什么要使用它? dbunit是一个基于junit扩展的数据库测试框架。它提供了大量的类对与数据库相关的操作进行了抽象和封装，虽然在80%的情况，你只需使用它极少的api。它通过使用用户自定义的数据集以及相关操作使数据库处于一种可知的状态，从而使得测试自动化、可重复和相对独立。虽然不用dbunit也可以达到这种目的，但是我们必须为此付出代价（编写大量代
DBUnit的原理
漢家郎
02-27 1307
dbunit是一个基于junit扩展的数据库测试框架。它提供了大量的类对与数据库相关的操作进行了抽象和封装，虽然在80%的情况，你只需使用它极少的api。它通过使用用户自定义的数据集以及相关操作使数据库处于一种可知的状态，从而使得测试自动化、可重复和相对独立。  这个所谓“可知的状态”，让人看上去是有点晕的，其实他的意思就是：当前数据库里的数据是已知的。比如，在运行每一个单元测试用例之前，数
【DBunit数据库测试秘籍】：掌握DBunit使用到高级技巧，轻松构建测试数据
![【DBunit数据库测试秘籍】：...DBunit是针对Java应用程序设计的数据库测试库，它提供了一种方式来初始化数据库状态以便于单元测试和功能测试。通过使用DBunit，开发者可以在测试开始前准备一个预期的数据库状态，并
【DBunit REST API测试集成】：如何使用DBunit进行高效API数据库测试
[【DBunit REST API测试集成】：如何使用DBunit进行高效API数据库测试](https://learn.microsoft.com/en-us/sql/ssms/tutorials/media/scripting-ssms/scriptedoutdb.png?view=sql-server-ver16) # 1. DBunit REST ...
对dbunit进行mybatis DAO层Excel单元测试(必看篇)
08-30
下面小编就为大家带来一篇对dbunit进行mybatis DAO层Excel单元测试(必看篇)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
单元测试JUnit4和DbUnit
03-16
单元测试入门学习，和dbunit结合开发
介绍dbunit的使用和原理,核心组件介绍
11-22
介绍dbunit的使用和原理,核心组件介绍
DbUnit.NET-开源
07-13
DbUnit.NET是一个专门为.NET开发者设计的开源数据库单元测试框架。这个框架的核心目标是帮助程序员在进行单元测试时，能够有效地管理和控制数据库的状态，确保每次测试的环境一致性，从而提高测试的可靠性和效率。 ...
【DBunit依赖注入揭秘】：在测试框架中实现DBunit依赖注入的奥秘
![【DBunit依赖注入揭秘】：在测试框架中实现DBunit依赖注入的奥秘]...当我们在单元测试中使用DBunit时，依赖注入可以帮助我们高效地管理数
DBUnit使用介绍
a7412605567的博客
04-04 289
一、DbUnit设计理念熟悉单元测试的开发人员都知道，在对数据库进行单元测试时候，通常采用的方案有运用模拟对象(mock objects)和stubs两种。通过隔离关联的数据库访问类，比如JDBC的相关操作类，来达到对数据库操作的模拟测试。然而某些特殊的系统，比如利 用了EJB的CMP(container-managed persistence)的系统，数据库的访问对象是在最底层而且很隐...
用DBUnit写单元测试
我想我是海
12-20 1476
目的搞清楚了就最容易做事了。嘿嘿。如果不知DBUnit是用来做什么的，就像个无头苍蝇，晃了半天都不清楚在看些什么。DBUnit的主要功能是可以为你的数据库测试提供稳定及一致的数据。DBUnit通过预先在XML文件设置数据值、使用Sql查询另外的表格为测试提供数据等等方式来达到这个目的，而通常我们只需要使用XML文件预置数据的方法即可。使用DBUnit来写单元测试至少有两个方法，一是直接继承Data
使用DBUnit做单元测试
fguyfff的博客
02-17 252
使用DBUnit做单元测试
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值