unit-testing - Groovy MockFor : How to avoid nested closures when using multiple mocks?

Question

我有三个类(class):

class B1 {
    def performB1(){}
}

class B2 {
    def performB2(){}
}

class A {
    private B1 b1
    private B2 b2

    A(b1, b2){
        this.b1 = b1
        this.b2 = b2
    }

    def perfromA(){
        b1.performB1()
        b2.performB2()
    }
}

我想测试方法 performA在类(class) A .所以我为类创建了模拟 B1和 B2 .这是我的课:

import groovy.mock.interceptor.MockFor;

 class ATest  extends GroovyTestCase {
     private MockFor b1Mock
     private MockFor b2Mock

    void setUp() {
        b1Mock = new MockFor(B1)
        b2Mock = new MockFor(B2)
    }


    void testIsEnoughSpaceOnArtifactory_failedToGetQuotaFromArtifactory(){
        b1Mock.demand.with {
            performB1 { println "Performing B1" }
        }

        b2Mock.demand.with {
            performB2 {println "Performing B2"}
        }

        b2Mock.use {
           b1Mock.use {
               def a = new A(new B1(), new B2())
               a.perfromA()
           }
        }
    }
}

它运作良好 - 我验证了它。它基于 this question .

但是，假设我有一个具有三个依赖项的类。它仍然是干净的代码。它需要3个模拟。代码看起来像这样:

b3Mock.use { 
    b2Mock.use {
        b1Mock.use {
            def a = new A(new B1(), new B2(), new B3())
            a.perfromA()
        }
    }
}

它看起来很可笑，而且远非干净。想象一下，我没有达到不超过 3 个依赖项的目标。然后我的测试看起来会更可笑。有没有办法在没有嵌套闭包的情况下验证模拟调用？我可以使用类似的东西(请参阅 here 以供引用):

b1Mock.use { 
    def a = new A(new B1(), b2Mock.proxyInstance(), b3Mock.proxyInstance())
    a.perfromA()
}
b2Mock.expect.verify()
b3Mock.expect.verify()

不幸的是，当我运行它时，出现以下错误:

java.lang.NullPointerException: Cannot invoke method performB2() on null object

是否可以在没有嵌套闭包的情况下在 groovy 中使用多个模拟来获得干净的代码？

Answer 1

以下脚本工作正常:

import groovy.mock.interceptor.MockFor
//------ CLASSES
class B1 { def performB1(){} }
class B2 { def performB2(){} }
class B3 { def performB3(){} }

class A {
    private B1 b1
    private B2 b2
    private B3 b3

    A(b1, b2, b3){
        this.b1 = b1
        this.b2 = b2
        this.b3 = b3
    }

    def perfromA(){
        b1.performB1()
        b2.performB2()
        b3.performB3()
    }
}
//------ TESTS
def b1Mock = new MockFor(B1)
def b2Mock = new MockFor(B2)
def b3Mock = new MockFor(B3)

b1Mock.demand.with {
    performB1 { println "Performing B1" }
}
b2Mock.demand.with {
    performB2 {println "Performing B2"}
}
b3Mock.demand.with {
    performB3 {println "Performing B3"}
}

def b2inst = b2Mock.proxyInstance()
def b3inst = b3Mock.proxyInstance()
b1Mock.use { 
    def a = new A(new B1(), b2inst, b3inst)
    a.perfromA()
}
b2Mock.verify(b2inst)
b3Mock.verify(b3inst)

并具有以下功能

def useAll(List<MockFor> mocks,Closure test){
    Closure use4all = mocks.inject(test){ Closure testX, next-> 
        return { next.use(testX) } 
    }
    use4all.call()
}

可以最小化嵌套使用闭包:

useAll([b1Mock,b2Mock,b3Mock]){
    def a = new A(new B1(), new B2(), new B3())
    a.perfromA()
}