@Spy for partial mocking in JUnit - Test Execution Trace

Test Overview

This test demonstrates how to use @Spy in JUnit with Mockito to partially mock an object. It verifies that a real method is called unless it is stubbed.

Test Code - JUnit 5 with Mockito

JUnit

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

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
public class SpyPartialMockTest {

    static class Calculator {
        public int add(int a, int b) {
            return a + b;
        }

        public int multiply(int a, int b) {
            return a * b;
        }
    }

    @Spy
    Calculator calculatorSpy;

    @Test
    void testPartialMockingWithSpy() {
        // Stub multiply method to return fixed value
        doReturn(10).when(calculatorSpy).multiply(2, 3);

        // Call add method - real method should be called
        int sum = calculatorSpy.add(2, 3);

        // Call multiply method - stubbed method should be called
        int product = calculatorSpy.multiply(2, 3);

        assertEquals(5, sum, "add method should call real implementation");
        assertEquals(10, product, "multiply method should return stubbed value");
    }
}

Execution Trace - 7 Steps

Step	Action	System State	Assertion	Result
1	Test starts	JUnit test runner initialized with MockitoExtension	—	PASS
2	Mockito creates a spy instance of Calculator	Calculator spy object ready with real methods available	—	PASS
3	Stub multiply(2, 3) method to return 10	multiply method on spy is stubbed for inputs (2,3)	—	PASS
4	Call add(2, 3) on spy	Real add method executes and returns 5	Verify add returns 5	PASS
5	Call multiply(2, 3) on spy	Stubbed multiply method returns 10	Verify multiply returns 10	PASS
6	Assertions check add == 5 and multiply == 10	Assertions pass successfully	assertEquals(5, sum) and assertEquals(10, product)	PASS
7	Test ends	Test completed with all assertions passing	—	PASS

Failure Scenario

Failing Condition: If the spy is not created properly or multiply method is not stubbed correctly

Execution Trace Quiz - 3 Questions

What does the @Spy annotation do in this test?

A Creates a full mock with no real method calls

B Creates a partial mock that calls real methods unless stubbed

C Injects dependencies automatically

D Runs the test in a separate thread

Key Result

Using @Spy allows you to test real method behavior while selectively overriding specific methods, which helps in testing complex objects without fully mocking them.

Practice

1. What does the @Spy annotation do in JUnit testing?

easy

A. Automatically runs all test methods in a class.

B. Creates a completely fake object with no real method calls.

C. Creates a real object but allows overriding some methods for partial mocking.

D. Mocks static methods of a class.

Solution

1. Step 1: Understand @Spy purpose

   @Spy creates a real instance of the class but allows selective method overriding.

2. Step 2: Compare with other mocking types

   Unlike full mocks, spies call real methods unless stubbed.

3. Final Answer:

   Creates a real object but allows overriding some methods for partial mocking. -> Option C

4. Quick Check:

   @Spy = Partial real object with override [OK]

Hint: Remember: @Spy means real object with some fake methods [OK]

Common Mistakes:

• Confusing @Spy with @Mock which creates full fake objects
• Thinking @Spy mocks static methods
• Assuming @Spy runs tests automatically

2. Which of the following is the correct way to initialize a spy object in a JUnit 5 test class using Mockito?

easy

A. @Spy MyClass mySpy; MockitoAnnotations.openMocks(this);

B. @Spy MyClass mySpy = new MyClass();

C. @Spy MyClass mySpy = Mockito.mock(MyClass.class);

D. @Spy MyClass mySpy = Mockito.spy(null);

Solution

1. Step 1: Recognize proper spy initialization

   Using @Spy requires calling MockitoAnnotations.openMocks(this) to initialize the spy fields.

2. Step 2: Check other options

   @Spy MyClass mySpy = new MyClass(); misses initialization call; C uses mock instead of spy; D tries spying on null which is invalid.

3. Final Answer:

   @Spy MyClass mySpy; MockitoAnnotations.openMocks(this); -> Option A

4. Quick Check:

   Initialize spies with openMocks(this) [OK]

Hint: Always call MockitoAnnotations.openMocks(this) to init @Spy [OK]

Common Mistakes:

• Not calling MockitoAnnotations.openMocks(this)
• Confusing spy creation with mock creation
• Trying to spy on null or uninitialized objects

3. Given the following code snippet, what will be the output of the test?

@Spy
List<String> spyList = new ArrayList<>();

@Test
void testSpyList() {
    spyList.add("one");
    spyList.add("two");
    Mockito.doReturn(100).when(spyList).size();
    System.out.println(spyList.size());
}

medium

A. 2

B. 100

C. 0

D. Throws NullPointerException

Solution

1. Step 1: Understand spy behavior with doReturn

   The spy calls real methods unless stubbed. Here, size() is stubbed to return 100.

2. Step 2: Analyze output of spyList.size()

   Despite adding two elements, size() returns 100 due to stubbing.

3. Final Answer:

   100 -> Option B

4. Quick Check:

   Stubbed spy method returns stub value [OK]

Hint: Stub spy methods with doReturn to override real calls [OK]

Common Mistakes:

• Expecting real method size() to return actual list size
• Using when(spyList.size()) instead of doReturn for spies
• Forgetting spy initialization causing NullPointerException

4. Identify the error in the following test code using @Spy:

@Spy
MyService service;

@Test
void testService() {
    service = new MyService();
    Mockito.doReturn("mocked").when(service).getData();
    assertEquals("mocked", service.getData());
}

medium

A. The spy object is not initialized with MockitoAnnotations.openMocks(this).

B. You cannot assign a new instance to a @Spy annotated field.

C. doReturn cannot be used with spy objects.

D. The assertEquals method is used incorrectly.

Solution

1. Step 1: Check spy initialization

   The @Spy field must be initialized by calling MockitoAnnotations.openMocks(this) before use.

2. Step 2: Analyze assignment and usage

   Assigning new instance manually is allowed but without initialization, spy won't work properly.

3. Final Answer:

   The spy object is not initialized with MockitoAnnotations.openMocks(this). -> Option A

4. Quick Check:

   Always init @Spy with openMocks(this) [OK]

Hint: Always initialize @Spy fields before test runs [OK]

Common Mistakes:

• Forgetting to call MockitoAnnotations.openMocks(this)
• Thinking manual assignment replaces initialization
• Believing doReturn can't be used with spies

5. You want to partially mock a complex service class PaymentProcessor to test only the processPayment() method while keeping other methods real. Which approach using @Spy is best to achieve this?

hard

A. Create a new PaymentProcessor instance without @Spy and call processPayment() directly.

B. Mock the entire PaymentProcessor class with @Mock and implement processPayment() manually.

C. Use @Spy but override all methods except processPayment() to avoid side effects.

D. Create a spy of PaymentProcessor and stub only processPayment() method with Mockito.doReturn().

Solution

1. Step 1: Understand partial mocking goal

   Partial mocking means real methods run except those stubbed.

2. Step 2: Choose spy with selective stubbing

   Using @Spy and stubbing only processPayment() lets you test that method while others behave normally.

3. Step 3: Evaluate other options

   Mocking entire class loses real behavior; overriding all except one is complex; no spy means no partial mocking.

4. Final Answer:

   Create a spy of PaymentProcessor and stub only processPayment() method with Mockito.doReturn(). -> Option D

5. Quick Check:

   @Spy + stub target method = partial mocking [OK]

Hint: Spy real object, stub only target method for partial mocking [OK]

Common Mistakes:

• Mocking entire class losing real method calls
• Overriding too many methods manually
• Not using @Spy for partial mocking