Spy objects in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of Spy Objects in Unit Testing

What is the primary purpose of using a spy object in unit testing with JUnit?

A To verify interactions with real objects while allowing actual method calls

B To simulate exceptions without calling any real methods

C To replace the entire implementation of a class with dummy methods

D To generate random test data automatically during tests

💡 Hint

Think about how spies differ from mocks in terms of method calls.

A spy object wraps a real object and allows you to verify method calls while still executing the actual methods. This helps in testing side effects and interactions.

❓ Predict Output

intermediate

Output of Spy Verification in JUnit

What will be the result of running this JUnit test using Mockito spy?

JUnit

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;

public class SpyTest {
    @Test
    public void testSpyList() {
        List<String> list = new ArrayList<>();
        List<String> spyList = spy(list);

        spyList.add("one");
        spyList.add("two");

        verify(spyList).add("one");
        verify(spyList).add("two");

        assert(spyList.size() == 2);
    }
}

A Test throws NullPointerException during spy creation

B Test passes successfully with both verifications and assertion true

C Test fails due to assertion error on spyList size

D Test fails because verify does not work on spy objects

💡 Hint

Remember that spy calls real methods unless stubbed.

The spy wraps the real list, so add() calls actually add elements. Verifications confirm the calls happened. The size is 2, so assertion passes.

❓ assertion

advanced

Correct Assertion for Spy Method Call Count

Which assertion correctly verifies that a spy object's method was called exactly three times?

JUnit

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

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

    @Test
    public void testAddCallCount() {
        Calculator calc = spy(new Calculator());
        calc.add(1, 2);
        calc.add(3, 4);
        calc.add(5, 6);

        // Which verify statement is correct?
    }
}

A verify(calc, atLeast(4)).add(anyInt(), anyInt());

B verify(calc, times(1)).add(anyInt(), anyInt());

C verify(calc, never()).add(anyInt(), anyInt());

D verify(calc, times(3)).add(anyInt(), anyInt());

💡 Hint

Count how many times add() is called in the test.

The add method is called three times, so verify with times(3) is correct.

🔧 Debug

advanced

Debugging Spy Stubbing Issue

Why does the following test fail with a NullPointerException when stubbing a spy method?

JUnit

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

public class SpyStubTest {
    public static class Service {
        public String getData() { return "real data"; }
    }

    @Test
    public void testStubSpy() {
        Service service = spy(new Service());
        when(service.getData()).thenReturn(null);

        String result = service.getData();
        assert(result == null);
    }
}

A NullPointerException occurs because getData() returns null by default

B Spy object cannot stub any methods, only mocks can

C Using when() on spy calls real method causing NullPointerException; use doReturn() instead

D Test fails because spy was not initialized with MockitoAnnotations

💡 Hint

Consider how Mockito handles stubbing on spies differently than mocks.

When stubbing spy methods, using when() calls the real method immediately, which can cause errors. Using doReturn() avoids calling the real method.

❓ framework

expert

Spy Object Behavior in Integration Testing

In a JUnit integration test using Mockito spies, which statement about spy objects is TRUE?

A Spies allow partial mocking, so real methods run unless stubbed, useful for verifying side effects in integration tests

B Spies completely replace the real object, so no real methods are executed during integration tests

C Spies automatically reset their state after each test without additional configuration

D Spies cannot be used in integration tests because they only work with unit tests

💡 Hint

Think about how spies differ from mocks and their use cases beyond unit tests.

Spies wrap real objects and allow real methods to run unless stubbed, making them useful to verify behavior and side effects in integration tests.