Support arguments capture for verify blocks

[0xnm]

It seems that capture is not supported for verify blocks.

Suppose we have the following:

interface Foobar {
    fun foo(bar: String)
}

And then we mock/verify it in the test:

val mockFoobar = mock<Foobar>()

mockFoobar.foo("bar")

verify {
    val container = mutableListOf<String>()
    mockFoobar.foo(capture(container))

    assertTrue(container.isNotEmpty())
}

This assertion will fail, because nothing was actually captured and container is empty.

Am I missing some additional setup or mock arguments capture is indeed not yet supported in verify blocks?

[lupuuss]

Hi! Just like in MockK, using capture inside a verify block doesn’t produce any results. This is because capture is more like a callback: it only records arguments when the associated answer is actually invoked.

What’s your specific use case? Could simply using capture within an every block address your needs?

[0xnm]

Thanks for looking at this!

The use-case is to just extract the argument for the more further assertion. Like speaking about the example above, it could be:

val value = container.first()
assertThat(value).isXXX()
...

Of course it is possible to use matching:

verify {
  mockFoobar.foo(bar = matching {
       assertThat(it).isXXX()
       true
  }
}

But coming with the Mockito Kotlin usage background, where captors can be used in the verify block:

val captor = argumentCaptor<String>()
verify(mockFoobar).foo(bar = captor.capture())

It was a bit confusing to see here that captor can be technically invoked in the verify block, but nothing is actually captured (maybe it is worth then to log some warning or make a mention in the docs?).

[lupuuss]

How does it work with the Mockito?? Does it push all the arguments that were recorded for matching call all at once??

fooBar.call(1)
fooBar.call(2)
verify {
    val list = mutableListOf<Int>()
    fooBar.call(capture(list))
    println(list) // prints [1, 2]
}

[0xnm]

Yes. This would be the following snippet:

val foobar = mock<Foobar>()
foobar.foo("a")
foobar.foo("b")

val captor = argumentCaptor<String>()
verify(foobar, times(2)).foo(captor.capture())

println(captor.allValues) // prints [a, b]

[lupuuss]

At first glance, it seems possible to implement. I'll investigate further. If possible, I'll include it in version 2.7.0.