@Spy for partial mocking in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a spy object for partial mocking.

JUnit

List<String> list = Mockito.[1](new ArrayList<>());

Drag options to blanks, or click blank then click option'

Amock

Bverify

Cspy

Dwhen

Attempts:

3 left

💡 Hint

Common Mistakes

Using mock() instead of spy() causes full mocking, not partial.

Using verify() or when() here is incorrect as they are for verification and stubbing.

The @Spy annotation or Mockito.spy() method creates a spy object that allows partial mocking of real objects.

2fill in blank

medium

Complete the code to stub a method on a spy object.

JUnit

Mockito.[1](spyList.size()).thenReturn(5);

Drag options to blanks, or click blank then click option'

Awhen

BdoReturn

Cverify

Dspy

Attempts:

3 left

💡 Hint

Common Mistakes

Using doReturn() without when() can cause confusion in spies.

Using verify() is for checking calls, not stubbing.

Use when() to stub methods on spy objects for partial mocking.

3fill in blank

hard

Fix the error in stubbing a spy method to avoid calling the real method.

JUnit

Mockito.[1](10).when(spyList).size();

Drag options to blanks, or click blank then click option'

Awhen

Bspy

Cverify

DdoReturn

Attempts:

3 left

💡 Hint

Common Mistakes

Using when() on spies calls the real method, which may cause errors.

Using verify() does not stub methods.

Using doReturn() avoids calling the real method on a spy during stubbing, preventing side effects.

4fill in blank

hard

Fill both blanks to stub a spy method without calling the real method.

JUnit

Mockito.[1](10).when(spyList).[2]();

Drag options to blanks, or click blank then click option'

AdoReturn

Bwhen

Csize

Dclear

Attempts:

3 left

💡 Hint

Common Mistakes

Using when() instead of doReturn() causes the real method to be called.

Using clear() instead of size() changes the method being stubbed.

Use doReturn(10).when(spyList).size() to stub the size() method on a spy without calling the real method.

5fill in blank

hard

Fill both blanks to verify a method call on a spy with a specific argument.

JUnit

Mockito.[1](spyList).[2]("test");

Drag options to blanks, or click blank then click option'

Averify

Badd

Cremove

Dclear

Attempts:

3 left

💡 Hint

Common Mistakes

Using doReturn() or when() instead of verify() for checking calls.

Using remove() or clear() instead of add() changes the method verified.

Use verify(spyList).add("test") to check that the add method was called with argument "test" on the spy.

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