verify() for interaction verification in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit test using Mockito's verify()?

Consider the following JUnit test code snippet using Mockito. What will be the test result after execution?

JUnit

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

class Service {
    void process() {}
}

public class VerifyTest {
    @Test
    void testVerifyCalledOnce() {
        Service service = mock(Service.class);
        service.process();
        verify(service).process();
    }
}

A Test passes successfully

B Test fails with WantedButNotInvoked exception

C Test fails with TooManyActualInvocations exception

D Test fails with NullPointerException

💡 Hint

Mockito's verify() checks if the method was called exactly once by default.

The test mocks the Service class, calls process() once, then verifies that process() was called exactly once. Since it was called once, the verification passes and the test passes.

❓ assertion

intermediate

Which verify() assertion checks that a method was never called?

In Mockito, which verify() usage correctly asserts that the method process() was never called on the mock?

JUnit

Service service = mock(Service.class);
// no call to service.process() here

A verify(service, times(0)).process();

B verifyNoMoreInteractions(service);

C verify(service).process();

D verify(service, never()).process();

💡 Hint

Check the Mockito documentation for verifying zero invocations.

verify(service, never()).process() asserts that process() was never called. times(0) is equivalent but less readable. verify(service).process() expects one call. verifyNoMoreInteractions checks no other calls beyond verified ones.

🔧 Debug

advanced

Why does this verify() call fail with TooManyActualInvocations?

Given the code below, why does the verify() call fail with a TooManyActualInvocations exception?

JUnit

Service service = mock(Service.class);
service.process();
service.process();
verify(service).process();

A Because verify() requires specifying times(2) explicitly

B Because process() was never called

C Because process() was called twice but verify() expects exactly one call by default

D Because the mock was not initialized properly

💡 Hint

Check how many times process() was called versus what verify() expects.

The method process() was called twice, but verify(service).process() expects exactly one call. This mismatch causes the TooManyActualInvocations exception.

🧠 Conceptual

advanced

What is the purpose of verifyNoMoreInteractions() in Mockito?

Select the best description of what verifyNoMoreInteractions(mock) does in Mockito tests.

A It resets the mock to remove all previous interactions

B It checks that no other methods besides those already verified were called on the mock

C It verifies that the mock was never called at all

D It verifies that all methods on the mock were called at least once

💡 Hint

Think about verifying that no unexpected calls happened.

verifyNoMoreInteractions(mock) ensures that after verifying some interactions, no other calls were made on the mock. It helps catch unexpected method calls.

❓ framework

expert

In a JUnit 5 test using Mockito, which verify() usage correctly checks a method was called exactly twice with specific arguments?

Given a mock of Service with method process(String input), which verify() call correctly asserts process("data") was called exactly twice?

JUnit

Service service = mock(Service.class);
service.process("data");
service.process("data");

A verify(service, times(2)).process("data");

B verify(service).process("data"); verify(service).process("data");

C verify(service, atLeast(2)).process("data");

D verify(service, times(1)).process(anyString());

💡 Hint

Check how to specify exact call counts with arguments in verify().

verify(service, times(2)).process("data") asserts the method was called exactly twice with argument "data". Option A verifies two separate calls but does not check call count properly. Option A allows two or more calls, not exactly two. Option A checks only one call with any string.