Grails 1.2参考文档速读（17）：测试

在TDD已经广为人知的背景下，Grails自然也不会对其视而不见，相反，它为测试提供了大量的支持，简化了测试编写的难度和工作量。测试有很多种类型，Grails直接支持的有两种：单元测试和集成测试，其他类型的测试都是通过插件来完成的。单元测试使用grails create-unit-test命令创建，文件保存在/test/unit下；集成测试由grails create-integeration-test创建，文件位于/test/integration。所有create-*命令都会自动创建集成测试，这两类测试的文件名后缀都是Tests。运行测试的命令是grails test-app，它的用法示例如下：运行全部测试：单元和集成测试。grails test-app
运行单个测试：grails test-app 测试名 //不要加Tests后缀
运行一组测试：grails test-app test1 test2 …//空格隔开
使用通配符：grails test-app some.org.*；grails test-app some.org.**
测试某个方法：grails test-app SimpleController.testLogin
测试完成之后会产生测试报告，位于test/reports。Grails将测试组织成“阶段”和“类型”：grails test-app phase:typephase：unit、integration、functional和other
type：junit针对unit和integration阶段
其他的测试插件可能带来其他的阶段和类型
执行junit集成测试的例子：grails test-app integration:integration。phase和type皆可省略，表示所有。grails test-app unit:。更细粒度的指定例子：grails test-app integration: unit: some.org.**。安装其他测试插件可能会引入其他的阶段和类型。现在，让我们来看看单元测试相关的内容。Grails不会为单元测试注入任何动态方法，它们在集成测试和运行时被注入。为完成单元测试，开发者需利用Mock。一般的思路是利用：Groovy Mock和ExpandoMetaClass。所幸，但是Grails为单元测试提供了大量的mock方法，简化了单元测试。这些mock是在grails.test.GrailsUnitTestCase中提供的。在GrailsUnitTestCase众多的mock方法中，首先要提及的就是mockFor，它是通用的Mock方法，使用如下：

def strictControl = mockFor(MyService)
strictControl.demand.someMethod(0..2) { String a, int b -> … }
strictControl.demand.static.aStaticMethod {-> … }

使用mockFor的通用模式是：mock.demand.(static.)?method(min…max){implement}。其中：static在mock静态方法时使用
min…max指定方法期望被调用的最小和最大次数，缺省是1..1，表示只调用一次
后面的闭包表示实现
mockFor的另一个参数是loose，表示mock出来的对象是否是严格的。缺省为false，即严格。所谓严格是指mock对象上的方法调用是有顺序的。

def looseControl = mockFor(MyService, true)

以上只是mock需要做的工作，它的结果就是我们需要的目标对象，通过在mock对象上调用createMock得到。在mock上调用verify来验证所期望的方法是否按预期方式调用。以上内容对于使用过easyMock的读者应该不会陌生的。mockFor例子：

def otherControl = mockFor(OtherService)
otherControl.demand.newIdentifier(1..1) {->
return testId
}
//要测试的服务
def testService = new MyService()
//注入mock实例
testService.otherService = otherControl.createMock()
//调用测试方法
def retval = testService.createSomething()

因为Domain Class实在太常用了，因此Grails也提供了对它的mock支持，这就是：mockDomain(class, testInstances = )，用于模拟Domain Class：testInstances相当于内存“数据库”
模拟了CRUD和findBy*操作，这些操作依据testInstances进行
在进行保存时会调用validate
没有实现Criteria和HQL
例子：

mockDomain(Item)
def testInstances = Item.list()

由于Grails已经对Domain Class提供了CRUD动态方法，单独对这些自动产生的方法进行测试的意义不再特别大。反观我们在创建Domain Class的时候，我们最常写的就是约束。因此，个人觉得，大多数对Domain Class的测试还是主要体现在对约束的测试上。当然，如果你还给Domain Class增加了其他的方法，对这些方法的测试也是必要的，除非它们实在太简单了。对于约束的测试，Grails提供了mockForConstraintsTests(class, testInstances = )，它们用于专门对Domain Class和Command Object进行约束测试。Grails对此只只模拟了validate方法：

mockForConstraintsTests(Book, [ existingBook ])
def book = new Book()
assertFalse book.validate()
//查找指定域，比较约束名
assertEquals "nullable", book.errors["title"]
assertEquals "nullable", book.errors["author"]

另一些常用的mock方法：mockLogging(class, enableDebug = false)，模拟log属性
mockController(class)，模拟Controller，与ControllerUnitTestCase结合使用
mockTagLib(class)，模拟TagLib，与TagLibUnitTestCase结合使用
以上对单元测试的讨论主要集中在对于Grails Mock方法的介绍了，至于如何书写，跟写junit测试没有太大区别。接下来，我们看看集成测试。Grails集成测试环境和运行时环境完全一样，但是使用Test环境的配置。对于request之类的对象，也是通过mock对象来完成的。request、response和session分别对应：MockHttpServletRequest
MockHttpServletResponse
MockHttpSession
需要注意的要点：不会调用拦截器，使用功能测试对它们进行测试。
对于Controller引用的Service，需显式注入。
使用Request的Params构造Command对象。
一个集成测试的例子：Controller：

class FooController {
def text = {
render "bar"
}
def someRedirect = {
redirect(action:"bar")
}
}

测试：

class FooControllerTests extends GroovyTestCase {
void testText() {
def fc = new FooController()
//触发对应的action
fc.text()
assertEquals "bar",
//注意这里
fc.response.contentAsString
}
void testSomeRedirect() {
def fc = new FooController()
fc.someRedirect()
assertEquals "/foo/bar",
fc.response.redirectedUrl
}
}

测试带服务的Controller的例子：

class FilmStarsTests extends GroovyTestCase {
def popularityService  //利用grails注入
public void testInjectedServiceInController () {
def fsc = new FilmStarsController()
//显式注入
fsc.popularityService = popularityService
……
}
}

对于Command Object：构造Params内容，模拟Command对象和Domain Class。

class AuthenticationController {
def signup = { SignupForm form -> …… }
}
//测试
def controller = new AuthenticationController()
controller.params.login = "marcpalmer"
controller.params.password = "secret"
controller.params.passwordConfirm = "secret"
controller.signup()

测试response内容（例子）：Controller实例.response.contentAsString
Controller实例.response.redirectedUrl
测试Render：render(view:"create", model:[book:book])：Controller实例.modelAndView.model.book，Controller实例.modelAndView.view
[book: new Book(params['book']) ]：Controller实例.book
模拟Request，先看一下Controller的代码：

def create = {
[book: new Book(params['book']) ]
}

测试代码的总框架：

void testCreate() {
def controller = new BookController()
模拟Request //使用不同模拟方法替换这里
def model = controller.create()
assert model.book
assertEquals "The Stand", model.book.title
}

使用XML模拟的方法（注意最后调用getBytes）：

controller.request.contentType = 'text/xml'
controller.request.contents = '''
<?xml version="1.0" encoding="ISO-8859-1"?>
<book>
<title>The Stand</title>
...
</book>
'''.getBytes()

使用JSON模拟（注意最后调用getBytes）：

controller.request.contentType = "text/json"
//需要指定class属性，方便构造domain class
//XML通过元素名就已经隐含指定
controller.request.content =
'{"id":1,"class":"Book","title":"The Stand"}'
.getBytes()

Web Flow实现了复杂的页面流，对于它的测试，在Grails中是使用grails.test.WebFlowTestCase。其中，需要注意的方法有：getFlow，指定使用哪个WebFlow定义
getFlowId，指定web flow id
startFlow，启动web flow
signalEvent，触发事件
看看例子：Web Flow定义：

class ExampleController {
def exampleFlow = {
start {
on("go") {
flow.hello = "world"
}.to "next"
}
next {
on("back").to "start"
on("go").to "end"
}
end()
}
}

测试例子：

class ExampleFlowTests extends grails.test.WebFlowTestCase {
def getFlow() { new ExampleController().exampleFlow }
String getFlowId() { "example" }
void testExampleFlow() {
def viewSelection = startFlow()
assertEquals "start", viewSelection.viewName
viewSelection = signalEvent("go")
assertEquals "next", viewSelection.viewName
assertEquals "world", viewSelection.model.hello
}
}

对于标签库的测试有两种测试方法：作为普通方法进行测试和作为页面元素进行测试。标签库

class FooTagLib {
def bar =  { attrs, body ->
out << "<p>Hello World!</p>"
}
def bodyTag =  { attrs, body ->
out << "<${attrs.name}>"
out << body()
out << "</${attrs.name}>"
}
}

作为普通方法进行测试，基类GroovyTestCase

class FooTagLibTests extends GroovyTestCase {
void testBarTag() {
assertEquals "<p>Hello World!</p>"
, new FooTagLib().bar(null,null)
}
void testBodyTag() {
assertEquals "<p>Hello World!</p>"
, new FooTagLib().bodyTag(name:"p") {
"Hello World!"
}
}
}

作为页面元素进行测试，用于集成测试，基类：grails.test.GroovyPagesTestCase

class FormatTagLibTests extends GroovyPagesTestCase {
void testTag() {
def template = '<g:foo />'
assertOutputEquals( '<p>Hello World!</p>', template)
//applyTemplate可以直接获得标签库的结果
def result = applyTemplate( template)
assertEquals '<p>Hello World!</p>', result
}
}

在集成测试中，使用Domain Class时，需要注意：需要显式flush，确保持久化，否则可能无法查询。