How does verifyNoMoreInteractions differ from verifyZeroInteractions

`verifyNoMoreInteractions()`

This method is used to ensure that no additional interactions occur on a mock object beyond what has already been verified using `verify()`. It should be called after all other `verify()` calls to confirm that there are no unverified interactions. If any unverified interactions are found, the test will fail. This method is particularly useful for ensuring that only the expected methods are called on a mock object during a test.

For example, if you have a mock object `mockContext` and you want to verify that only the `addError()` method is called on it, you would use `verifyNoMoreInteractions()` like this:

java
Context mockContext = mock(Context.class);
Validator validator = new Validator(mockContext);
validator.validate("Hello world");
verify(mockContext).addError("No space allowed.");
verifyNoMoreInteractions(mockContext);

`verifyZeroInteractions()`

This method checks that no interactions at all have occurred on a mock object. It is similar to `verifyNoMoreInteractions()` in that it ensures no interactions are present, but it does not require prior `verify()` calls. It is typically used when you want to ensure that a mock object is not used at all during a test.

In Mockito versions prior to 3.x, `verifyZeroInteractions()` behaves the same as `verifyNoMoreInteractions()`, but in newer versions, the behavior might differ slightly, with `verifyZeroInteractions()` specifically checking for no interactions whatsoever.

Here's how you might use `verifyZeroInteractions()` to ensure that a mock object `setter` is not interacted with:

java
verifyZeroInteractions(setter);

Key Differences

- Purpose: `verifyNoMoreInteractions()` is used after verifying specific interactions to ensure no additional interactions occur, while `verifyZeroInteractions()` checks that there are no interactions at all.
- Usage Context: `verifyNoMoreInteractions()` is typically used after other `verify()` calls, whereas `verifyZeroInteractions()` can be used independently.
- Behavior in Different Versions: In Mockito versions prior to 3.x, both methods behave similarly, but in newer versions, `verifyZeroInteractions()` might be more strictly about ensuring no interactions.

In summary, while both methods can be used to ensure that mock objects are not over-interacted with, `verifyNoMoreInteractions()` is more about ensuring that only the expected interactions have occurred, whereas `verifyZeroInteractions()` is about ensuring no interactions at all.