@Spy for partial mocking in JUnit - Framework Patterns

Framework Mode - @Spy for partial mocking

Folder Structure

project-root/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/example/app/
│   │           └── Service.java
│   └── test/
│       └── java/
│           └── com/example/app/
│               ├── ServiceTest.java  <-- contains @Spy usage
│               └── utils/
│                   └── TestUtils.java
├── pom.xml  <-- Maven build and dependencies
└── README.md
    

Test Framework Layers

• Test Classes: Contain test methods using JUnit and Mockito annotations like @Spy for partial mocking.
• Service Layer: Application classes under test, e.g., Service.java.
• Test Utilities: Helper classes for common test setup or data.
• Mocking Layer: Uses Mockito to create spies (@Spy) and mocks (@Mock) for controlling behavior.
• Configuration: Maven pom.xml manages dependencies and test execution.

Configuration Patterns

• Dependencies: Use pom.xml to include JUnit 5 and Mockito dependencies.
• Test Runner: Use JUnit 5 with MockitoExtension to enable @Spy annotation processing.
• Environment: Tests run locally or in CI with standard JVM settings.
• Credentials: Not typically needed for unit tests with @Spy, but external configs can be loaded if needed.

<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-junit-jupiter</artifactId>
  <version>5.4.0</version>
  <scope>test</scope>
</dependency>

<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter-engine</artifactId>
  <version>5.9.3</version>
  <scope>test</scope>
</dependency>
    

Test Reporting and CI/CD Integration

• JUnit Reports: Standard XML and HTML reports generated by Maven Surefire plugin.
• Mockito Logs: Mockito does not produce logs by default; use assertions to verify spy behavior.
• CI/CD: Integrate tests in pipelines (GitHub Actions, Jenkins) to run on each commit and fail builds on test failures.
• Coverage: Use JaCoCo plugin to measure code coverage including partially mocked methods.

Best Practices for @Spy Partial Mocking

• Use @Spy to wrap real objects when you want to call real methods but override some behavior.
• Always initialize @Spy objects with MockitoExtension or MockitoAnnotations.openMocks() to avoid null pointers.
• Prefer @Spy on concrete classes, not interfaces, because spies wrap real instances.
• Keep tests focused: use @Spy only when partial mocking is necessary to avoid overcomplicating tests.
• Verify interactions on spies to ensure correct method calls and side effects.

Self Check

Where in this folder structure would you add a new spy object for a helper class used in ServiceTest.java?

Key Result

Use @Spy in JUnit tests to partially mock real objects, enabling selective method overriding while preserving original behavior.

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