Spy objects in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a spy of the List class using Mockito.

JUnit

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

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

Aspy

Bmock

Cverify

Dwhen

Attempts:

3 left

💡 Hint

Common Mistakes

Using mock() instead of spy() will create a mock without real method calls.

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

Mockito.spy() creates a spy object that wraps a real instance, allowing you to track interactions while keeping original behavior.

2fill in blank

medium

Complete the code to verify that the add method was called once on the spyList.

JUnit

Mockito.[1](spyList).add("item");

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

Awhen

Bspy

Cverify

Dmock

Attempts:

3 left

💡 Hint

Common Mistakes

Using when() instead of verify() confuses stubbing with verification.

Using spy() or mock() here is incorrect because they create objects, not verify calls.

Mockito.verify() is used to check if a method was called on a mock or spy object.

3fill in blank

hard

Fix the error in stubbing the size method of spyList to return 5.

JUnit

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

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

Awhen

Bverify

Cspy

DdoReturn

Attempts:

3 left

💡 Hint

Common Mistakes

Using when(spyList.size()) calls the real method immediately, which can cause errors.

Using verify() or spy() here is incorrect for stubbing.

When stubbing spy methods, doReturn().when() is preferred to avoid calling the real method during stubbing.

4fill in blank

hard

Fill both blanks to stub the get method of spyList to return "mocked" for index 0.

JUnit

Mockito.[1]("mocked").when(spyList).[2](0);

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

AdoReturn

Bwhen

Cget

Dspy

Attempts:

3 left

💡 Hint

Common Mistakes

Using when() in the first blank causes the real method to be called during stubbing.

Using spy() or verify() in blanks is incorrect here.

doReturn(value).when(spy).method(args) is the correct pattern to stub spy methods. Here, get(0) is stubbed to return "mocked".

5fill in blank

hard

Fill all three blanks to verify that the clear method was called exactly twice on spyList.

JUnit

Mockito.[1](spyList, Mockito.[2](2)).[3]();

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

Averify

Btimes

Cclear

Dspy

Attempts:

3 left

💡 Hint

Common Mistakes

Using spy() in the first blank instead of verify().

Using times() incorrectly or omitting it causes wrong verification.

Using wrong method name in the third blank.

verify(mock, times(n)).method() checks that method was called n times on the mock or spy.

Practice

1. What is the main purpose of using a spy object in JUnit testing?

easy

A. To generate random data for testing

B. To completely replace the real object with a fake one

C. To observe real object behavior and verify method calls

D. To speed up test execution by skipping method calls

Solution

1. Step 1: Understand spy object behavior

   A spy wraps a real object, allowing it to behave normally while tracking interactions.

2. Step 2: Identify spy's main use

   Spies let you verify if certain methods were called without changing the real behavior.

3. Final Answer:

   To observe real object behavior and verify method calls -> Option C

4. Quick Check:

   Spy = observe real + verify calls [OK]

Hint: Spy watches real object calls without changing behavior [OK]

Common Mistakes:

• Confusing spy with mock that replaces behavior
• Thinking spy speeds up tests by skipping calls
• Believing spy generates test data

2. Which of the following is the correct way to create a spy object using Mockito in JUnit?

easy

A. MyClass spy = Mockito.spy(new MyClass());

B. MyClass spy = Mockito.mock(MyClass.class);

C. MyClass spy = new MyClass();

D. MyClass spy = Mockito.verify(new MyClass());

Solution

1. Step 1: Recall Mockito spy syntax

   Mockito creates a spy by wrapping a real instance: Mockito.spy(realObject).

2. Step 2: Match options to syntax

   MyClass spy = Mockito.spy(new MyClass()); correctly uses Mockito.spy(new MyClass()) to create a spy.

3. Final Answer:

   MyClass spy = Mockito.spy(new MyClass()); -> Option A

4. Quick Check:

   Spy creation = Mockito.spy(real instance) [OK]

Hint: Spy wraps real instance with Mockito.spy() [OK]

Common Mistakes:

• Using Mockito.mock() instead of spy()
• Trying to spy without a real instance
• Confusing verify() with spy()

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

List<String> list = new ArrayList<>();
List<String> spyList = Mockito.spy(list);
spyList.add("apple");
spyList.add("banana");
Mockito.verify(spyList).add("apple");
System.out.println(spyList.size());

medium

A. 0

B. Throws an exception

C. 1

D. 2

Solution

1. Step 1: Understand spy behavior on add()

   Spy calls real methods, so add("apple") and add("banana") add elements to the list.

2. Step 2: Verify method call and size

   Verification confirms add("apple") was called. The list now contains two elements, so size() returns 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Spy calls real methods, size = 2 [OK]

Hint: Spy calls real methods; size reflects added elements [OK]

Common Mistakes:

• Assuming spy does not call real methods
• Expecting size to be 0 after add calls
• Confusing verify with changing behavior

4. Identify the error in the following test code using a spy:

List<String> list = new ArrayList<>();
List<String> spyList = Mockito.spy(list);
Mockito.when(spyList.size()).thenReturn(5);
spyList.add("orange");
System.out.println(spyList.size());

medium

A. Spy must be created with Mockito.mock()

B. Cannot stub spy methods with Mockito.when() directly

C. List cannot be spied because it's an interface

D. No error; output will be 1

Solution

1. Step 1: Recognize stubbing on spy

   Stubbing spy methods with Mockito.when() can cause real method calls and errors.

2. Step 2: Correct stubbing approach

   Use doReturn(5).when(spyList).size() to stub spy methods safely.

3. Final Answer:

   Cannot stub spy methods with Mockito.when() directly -> Option B

4. Quick Check:

   Spy stubbing = use doReturn() not when() [OK]

Hint: Stub spy methods with doReturn(), not when() [OK]

Common Mistakes:

• Using Mockito.when() on spy causing real calls
• Confusing spy creation with mock creation
• Thinking interfaces can't be spied

5. You want to test a service method that calls a repository's save() method. You want to keep the real repository behavior but verify save() was called exactly once. Which is the best approach using spy objects?

hard

A. Create a spy of the repository, call the service method, then verify save() was called once

B. Mock the repository and stub save() to do nothing, then verify call count

C. Use a real repository without spy or mock and check database manually

D. Create a mock repository and verify save() was never called

Solution

1. Step 1: Understand spy use case

   Spy lets real methods run while tracking calls, perfect for verifying save() without changing behavior.

2. Step 2: Apply spy to repository and verify

   Create spy of repository, call service method, then verify save() was called once.

3. Final Answer:

   Create a spy of the repository, call the service method, then verify save() was called once -> Option A

4. Quick Check:

   Spy = real behavior + verify calls [OK]

Hint: Spy real repo to verify calls without changing behavior [OK]

Common Mistakes:

• Mocking instead of spying loses real behavior
• Checking database manually is slow and unreliable
• Verifying save was never called contradicts test goal