`
snoopy7713
  • 浏览: 1152227 次
  • 性别: Icon_minigender_2
  • 来自: 火星郊区
博客专栏
Group-logo
OSGi
浏览量:0
社区版块
存档分类
最新评论

单元测试系列之4:使用Unitils测试DAO层

阅读更多

引述 :Spring 的测试框架为我们提供一个强大的测试环境,解决日常单元测试中遇到的大部分测试难题:如运行多个测试用例和测试方法时,Spring上下文只需创建一次; 数据库现场不受破坏;方便手工指定Spring配置文件、手工设定Spring容器是否需要重新加载等。但也存在不足的地方,基本上所有的Java应用都 涉及数据库,带数据库应用系统的测试难点在于数据库测试数据的准备、维护、验证及清理。Spring 测试框架并不能很好地解决所有问题。要解决这些问题,必须整合多方资源,如DbUnit、Unitils、Mokito等。其中Unitils正是这样的 一个测试框架。

数据库测试的难点

    按照Kent Back的观点,单元测试最重要的特性之一应该是可重复性。不可重复的单元测试是没有价值的。因此好的单元测试应该具备独立性和可重复性,对于业务逻辑 层,可以通过Mockito底层对象和上层对象来获得这种独立性和可重复性。而DAO层因为是和数据库打交道的层,其单元测试依赖于数据库中的数据。要实 现DAO层单元测试的可重复性就需要对每次因单元测试引起数据库中的数据变化进行还原,也就是保护单元测试数据库的数据现场。

扩展Dbunit用Excel准备数据

    在测试数据访问层(DAO)时,通常需要经过测试数据的准备、维护、验证及清理的过程。这个过程不仅烦锁,而且容易出错,如数据库现场容易遭受破坏、如何 对数据操作正确性进行检查等。虽然Spring测试框架在这一方面为我们减轻了很多工作,如通过事务回滚机制来保存数据库现场等,但对测试数据及验证数据 准备方面还没有一种很好的处理方式。Unitils框架出现,改变了难测试DAO的局面,它将SpringModule、DatabaseModule、 DbUnitModule等整合在一起,使得DAO的单元测试变得非常容易。基于Unitils框架的DAO测试过程如图16-6所示。



   以JUnit作为整个测试的基础框架,并采用DbUnit作为自动管理数据库的工具,以XML、Excel作为测试数据及验证数据准备,最后通过 Unitils的数据集注解从Excel、XML文件中加载测试数据。使用一个注解标签就可以完成加载、删除数据操作。由于XML作为数据集易用性不如 Excel,在这里就不对XML数据集进行讲解。下面我们主要讲解如何应用Excel作为准备及验证数据的载体,减化DAO单元测试。由于Unitils 没有提供访问Excel的数据集工厂,因此需要编写插件支持Excel格式数据源。Unitils提供一个访问XML的数据集工厂 MultiSchemaXmlDataSetFactory,其继承自DbUnit提供的数据集工厂接口DataSetFactory。我们可以参考这个 XML数据集工厂类,编写一个访问Excel的数据集工厂MultiSchemaXlsDataSetFactory及Excel数据集读取器 MultiSchemaXlsDataSetReader,然后在数据集读取器中调用Apache POI类库来读写Excel文件。如代码清单16-20所示。

Java代码  收藏代码
  1. import  org.unitils.core.UnitilsException;  
  2. import  org.unitils.DbUnit.datasetfactory.DataSetFactory;  
  3. import  org.unitils.DbUnit.util.MultiSchemaDataSet;  
  4. …  
  5. public   class  MultiSchemaXlsDataSetFactory  implements  DataSetFactory {  
  6. protected  String defaultSchemaName;  
  7.   
  8.     //① 初始化数据集工厂   
  9.     public   void  init(Properties configuration, String defaultSchemaName) {  
  10.         this .defaultSchemaName = defaultSchemaName;  
  11.     }  
  12.   
  13.     //② 从Excel文件创建数据集   
  14.     public  MultiSchemaDataSet createDataSet(File... dataSetFiles) {  
  15.         try  {  
  16.             MultiSchemaXlsDataSetReader xlsDataSetReader =   
  17.                   new  MultiSchemaXlsDataSetReader(defaultSchemaName);  
  18.             return  xlsDataSetReader.readDataSetXls(dataSetFiles);  
  19.         } catch  (Exception e) {  
  20.             throw   new  UnitilsException( "创建数据集失败: "   
  21.                     + Arrays.toString(dataSetFiles), e);  
  22.         }  
  23.     }  
  24.   
  25.     //③  获取数据集文件的扩展名   
  26.     public  String getDataSetFileExtension() {  
  27.         return   "xls" ;  
  28.     }  
  29. }  
  30. …  



   与XML数据集工厂MultiSchemaXmlDataSetFactory一样,Excel的数据集工厂也需要实现数据集工厂接口 DataSetFactory的三个方法:init(…)、createDataSet(File... dataSetFiles)、getDataSetFileExtension()。在①处,初始化数据集工厂,需要设置一个默认的数据库表模式名称 defaultSchemaName。在②处,执行创建多数据集,具体读取构建数据集的过程封装在Excel读取器 MultiSchemaXlsDataSetReader中。在③处,获取数据集文件的扩展名,对Excel文件而言就是“xls”。下面来看一下这个数 据集读取器的实现代码。

Java代码  收藏代码
  1. import  org.unitils.core.UnitilsException;  
  2. import  org.unitils.DbUnit.datasetfactory.DataSetFactory;  
  3. import  org.unitils.DbUnit.util.MultiSchemaDataSet;  
  4. …  
  5. // Excel数据集读取器   
  6. public   class  MultiSchemaXlsDataSetReader {  
  7.     private  String defaultSchemaName;  
  8.       
  9.     public  MultiSchemaXlsDataSetReader(String defaultSchemaName) {  
  10.         this .defaultSchemaName = defaultSchemaName;  
  11.     }     
  12.      // Excel数据集读取器   
  13.     public  MultiSchemaDataSet readDataSetXls(File... dataSetFiles) {  
  14.         try  {  
  15.             Map<String, List<ITable>> tableMap = getTables(dataSetFiles);  
  16.             MultiSchemaDataSet dataSets = new  MultiSchemaDataSet();  
  17.             for  (Entry<String, List<ITable>> entry : tableMap.entrySet()) {  
  18.                 List<ITable> tables = entry.getValue();  
  19.                 try  {  
  20.                     DefaultDataSet ds = new  DefaultDataSet(tables  
  21.                             .toArray(new  ITable[] {}));  
  22.                     dataSets.setDataSetForSchema(entry.getKey(), ds);  
  23.                 } catch  (AmbiguousTableNameException e) {  
  24.                     throw   new  UnitilsException( "构造DataSet失败!" ,  e);  
  25.                 }  
  26.             }  
  27.             return  dataSets;  
  28.         } catch  (Exception e) {  
  29.             throw   new  UnitilsException( "解析EXCEL文件出错:" , e);  
  30.         }  
  31.     }  
  32. …  
  33. }  
  34. …  



  根据传入的多个Excel文件,构造一个多数据集。 其中一个数据集对应一个Excel文件,一个Excel的Sheet表对应一个数据库Table。通过DbUnit提供Excel数据集构造类 XlsDataSet,可以很容易将一个Excel文件转换为一个数据集:XlsDataSet(new FileInputStream(xlsFile))。最后将得到的多个DataSet用MultiSchemaDataSet进行封装。
  下面就以一个用户DAO的实现类WithoutSpringUserDaoImpl为例,介绍如何使用我们实现的Excel数据集工厂。为了让Unitils使用自定义的数据集工厂,需要在unitils.properties配置文件中指定自定义的数据集工厂。

引用

DbUnitModule.DataSet.factory.default=sample.unitils.dataset.excel.MultiSchemaXlsDataSetFactory
DbUnitModule.ExpectedDataSet.factory.default=sample.unitils.dataset.excel.MultiSchemaXlsDataSetFactory



  其中DbUnitModule.DataSet.factory.default是配置数据集工厂类,在测试方法中可以使用@DataSet 注解加载指定的准备数据。默认是XML数据集工厂,这里指定自定义数据集工厂类全限定名为   sample.unitils.dataset.excel.MultiSchemaXlsDataSetFactory。
  其中DbUnitModule. ExpectedDataSet.factory.default是配置验证数据集工厂类,也是指定自定义数据集工厂类,使用@ ExpectedDataSet注解加载验证数据。

Java代码  收藏代码
  1. import  org.unitils.core.UnitilsException;  
  2. import  org.unitils.DbUnit.datasetfactory.DataSetFactory;  
  3. import  org.unitils.DbUnit.util.MultiSchemaDataSet;  
  4. …  
  5. public   class  UserDaoTest  extends  UnitilsJUnit4 {  
  6.     @Test   
  7.     @DataSet   //① 准备测试数据   
  8.     public   void  getUser() {  
  9.         …  
  10.     }  
  11.   
  12.     @Test   
  13.     @DataSet ( "BaobaoTao.SaveUser.xls" //② 准备测试数据 -   
  14.     @ExpectedDataSet   //③ 准备验证数据   
  15.     public   void  saveUser() throws  Exception  {  
  16.         …  
  17.     }  
  18.   
  19. }  
  20. …  



  @DateSet 注解表示了测试时需要寻找DbUnit的数据集文件进行加载,如果没有指明数据集的文件名,则Unitils自动在当前测试用例所在类路径下加载文件名为 测试用例类名的数据集文件,实例中①处,将到UserDaoTest.class所在目录加载WithExcelUserDaoTest.xls 数据集文件。
  @ExpectedDataSet注解用于加载验证数据集文件,如果没有指明数据集的文件名,则会在当前测试用例所在类路径下加载文件名为 testClassName.methodName-result.xls的数据集文件。实例中③处将加载UserDaoTest. saveUser.result.xls数据集文件。

测试实战

  使用JUnit作为基础测试框架,结合Unitils、DbUnit管理测试数据,并使用我们编写的Excel数据集工厂(见代码清单16 20)。从Excel数据集文件中获取准备数据及验证数据,并使用HSQLDB作为测试数据库。下面详细介绍如何应用Excel准备数据集及验证数据集来 测试DAO。
  在进行DAO层的测试之前,我们先来认识一下需要测试的UserDaoImpl用户数据访问类。UserDaoImpl用户数据访问类中拥有一个获取用户信息和保存注册用户信息的方法,其代码如下所示。

Java代码  收藏代码
  1. import  java.util.List;  
  2. import  org.hibernate.Session;  
  3. import  org.hibernate.SessionFactory;  
  4. import  org.springframework.orm.hibernate3.HibernateTemplate;  
  5. import  com.baobaotao.dao.UserDao;  
  6. import  com.baobaotao.domain.User;  
  7. public   class  UserDaoImpl  implements  UserDao {  
  8.   
  9.     //通过用户名获取用户信息   
  10. public  User findUserByUserName(String userName) {  
  11.         String hql = " from User u where u.userName=?" ;  
  12.         List<User> users = getHibernateTemplate().find(hql, userName);  
  13.         if  (users !=  null  && users.size() >  0 )  
  14.             return  users.get( 0 );  
  15.         else   
  16.             return   null ;  
  17.     }  
  18.   
  19. //保存用户信息   
  20.     public   void  save(User user) {  
  21.         getHibernateTemplate().saveOrUpdate(user);  
  22.     }  
  23.     …  
  24. }  



  我们认识了需要测试的UserDaoImpl用户数据访问类之后,还需要认识一下用于表示用户领域的对象User,在演示测试保存用户信息及获取用户信息时需要用到此领域对象,其代码如下所示。

Java代码  收藏代码
  1. import  javax.persistence.Column;  
  2. import  javax.persistence.Entity;  
  3. …  
  4. @Entity   
  5. @GeneratedValue (strategy = GenerationType.IDENTITY)  
  6. @Table (name =  "t_user" )  
  7. public   class  User  implements  Serializable{  
  8.     @Id   
  9.     @Column (name =  "user_id" )  
  10.     protected   int  userId;  
  11.   
  12.     @Column (name =  "user_name" )  
  13.     protected  String userName;  
  14.   
  15.     protected  String password;  
  16.   
  17.     @Column (name =  "last_visit" )  
  18.     protected  Date lastVisit;  
  19.   
  20.     @Column (name =  "last_ip" )  
  21.     protected  String lastIp;  
  22.   
  23.     @Column (name =  "credits" )  
  24.     private   int  credits;  
  25.     …  
  26. }  


  用户登录日志领域对象LoginLog与用户领域对象Hibernate注解配置一致,这里就不再列出,读者可以参考本书附带光盘中的实例代 码。在实例测试中,我们直接使用Hibernate进行持久化操作,所以还需要对Hibernate进行相应配置,详细的配置清单如下所示。

Xml代码  收藏代码
  1. <? xml   version = "1.0"   encoding = "UTF-8" ?>   
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">   
  5. < hibernate-configuration >   
  6.     < session-factory >   
  7.         <!--①  SQL方言,这边设定的是HSQL -->   
  8.         < property   name = "dialect" > org.hibernate.dialect.HSQLDialect </ property >   
  9.         <!--② 数据库连接配置 -->   
  10.         < property   name = "hibernate.connection.driver_class" > org.hsqldb.jdbcDriver </ property >   
  11.         < property   name = "hibernate.connection.url" >   
  12. jdbc:hsqldb:data/sampledb  
  13. </ property >   
  14.         <!--设置连接数据库的用户名-->   
  15.         < property   name = "hibernate.connection.username" > sa </ property >   
  16.         <!--设置连接数据库的密码-->   
  17.         < property   name = "hibernate.connection.password" > </ property >   
  18.         <!--③ 设置显示sql语句方便调试-->   
  19.         < property   name = "hibernate.show_sql" > true </ property >   
  20.         <!--④  配置映射 -->   
  21.         < property   name = "configurationClass" >   
  22. org.hibernate.cfg.AnnotationConfiguration  
  23. </ property >   
  24.         < mapping   class = "com.baobaotao.domain.User"   />   
  25.         < mapping   class = "com.baobaotao.domain.LoginLog"   />   
  26.     </ session-factory >   
  27. </ hibernate-configuration >   



  选用HSQLDB作为测试数据库,在①处,配置HSQLDB的SQL方言HSQLDialect。在②处,对连接数据库驱动及数据库连接进行相应的配置。 为了方便测试调试,在③处设置显示Hibernate生成的SQL语句。在④处启用Hibernate的注解功能,并配置相应的领域对象,如实例中的 User、LoginLog。将配置好的hibernate.cfg.xml放在src目录下。

配置Unitils测试环境

  要在单元测试中更好地使用Unitils ,首先需要在测试源码的根目录中创建一个项目级unitils.properties 配置文件,实例中unitils.properties详细配置清单如下所示。

Java代码  收藏代码
  1. #① 启用unitils所需模块   
  2. unitils.modules=database,dbunit,hibernate,spring  
  3.   
  4. #自定义扩展模块,详见实例源码  
  5. unitils.module.dbunit.className=sample.unitils.module.CustomExtModule  
  6.   
  7. #② 配置数据库连接  
  8. database.driverClassName=org.hsqldb.jdbcDriver  
  9. database.url=jdbc:hsqldb:data/sampledb;shutdown=true   
  10. database.userName=sa  
  11. database.password=  
  12. database.schemaNames=public   
  13. database.dialect = hsqldb  
  14.   
  15. #③ 配置数据库维护策略.  
  16. updateDataBaseSchema.enabled=true   
  17.   
  18. #④ 配置数据库表创建策略  
  19. dbMaintainer.autoCreateExecutedScriptsTable=true   
  20. dbMaintainer.script.locations=D:/masterSpring/chapter16/resources/dbscripts  
  21.   
  22. #⑤ 数据集加载策略  
  23. #DbUnitModule.DataSet.loadStrategy.default =org.unitils.dbunit.datasetloadstrategy.InsertLoadStrategy   
  24.   
  25.   
  26. #⑥ 配置数据集工厂  
  27. DbUnitModule.DataSet.factory.default =sample.unitils.dataset.excel.MultiSchemaXlsDataSetFactory  
  28. DbUnitModule.ExpectedDataSet.factory.default =sample.unitils.dataset.excel.MultiSchemaXlsDataSetFactory  
  29.   
  30. #⑦ 配置事务策略  
  31. DatabaseModule.Transactional.value.default =commit  
  32.   
  33. #⑧ 配置数据集结构模式XSD生成路径  
  34. dataSetStructureGenerator.xsd.dirName=resources/xsd  



   我们知道unitils.properties中配置的属性是整个项目级别的,整个项目都可以使用这些全局的属性配置。特定用户使用的属性可以设置在 unitils-local.properties 文件中,比如user、password和schema,这样每个开发者就使用自定义的测试数据库的schema,而且彼此之间也不会产生影响,实例的详 细配置清单如下所示。

Java代码  收藏代码
  1. …  
  2. database.userName=sa  
  3. database.password=  
  4. database.schemaNames=public   
  5. …  


  
   如果用户分别在unitils.properties文件及unitils -local.properties文件中对相同属性配置不同值时,将会以unitils-local.properties 配置内容为主。如在unitils.properties配置文件中,也配置了database.schemaNames=xxx,测试时启用的是用户自 定义配置中的值database.schemaNames=public。

   默认的数据集加载机制采用先清理后插入的策略,也就是数据在被写入数据库的时候是会先删除数据集中有对应表的数据,然后将数据集中的数据写入数据库。这个 加载策略是可配置的,我们可以通过修改DbUnitModule.DataSet.loadStrategy.default的属性值来改变加载策略。如 实例代码清单16 27中⑤配置策略,这时加载策略就由先清理后插入变成了插入,数据已经存在表中将不会被删除,测试数据只是进行插入操作。可选的加载策略列表如下所示。

  •   CleanInsertLoadStrategy:先删除dateSet中有关表的数据,然后再插入数据。
  •   InsertLoadStrategy:只插入数据。
  •   RefreshLoadStrategy:有同样key的数据更新,没有的插入。
  •   UpdateLoadStrategy: 有同样key的数据更新,没有的不做任何操作。



配置事务策略

   在测试DAO的时候都会填写一些测试数据,每个测试运行都会修改或者更新了数据,当下一个测试运行的时候,都需要将数据恢复到原有状态。如果使用的是 Hibernate或者JPA,需要每个测试都运行在事务中,保证系统的正常工作。默认情况下,事务管理是disabled的,我们可以通过修改 DatabaseModule.Transactional.value.default配置选项,如实例代码清单16 27中⑧配置策略,这时每个测试都将执行commit,其他可选的配置属性值有rollback和disabled。

准备测试数据库及测试数据

   配置好了Unitils基本配置、加载模块、数据集创建策略、事务策略之后,我们就着手开始测试数据库及测试数据准备工作,首先我们创建测试数据库。

创建测试数据库

   在源码包根目录下创建一个dbscripts文件夹(文件夹目录结构如图16-7所示),且这个文件夹必须与在unitils.properties 文件中dbMaintainer.script.locations配置项指定的位置一致,如代码清单16 27中④ 所示。

   在这个文件夹中创建一个数据库创建脚本文件001_create_sampledb.sql,里面包含创建用户表t_user 及登录日志表t_login_log,详细的脚本如下所示。

Sql代码  收藏代码
  1. CREATE   TABLE  t_user (  
  2. user_id INT  generated  by   default   as  identity (start  with  100),  
  3. user_name VARCHAR (30),credits  INT ,  
  4. password    VARCHAR (32),last_visit  timestamp ,  
  5. last_ip  VARCHAR (23),  primary   key  (user_id));  
  6.   
  7. CREATE   TABLE  t_login_log (  
  8. login_log_id  INT  generated  by   default   as  identity (start  with  1),   
  9. user_id   INT ,  
  10. ip  VARCHAR (23),  
  11. login_datetime timestamp ,  
  12. primary   key  (login_log_id));  


   细心的读者可能会发现这个数据库创建脚本文件名好像存在一定的规则,是的,这个脚本文件命名需要按以下规则命名:版本号 +  “_” +  “自定义名称” + “ .sql” 。

连接到测试数据库

   测试DAO时,读者要有个疑问,测试数据库用到的数据源来自哪里,怎么让我们测试的DAO类来使用我们的数据源。执行测试实例的时候,Unitils 会根据我们定义的数据库连接属性来创建一个数据源实例连接到测试数据库。随后的DAO测试会重用相同的数据源实例。建立连接的细节定义在 unitils.properties配置文件中,如代码清单16 27中的② 配置部分所示。

用Excel准备测试数据

   准备好测试数据库之后,剩下的工作就是用Excel来准备测试数据及验证数据,回顾一下我们要测试的UserDaoImpl 类(代码清单16 24),需要对其中的获取用户信息方法findUserByUserName()及保存用户信息方法saveUser()进行测试,所以我们至少需要准备 三个Excel数据集文件 ,分别是供查询用户用的数据集BaobaoTao.Users.xls、供保存用户信息用的数据集BaobaoTao.SaveUser.xls及供保存 用户信息用的验证数据集BaobaoTao. ExpectedSaveUser.xls。下面以用户数据集BaobaoTao.Users.xls实例进行说明,如图16-8所示。


   在①处t_user表示数据库对应的表名称。在②处表示数据库中t_user表对应的字段名称。在③处表示准备测试的模拟数据。一个数据集文件可以对应多 张表,一个Sheet对就一张表。把创建好的数据集文件放到与测试类相同的目录中,如实例中的UserDaoTest类位于 com.baobaotao.dao包中,则数据集文件需要放到当前包中。其他两个数据集文件数据结构如图16-9和16-10所示。



编写UserDaoImpl的测试用例

  完成了Unitils环境配置、准备测试数据库及测试数据之后,就可以开始编写用户DAO单元测试类,下面我们为用户数据访问UserDaoImpl编写测试用例类。

Java代码  收藏代码
  1. import  org.unitils.core.UnitilsException;  
  2. import  org.unitils.DbUnit.datasetfactory.DataSetFactory;  
  3. import  org.unitils.DbUnit.util.MultiSchemaDataSet;  
  4. …  
  5. @SpringApplicationContext ( { "baobaotao-dao.xml"  })  //① 初始化Spring容器   
  6. public   class  UserDaoTest  extends  UnitilsJUnit4 {  
  7.   
  8.     @SpringBean ( "jdbcUserDao" )   //② 从Spring容器中加载DAO   
  9.     private  UserDao userDao;      
  10.   
  11.     @Before   
  12.     public   void  init() {  
  13.           
  14.     }  
  15.    …  
  16. }  


   在①处,通过Unitils提供@ SpringApplicationContext注解加载Spring配置文件,并初始化Spring容器。在②处,通过@SpringBean注解从 Spring容器加载一个用户DAO实例。编写UserDaoTest测试基础模型之后,接下来就编写查询用户信息 findUserByUserName()的测试方法。

代码清单16 31 UserDaoTest.findUserByUserName()测试

Java代码  收藏代码
  1. import  org.unitils.core.UnitilsException;  
  2. import  org.unitils.DbUnit.datasetfactory.DataSetFactory;  
  3. import  org.unitils.DbUnit.util.MultiSchemaDataSet;  
  4. …  
  5. public   class  UserDaoTest  extends  UnitilsJUnit4 {  
  6. …  
  7.   
  8. @Test   //① 标志为测试方法   
  9.     @DataSet ( "BaobaoTao.Users.xls" //② 加载准备用户测试数据   
  10.     public   void  findUserByUserName() {  
  11.         User user = userDao.findUserByUserName("tony" );  //③ 从数据库中加载tony用户   
  12.         assertNull("不存在用户名为tony的用户!" , user);  
  13.         user = userDao.findUserByUserName("jan" );  //④ 从数据库中加载jan用户   
  14.         assertNotNull("jan用户存在!" , user);  
  15.         assertEquals("jan" , user.getUserName());  
  16.         assertEquals("123456" ,user.getPassword());  
  17.         assertEquals(10 ,user.getCredits());   
  18.     }  
  19. …  
  20. }  



   在①处,通过JUnit提供@Test注解,把当前方法标志为可测试方法。在②处,通过Unitils提供的@DataSet注解从当前测试类 UserDaoTest.class所在的目录寻找支持DbUnit的数据集文件并进行加载。执行测试逻辑之前,会把加载的数据集先持久化到测试数据库 中,具体加载数据集的策略详见上文“配置数据集加载策略”部分。实例中采用的默认加载策略,即先删除测试数据库对应表的数据再插入数据集中的测试数据。这 种策略可以避免不同测试方法加载数据集相互干扰。在③处执行查询用户方法时,测试数据库中t_user表数据已经是如图16-8 BaobaoTao.Users.xls所示的数据,因此查询不到“tony”用户信息。在④处,执行查询“jan”用户信息,从测试数据集可以看出,可 以加载到“jan”的详细信息。最后在IDE中执行UserDaoTest. findUserByUserName()测试方法,按我们预期通过测试,测试结果如图16-11所示。


   完成了查询用户的测试之后,我们开始着手编写保存用户信息的测试方法,详细的实现代码如下所示。

Java代码  收藏代码
  1. import  org.unitils.core.UnitilsException;  
  2. import  org.unitils.DbUnit.datasetfactory.DataSetFactory;  
  3. import  org.unitils.DbUnit.util.MultiSchemaDataSet;  
  4. …  
  5. public   class  UserDaoTest  extends  UnitilsJUnit4 {  
  6. …     
  7.   
  8. @Test    //① 标志为测试方法   
  9.     @ExpectedDataSet ( "BaobaoTao.ExpectedSaveUser.xls" //准备验证数据   
  10.     public   void  saveUser() throws  Exception  {  
  11.         User u = new  User();  
  12.         u.setUserId(1 );  
  13.         u.setUserName("tom" );  
  14.         u.setPassword("123456" );  
  15.         u.setLastVisit(getDate("2011-06-06 08:00:00" , "yyyy-MM-dd HH:mm:ss" ));  
  16.         u.setCredits(30 );  
  17.         u.setLastIp("127.0.0.1" );  
  18.         userDao.save(u);  //执行用户信息更新操作   
  19.     }  
  20. …  
  21. }  


   在①处,通过JUnit提供@Test注解,把当前方法标志为可测试方法。在②处,通过Unitils提供的@ExpectedDataSet注解从当前 测试类UserDaoTest.class所在的目录寻找支持DbUnit的验证数据集文件并进行加载,之后验证数据集里的数据和数据库中的数据是否一 致。在UserDaoTest.saveUser()测试方法中创建一个User实例,并设置与图16-10 验证数据集中相同的数据,然后执行保存用户操作。最后在IDE中执行UserDaoTest.saveUser()测试方法,执行结果如图16-12所 示。

   虽然已经成功完成了保存用户信息UserDaoTest.saveUser() 方法测试,但还是存在不足的地方,我们测试数据通过硬编码方式直接设置在User实例中。如果需要更改测试数据,只能更改测试代码。大大削减了测试的灵活 性。如果能直接从Excel数据集获取测试数据,并自动绑定到目标对象,那我们的测试用例就更加完美。为此笔者编写了一个获取Excel数据集Bean工 厂XlsDataSetBeanFactory,用于自动绑定数据集到测试对象。我们对上面的测试方法进行整改,实现代码如代码清单16-33所示。

Java代码  收藏代码
  1. import  org.unitils.core.UnitilsException;  
  2. import  org.unitils.DbUnit.datasetfactory.DataSetFactory;  
  3. import  org.unitils.DbUnit.util.MultiSchemaDataSet;  
  4. import  sample.unitils.dataset.util.XlsDataSetBeanFactory;  
  5. …  
  6. public   class  UserDaoTest  extends  UnitilsJUnit4 {  
  7. …     
  8.   
  9. @Test    //① 标志为测试方法   
  10.     @ExpectedDataSet ( "BaobaoTao.ExpectedSaveUser.xls" //准备验证数据   
  11.     public   void  saveUser() throws  Exception  {  
  12.   
  13. //② 从保存数据集中创建Bean   
  14.     User u  = XlsDataSetBeanFactory.createBean("BaobaoTao.SaveUser.xls”   
  15. ,"t_user" , User. class );  
  16.         userDao.save(u); //③ 执行用户信息更新操作   
  17.     }  
  18. …  
  19. }  


   在②处,通过XlsDataSetBeanFactory.createBean()方法,从当前测试类所在目录加载 BaobaoTao.SaveUser.xls数据集文件,其数据结构如图16-9所示。把BaobaoTao.SaveUser.xls中名称为 t_user 的Sheet页中的数据绑定到User对象,如果当前Sheet页有多条记录,可以通过 XlsDataSetBeanFactory.createBeans()获取用户列表List<User>。最后在IDE中重新执行 UserDaoTest.saveUser()测试方法,执行结果如图16-13所示。

   从测试结果可以看出,执行UserDaoTest.saveUser()测试失败。从右边的失败报告信息我们可以看出,是由于模拟用户的积分与我们期望数 据不一致造成,期望用户积分是30,而我们保存用户的积分是10。重新对比一下图16-9 BaobaoTao.SaveUser.xls数据集数据与图16-10 BaobaoTao.ExpectedSaveUser.xls数据集的数据,确实我们准备保存数据集的数据与验证结果的数据不一致。把 BaobaoTao.SaveUser.xls数据集中的用户积分更改为30,最后在IDE中重新执行UserDaoTest.saveUser()测试 方法,执行结果如图16-14所示。

   从测试结果可以看出,保存用户通过测试。从上述的测试实战,我们已经体验到用Excel准备测试数据与验证数据带来的便捷性。到此,我们完成了DAO测试 的整个过程,对于XlsDataSetBeanFactory具体实现,读者可以查看本章的实例源码,这里就不做详细分析。下面是实现基本骨架。

Java代码  收藏代码
  1. import  org.dbunit.dataset.Column;  
  2. import  org.dbunit.dataset.DataSetException;  
  3. import  org.dbunit.dataset.IDataSet;  
  4. import  org.dbunit.dataset.ITable;  
  5. import  org.dbunit.dataset.excel.XlsDataSet;  
  6. …     
  7. public   class  XlsDataSetBeanFactory {  
  8.       
  9.     //从Excel数据集文件创建多个Bean   
  10.     public   static  <T> List<T> createBeans(String file, String tableName,  
  11.             Class<T> clazz) throws  Exception {  
  12.         BeanUtilsBean beanUtils = createBeanUtils();  
  13.         List<Map<String, Object>> propsList = createProps(file, tableName);  
  14.         List<T> beans = new  ArrayList<T>();  
  15.         for  (Map<String, Object> props : propsList) {  
  16.             T bean = clazz.newInstance();  
  17.             beanUtils.populate(bean, props);  
  18.             beans.add(bean);  
  19.         }  
  20.         return  beans;  
  21.     }  
  22.   
  23.     //从Excel数据集文件创建多个Bean   
  24.     public   static  <T> T createBean(String file, String tableName, Class<T> clazz)  
  25.             throws  Exception {  
  26.         BeanUtilsBean beanUtils = createBeanUtils();  
  27.         List<Map<String, Object>> propsList = createProps(file, tableName);  
  28.         T bean = clazz.newInstance();  
  29.         beanUtils.populate(bean, propsList.get(0 ));  
  30.         return  bean;  
  31.     }  
  32. …  
  33. }  
分享到:
评论
1 楼 iceaugust 2012-08-24  
这个是 Spring 3.x企业应用开发实战 中的16章,单独看可能有些突兀,你要是能提供其它除网上能下到的1、16、17那几章之外的章节就好了。

相关推荐

    使用Unitils测试DAO

    综上所述,"使用Unitils测试DAO"的主题涵盖了如何利用Unitils库和DBUnit组件来创建可靠的DAO层测试,包括数据库的初始化、数据集的管理、断言的使用,以及自定义工具类的创建和源码分析。这种测试方法有助于提升代码...

    SpringBoot 多模块Dao层单元测试

    3. **编写Dao层测试** 在Dao层模块下创建对应的测试类,例如`UserDaoTest.java`。这里我们可以使用Mockito来创建Dao层所依赖的数据源的模拟对象,避免在测试中实际访问数据库。测试类示例: ```java import org....

    使用junit测试ssh中的dao

    标题“使用junit测试ssh中的dao”涉及到的是Java开发中的单元测试技术,特别是针对SSH(Struts2、Spring、Hibernate)框架中的数据访问对象(DAO)进行测试。SSH是Java Web开发中常用的三大开源框架,它们协同工作以...

    Integrete unitils for database(dao) testing

    5. **DAO支持**:Unitils还提供了对各种ORM框架(如Hibernate、JPA)的集成,简化了DAO层的测试。它可以自动管理实体的持久化状态,无需手动调用flush和clear方法。 6. **代码覆盖率**:虽然Unitils本身并不直接...

    单元测试之道Java版:使用JUnit

    《单元测试之道Java版:使用JUnit》是一本深入讲解如何在Java开发中运用JUnit进行单元测试的专业书籍。单元测试是软件开发过程中的重要环节,它能够确保代码的正确性,提高代码质量,以及便于后期的维护和重构。...

    对dbunit进行mybatis DAO层Excel单元测试(必看篇)

    一、Mybatis DAO层测试难点 在mybatis DAO层中,对数据库的单元测试存在一些难点: 1. 可重复性:每次运行单元测试,得到的数据是重复的独立的。 2. 独立性:测试数据与实际数据相互独立。 3. 数据库中脏数据...

    利用JUnit和Spring-test对SpringJDBC组件DAO层测试

    总之,通过JUnit和Spring-test的结合使用,我们可以对SpringJDBC组件的DAO层进行全面、严谨的测试,确保其功能的正确性和稳定性。同时,合理配置Druid数据源,有助于优化测试性能。测试不仅是为了找出问题,更是为了...

    JDBC相关单元测试及通用的Dao

    jdbc详细测试用例,包括connection ,statement,preparedstatement,resultset,BeanUtils,DBUtils,数据库连接池dbcp,cp03的单元测试,及dao层的统一封装,适合项目开发人员学习和项目中使用。

    使用JUnit进行单元测试PPT

    在Spring框架中进行单元测试,特别是测试DAO层,通常需要准备默认数据和测试数据,并可能需要模拟Spring的IoC容器。尽管Spring推荐使用隔离的测试,但在实际项目中,直接使用Spring框架进行测试可以简化流程。 通过...

    自动测试所有dao单元测试

    NULL 博文链接:https://zhuliang1984723.iteye.com/blog/2260856

    数据库操作的单元测试

    传统的单元测试通常不涉及外部资源,但当测试的对象直接与数据库交互时(例如DAO层),就需要确保数据库处于一个已知且可预测的状态。DBunit允许开发者在测试前将数据库的状态设定为一个特定的状态,并在测试结束后...

    DBUnit 进行单元测试

    4. **设置前处理**:在测试开始前,使用DBUnit的`IDatabaseConnection`和`IDataSet`接口加载数据集,并通过`DatabaseOperation.CLEAN_INSERT`操作清空现有数据并插入测试数据。 5. **执行测试**:编写JUnit测试用例...

    spring MVC junit 单元测试(controller)

    在Spring MVC框架中,单元测试是确保代码质量的重要步骤,特别是在控制器层(Controller)。这篇博客主要探讨了如何使用JUnit进行Spring MVC Controller的单元测试。在实际开发中,单元测试可以帮助我们尽早发现潜在...

    junit测试spring,hibernate的dao层代码

    将 `JUnit` 与 `Spring`、`Hibernate` 结合使用,可以对 `DAO(Data Access Object)` 层进行有效的测试,确保数据访问逻辑的正确性。 首先,`DAO` 层是业务逻辑和数据库操作之间的隔离层,通常包含了增删改查等...

    SSH单元测试代码整理

    4. **Mock对象**:使用Mockito等库模拟DAO层或Service层的对象,避免实际数据库交互,简化测试。 5. **断言**:使用JUnit提供的断言方法,如`assertEquals`,确保预期结果与实际结果一致。 6. **异常测试**:测试...

    Java练习项目: web,service,dao的无框架练习项目

    JUnit是Java常用的单元测试框架,可以对Service和DAO层的方法进行测试。而像Mockito这样的库可以帮助模拟协作对象,以便于在没有真实数据库的情况下测试Service层。 8. **部署**: 项目部署通常需要将打包后的WAR...

    hibernate 单元测试批处理代码

    6. **使用Mockito进行依赖注入**:在单元测试中,我们可能需要模拟其他组件,比如Service层的其他服务或者数据库连接。Mockito是一个优秀的Java模拟库,它可以用来创建和配置模拟对象,从而隔离被测试的代码。 7. *...

    Spring对于业务层的单元测试支持

    其中,Spring对于业务层的单元测试和集成测试提供了丰富的工具和功能,使得开发者能够更加高效地对代码进行验证和调试。本文将深入探讨Spring如何帮助我们进行业务层的测试。 首先,单元测试主要关注的是单个类或...

    Spring的作用贯穿了整个中间层,将Web层、Service层、DAO层及PO无缝整合

    - **DAO层**:使用Hibernate进行数据库操作。 - **Service层**:处理具体的业务逻辑。 - **Action**:接收请求并调用Service层进行处理。 5. **整合测试**:完成各层的编码后,需要进行综合测试以确保所有部分都...

    unitils-3.3-with-dependencies.zip

    10. **持久层测试**:支持对实体和会话工厂的验证,确保数据操作的正确性。 这个压缩包中的"unitils-3.3"可能包含了以下文件结构: - `unitils-3.3.jar`:主库文件,包含Unitils的核心功能。 - `unitils-dbunit....

Global site tag (gtag.js) - Google Analytics