BlogJava-心有多大，舞台就有多大-随笔分类-grailshttp://www.blogjava.net/yangpingyu/category/48541.htmlzh-cnSat, 14 May 2011 09:55:04 GMTSat, 14 May 2011 09:55:04 GMT60grails学习（二）grails单元测试http://www.blogjava.net/yangpingyu/archive/2011/05/13/350200.htmlyangpingyuyangpingyuFri, 13 May 2011 13:40:00 GMThttp://www.blogjava.net/yangpingyu/archive/2011/05/13/350200.htmlhttp://www.blogjava.net/yangpingyu/comments/350200.htmlhttp://www.blogjava.net/yangpingyu/archive/2011/05/13/350200.html#Feedback0http://www.blogjava.net/yangpingyu/comments/commentRss/350200.htmlhttp://www.blogjava.net/yangpingyu/services/trackbacks/350200.html
软件的bug是无法避免，但是我们可以尽量减少bug，不断提升代码质量。刚我也说过，上述问题造成的原因是没有做测试。测试包括很多了，单元测试、集成测试和功能测试等等。既然测试如此重要，每完成一个类都能进行测试。

以前也许你比较纠结，没有好的工具，现在java社区非常活跃，我们可以选择的太多太多了：junit4，jmock，mockito，easymock，TestNg等等。如果你用过grails，那么你更清楚，此类快速开发框架已经帮我们集成好了。使用起来非常简单。所以今天我主要讲述下grails的单元测试。

假设需求：我们给每个用户分配工作，每个人都要完成两件事情，第一件事情：根据自己的用户名返回欢迎信息；第二件事情：根据自己的地址返回国家地区。

详细设计

用户信息类：
package com.test.domian

class User {

    int id
    String name
    String address
    
    static constraints = {
    }
}

工作服务接口：
package com.test.services

class WorkService {

    /**
     * 根据用户名返回欢迎字符
     * @param userName
     * @return
     */
    def processWorkOne(String userName) {
    }
    
    /**
     * 根据地址返回地区
     * @param address
     * @return
     */
    def processWorkTwo(String address){
    }
    
}

用户工作服务：
package com.test.services

import com.test.domian.User

class UserService {

    def workService
    
    def doWork() {
        
        def userList = User.list()
        userList.each {
            it.name = workService.processWorkOne(it.name)
            it.address = workService.processWorkTwo(it.address)
            
        }
    }
}

我们重点来看下测试类：
package com.test.services

import grails.test.*

import com.test.domian.User

class UserServiceTests extends GrailsUnitTestCase {
    protected void setUp() {
        super.setUp()
    }

    protected void tearDown() {
        super.tearDown()
    }

    void testDoWork() {
        
        //构造数据，类似于数据库存在三条记录
        def user1 = new User(id:1, name:"lucy", address:"hangzhou")
        def user2 = new User(id:2, name:"lily", address:"wenzhou")
        def user3 = new User(id:3, name:"lilei", address:"beijing")
        mockDomain User, [user1, user2, user3]
        
        //mock WorkService接口的processWorkOne方法和processWorkTwo方法
        def workControl = mockFor(WorkService)
        def userCount = User.count()
        while(userCount-- > 0){
            workControl.demand.processWorkOne(1..1){String userName ->
                return "hello world, " << userName
            }
            workControl.demand.processWorkTwo(1..1){String address ->
                return "location in " << address
            }
        }
        def workService = workControl.createMock()
        
        //把构造好的workservice传给userservice
        UserService userService = new UserService()
        userService.workService = workService
        
        userService.doWork()
        
        def user4 = User.findById(1)
        assertEquals "hello world, lucy", user4.name
        assertEquals "location in hangzhou", user4.address
    }
}

以下着重来具体说明：
1、mockDomain方法就是构造数据，包括domain类的动态方法都可以使用，比如：save（），list（），findby*（）等。代码中的User.count(); User.list();就是因为调用了mockDomain方法才可以正常使用。如果是集成测试的话，grails会帮我们构造好，可以直接使用。但这里是单元测试，所以需要自己mock。

2、mockFor方法就是给WorkService构造一个对象，然后给workControl对象的demand代理创建两个UserService中用的processWorkOne和processWorkTwo方法，代码中用到了1..1，表示mock对象只能调用这个方法一次，为什么要循环三次设置processWorkOne和processWorkTwo方法呢？因为我们在UserService是对三个对象分别进行调用处理这两件事情。也许你会想，干嘛不直接把1..3（最少调用一次，最多调用三次）。是的，我最开始也是这么来处理，可是单元测试就是同不过。
如果把UserService类中的
workControl.demand.processWorkOne(1..1){String userName ->
       return "hello world, " << userName
 }
改成
workControl.demand.processWorkOne(1..3){String userName ->
       return "hello world, " << userName
 }
然后把UserServiceTests类中的：
userList.each {
            it.name = workService.processWorkOne(it.name)
            it.address = workService.processWorkTwo(it.address)
}
改成
userList.each {
            it.name = workService.processWorkOne(it.name)
            it.name = workService.processWorkOne(it.name)
            it.name = workService.processWorkOne(it.name)
            it.address = workService.processWorkTwo(it.address)
}
单元测试可以通过，但是改成这样
userList.each {
            it.name = workService.processWorkOne(it.name)
            it.name = workService.processWorkOne(it.name)
            it.address = workService.processWorkTwo(it.address)
            it.name = workService.processWorkOne(it.name)
}
单元测试通不过。
以上就是表明1..3的含义：这个方法要连续被调用至少一次，至多三次。
但是有的人说我在UserService中就要这么写
userList.each {
            it.name = workService.processWorkOne(it.name)
            it.name = workService.processWorkOne(it.name)
            it.address = workService.processWorkTwo(it.address)
            it.name = workService.processWorkOne(it.name)
}
那我要怎么改单元测试才能通过？
我们把UserServiceTests的demand这段代码
workControl.demand.processWorkOne(1..1){String userName ->
      return "hello world, " << userName
}
workControl.demand.processWorkTwo(1..1){String address ->
       return "location in " << address
}
改成
workControl.demand.processWorkOne(1..2){String userName ->
       return "hello world, " << userName
}
workControl.demand.processWorkTwo(1..1){String address ->
        return "location in " << address
 }
workControl.demand.processWorkOne(1..1){String address ->
        return "location in " << address
 }
这样就通过了。
以上就是说明构造出来的函数只能按照构造的顺序调用。今天就是因为这个花了我好长时间啊，希望我理解是正确的。如有不对，请留言纠正。

yangpingyu 2011-05-13 21:40 发表评论
]]>grails学习（一）Grails工程与maven集成http://www.blogjava.net/yangpingyu/archive/2011/05/10/349898.htmlyangpingyuyangpingyuTue, 10 May 2011 02:34:00 GMThttp://www.blogjava.net/yangpingyu/archive/2011/05/10/349898.htmlhttp://www.blogjava.net/yangpingyu/comments/349898.htmlhttp://www.blogjava.net/yangpingyu/archive/2011/05/10/349898.html#Feedback0http://www.blogjava.net/yangpingyu/comments/commentRss/349898.htmlhttp://www.blogjava.net/yangpingyu/services/trackbacks/349898.html 

Grails工程与maven集成

Grails其实也有自己的一些项目管理命令，如：grails package，grails test-app，grails war等。但是公司现在基本上都是用maven来管理项目，所以从管理上进行统一的目的，我们也让grails工程由maven来管理。

Grails与maven集成是靠maven插件机制。

接下来描述下集成的步骤：

1、在$home/.m2/settings.xml中配置plugin group

<settings>

 …

 <pluginGroups>

    <pluginGroup>org.grails</pluginGroup>

 </pluginGroups>

</settings>

没有配置之前，要运行grails：help命令要这样写：mvn org.grails:help，有了配置之后我们就可以这么写：mvn grails:help。

2、我们创建一个maven管理的grails工程

Mvn org.apache.maven.plugins:maven-archetype-plugin:2.0-alpha-4:generate
    -DarchetypeGroupId=org.grails 
    -DarchetypeArtifactId=grails-maven-archetype 
    -DarchetypeVersion=1.2.0 
-DgroupId=example -DartifactId=my-app
grails-maven-archetype这里用的是1.2.0版本，好像maven3集成的版本比这个要新。
 
3、进入my-app当前目录，运行mvn initialize
在运行过程中可能会出现如下问题：
Resolving plugin JAR dependencies …
:: problems summary ::
:::: WARNINGS
               module not found: org.hibernate#hibernate-core;3.3.1.GA
那么你在application.properties文件中添加plugins.hibernate=1.3.2
plugins.tomcat=1.3.2两个插件。最后运行mvn compile重新编译工程。
 
4、我们是用springsource tool suite开发，导入工程。项目中需要对excel操作，我们采用jxl.jar开源包。在pom文件中配置如下内容：

<dependency>

      <groupId>jxl</groupId>

      <artifactId>jxl</artifactId>

      <version>2.4.2</version>

</dependency>
重新编译下工程，但是引用jxl包中类的文件还是报错，说找不到类。这怎么回事呢？我也很纳闷，一般maven工程都是这样就可以。
 
后来在官方文档上看到一句话：pom=true。只要把这句话加到conf/BuildConfig.groovy文件中的grails.project.dependency.resolution方法中。如图：
 
重新编译，但是还是报错。Ide还是无法引用jxl包中的类。后来发现在grails tools中找到了一个命令。
 
执行过后，已经加入到了grails dependencies中。
 
为什么会这样呢，是因为有两套机制造成的。
第一套机制：maven自身管理项目的机制。
第二套机制：grails也有自己的一套管理机制。
 
l 在绝大多数情况下maven通过grails的集成插件可以对工程进行打包，部署，运行测试等管理。
l Grails可以通过自己的grails war等命令进行打包，部署，运行测试等管理。
l Grails也可以通过配置pom=true让grails那套管理机制用pom中的配置，不使用自己的管理机制。此时你就不用在conf/BuildConfig.groovy中管理依赖和资源库等配置。
 

yangpingyu 2011-05-10 10:34 发表评论
]]>