Groovy MockFor：使用多个模拟时如何避免嵌套闭包？

Question

我有三个 classes:

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()
    }
}

我想测试 class A 中的方法 performA。所以我为 classes B1 和 B2 创建了模拟。这是我的 class:

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.

但是，假设我有一个具有三个依赖项的 class。它仍然是干净的代码。它需要 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 中使用多个 mock 而无需嵌套闭包以获得干净的代码？

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()
}

可以将嵌套 use-closures 最小化为：

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

Groovy MockFor：使用多个模拟时如何避免嵌套闭包？

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

groovy

unit-testing

mocking

clean-architecture