使用闭包替代Mock做测试

http://groovy.codehaus.org/Developer+Testing+using+Closures+instead+of+Mocks
觉得这篇文章对mock测试不错, 简单翻译一下.

在一些简单的测试场景下, 可以采用闭包加"as"关键字来实现我们需要mock的对象.
这种做法针对"面向接口编程"和"依赖注入"非常有效.
比如有这样的接口:

interface Logger { def log(message) } 
interface Helper { def doSomething(param) } 
interface Factory { Helper getInstance() } 

有这样的实现类:

class MyApp { 
    private factory 
    private logger 
    MyApp(Factory factory, Logger logger) { 
        this.logger = logger this.factory = factory
    } 
    def doMyLogic(param) { 
        factory.getInstance().doSomething(param) 
        logger.log('Something done with: ' + param)
    }
}

具体用闭包的写法:

def param = 'DUMMY STRING'
def logger = { message -> assert message == 'Something done with: ' + param}
def helper = { assert it == param }
def factory = { helper as Helper }
def myApp = new MyApp(factory as Factory, logger as Logger)
myApp.doMyLogic(param)

只mock一个方法相对来说比较简单, 如果需要同时mock多个方法, 比如这种:

interface Helper {
    def doSomething(param)
    def doSomethingElse(param)
}
    def doMyLogic(param) {
        def helper = factory.getInstance()
        helper.doSomething(param)
        helper.doSomethingElse(param)
        logger.log('Something done with: ' + param)
    }

对于这种情况, 可以创建一个以要mock的方法为key, 以闭包为value的map, 然后将map as为指定的接口:

def helperMethod = { assert it == param }
def helper = [doSomething:helperMethod, doSomethingElse:helperMethod]
// as before
def factory = { helper as Helper }

如果两个方法执行同样的内容的话, 其实可以这样写:

def factory = { helperMethod as Helper }

延伸阅读:
http://groovy.codehaus.org/Groovy+way+to+implement+interfaces
这篇文章也不错, 用闭包代替接口

一个接口可以用闭包来实现:

// a readable puts chars into a CharBuffer and returns the count of chars added
def readable = { it.put("12 34".reverse()); 5 } as Readable

// the Scanner constructor can take a Readable
def s = new Scanner(readable)
assert s.nextInt() == 43

对于有多个方法的这样定义:

interface X
{ void f(); void g(int n); void h(String s, int n); }

x = {Object[] args -> println "method called with $args"} as X
x.f()
x.g(1)
x.h("hello",2)

那么接口的每一个方法被调用的时候都会执行闭包. 为了适应多个方法, 闭包中的参数使用了数组

更通用的做法是用map来模拟多个方法的情况:

impl = [
  i: 10,
  hasNext: { impl.i > 0 },
  next: { impl.i-- },
]
iter = impl as Iterator
while ( iter.hasNext() )
  println iter.next()

如果指定的方法为在map中没有对应的key, 那么会抛空指针异常

interface X
{ void f(); void g(int n); void h(String s, int n); }

x = [ f: {println "f called"} ] as X
x.f()
//x.g()    // NPE here

下面是一种错误的写法:

x = { f: {println "f called"} } as X
x.f()
x.g(1)

因为这个是定义了一个闭包而不是一个map, 而且从groovy的语法来说也是不允许的.

更多的as用法, 可以看这里(http://johnnyjian.iteye.com/blog/160796)

这里有一点需要注意, as的class类型必须是一个静态的引用, 否则是失败, 但是了动态指定as的具体类型, 也可以使用asType这样写:

def loggerInterface = Class.forName( 'my.LoggerInterface' )
def logger = [
               log : { Object[] params -> println "LOG: ${params[0]}"; if( params.length > 1 ) params[1].printStackTrace() },
               close : { println "logger.close called" }
             ].asType( loggerInterface )

评论

2 楼 macrochen 2010-08-22  

JohnnyJian 写道

引用

x = { f: {println "f called"} } as X

这个闭包在语法上是允许的，f是一个标签，{println "f called"}是一个被定义了但是没有被调用的闭包

我搞错了, 这个在语法上的确是可以的

1 楼 JohnnyJian 2010-08-19  

引用

x = { f: {println "f called"} } as X

这个闭包在语法上是允许的，f是一个标签，{println "f called"}是一个被定义了但是没有被调用的闭包