Verify Spock mock with specified timeout

Question

In Mockito there is option to verify if mock method has been called, and specify timeout for this verification (VerificationWithTimeout), for example:

Answer 1

I was trying to use PollingConditions to satisfy a similar scenario (which wasn't helpful), but instead found satisfaction in Spock's BlockingVariables. To verify that SomeService.method() is invoked at least once in function ClassBeingTested.method() within a given timeout period:

def "verify an interaction happened at least once within 200ms"(){
    given:
        def result = new BlockingVariable<Boolean>(0.2) // 200ms
        SomeService someServiceMock = Mock()
        someServiceMock.method() >> {
            result.set(true)
        }
        ClassBeingTested clazz = new ClassBeingTested(someService: someServiceMock)
    when:
        clazz.someMethod()
    then:
        result.get()
}

When the result is set, the blocking condition will be satisfied and result.get() would have to return true for the condition to pass. If it fails to be set within 200ms, the test will fail with a timeout exception.

Answer 2

There is no equivalent in Spock. (PollingConditions can only be used for conditions, not for interactions.) The closest you can get is to add a sleep() statement in the then block:

when:
...

then:
sleep(200)
(1.._) * mock.baz()

Answer 3

This doesn't do exactly what the question asked, but I found it a bit cleaner that using a variable. If you have other conditions to asynchronously test in addition to the interaction, then you can declare the interactions at mock creation time and then use PollingConditions to test the other conditions. PollingConditions will either fail the test or block until the conditions pass, so that by the time the interaction is tested, the method should have been called:

@MicronautTest
class KernelManagerTest extends Specification {

    @Inject
    KernelManager kernelManager

    //create conditions
    PollingConditions conditions = new PollingConditions(timeout: 10, initialDelay: 1)

    class Exits {

        static createKernel (String[] args) {
            System.exit(args[0].toInteger())
        }

    }

    def "handles a system exit from within kernel"() {
        given:
        // set custom kernel
        kernelManager.kernelClass = Exits
        // create custom logger
        kernelManager.log = Mock(Logger) {
            1 * warn("Kernel exited unexpectedly.", _ as UnexpectedExitException)
        }

        when:
        // create new kernel (exit 1)
        kernelManager.startNewKernel("1")

        then:
        conditions.eventually {
            kernelManager.kernelInstances.size() == 0
            kernelManager.kernelThreads.size() == 0
        }
    }
}

Answer 4

Using PollingConditions and a boolean variable, the following example evaluates a function until it satisfies an interaction.

def "test the config watcher to reload games if a new customer directory is added"() {

given:
def conditions = new PollingConditions(initialDelay: 1, timeout: 60, factor: 1.25)
def mockGameConfigLoader = Mock(GameConfigLoader)
def gameConfigWatcher= new GameConfigWatcher(mockGameConfigLoader)
boolean gamesReloaded = false

when:
conditions.eventually {
    gameConfigWatcher.listenEvents()
    assert gamesReloaded
}

then:
1 * mockGameConfigLoader.loadAllGameConfigs() >> {
    gamesReloaded = true
}
0 * _

}