单元测试系列之3：测试整合之王Unitils

时间  2021-08-15
标签 java spring sql 数据库 数组 session 架构 app 框架 dom 栏目 Java 繁體版
原文   原文链接

引述：程序测试对保障应用程序正确 性而言，其重要性怎么样强调都不为过。JUnit是必须事先掌握的测试框架，大多数测试框架和测试工具都在此基础上扩展而来，Spring对测试所提供的 帮助类也是在JUnit的基础上进行演化的。直接使用JUnit测试基于Spring的应用存在诸多不便，不可避免地须要将大量的精力用于应付测试夹具准 备、测试现场恢复、访问测试数据操做结果等边缘性的工做中。Mockito、Unitils、Dbunit等框架的出现，这些问题有了很好的解决方案，特 别是Unitils结合Dbunit对测试DAO层提供了强大的支持，大大提升了编写测试用例的效率和质量。

   Unitils海纳百川（Junit,dbunit,mockito spring hibernate and so on..），以打造一个在实际应用开发中真正实战的测试框架，是致力于应用实战的开发者不得不学习的开源框架。

Unitils概述

   Unitils测试框架目的是让单元测试变得更加容易和可维护。Unitils构建在DbUnit与EasyMock项目之上并与JUnit和 TestNG相结合。支持数据库测试，支持利用Mock对象进行测试并提供与Spring和Hibernate相集成。Unitils设计成以一种高度可 配置和松散耦合的方式来添加这些服务到单元测试中，目前其最新版本是3.1。

Unitils功能特色
java

  •  自动维护和强制关闭单元测试数据库（支持Oracle、Hsqldb、MySQL、DB2）。
  •  简化单元测试数据库链接的设置。
  •  简化利用DbUnit测试数据的插入。
  •  简化Hibernate session管理。
  •  自动测试与数据库相映射的Hibernate映射对象。
  •  易于把Spring管理的Bean注入到单元测试中，支持在单元测试中使用Spring容器中的Hibernate SessionFactory。
  •  简化EasyMock Mock对象建立。
  •  简化Mock对象注入，利用反射等式匹配EasyMock参数。



Unitils模块组件

   Unitils经过模块化的方式来组织各个功能模块，采用相似于Spring的模块划分方式，如unitils-core、unitils-database、unitils-mock等。比之前整合在一个工程里面显得更加清晰，目前全部模块以下所示：spring

  •   unitils-core：核心内核包。
  •   unitils-database：维护测试数据库及链接池。
  •   unitils-DbUnit：使用DbUnit来管理测试数据。
  •   unitils-easymock：支持建立Mock和宽松的反射参数匹配。
  •   unitils-inject：支持在一个对象中注入另外一个对象。
  •   unitils-mock：整合各类Mock，在Mock的使用语法上进行了简化。
  •   unitils-orm：支持Hibernate、JPA的配置和自动数据库映射检查。
  •   unitils-spring：支持加载Spring的上下文配置，并检索和Spring Bean注入。


   Unitils的核心架构中包含Moudule和TestListener两个概念，相似Spring中黏连其余开源软件中的FactoryBean概念。能够当作第三方测试工具的一个黏合剂。总体框架如图16-4所示：



   经过TestListener能够在测试运行的不一样阶段注入某些功能。同时某一个TestListener又被一个对应的Module所持有。 Unitils也能够当作一个插件体系结构，TestListener在整个Unitils中又充当了插件中扩展点的角色，从TestListener这 个接口中咱们能够看到，它能够在crateTestObject、before(after)Class、 before(after)TestMethod、beforeSetup、afterTeardown的不一样切入点添加不一样的动做。

Unitils配置文件 sql

  •   unitils-defaults.properties：默认配置文件，开启全部功能。
  •   unitils.properties：项目级配置文件，用于项目通用属性配置。
  •   unitils-local.properties：用户级配置文件，用于我的特殊属性配置。


    Unitils的配置定义了通常配置文件的名字unitils.properties和用户自定义配置文件unitils- local.properties，并给出了默认的模块及模块对应的className，便于Unitils加载对应的模块module。可是若是用户分 别在unitils.properties文件及unitils -local.properties文件中对相同属性配置不一样值时，将会以unitils-local.properties 的配置内容为主。

Unitils断言

   典型的单元测试通常都包含一个重要的组成部分：对比实际产生的结果和但愿的结果是否一致的方法，即断言方法（assertEquals）。Unitils 为咱们提供了一个很是实用的断言方法，咱们以第2章中编写的用户领域对象User为蓝本，比较两个User对象的实例来开始认识Unitils的断言之 旅。

assertReflectionEquals：反射断言

    在Java世界中，要比较现有两个对象实例是否相等，若是类没有重写equals()方法，用两个对象的引用是否一致做为判断依据。有时候，咱们并不须要 关注两个对象是否引用同一个对象，只要两个对象的属性值同样就能够了。在JUnit单元测试中，有两种测试方式进行这样的场景测试：一是在比较实体类中重 写equals()方法，而后进行对象比较；二是把对象实例的属性一个一个进行比较。无论采用哪一种方法，都比较烦锁，Unitils为咱们提供了一种很是 简单的方法，即便用ReflectionAssert.assertReflectionEquals方法， 如代码清单16-11所示： 数据库

Java代码   收藏代码
  1. package com.baobaotao.test;  
  2. import java.util.*;  
  3. import org.junit.Test;  
  4. import static org.unitils.reflectionassert.ReflectionAssert.*;  
  5. import static org.unitils.reflectionassert.ReflectionComparatorMode.*;  
  6. import com.baobaotao.domain.User;  
  7.   
  8. public class AssertReflectionEqualsTest {  
  9.     @Test  
  10.     public void testReflection(){  
  11.         User user1 = new User("tom","1234");  
  12.         User user2 = new User("tom","1234");  
  13.         ReflectionAssert.assertReflectionEquals(user1, user2);  
  14.     }  
  15.   
  16. }  



    ReflectionAssert. AssertReflectionEquals（指望值，实际值，比较级别）方法为咱们提供了各类级别的比较断言。下面咱们依次介绍这些级别的比较断言。
    ReflectionComparatorMode.LENIENT_ORDER：忽略要断言集合collection 或者array 中元素的顺序。
    ReflectionComparatorMode.IGNORE_DEFAULTS：忽略Java类型默认值，如引用类型为null，整型类型为0，或者布尔类型为false时，那么断言忽略这些值的比较。
    ReflectionComparatorMode.LENIENT_DATES：比较两个实例的Date是否是都被设置了值或者都为null，而忽略Date的值是否相等。

assertLenientEquals：断言

   ReflectionAssert 类为咱们提供了两种比较断言：既忽略顺序又忽略默认值的断言assertLenientEquals，使用这种断言就能够进行简单比较。下面经过实例学习其具体的用法，如代码清单16-12所示。数组

Java代码   收藏代码
  1. package com.baobaotao.test;  
  2. import java.util.*;  
  3. …  
  4. public class AssertReflectionEqualsTest {  
  5.       Integer orderList1[] = new Integer[]{1,2,3};  
  6.       Integer orderList2[] = new Integer[]{3,2,1};  
  7.   
  8.           
  9.         //① 测试两个数组的值是否相等，忽略顺序  
  10.         //assertReflectionEquals(orderList1, orderList2,LENIENT_ORDER);  
  11. assertLenientEquals(orderList1, orderList2);  
  12.   
  13.           
  14.         //② 测试两个对象的值是否相等，忽略时间值是否相等  
  15.         User user1 = new User("tom","1234");  
  16.         Calendar cal1 = Calendar.getInstance();  
  17.         user1.setLastVisit(cal1.getTime());  
  18.         User user2 = new User("tom","1234");  
  19.         Calendar cal2 = Calendar.getInstance();  
  20.         cal2.set(Calendar.DATE, 15);  
  21.         user2.setLastVisit(cal2.getTime());  
  22. //assertReflectionEquals(user1, user2,LENIENT_DATES);  
  23.         assertLenientEquals(user1, user2);  
  24. }  



assertPropertyXxxEquals：属性断言

   assertLenientEquals 和assertReflectionEquals 这两个方法是把对象做为总体进行比较，ReflectionAssert 类还给咱们提供了只比较对象特定属性的方法：assertPropertyReflection   Equals()和assertPropertyLenientEquals()。下面经过实例学习其具体的用法，如代码清单16-13所示。 session

Java代码   收藏代码
  1. package com.baobaotao.test;  
  2. import java.util.*;  
  3. …  
  4. public class AssertReflectionEqualsTest {  
  5.       User user = new User("tom","1234");  
  6.       assertPropertyReflectionEquals("userName", "tom", user);  
  7.       assertPropertyLenientEquals("lastVisit", null, user);  
  8. }  


   assertPropertyReflectionEquals()断言是默认严格比较模式可是能够手动设置比较级别的断言，assertPropertyLenientEquals()断言是具备忽略顺序和忽略默认值的断言。


集成Spring

   Unitils 提供了一些在Spring 框架下进行单元测试的特性。Spring 的一个基本特性就是，类要设计成为没有Spring 容器或者在其余容器下仍然易于进行单元测试。可是不少时候在Spring 容器下进行测试仍是很是有用的。
   Unitils 提供了如下支持 Spring 的特性：架构

  •   ApplicationContext 配置的管理；
  •  在单元测试代码中注入Spring 的Beans；
  •  使用定义在Spring 配置文件里的Hibernate SessionFactory；
  •  引用在Spring 配置中Unitils 数据源。



ApplicationContext 配置
   能够简单地在一个类、方法或者属性上加上@SpringApplicationContext 注解，并用Spring的配置文件做为参数，来加载Spring应用程序上下文。下面咱们经过实例来介绍一下如何建立ApplicationContext。 app

Java代码   收藏代码
  1. import org.junit.Test;  
  2. import org.springframework.context.ApplicationContext;  
  3. import org.unitils.UnitilsJUnit4;  
  4. import org.unitils.spring.annotation.SpringApplicationContext;  
  5. import org.unitils.spring.annotation.SpringBean;  
  6. import com.baobaotao.service.UserService;  
  7. import static org.junit.Assert.*;  
  8. //①用户服务测试  
  9. public class UserServiceTest extends UnitilsJUnit4 {  
  10.   
  11. //①-1 加载Spring配置文件  
  12.     @SpringApplicationContext({"baobaotao-service.xml", "baobaotao-dao.xml"})  
  13.     private ApplicationContext applicationContext;  
  14.   
  15. //①-1 加载Spring容器中的Bean  
  16.     @SpringBean("userService")  
  17.     private UserService userService;  
  18.       
  19. //①-3 测试Spring容器中的用户服务Bean  
  20. @Test  
  21.     public void testUserService (){  
  22.         assertNotNull(applicationContext);  
  23.         assertNotNull(userService.findUserByUserName("tom"));  
  24.     }  
  25. }  
  26. …  



   在①-1处，经过@SpringApplicationContext 注解加载baobaotao-service.xml和baobaotao- dao.xml两个配置文件，生成一个Spring应用上下文，咱们就能够在注解的范围内引用applicationContext这个上下文。在①-2 处，经过@SpringBean注解注入当前Spring容器中相应的Bean，如实例中加载ID为“userService”的Bean到当前测试范 围。在①-3处，经过JUnit断言验证是否成功加载applicationContext和userService。Unitils加载Spring上 下文的过程是：首先扫描父类的@SpringApplicationContext注解，若是找到了就在加载子类的配置文件以前加载父类的配置文件，这样 就可让子类重写配置文件和加载特定配置文件。
   细心的读者可能会发现，采用这种方式加载Spring应用上下文，每次执行测试时，都会重复加载Spring应用上下文。Unitils为咱们提供在类上加载Spring应用上下文的能力，以免重复加载的问题。 框架

Java代码   收藏代码
  1. …  
  2. @SpringApplicationContext({"baobaotao-service.xml", "baobaotao-dao.xml"})  
  3. public class BaseServiceTest extends UnitilsJUnit4 {  
  4.       
  5.  //加载Spring上下文  
  6.     @SpringApplicationContext  
  7.     public ApplicationContext applicationContext;  
  8.   
  9. }  


  
   在父类BaseServiceTest里指定了Spring配置文件，Spring应用上下文只会建立一次，而后在子类 SimpleUserServiceTest 里会重用这个应用程序上下文。加载Spring应用上下文是一个很是繁重的操做，若是重用这个Spring应用上下文就会大大提高测试的性能。dom

Java代码   收藏代码
  1. …  
  2. public class SimpleUserServiceTest extends BaseServiceTest {  
  3.       
  4. //① Spring容器中加载Id为"userService"的Bean  
  5.     @SpringBean("userService")  
  6.     private UserService userService1;  
  7.   
  8. //② 从Spring容器中加载与UserService相同类型的Bean  
  9.     @SpringBeanByType  
  10.     private UserService userService2;  
  11.   
  12.     //③ 从Spring容器中加载与userService相同名称的Bean  
  13.     @SpringBeanByName  
  14.     private  UserService userService;  
  15.       
  16.      //④ 使用父类的Spring上下文  
  17.     @Test  
  18.     public void testApplicationContext(){  
  19.         assertNotNull(applicationContext);  
  20.     }  
  21.       
  22.     @Test  
  23.     public void testUserService(){  
  24.         assertNotNull(userService.findUserByUserName("tom"));  
  25.         assertNotNull(userService1.findUserByUserName("tom"));  
  26.         assertNotNull(userService2.findUserByUserName("tom"));  
  27.     }  
  28. }  
  29. …  



   在①处，使用@SpringBean 注解从Spring容器中加载一个ID为userService的Bean。在②处，使用@ SpringBeanByType注解从Spring容器中加载一个与UserService相同类型的Bean，若是找不到相同类型的Bean，就会抛 出异常。在③处，使用@SpringBeanByName 注解从Spring容器中加载一个与当前属性名称相同的Bean。

集成Hibernate

   Hibernate是一个优秀的O / R开源框架，它极大地简化了应用程序的数据访问层开发。虽然咱们在使用一个优秀的O/R框架，但并不意味咱们无须对数据访问层进行单元测试。单元测试仍然 很是重要。它不只能够确保Hibernate映射类的映射正确性，也能够很便捷地测试HQL查询等语句。Unitils为方便测试 Hibernate，提供了许多实用的工具类，如HibernateUnitils就是其中一个，使用 assertMappingWithDatabaseConsistent()方法，就能够方便测试映射文件的正确性。

SessionFactory 配置

   能够简单地在一个类、方法或者属性上加上@ HibernateSessionFactory 注解，并用Hibernate的配置文件做为参数，来加载Hibernate上下文。下面咱们经过实例来介绍一下如何建立SessionFactory。

Java代码   收藏代码
  1. …  
  2. @HibernateSessionFactory("hibernate.cfg.xml")  
  3. public class BaseDaoTest extends UnitilsJUnit4 {  
  4.     @HibernateSessionFactory  
  5.     public SessionFactory sessionFactory;  
  6.       
  7.   
  8.     @Test  
  9.     public void testSessionFactory(){  
  10.         assertNotNull(sessionFactory);  
  11.     }  
  12. }  



    在父类BaseDaoTest里指定了Hibernate配置文件，Hibernate应用上下文只会建立一次，而后在子类 SimpleUserDaoTest里会重用这个应用程序上下文。加载Hibernate应用上下文是一个很是繁重的操做，若是重用这个 Hibernate应用上下文就会大大提高测试的性能。

Java代码   收藏代码
  1. …  
  2. public class SimpleUserDaoTest extends BaseDaoTest {  
  3.     private UserDao userDao;  
  4.   
  5. //① 初始化UserDao  
  6. @Before  
  7.     public void init(){  
  8.          userDao = new WithoutSpringUserDaoImpl();  
  9.         userDao.setSessionFactory(sessionFactory); //使用父类的SessionFactory  
  10.     }  
  11.   
  12. //② Hibernate映射测试  
  13. @Test  
  14.     public void testMappingToDatabase() {  
  15.         HibernateUnitils.assertMappingWithDatabaseConsistent();  
  16. }  
  17.   
  18. //③ 测试UserDao  
  19.     @Test  
  20.     public void testUserDao(){  
  21.         assertNotNull(userDao);  
  22.         assertNotNull(userDao.findUserByUserName("tom"));  
  23.         assertEquals("tom", userDao.findUserByUserName("tom").getUserName());  
  24.     }  
  25. }  
  26. …  



   为了更好演示如何应用Unitils测试基于Hibernate数据访问层，在这个实例中不使用Spring框架。因此在执行测试时，须要先建立相应的数 据访问层实例，如实例中的userDao。其建立过程如①处所示，先手工实例化一个UserDao，而后获取父类中建立的SessionFactory， 并设置到UserDao中。在②处，使用Unitils提供的工具类HibernateUnitils中的方法测试咱们的Hibernate映射文件。在 ③处，经过JUnit的断言验证 UserDao相关方法，看是否与咱们预期的结果一致。

集成Dbunit
   
   Dbunit是一个基于JUnit扩展的数据库测试框架。它提供了大量的类，对数据库相关的操做进行了抽象和封装。Dbunit经过使用用户自定义的数据 集以及相关操做使数据库处于一种可知的状态，从而使得测试自动化、可重复和相对独立。虽然不用Dbunit也能够达到这种目的，可是咱们必须为此付出代价 （编写大量代码、测试及维护）。既然有了这么优秀的开源框架，咱们又何须再造轮子。目前其最新的版本是2.4.8。
    随着Unitils的出现，将Spring、Hibernate、DbUnit等整合在一块儿，使得DAO层的单元测试变得很是容易。Unitils采用模 块化方式来整合第三方框架，经过实现扩展模块接口org.unitils.core.Module来实现扩展功能。在Unitils中已经实现一个 DbUnitModule，很好整合了DbUnit。经过这个扩展模块，就能够在Unitils中使用Dbunit强大的数据集功能，如用于准备数据的 @DataSet注解、用于验证数据的@ExpectedDataSet注解。Unitils集成DbUnit流程图如图16-5所示。



16.4.5  自定义扩展模块

   Unitils经过模块化的方式来组织各个功能模块，对外提供一个统一的扩展模块接口org.unitils.core.Module来实现与第三方框架 的集成及自定义扩展。在Unitils中已经实现目前一些主流框架的模块扩展，如Spring、Hibernate、DbUnit、Testng等。若是 这些内置的扩展模块没法知足需求，咱们能够实现本身的一些扩展模块。扩展Unitils模块很简单，如代码清单16-19所示。

Java代码   收藏代码
  1. package sample.unitils.module;  
  2. import java.lang.reflect.Method;  
  3. import org.unitils.core.TestListener;  
  4. import org.unitils.core. Module;  
  5. //① 实现Module接口  
  6. public class CustomExtModule implements Module {  
  7.      //② 实现获取测试监听的方法  
  8.     public TestListener getTestListener() {  
  9.         return new CustomExtListener();  
  10.     }  
  11.       
  12.     //② 新建监听模块   
  13.     protected class CustomExtListener extends TestListener {  
  14.          //③ 重写 TestListener里的相关方法，完成相关扩展的功能  
  15.         @Override  
  16.         public void afterTestMethod(Object testObject, Method testMethod,  
  17.                 Throwable testThrowable) {  
  18. …  
  19.         }  
  20.   
  21.         @Override  
  22.         public void beforeTestMethod(Object testObject, Method testMethod) {  
  23. …  
  24.         }  
  25.     }  
  26. …  
  27. }  


在①处新建自定义扩展模块CustomExtModule，实现Module接口。在②处新建自定义监听模块，继承TestListener。在 ③处重写（@Override）TestListener里的相关方法，完成相关扩展的功能。实现自定义扩展模块以后，剩下的工做就是在Unitils配 置文件unitils.properties中注册这个自定义扩展的模块：

引用
unitils.modules=…,custom
unitils.module. custom.className= sample.unitils.module.CustomExtModule

http://stamen.iteye.com/blog/1480316

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程