Invocation count is wrong when capturing arguments against sealed class types

Assume you have a sealed class hierarchy as follows:

sealed class MyType {
  data class Open(val something: String) : MyType()
  data class Finish(val reason: String) : MyType()
}

Let's say the production code that I'm verifying against has a method with the following structure:

class MyClass {
  fun doStuff(myType: MyType) {
    // ...
  }
}

So, somewhere in the production code we do this: myClass.doStuff(MyType.Open("something")). Later, in another place, we do this: myClass.doStuff(MyType.Finish("reason")).

In my test, this is the setup I am trying to use for verifying that myClass invoked doStuff() exactly once with the parameter MyType.Finish:

import com.nhaarman.mockitokotlin2.argumentCaptor
import org.mockito.Mockito.*

@Test
fun someTest() {
  argumentCaptor<MyType.Finish>().apply {
    verify(myClass, times(1)).send(capture())
  }
}

The test fails with the following output:

org.mockito.exceptions.verification.TooManyActualInvocations: myClass.doStuff(); Wanted 1 time: -> at "location in test method" But was 2 times: -> at "location where I call myClass.doStuff(MyType.Open("something"))" -> at "location where I call myClass.doStuff(MyType.Finish("reason"))"

So, the argumentCaptor specified with the type MyType.Finish captures all invocations where the superclass MyType is used.

mockito / mockito-kotlin

Invocation count is wrong when capturing arguments against sealed class types #349