In Mockito, `verifyZeroInteractions` is a specialized verification method used to ensure that no method calls are made on a mocked object during a test. This method is crucial for maintaining the purity of unit tests by preventing unintended interactions that could indicate flaws in logic or unnecessary dependencies.
Differences from Other Verification Methods
1. Purpose and Behavior:
- `verifyZeroInteractions`: This method checks that no method calls have been made on a mocked object. If any method call is detected, Mockito throws an exception, causing the test to fail. It is used to assert that a mock object remains untouched during the test execution[1][4].
- `verify`: This method is used to verify that specific method calls occur as expected. It allows you to check if a method was called with specific arguments and can be used with various verification modes like `times()`, `atLeast()`, and `atMost()` to specify the number of invocations[2][7].
2. Verification Modes:
- `verifyZeroInteractions` does not support verification modes. It simply checks for the absence of any interactions.
- `verify` supports multiple verification modes, such as `times()`, `atLeast()`, `atLeastOnce()`, and `atMost()`, allowing you to specify how many times a method should be called[2][7].
3. Order of Invocation:
- `verifyZeroInteractions` does not concern itself with the order of method calls since it checks for no interactions at all.
- `verify` can be used with `InOrder` to verify the order of method invocations on mock objects. This is useful when the sequence of method calls is important[2][7].
4. Use Cases:
- `verifyZeroInteractions` is typically used when you want to ensure that a mock object is not used at all in a test scenario. This helps in isolating the unit under test and ensuring that no side effects occur due to unexpected interactions[1][4].
- `verify` is used in scenarios where you need to confirm that specific interactions occur between objects. It is essential for testing the expected behavior of a system under test[2][7].
5. Relationship with `verifyNoMoreInteractions`:
- `verifyZeroInteractions` checks that no interactions have occurred at all.
- `verifyNoMoreInteractions` checks that all interactions on a mock object have been verified. It ensures that there are no unverified interactions left after using `verify` for specific method calls[3][9].
In summary, `verifyZeroInteractions` is a specialized method focused on ensuring no interactions occur, while `verify` is more versatile, allowing you to check for specific interactions and their frequency. Both methods are essential in unit testing with Mockito, serving different purposes depending on the test scenario.
Citations:[1] https://www.dhiwise.com/post/how-to-use-verifyzerointeractions-for-better-flutter-tests
[2] https://www.dhiwise.com/post/mastering-unit-testing-a-complete-guide-to-mockito-verify
[3] https://stackoverflow.com/questions/52396683/difference-between-verifynomoreinteractions-and-verifyzerointeractions-in-mockit
[4] https://www.lambdatest.com/automation-testing-advisor/selenium/methods/org.mockito.Mockito.verifyZeroInteractions
[5] https://stackoverflow.com/questions/64239160/using-mockito-when-to-mock-and-verify-vs-mockito-verify
[6] https://www.javacodegeeks.com/2015/11/mockito-verification.html
[7] https://www.toptal.com/java/a-guide-to-everyday-mockito
[8] https://www.baeldung.com/mockito-verify
[9] https://www.digitalocean.com/community/tutorials/mockito-verify