Java verify void method calls n times with Mockito

by

The necessary method is Mockito#verify:

public static <T> T verify(T mock,
                           VerificationMode mode)

mock is your mocked object and mode is the VerificationMode that describes how the mock should be verified. Possible modes are:

verify(mock, times(5)).someMethod("was called five times");
verify(mock, never()).someMethod("was never called");
verify(mock, atLeastOnce()).someMethod("was called at least once");
verify(mock, atLeast(2)).someMethod("was called at least twice");
verify(mock, atMost(3)).someMethod("was called at most 3 times");
verify(mock, atLeast(0)).someMethod("was called any number of times"); // useful with captors
verify(mock, only()).someMethod("no other method has been called on the mock");

You’ll need these static imports from the Mockito class in order to use the verify method and these verification modes:

import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.atMost;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

So in your case the correct syntax will be:

Mockito.verify(mock, times(4)).send()

This verifies that the method send was called 4 times on the mocked object. It will fail if it was called less or more than 4 times.

If you just want to check, if the method has been called once, then you don’t need to pass a VerificationMode. A simple

verify(mock).someMethod("was called once");

would be enough. It internally uses verify(mock, times(1)).someMethod("was called once");.

It is possible to have multiple verification calls on the same mock to achieve a “between” verification. Mockito doesn’t support something like this verify(mock, between(4,6)).someMethod("was called between 4 and 6 times");, but we can write

verify(mock, atLeast(4)).someMethod("was called at least four times ...");
verify(mock, atMost(6)).someMethod("... and not more than six times");

instead, to get the same behaviour. The bounds are included, so the test case is green when the method was called 4, 5 or 6 times.

More Related Contents:

  1. Test class with a new() call in it with Mockito
  2. Mockito : how to verify method was called on an object created within a method?
  3. How to tell a Mockito mock object to return something different the next time it is called?
  4. How to use ArgumentCaptor for stubbing?
  5. How to mock new Date() in java using Mockito
  6. How to verify that a specific method was not called using Mockito?
  7. Why are my mocked methods not calld when executing a unit test?
  8. Forming Mockito “grammars”
  9. Why are my mocked methods not called when executing a unit test?
  10. How do I test a class that has private methods, fields or inner classes?
  11. Mocking static methods with Mockito
  12. How to mock a final class with mockito
  13. How to run test methods in specific order in JUnit4?
  14. Difference between @Mock, @MockBean and Mockito.mock()
  15. Assert equals between 2 Lists in Junit
  16. Mockito: Trying to spy on method is calling the original method
  17. How to test that no exception is thrown?
  18. Multiple RunWith Statements in jUnit
  19. How to use JUnit to test asynchronous processes
  20. Mockito – NullpointerException when stubbing Method
  21. AssertEquals 2 Lists ignore order
  22. Using different classloaders for different JUnit tests?
  23. How do I mock a REST template exchange?
  24. java.lang.NoClassDefFoundError in junit
  25. how to export (JUnit) test suite as executable jar
  26. Testing against Java EE 6 API
  27. How do I unit test jdbc code in java? [closed]
  28. How to mock RestTemplate in Java Spring?
  29. Powermock – java.lang.IllegalStateException: Failed to transform class
  30. Integration tests for AspectJ

Leave a Comment