Test doubles, fakes and Mockito

A test double is any object that stands in for a real dependency during a test, as a stunt double stands in for an actor. Test doubles let a test run code that normally talks to a database, an SMS provider or the system clock, without any of them: the test hands the code a double, then checks the result or what the code did with the double. Test doubles come in five kinds. Fakes are working, simplified implementations, such as a repository that keeps its data in a list, and they are usually the best double for an interface your own code defines. Mockito is a widely used Java library that creates stubs, spies and mocks at run time, which suits checking calls to systems you do not control. This lesson tests a desk booking service with a fake, a fixed Clock and Mockito, on JDK 25 with JUnit 6.1.3, AssertJ 3.27.7 and Mockito 5.24.0.

Five kinds of test double

The names come from Gerard Meszaros’s book on xUnit test patterns, as Martin Fowler’s article on mocks and stubs sums them up:

The difference that matters most in practice is between checking state, what the code produced or stored, and checking behaviour, which calls it made. Fakes, stubs and spies support the first; only mocks insist on the second. Tests that check state survive refactorings that keep the result the same, while tests that check every call break whenever the code calls its dependencies differently.

A fake repository and a fixed clock

DeskBookingService books a desk for a day. It refuses a day in the past and a desk that is taken, saves the booking and sends a confirmation. It receives its three dependencies in its constructor, which is what lets a test replace each one.

package com.example.desks;

import java.time.Clock;
import java.time.LocalDate;

/** Books desks in a shared office: never a day in the past, never a desk that is taken. */
public final class DeskBookingService {

    private final BookingRepository bookings;
    private final Notifier notifier;
    private final Clock clock;

    public DeskBookingService(BookingRepository bookings, Notifier notifier, Clock clock) {
        this.bookings = bookings;
        this.notifier = notifier;
        this.clock = clock;
    }

    public Booking book(String member, String desk, LocalDate day) {
        LocalDate today = LocalDate.now(clock); // today where the office is, from the clock it was given
        if (day.isBefore(today)) {
            throw new IllegalArgumentException("cannot book a day in the past: " + day);
        }
        if (bookings.isBooked(desk, day)) {
            throw new IllegalStateException("desk " + desk + " is taken on " + day);
        }
        Booking booking = new Booking(member, desk, day);
        bookings.save(booking);
        notifier.send(member, "Desk " + desk + " is yours on " + day);
        return booking;
    }
}

package com.example.desks;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

/** A fake: a real, working repository that keeps its bookings in a list instead of a database. */
public final class InMemoryBookings implements BookingRepository {

    private final List<Booking> saved = new ArrayList<>();

    @Override
    public boolean isBooked(String desk, LocalDate day) {
        return saved.stream().anyMatch(b -> b.desk().equals(desk) && b.day().equals(day));
    }

    @Override
    public void save(Booking booking) {
        saved.add(booking);
    }

    @Override
    public List<Booking> forMember(String member) {
        return saved.stream().filter(b -> b.member().equals(member)).toList();
    }

    @Override
    public List<Booking> bookingsOn(LocalDate day) {
        return saved.stream().filter(b -> b.day().equals(day)).toList();
    }
}

package com.example.desks;

import java.util.ArrayList;
import java.util.List;

/** A spy written by hand: it does nothing but remember every message it was asked to send. */
public final class RecordingNotifier implements Notifier {

    public final List<String> sent = new ArrayList<>();

    @Override
    public void send(String member, String message) {
        sent.add(member + ": " + message);
    }
}

package com.example.desks;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class DeskBookingServiceTest {

    // 10:00 in the office's time zone: "today" is the same on every computer and in every year
    private static final Clock TEN_AM = Clock.fixed(Instant.parse("2028-03-01T04:30:00Z"), ZoneId.of("Asia/Kolkata"));
    private static final LocalDate TODAY = LocalDate.of(2028, 3, 1);

    private InMemoryBookings bookings;
    private RecordingNotifier notifier;
    private DeskBookingService service;

    @BeforeEach
    void setUp() {
        bookings = new InMemoryBookings();
        notifier = new RecordingNotifier();
        service = new DeskBookingService(bookings, notifier, TEN_AM);
    }

    @Test
    void booksAFreeDeskAndConfirmsIt() {
        service.book("asha", "D-12", TODAY);

        assertThat(bookings.forMember("asha")).containsExactly(new Booking("asha", "D-12", TODAY));
        assertThat(notifier.sent).containsExactly("asha: Desk D-12 is yours on 2028-03-01");
    }

    @Test
    void refusesADeskThatIsTaken() {
        service.book("asha", "D-12", TODAY);

        assertThatThrownBy(() -> service.book("ravi", "D-12", TODAY)).isInstanceOf(IllegalStateException.class);
        assertThat(bookings.forMember("ravi")).isEmpty();
        assertThat(notifier.sent).hasSize(1);
    }

    @Test
    void refusesYesterday() {
        assertThatThrownBy(() -> service.book("asha", "D-12", TODAY.minusDays(1)))
                .hasMessage("cannot book a day in the past: 2028-02-29");
        assertThat(notifier.sent).isEmpty();
    }
}

from session import launch, libraries, run

libraries("desks")
run(f"""
cd desks
ls lib
javac -d classes -cp 'lib/*' com/example/desks/*.java
# The fake repository and the hand-written spy: no mocking library involved.
{launch("--select-class com.example.desks.DeskBookingServiceTest", agent=False)}
# Mockito doubles, with Mockito attached as a Java agent when the JVM starts.
{launch("--select-class com.example.desks.ConfirmationTest")}
""")

$ cd desks
$ ls lib
assertj-core-3.27.7.jar
byte-buddy-1.17.7.jar
byte-buddy-agent-1.17.7.jar
junit-platform-console-standalone-6.1.3.jar
mockito-core-5.24.0.jar
mockito-junit-jupiter-5.24.0.jar
objenesis-3.3.jar
$ javac -d classes -cp 'lib/*' com/example/desks/*.java
# The fake repository and the hand-written spy: no mocking library involved.
$ java -cp 'lib/*:classes' org.junit.platform.console.ConsoleLauncher execute --select-class com.example.desks.DeskBookingServiceTest --include-engine junit-jupiter --disable-banner
╷
└─ JUnit Jupiter ✔
   └─ DeskBookingServiceTest ✔
      ├─ refusesYesterday() ✔
      ├─ refusesADeskThatIsTaken() ✔
      └─ booksAFreeDeskAndConfirmsIt() ✔

Test run finished after … ms
[         2 containers found      ]
[         0 containers skipped    ]
[         2 containers started    ]
[         0 containers aborted    ]
[         2 containers successful ]
[         0 containers failed     ]
[         3 tests found           ]
[         0 tests skipped         ]
[         3 tests started         ]
[         0 tests aborted         ]
[         3 tests successful      ]
[         0 tests failed          ]

# Mockito doubles, with Mockito attached as a Java agent when the JVM starts.
$ java -javaagent:lib/mockito-core-5.24.0.jar -cp 'lib/*:classes' org.junit.platform.console.ConsoleLauncher execute --select-class com.example.desks.ConfirmationTest --include-engine junit-jupiter --disable-banner
OpenJDK 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
╷
└─ JUnit Jupiter ✔
   └─ ConfirmationTest ✔
      ├─ sendsNothingWhenTheDeskIsTaken() ✔
      └─ sendsOneConfirmation() ✔

Test run finished after … ms
[         2 containers found      ]
[         0 containers skipped    ]
[         2 containers started    ]
[         0 containers aborted    ]
[         2 containers successful ]
[         0 containers failed     ]
[         2 tests found           ]
[         0 tests skipped         ]
[         2 tests started         ]
[         0 tests aborted         ]
[         2 tests successful      ]
[         0 tests failed          ]

InMemoryBookings is a fake: save a booking and it really answers that the desk is taken that day, so the second test could book a desk and then try again. RecordingNotifier is a spy: it sends nothing and remembers every message, so a test can read exactly what a member would have received. Clock.fixed(…) stubs time: the service asks LocalDate.now(clock), and the answer is the same day on every computer, in every time zone and in every year, so refusesYesterday knows which day yesterday was. All three tests used only plain Java objects, without any mocking library.

A first Mockito test

ConfirmationTest checks the same service with Mockito, which ran second in the session above:

package com.example.desks;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import org.junit.jupiter.api.Test;

/** The same service with Mockito doubles: a stubbed repository and a mock notifier whose calls are verified. */
class ConfirmationTest {

    private static final Clock TEN_AM = Clock.fixed(Instant.parse("2028-03-01T04:30:00Z"), ZoneId.of("Asia/Kolkata"));
    private static final LocalDate TODAY = LocalDate.of(2028, 3, 1);

    @Test
    void sendsOneConfirmation() {
        BookingRepository bookings = mock(BookingRepository.class); // every method answers false, 0, null or empty
        Notifier notifier = mock(Notifier.class);
        DeskBookingService service = new DeskBookingService(bookings, notifier, TEN_AM);

        service.book("asha", "D-12", TODAY);

        verify(notifier).send("asha", "Desk D-12 is yours on 2028-03-01");
    }

    @Test
    void sendsNothingWhenTheDeskIsTaken() {
        BookingRepository bookings = mock(BookingRepository.class);
        when(bookings.isBooked("D-12", TODAY)).thenReturn(true);
        Notifier notifier = mock(Notifier.class);
        DeskBookingService service = new DeskBookingService(bookings, notifier, TEN_AM);

        assertThrows(IllegalStateException.class, () -> service.book("ravi", "D-12", TODAY));

        verify(notifier, never()).send(anyString(), anyString());
    }
}

mock(Notifier.class) creates an object that implements the interface and records every call. An unstubbed method returns a default, false, 0, an empty collection or null, which is why the repository mock answered that the desk was free. when(…).thenReturn(…) stubs one answer for one set of arguments. verify(notifier).send(…) passes only if that call happened exactly once, and never() checks that it did not happen at all.

The session started the JVM with -javaagent:lib/mockito-core-5.24.0.jar. On Java 21 and later, Mockito’s documentation asks for this setup, because the JDK now warns when a library attaches itself as an agent while the program runs. The line about class sharing is a note from the JVM: Mockito added classes to the boot class path, so the JVM now uses its archive of prepared classes (class data sharing) for the boot loader’s classes only, which costs a little start-up time and nothing else.

The table leads to a rule of thumb: use mocks where the call is the behaviour, such as “a confirmation was sent once”, and real objects or fakes elsewhere. Mockito’s own documentation tells readers not to mock a List but to use a real one. Mock types you do not own, such as a vendor’s SDK, sparingly, and write fakes for the interfaces your code defines.

Four Mockito tools that the rest of this lesson uses, in one sentence each:

• Argument matchers such as anyString() and eq(…) match arguments by a rule instead of by equals.
• ArgumentCaptor records the argument of a call so that the test can check it afterwards.
• MockitoExtension creates @Mock fields for each test and fails tests whose stubs were never used.
• A contract test is one set of tests run against both the fake and the real implementation.

Mockito in depth: the extension, captors and strict stubs Pro: opens with a Pro, Premium or Ultimate pass

When mocks hurt: a refactoring, a lying fake and contract tests Pro: opens with a Pro, Premium or Ultimate pass

Mockito on JDK 25, its Maven setup and a slow-service exercise Pro: opens with a Pro, Premium or Ultimate pass

Interview questions

Key takeaways

• A test double replaces a real dependency in a test: a dummy, a stub, a spy, a mock or a fake.
• Prefer checking state with fakes and stubs; use mocks where the call itself is the behaviour.
• Inject a Clock and give tests Clock.fixed(…), so “today” is the same everywhere.
• Mockito’s mock, when(…).thenReturn(…) and verify(…) stub and check calls; attach Mockito as a Java agent on JDK 21 and later.