Spy objects in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Spy object in testing?

A Spy object is a special test double that wraps a real object to record how it is used, allowing verification of method calls while still executing the original methods.

intermediate

How does a Spy differ from a Mock?

A Spy calls the real methods and records interactions, while a Mock replaces the real object and only simulates behavior without calling real methods.

beginner

Show a simple example of creating a Spy in JUnit with Mockito.

Example:

List<String> list = new ArrayList<>();
List<String> spyList = Mockito.spy(list);
spyList.add("test");
Mockito.verify(spyList).add("test");

intermediate

Why use a Spy object instead of a real object in tests?

Using a Spy lets you check how the object is used (like which methods were called) without losing the real behavior, helping to verify interactions and side effects.

advanced

What is a common pitfall when using Spy objects?

A common pitfall is that Spies call real methods, which can cause unwanted side effects or errors if the real methods depend on external systems or state.

What does a Spy object do in a test?

A Calls real methods and records interactions

B Only simulates methods without calling real ones

C Replaces the entire system under test

D Generates random test data

A Spy calls the real methods of the object and records how they are used for verification.

Which library is commonly used with JUnit to create Spy objects?

A Mockito

B JUnitParams

C AssertJ

D Hamcrest

Mockito is a popular mocking framework that supports creating Spy objects in JUnit tests.

What is a risk when using Spy objects in tests?

A Spy objects never call real methods

B Real methods may cause side effects

C Spy objects cannot verify method calls

D Spy objects replace the entire application

Since Spies call real methods, those methods might cause side effects or errors if not handled carefully.

How do you verify a method call on a Spy object in Mockito?

A verifyMethod(spyObject, methodName)

B spyObject.assertCalled()

C Mockito.verify(spyObject).methodName()

D spyObject.checkCall()

Mockito uses the verify() method to check if a method was called on a Spy or Mock.

Which statement is true about Spy objects?

A They do not record method calls

B They completely replace real objects with fake ones

C They cannot be used with JUnit

D They wrap real objects and allow partial mocking

Spies wrap real objects and allow you to mock some methods while keeping others real.

Explain what a Spy object is and when you would use it in testing.

Think about how a Spy lets you check real method calls.

Describe how to create and verify a Spy object in a JUnit test using Mockito.

Remember the example with a List and verify method call.

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