Verification times (times, never, atLeast) in JUnit - Test Execution Trace

Test Overview

This test verifies how many times a mock method is called using JUnit with Mockito. It checks that a method is called exactly twice, never called with a certain argument, and called at least once.

Test Code - JUnit with Mockito

JUnit

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

public class VerificationTimesTest {

    interface Service {
        void performAction(String input);
    }

    @Test
    void testVerificationTimes() {
        Service mockService = mock(Service.class);

        // Call performAction twice with "hello"
        mockService.performAction("hello");
        mockService.performAction("hello");

        // Call performAction once with "world"
        mockService.performAction("world");

        // Verify performAction called exactly twice with "hello"
        verify(mockService, times(2)).performAction("hello");

        // Verify performAction never called with "test"
        verify(mockService, never()).performAction("test");

        // Verify performAction called at least once with "world"
        verify(mockService, atLeast(1)).performAction("world");
    }
}

Execution Trace - 7 Steps

Step	Action	System State	Assertion	Result
1	Test starts	JUnit test runner initialized, Mockito mock created for Service interface	—	PASS
2	Calls mockService.performAction("hello") twice	Mock records two calls with argument "hello"	—	PASS
3	Calls mockService.performAction("world") once	Mock records one call with argument "world"	—	PASS
4	Verifies performAction called exactly twice with "hello" using verify(mockService, times(2))	Mockito checks recorded calls for "hello" argument	Exactly 2 calls with "hello" found	PASS
5	Verifies performAction never called with "test" using verify(mockService, never())	Mockito checks recorded calls for "test" argument	No calls with "test" found	PASS
6	Verifies performAction called at least once with "world" using verify(mockService, atLeast(1))	Mockito checks recorded calls for "world" argument	At least 1 call with "world" found	PASS
7	Test ends successfully	All verifications passed	—	PASS

Failure Scenario

Failing Condition: If performAction is called fewer or more times than expected for a verification, or called with unexpected arguments

Execution Trace Quiz - 3 Questions

What does verify(mockService, never()).performAction("test") check?

A That performAction was called exactly once with argument "test"

B That performAction was called at least once with argument "test"

C That performAction was never called with argument "test"

D That performAction was called twice with argument "test"

Key Result

Use verification times to precisely check how many times a mock method is called, which helps catch unexpected behavior in your code.

Practice

1. Which Mockito verification method checks that a method was called exactly 3 times?

easy

A. verify(mock, atMost(3)).method()

B. verify(mock, never()).method()

C. verify(mock, atLeast(3)).method()

D. verify(mock, times(3)).method()

Solution

1. Step 1: Understand times(n) usage

   The times(n) method verifies that the method was called exactly n times.

2. Step 2: Match the exact call count

   Since the question asks for exactly 3 calls, times(3) is the correct choice.

3. Final Answer:

   verify(mock, times(3)).method() -> Option D

4. Quick Check:

   Exact call count = times(n) [OK]

Hint: Use times(n) for exact call count verification [OK]

Common Mistakes:

• Confusing times(n) with atLeast(n)
• Using never() when calls exist
• Using atMost(n) instead of times(n)

2. Which of the following is the correct syntax to verify that a method was never called using Mockito?

easy

A. verify(mock, never()).method();

B. verify(mock, atLeast(0)).method();

C. verify(mock, times(0));

D. verify(mock).never().method();

Solution

1. Step 1: Identify the correct method for zero calls

   Mockito provides never() to verify that a method was not called at all.

2. Step 2: Check syntax correctness

   The correct syntax is verify(mock, never()).method();. Using times(0) also works but never() is clearer and preferred.

3. Final Answer:

   verify(mock, never()).method(); -> Option A

4. Quick Check:

   No calls = never() [OK]

Hint: Use never() to verify zero calls clearly [OK]

Common Mistakes:

• Using times(0) instead of never() for clarity
• Incorrect chaining like verify(mock).never()
• Using atLeast(0) which always passes

3. Given the following code snippet:

verify(mock, atLeast(2)).process();

Which statement is true about the verification?

medium

A. The method process() must be called exactly 2 times.

B. The method process() must be called at most 2 times.

C. The method process() must be called at least 2 times or more.

D. The method process() must never be called.

Solution

1. Step 1: Understand atLeast(n) meaning

   The atLeast(n) method verifies that the method was called at least n times, meaning 2 or more times.

2. Step 2: Match the verification condition

   Since the code uses atLeast(2), it means the method must be called 2 or more times, not exactly 2.

3. Final Answer:

   The method process() must be called at least 2 times or more. -> Option C

4. Quick Check:

   Minimum calls = atLeast(n) [OK]

Hint: atLeast(n) means minimum n calls, not exact [OK]

Common Mistakes:

• Confusing atLeast(n) with times(n)
• Thinking atLeast(n) means at most n
• Assuming never() means zero calls only

4. Identify the error in this Mockito verification:

verify(mock, never).execute();

medium

A. Using times() instead of never()

B. Missing parentheses after never()

C. Incorrect method name execute()

D. No error, syntax is correct

Solution

1. Step 1: Check syntax of never()

   The never() method requires parentheses to be called as a method.

2. Step 2: Identify missing parentheses

   The code uses never without parentheses, which is a syntax error.

3. Final Answer:

   Missing parentheses after never() -> Option B

4. Quick Check:

   never() requires parentheses [OK]

Hint: Always add () after never to avoid syntax errors [OK]

Common Mistakes:

• Omitting parentheses after never
• Confusing never with times(0)
• Assuming method name causes error

5. You want to verify that a method update() was called at least once but no more than 5 times. Which Mockito verification code correctly expresses this?

hard

A. verify(mock, atLeast(1)).update(); verify(mock, atMost(5)).update();

B. verify(mock, times(1)).update(); verify(mock, times(5)).update();

C. verify(mock, never()).update();

D. verify(mock, atLeast(5)).update();

Solution

1. Step 1: Understand the requirement

   The method update() must be called at least once and at most 5 times.

2. Step 2: Use correct verification methods

   Use atLeast(1) to check minimum calls and atMost(5) to check maximum calls.

3. Step 3: Combine verifications

   Both verifications must be done separately to ensure the call count is between 1 and 5.

4. Final Answer:

   verify(mock, atLeast(1)).update(); verify(mock, atMost(5)).update(); -> Option A

5. Quick Check:

   Range check = atLeast + atMost [OK]

Hint: Combine atLeast(n) and atMost(m) for call count range [OK]

Common Mistakes:

• Using times() twice with different values
• Using never() when calls exist
• Using only atLeast(5) which ignores max limit