I want to verify if a method is called at least once through mockito verify. I used verify and it complains like this:
org.mockito.exceptions.verification.TooManyActualInvocations: Wanted 1 time: But was 2 times. Undesired invocation: 
Add a comment |
2 Answers
Using the appropriate VerificationMode:
import static org.mockito.Mockito.atLeast; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; verify(mockObject, atLeast(2)).someMethod("was called at least twice"); verify(mockObject, times(3)).someMethod("was called exactly three times"); 
5 Comments
Wim Deblauwe
You can also use
Mockito.times(...) instead of VerificationModeFactory.times(...) for the static import
Roger
import static org.mockito.Mockito.times;. Generally importing packages with "internal" in them (import static org.mockito.internal.verification.VerificationModeFactory.times;) is discouraged.
Glenn Bech
is there another way of writing times(1) ?
nbrooks
@GlennBech You can just omit that, it's implicit; the default
verify(mockObject).someMethod("") looks for exactly 1 interaction (no more, no less). If, instead, you want at least one invocation of the method, you can use the atLeastOnce() specifier.
Phong Nguyen
@Roger I agree with you, for a beginning TDD practicer like me, static import make me more confuse about remembering the methods or which framework is using (Mockito, Espresso, or just normal unit test).
For Kotlin:
build gradle:
testImplementation "com.nhaarman.mockitokotlin2:mockito-kotlin:2.2.0" code:
interface MyCallback { fun someMethod(value: String) } class MyTestableManager(private val callback: MyCallback) { fun perform(){ callback.someMethod("first") callback.someMethod("second") callback.someMethod("third") } } test:
import com.nhaarman.mockitokotlin2.times import com.nhaarman.mockitokotlin2.verify import com.nhaarman.mockitokotlin2.mock ... val callback: MyCallback = mock() val uut = MyTestableManager(callback) uut.perform() val captor: KArgumentCaptor<String> = com.nhaarman.mockitokotlin2.argumentCaptor<String>() verify(callback, times(3)).someMethod(captor.capture()) assertTrue(captor.allValues[0] == "first") assertTrue(captor.allValues[1] == "second") assertTrue(captor.allValues[2] == "third") For Java:
Lombok used to simplify. You can also type out the constructor if you prefer.
build gradle:
testImplementation "org.mockito:mockito-core:3.6.28" code:
// MyCallback.java public interface MyCallback { void someMethod(String value); } // MyTestableManager.java public class MyTestableManager { private MyCallback callback; public MyTestableManager(MyCallback callback) { this.callback = callback; } public void perform(){ callback.someMethod("first"); callback.someMethod("second"); callback.someMethod("third"); } } test:
import org.mockito.Mockito.times; import org.mockito.Mockito.verify; import org.mockito.Mock; import org.mockito.Captor; // whatever other imports you need @Mock private MyCallback callback; @Captor private ArgumentCaptor<String> captor; private MyTestableManager uut = new MyTestableManager(callback); // in your test method: uut.perform() verify(callback, times(3)).someMethod(captor.capture()) assertTrue(captor.getAllValues().get(0) == "first") assertTrue(captor.getAllValues().get(1) == "second") assertTrue(captor.getAllValues().get(2) == "third") 
2 Comments
Egor Hans
In case you wonder about my edits: Annotation-based mock creation is usually preferable in Java, but I wasn't sure if it's a thing in Mockito Kotlin. As for renaming manager to uut, that's just conventions - the object that's being tested (the unit under test) is usually named uut or sut (not sure what the latter stands for).
Jonathan F.
Thank you for elaborating about the
captor mecanism, works great!