Mockito — co to je, klíčové pojmy a princip fungování

Co je Mockito?

Mockito je knihovna s otevřeným zdrojovým kódem pro vytváření mock-objektů (atrap) v jednotkových testech v Javě, Kotlinu a dalších JVM jazycích. Na rozdíl od JUnit, který je zodpovědný za spouštění testů, Mockito řeší problém izolace — nahrazuje skutečné závislosti testované třídy předvídatelnými objekty.

Bez mocků vyžaduje testování metody, která přistupuje k databázi nebo externímu API, nastavení skutečného prostředí — nasazení DB, spuštění serveru. Mockito nahrazuje tyto závislosti objekty s pevným chováním: metoda repository.findById(1) vždy vrací určitý objekt User, aniž by přistupovala k databázi.

Architektura Mockito je založena na vzoru Proxy (pro rozhraní a třídy). Knihovna generuje podtřídu nebo proxy pro zadaný typ a zachycuje všechna volání metod, vracející výchozí hodnoty nebo hodnoty nastavené pomocí when().thenReturn().

Jak Mockito funguje

Princip fungování Mockito je založen na třech základních operacích: vytvoření mocku, nastavení chování (stubbing) a ověření volání (verification). Každá operace používá statické metody z třídy org.mockito.Mockito — nejvíce načítané třídy v ekosystému Java podle statistik Maven Central. Všechna volání metod mocku jsou zaznamenávána v paměti, což umožňuje pozdější kontrolu pomocí verify.

Tři kroky testu s Mockito

Typický test s Mockito se skládá ze tří fází: Arrange — vytvoření mocků a nastavení stubů pomocí when().thenReturn(), Act — volání testované metody, Assert — kontrola výsledku pomocí assertEquals a verify(mock). Tento přístup se nazývá AAA (Arrange-Act-Assert).

Základní příklad s mockem úložiště

Podívejme se na jednoduchý test, kde Mockito nahrazuje úložiště uživatelů. Metoda when().thenReturn() nastavuje mock tak, aby volání findById vracelo předem připravený objekt User.

// Vytváříme mock úložiště
UserRepository mockRepo = mock(UserRepository.class);

// Nastavujeme chování: při findById(1) vrať uživatele
when(mockRepo.findById(1)).thenReturn(new User("Alice"));

// Kontrolujeme, že metoda byla skutečně volána
User result = mockRepo.findById(1);
assertEquals("Alice", result.getName());
verify(mockRepo).findById(1);

Vytváření mock-objektů

Mockito poskytuje dva způsoby vytváření mocků: statickou metodu mock(Class) a anotaci @Mock s inicializací pomocí MockitoAnnotations.openMocks(). První způsob je kompaktní pro jeden-dva mocky, druhý je pohodlný, když je závislostí mnoho — anotace snižují boilerplate kód.

Pomocí statické metody mock()

Metoda mock() přijímá třídu a vrací objekt-atrapu, který lze nastavit pomocí when().thenReturn(). Všechny nenastavené metody vracejí výchozí hodnoty: 0 pro čísla, false pro boolean, null pro objekty.

ApiClient apiClient = mock(ApiClient.class);
Database database = mock(Database.class);

Pomocí anotace @Mock s JUnit 5

Anotace @Mock v kombinaci s @ExtendWith(MockitoExtension.class) automaticky vytváří mocky pro všechna pole testovací třídy. Rozšíření MockitoExtension je zodpovědné za inicializaci před každým testem.

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void getUserShouldReturnUserFromRepo() {
        when(userRepository.findById(1)).thenReturn(new User("Alice"));
        User result = userService.getUser(1);
        assertEquals("Alice", result.getName());
    }
}

Stubbing: nastavení chování mocku

Stubbing — proces určení toho, co má metoda mocku vrátit při volání s určitými argumenty. Základní syntaxe: when(mock.method(args)).thenReturn(value). Pro různé scénáře Mockito nabízí několik variant then-metod.

Dynamická odpověď pomocí thenAnswer

Když návratová hodnota závisí na argumentech volání, používá se thenAnswer s lambdou. To je užitečné pro simulaci práce s reálnými daty — například generování ID na základě předaného objektu.

when(repository.save(any())).thenAnswer(invocation -> {
    User user = invocation.getArgument(0);
    user.setId(42);
    return user;
});

Verify: ověření interakcí s mockem

Verify je jedinečná schopnost Mockito, kterou starší knihovny mock-objektů (EasyMock, jMock) neposkytují.

Verify dělá testy spolehlivějšími, protože kontroluje nejen návratovou hodnotu, ale také vedlejší efekty — volání metod, které nevracejí výsledek (void metody). Metoda verify(mock).methodName(args) ověřuje, zda byla určitá metoda mocku volána se zadanými argumenty. To umožňuje testovat nejen výsledek, ale také proces — fakt obrácení se na závislost.

Kontrola počtu volání

Ve výchozím nastavení verify kontroluje, že metoda byla volána právě jednou. Pokud je potřeba jiný počet — používají se times(n), atLeast(n), never() a další modifikátory z třídy Mockito.

// Kontrola počtu volání
verify(repository, times(3)).save(any());
verify(repository, never()).delete(any());
verify(repository, atLeastOnce()).findById(1);

// Kontrola pořadí volání
InOrder inOrder = inOrder(repository);
inOrder.verify(repository).save(any());
inOrder.verify(repository).flush();

ArgumentCaptor pro zachycení argumentů

Když je třeba ověřit, s jakým přesným objektem byla metoda volána, používá se ArgumentCaptor. Ten zachycuje hodnotu argumentu během volání a umožňuje kontrolovat jeho pole samostatně. ArgumentCaptor je zvláště užitečný, když testovaný kód vytváří objekt uvnitř sebe a předává jej závislosti — tento objekt nelze jinak zkontrolovat.

ArgumentCaptor<User> captor = ArgumentCaptor.forClass(User.class);
verify(repository).save(captor.capture());
assertEquals("Alice", captor.getValue().getName());

Anotace @Mock a @InjectMocks

@Mock a @InjectMocks — dvě klíčové anotace Mockito, které výrazně snižují boilerplate kód. @Mock vytváří mock pro pole a @InjectMocks vkládá všechny mocky z testovací třídy do testovaného objektu pomocí konstruktoru, setteru nebo pole.

Mechanismus @InjectMocks se pokouší vložit závislosti v následujícím pořadí: konstruktor s největším počtem argumentů, setter podle typu, soukromé pole. Pokud žádný způsob nefunguje — objekt zůstává s null závislostmi a test selže s NullPointerException.

Pravidla používání @InjectMocks

Je důležité pochopit: @InjectMocks neanalyzuje typy polí — vkládá jakýkoli mock kompatibilní podle typu. Pokud třída obsahuje dvě pole stejného typu — Mockito může vložit nesprávný mock. V takových případech se doporučuje použít explicitní konstruktor s předáním mocků.

Mockito v Android projektech

V Android vývoji se Mockito používá společně s JUnit pro testování ViewModel, Repository a UseCase. Protože tyto třídy běží na JVM bez Android kontextu, Mockito nahrazuje jejich závislosti — Room DAO, Retrofit API, SharedPreferences — stuby s předvídatelným chováním.

Nastavení Gradle pro Mockito

Pro přidání Mockito do Android projektu stačí přidat závislost mockito-core nebo mockito-inline (ta podporuje mockování finálních tříd a statických metod). Verze 5.12.0 (2024) zahrnuje podporu Java 21 a vylepšenou integraci s JUnit 5.

// build.gradle.kts (modul)
dependencies {
    testImplementation("org.mockito:mockito-core:5.12.0")
    testImplementation("org.mockito:mockito-junit-jupiter:5.12.0")
}

Mockito a PowerMock: zastaralá praxe

Dříve bylo pro mockování statických metod a konstruktorů vyžadováno PowerMock — rozšíření pracující pomocí bytecode instrumentace. Od Mockito 5.x s mockito-inline je tato funkce vestavěna přímo: mockStatic(ClassName.class) umožňuje mockovat statické metody bez dalších knihoven.

Testování ViewModel s Mockito

Typický scénář: ViewModel volá metodu úložiště a transformuje výsledek do UI stavu. Mockito nahrazuje úložiště a test kontroluje, že ViewModel správně zpracovává úspěšnou odpověď a chybu. Při použití Clean Architecture se vytvářejí mocky pro každou vrstvu: DataSource, Repository a UseCase — to umožňuje testovat každou vrstvu izolovaně.

• success case — when(repo.getData()).thenReturn(Result.success(data)) → kontrolujeme state = Success(data).
• error case — when(repo.getData()).thenReturn(Result.error(exception)) → kontrolujeme state = Error(message).
• loading state — verify, že ViewModel nastavil isLoading = true před voláním úložiště.