Spring高级程序设计 21 使用Spring进行测试

1进行单元测试 
测试数据库时非常脆弱：数据的改变可能会影响测试的结果。 
为目标的依赖创建桩（stub）或mock类是更好的解决方案。 
可以使用jMock开源库来快速、简单的定义mock对象。 

stub：通常指的是目标接口的简单实现，他通常只响应对应的测试中的调用，起作用是为被测试的类创建必要的输入。 
mock：是实际的实现对象，被测试的类会使用到他。 


2单元测试 
demo：利用Jmock 

被mock的dao：

 package cn.partner4java.mock.dao;

 import cn.partner4java.mock.bean.Hello;

 public interface HelloDao {
     Hello getById(Long helloId);
 }

 package cn.partner4java.mock.dao;

 import cn.partner4java.mock.bean.Hello;

 public class HelloDaoImpl implements HelloDao {

     public Hello getById(Long helloId) {
         //这里面借助什么hibernate之类的，获取实体通过id
         return null;
     }
 }

Service：

 package cn.partner4java.mock.service;

 import cn.partner4java.mock.bean.Hello;

 public interface HelloService {
     Hello findById(Long helloId);
 }

 package cn.partner4java.mock.service;

 import cn.partner4java.mock.bean.Hello;
 import cn.partner4java.mock.dao.HelloDao;

 public class HelloServiceImpl implements HelloService {
     private HelloDao helloDao;
     public void setHelloDao(HelloDao helloDao) {
         this.helloDao = helloDao;
     }

     public Hello findById(Long helloId) {
         //还额外添加了一些业务逻辑的操作，那么，我们测试的就是这部分业务逻辑操作
         Hello hello = helloDao.getById(helloId);
         hello.setName(hello.getName() + " !");
         return hello;
     }

 }

编写testcase：

 package cn.partner4java.mock.test;

 import org.jmock.Mock;
 import org.jmock.MockObjectTestCase;

 import cn.partner4java.mock.bean.Hello;
 import cn.partner4java.mock.dao.HelloDao;
 import cn.partner4java.mock.service.HelloServiceImpl;

 public class HelloServiceImplTest extends MockObjectTestCase{
     private Mock mock;
     private HelloServiceImpl helloService;

     protected void setUp() throws Exception {
         this.mock = new Mock(HelloDao.class);
         helloService = new HelloServiceImpl();
         helloService.setHelloDao((HelloDao)this.mock.proxy());
     }

     public void testFindById() {
         Long id = 1L;
         Hello hello = new Hello();
         hello.setId(id);
         hello.setName("HelloWorld");
         this.mock.expects(once()).method("getById").with(eq(id)).will(returnValue(hello));

         Hello helloS = this.helloService.findById(id);
         System.out.println(helloS);
     }

 }

对web层进行单元测试 
Spring在包org.springframework.mock.web中为Web应用所使用的接口提供了方便的桩实现。这个包具备了Servlet API桩对象的集合。 






3集成测试 
Spring提供的测试类，可简化Spring的测试工作。 

1、AbstractSpringContextTests 
提供简化的统一构建context的方式。

 public class DefaultUserServiceIntegrationTests2 extends AbstractSpringContextTests {

     protected ConfigurableApplicationContext loadContext(Object o) {
         String[] paths = new String[]{
                 "classpath*:/com/apress/prospring2/ch22/dataaccess/applicationContext-dataaccess.xml",
                 "classpath*:/com/apress/prospring2/ch22/services/applicationContext-services.xml"
         };
         return new ClassPathXmlApplicationContext(paths);
 //        return this.loadContext)
     }


     public void testRegister() throws Exception {
         ApplicationContext context = getContext("mytestcontext");
         UserService userService = (UserService) context.getBean("userService");

2、AbstractDependencyInjectionSpringContextTests 
简化bean查找。 
方式一：设置一个私有字段，会自动匹配类型 

 public class DefaultUserServiceIntegrationTests3 extends AbstractDependencyInjectionSpringContextTests {
     private UserService userService;

     protected String[] getConfigLocations() {
         String[] paths = new String[]{
                 "classpath*:/com/apress/prospring2/ch22/dataaccess/applicationContext-dataaccess.xml",
                 "classpath*:/com/apress/prospring2/ch22/services/applicationContext-services.xml"
         };
         return paths;
     }

     public void testRegister() throws Exception {
         userService.register(..);

方式二：如果类型有多个，那么可以匹配名称，需要设置为把private设置为protected，且名字为查找的名称，然后在构造方法中设置一个开关 setPopulateProtectedVariables(true) 

 public class DefaultUserServiceIntegrationTests3 extends AbstractDependencyInjectionSpringContextTests {
     protected UserService userService;

     public DefaultUserServiceIntegrationTests3() {
         setPopulateProtectedVariables(true);
     }

     protected String[] getConfigLocations() {
         String[] paths = new String[]{
                 "classpath*:/com/apress/prospring2/ch22/dataaccess/applicationContext-dataaccess.xml",
                 "classpath*:/com/apress/prospring2/ch22/services/applicationContext-services.xml"
         };
         return paths;
     }

     public void testRegister() throws Exception {
         userService.register(...);

3、AbstractTransactionalSpringContextTests 
不会让你影响到数据库，会自动在测试完成后回滚事务。或者通过setComplete()来额外指明提交事务。或者通过endTransaction()方法测试用例结束前结束事务。 
当你需要测试添加、查询或删除数据中的行时，可以使用AbstractTransactionalDataSourceSpringContextTests，他继承了AbstractTransactionalSpringContextTests，增加了可以测试数据行的功能，事务在测试方法的最后回滚，因此数据库最后还是会保持一致。 



4、AbstractAnnotationAwareTransactionalTests 
继承了AbstractTransactionalDataSourceSpringContextTests，除了公开SimpleJdbcTemplate之外，还引入了Java 5的注解。 
1.@Repeat 
被注解的方法被会重复测试多次。 
@Repeat(10) 
2.@Timed 
希望测试在制定的时间内完成，ms 
@Timed(millis = 5000) 
3.@Rollback 
@Rollback(true)会在测试方法执行完毕后对事务进行回滚，如果设置为false，那么事务会被提交，这样就无需使用setComplete()方法，增加了代码的可读性。 
4.@NotTransactional 
表示测试方法没有事务，方法不会运行在事务上下文中。 
5.@ExpectedException 
表示我们期望测试方法会抛出异常，期望的异常类以参数的形式传进来。 
@ExpectedException(IllegalArgumentException.class)就是测试中会抛出这个异常，不然就不对。 
6.@DirtiesContext 
标识测试方法会在执行过程中改变Spring Context，就是执行方法结束后，Spring context会从配置文件中重新构建。 
AbstractDependencyInjectionSpringContextTests的setDirty()方法也可以实现。 
7.@IfProfileValue和@ProfileValueSourceConfiguration 
检查提供的名字（来自配置好的ProfileValueSource）的返回值，如果值匹配就会执行测试，否则会忽略掉测试。 
默认ProfileValueSource是SystemProfileValueSource，否则使用@ProfileValueSourceConfiguration指定。 





JNDI：

 public class DefaultUserServiceIntegrationTests3 extends AbstractDependencyInjectionSpringContextTests {
     protected UserService userService;

     public static void buildJndi() {
         try {
             SimpleNamingContextBuilder builder;
             builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();

             String connectionString = "jdbc:oracle:thin:@oracle.devcake.co.uk:1521:INTL";
             builder.bind("java:comp/env/jdbc/prospring2/ch22", new DriverManagerDataSource(
                     "oracle.jdbc.driver.OracleDriver", connectionString, "PROSPRING", "x******6"));
         } catch (NamingException e) {
             // noop
         }
     }

     public DefaultUserServiceIntegrationTests3() {
         buildJndi();
         setPopulateProtectedVariables(true);
     }

     protected String[] getConfigLocations() {
         String[] paths = new String[]{
                 "classpath*:/com/apress/prospring2/ch22/dataaccess/applicationContext-dataaccess.xml",
                 "classpath*:/com/apress/prospring2/ch22/services/applicationContext-services.xml"
         };
         return paths;
     }

注意：带有事务的Spring测试（继承AbstractTransactionalSpringContextTests的类）依赖于java.sql.DataSource和PlatformTransactionManager，所以只能为应用和测试维护对Spring context的单独的数据库访问。 





4Spring TestContext Framework 
是一个不依赖于测试框架（JUnit等）的测试环境，也是注解驱动的。（2.5版本后引入） 
位于org.springframework.test.context包中。 

@ContextConfiguration(locations = {"/com/apress/prospring2/ch22/dataaccess/applicationContext-dataaccess.xml", "/com/apress/prospring2/ch22/services/applicationContext-services.xml"}) 
定义在类上的注解，定义context。 


@Autowired注解用于按类型加载bean。或者俺名称加载@Resource(name="...") 


@TransactionConfiguration(transactionManager = "myTransactionManager") 
定义在类上的注解，定义transaction。可以忽略，就会寻找默认的bean名称transactionManager。还可以设置defaultRollback。 

@BeforeTransaction与@AfterTransaction 
方法上的注解。事务前后所运行的方法。 



支持类： 
还可以使用JUnit测试环境，而TestContext测试代码还是一样的。 
JUnit 3.8提供了：AbstractTransactionalJUnit38SpringContextTests和AbstractJUnit38SpringContextTests。 
JUnit 4提供了：AbstractTransactionalJUnit4SpringContextTests和AbstractJUnit4SpringContextTests 

在上面的注解的基础上还可以使用一下注解： 
1.@Repeat 
被注解的方法被会重复测试多次。 
@Repeat(10) 
2.@Timed 
希望测试在制定的时间内完成，ms 
@Timed(millis = 5000) 
3.@Rollback 
@Rollback(true)会在测试方法执行完毕后对事务进行回滚，如果设置为false，那么事务会被提交，这样就无需使用setComplete()方法，增加了代码的可读性。 
4.@NotTransactional 
表示测试方法没有事务，方法不会运行在事务上下文中。 
5.@ExpectedException 
表示我们期望测试方法会抛出异常，期望的异常类以参数的形式传进来。 
@ExpectedException(IllegalArgumentException.class)就是测试中会抛出这个异常，不然就不对。 
6.@DirtiesContext 
标识测试方法会在执行过程中改变Spring Context，就是执行方法结束后，Spring context会从配置文件中重新构建。 
AbstractDependencyInjectionSpringContextTests的setDirty()方法也可以实现。 
7.@IfProfileValue和@ProfileValueSourceConfiguration 
检查提供的名字（来自配置好的ProfileValueSource）的返回值，如果值匹配就会执行测试，否则会忽略掉测试。 
默认ProfileValueSource是SystemProfileValueSource，否则使用@ProfileValueSourceConfiguration指定。 

demo：

 @ContextConfiguration(locations = {"/com/apress/prospring2/ch22/dataaccess/applicationContext-dataaccess.xml","/com/apress/prospring2/ch22/services/applicationContext-services.xml"})
 @TransactionConfiguration(transactionManager = "myTransactionManager")
 public class DefaultUserServiceIntegrationTests extends AbstractTransactionalJUnit38SpringContextTests {

     protected UserService userService;

     public DefaultUserServiceIntegrationTests() {

     }

     @AfterTransaction
     public void checkDatabaseState() {
         assertEquals("No users should be saved in this test", 0, this.userService.findAllUsers().size());
     }

     @Repeat(10)
     @Timed(millis = 5000)
     @ExpectedException(IllegalArgumentException.class)
     public void testRegister() throws Exception {
         System.out.println("done");
         User user = new User();
         user.setUsername("jonhs");
         user.setPassword("hTy86dj");

         userService.register(user);

         assertNotNull("User not saved!", user.getId());

         User user2 = new User();
         user2.setUsername("jonhs");
         user2.setPassword("fGC467");

         userService.register(user2);


     }

     @ExpectedException(IllegalArgumentException.class)
     public void testRegisterIncorrectPassword() throws Exception {

         User user3 = new User();
         user3.setUsername("jandD");
         user3.setPassword("fgh85");
         userService.register(user3);
     }

     @Autowired(required = false)
     public void setUserService(UserService userService) {
         this.userService = userService;
     }

     @Autowired(required = false)
     public void setDataSource(DataSource dataSource) {
         super.setDataSource(dataSource);
     }
 }