مراقبة الكائنات الحقيقية

In Mockito, you've learned to create mocks to fully control object behavior. But what if you only want to change a few methods while keeping the original behavior for others?

That's where spies come in! A spy wraps a real object, allowing you to:

• Call the object's actual methods by default.
• Override (stub) specific methods to return predefined values.
• Verify interactions with the real object.

Think of it as 'partial mocking' – using the real thing, but with a few tweaks.

Creating a spy is straightforward. Instead of Mockito.mock(), you use Mockito.spy() and pass in an instance of the real object you want to spy on.

Let's define a simple DataService class we'll use for our examples. This service will perform some operations.

The key characteristic of a spy is that, by default, it will call the actual methods of the object it's wrapping. This is different from a mock, which has no real implementation and returns default values.

Let's see our spyService call a real method:

While spies call real methods by default, you can still stub them to return specific values or throw exceptions, just like with mocks. This lets you control parts of the object's behavior.

However, when stubbing a spy, it's often safer to use doReturn().when() syntax:

• Mockito.when(spy.method()).thenReturn(value) might execute the real method first if it's called during the when() part.
• Mockito.doReturn(value).when(spy).method() avoids calling the real method during stubbing, which is crucial if the real method has side effects or throws exceptions.

Let's stub our spyService's fetchData method to return a custom value for a specific ID, while other calls still go to the real method:

Just like with mocks, you can use Mockito.verify() to ensure that certain methods were called on your spy. This is powerful for confirming that your code interacts with the real object as expected.

verify() works exactly the same for spies as it does for mocks. You can check:

• If a method was called.
• How many times it was called.
• With what arguments it was called.

Let's verify that our fetchData method was called on the spy, even when it executed its real implementation:

It's crucial to understand when to use a spy versus a traditional mock:

• Mocks: Create a completely fake object. All methods are 'empty' and return default values unless you explicitly stub them. Ideal for isolating the unit under test.
• Spies: Wrap a real object. All methods execute their actual implementation unless you explicitly stub them. Useful when you want to use most of the real object's behavior but control a few specific interactions.

Prefer mocks for true unit isolation. Use spies when dealing with complex objects where only a few methods need to be controlled, or for legacy code.

Spies are particularly useful in scenarios where:

• You're testing a class that interacts with a complex dependency, and you only need to override a small part of that dependency's behavior.
• You have a legacy class with many methods, and creating a full mock would be tedious, but you need to ensure some methods are called or return specific values.
• You want to test partial behavior of a real object without fully replacing it.

However, use them sparingly. Over-reliance on spies can lead to less isolated tests that are harder to maintain.

You've successfully learned about Mockito spies!

• Spies wrap real objects, allowing you to use their actual methods by default.
• You create them with Mockito.spy(realObject).
• You can stub specific methods using doReturn().when(spy).method() to override their behavior.
• You can verify interactions on spies using Mockito.verify(), just like with mocks.
• Use spies carefully, primarily when partial control over a real object is needed, rather than full isolation.

This flexibility helps you write more targeted tests for complex scenarios.