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

Question

I have three 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()
}
}
I want to test the method performA in the class A. So I created mocks for classes B1 and B2. Here is my 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()
}
}
}
}
It works well- I verified it. It is based on this question.
However, suppose that I have a class with three dependencies. It is still clean code. It requires 3 mocks. The code would look like that:
b3Mock.use {
b2Mock.use {
b1Mock.use {
def a = new A(new B1(), new B2(), new B3())
a.perfromA()
}
}
}
It looks ridiculous and is far from being clean. Imagine that I failed to meet the goal of no more than 3 dependencies. Then my tests will look like even more ridiculous. Is there a way to verify calls on mocks without nested closures? I could use something like that (see here for reference):
b1Mock.use {
def a = new A(new B1(), b2Mock.proxyInstance(), b3Mock.proxyInstance())
a.perfromA()
}
b2Mock.expect.verify()
b3Mock.expect.verify()
Unfortunately, when I run it, I get the following error:
java.lang.NullPointerException: Cannot invoke method performB2() on null object
Is it possible to use multiple mocks in groovy without nested closures to have clean code?

Answer 1

the following script works fine:
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)
and with the following function
def useAll(List<MockFor> mocks,Closure test){
Closure use4all = mocks.inject(test){ Closure testX, next->
return { next.use(testX) }
}
use4all.call()
}
possible to minimize nested use-closures to this:
useAll([b1Mock,b2Mock,b3Mock]){
def a = new A(new B1(), new B2(), new B3())
a.perfromA()
}