Mockito — mi ez, kulcsfogalmak és működési elv

Mi az a Mockito?

A Mockito egy nyílt forráskódú könyvtár mock-objektumok (álobjektumok) létrehozására Java, Kotlin és más JVM nyelvek egységtesztjeiben. Ellentétben a JUnit-tal, amely a tesztek futtatásáért felelős, a Mockito az elkülönítés problémáját oldja meg — a tesztelt osztály valódi függőségeit kiszámítható objektumokkal helyettesíti.

Mockok nélkül egy adatbázist vagy külső API-t elérő metódus tesztelése a valós környezet beállítását igényli — adatbázis telepítése, szerver indítása. A Mockito ezeket a függőségeket rögzített viselkedésű objektumokkal helyettesíti: a repository.findById(1) metódus mindig egy adott User objektumot ad vissza anélkül, hogy az adatbázishoz fordulna.

A Mockito architektúrája a Proxy mintán alapul (interfészekhez és osztályokhoz). A könyvtár alkategóriát vagy proxyt generál a megadott típushoz, és az összes metódushívást elfogja, alapértelmezett vagy a when().thenReturn() által beállított értékeket adva vissza.

Hogyan működik a Mockito

A Mockito működési elve három alapműveletre épül: mock létrehozása, viselkedés beállítása (stubbing) és hívások ellenőrzése (verification). Minden művelet a org.mockito.Mockito osztály statikus metódusait használja — a Maven Central statisztikái szerint a Java ökoszisztéma legtöbbet töltött osztályát. A mock összes metódushívása rögzítésre kerül a memóriában, lehetővé téve későbbi ellenőrzésüket a verify segítségével.

A teszt három lépése Mockitóval

Egy tipikus Mockitóval írt teszt három fázisból áll: Arrange — mockok létrehozása és stubok beállítása a when().thenReturn() segítségével, Act — a tesztelt metódus meghívása, Assert — az eredmény ellenőrzése assertEquals és verify(mock) segítségével. Ezt a megközelítést AAA-nak (Arrange-Act-Assert) hívják.

Alapvető példa adattár mockkal

Nézzünk egy egyszerű tesztet, ahol a Mockito helyettesíti a felhasználói adattárat. A when().thenReturn() metódus úgy állítja be a mockot, hogy a findById hívás egy előre elkészített User objektumot adjon vissza.

// Létrehozzuk az adattár mockját
UserRepository mockRepo = mock(UserRepository.class);

// Beállítjuk a viselkedést: findById(1) esetén adja vissza a felhasználót
when(mockRepo.findById(1)).thenReturn(new User("Alice"));

// Ellenőrizzük, hogy a metódus tényleg meghívásra került
User result = mockRepo.findById(1);
assertEquals("Alice", result.getName());
verify(mockRepo).findById(1);

Mock-objektumok létrehozása

A Mockito két módot kínál mockok létrehozására: a statikus mock(Class) metódust és a @Mock annotációt a MockitoAnnotations.openMocks() segítségével történő inicializálással. Az első mód tömör egy-két mock esetén, a második akkor kényelmes, ha sok a függőség — az annotációk csökkentik a boilerplate kódot.

A statikus mock() metódussal

A mock() metódus egy osztályt fogad és visszaad egy álobjektumot, amely a when().thenReturn() segítségével állítható be. Az összes nem beállított metódus alapértelmezett értékeket ad vissza: 0 számoknál, false boolean-nál, null objektumoknál.

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

A @Mock annotációval JUnit 5-ben

A @Mock annotáció a @ExtendWith(MockitoExtension.class) -vel kombinálva automatikusan mockokat hoz létre a tesztosztály összes mezőjéhez. A MockitoExtension kiterjesztés felel az inicializálásért minden teszt előtt.

@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: a mock viselkedésének beállítása

A Stubbing annak meghatározása, hogy a mock metódusa mit adjon vissza, amikor meghatározott argumentumokkal hívják. Alap szintaxis: when(mock.method(args)).thenReturn(value). Különböző forgatókönyvekhez a Mockito több then-metódus variációt kínál.

Dinamikus válasz a thenAnswer segítségével

Amikor a visszatérési érték függ a hívás argumentumaitól, a thenAnswer használható lambdával. Ez hasznos a valós adatokkal való munka szimulálásához — például ID generálása az átadott objektum alapján.

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

Verify: a mockkal való interakciók ellenőrzése

A Verify a Mockito egyedi képessége, amelyet a régebbi mock-objektum könyvtárak (EasyMock, jMock) nem nyújtanak.

A Verify megbízhatóbbá teszi a teszteket, mivel nemcsak a visszatérési értéket ellenőrzi, hanem a mellékhatásokat is — azon metódusok hívásait, amelyek nem adnak vissza eredményt (void metódusok). A verify(mock).methodName(args) metódus ellenőrzi, hogy a mock egy adott metódusa a megadott argumentumokkal lett-e meghívva. Ez lehetővé teszi nemcsak az eredmény, hanem a folyamat tesztelését is — a függőség elérésének tényét.

A hívások számának ellenőrzése

Alapértelmezés szerint a verify azt ellenőrzi, hogy a metódus pontosan egyszer lett meghívva. Ha más szám szükséges — a times(n), atLeast(n), never() és más módosítók használhatók a Mockito osztályból.

// Hívások számának ellenőrzése
verify(repository, times(3)).save(any());
verify(repository, never()).delete(any());
verify(repository, atLeastOnce()).findById(1);

// Hívások sorrendjének ellenőrzése
InOrder inOrder = inOrder(repository);
inOrder.verify(repository).save(any());
inOrder.verify(repository).flush();

ArgumentCaptor az argumentumok rögzítésére

Amikor ellenőrizni kell, hogy a metódus pontosan melyik objektummal lett meghívva, az ArgumentCaptor használható. Ez rögzíti az argumentum értékét a hívás során, és lehetővé teszi a mezők külön-külön történő ellenőrzését. Az ArgumentCaptor különösen akkor hasznos, amikor a tesztelt kód belsőleg hoz létre egy objektumot és adja át a függőségnek — ezt az objektumot másképp nem lehet ellenőrizni.

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

@Mock és @InjectMocks annotációk

@Mock és @InjectMocks — a Mockito két kulcsfontosságú annotációja, amelyek jelentősen csökkentik a boilerplate kódot. A @Mock egy mezőhöz hoz létre mockot, a @InjectMocks pedig a tesztosztály összes mockját injektálja a tesztelt objektumba konstruktoron, setteren vagy mezőn keresztül.

A @InjectMocks mechanizmus a következő sorrendben próbálja injektálni a függőségeket: a legtöbb argumentummal rendelkező konstruktor, setter típus alapján, privát mező. Ha egyik mód sem működik — az objektum null függőségekkel marad, és a teszt NullPointerException-nel megbukik.

A @InjectMocks használatának szabályai

Fontos megérteni: a @InjectMocks nem elemzi a mezők típusait — bármilyen, típusban kompatibilis mockot behelyez. Ha az osztályban két azonos típusú mező van — a Mockito rossz mockot injektálhat. Ilyen esetekben ajánlott explicit konstruktor használata a mockok átadásával.

Mockito Android projektekben

Az Android fejlesztésben a Mockito a JUnit-tal együtt használatos ViewModel, Repository és UseCase tesztelésére. Mivel ezek az osztályok a JVM-en futnak Android kontextus nélkül, a Mockito a függőségeiket — Room DAO, Retrofit API, SharedPreferences — kiszámítható viselkedésű stubokkal helyettesíti.

Gradle beállítás a Mockitóhoz

A Mockito Android projekthez adásához elegendő a mockito-core vagy mockito-inline függőséget hozzáadni (utóbbi támogatja a végleges osztályok és statikus metódusok mockolását). Az 5.12.0 verzió (2024) tartalmazza a Java 21 támogatását és a JUnit 5-tel való továbbfejlesztett integrációt.

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

Mockito és PowerMock: elavult gyakorlat

Korábban a statikus metódusok és konstruktorok mockolásához PowerMock kellett — egy bájtkód-instrumentáción keresztül működő kiterjesztés. A Mockito 5.x-től kezdve a mockito-inline segítségével ez a funkció közvetlenül beépítésre került: a mockStatic(ClassName.class) lehetővé teszi a statikus metódusok mockolását további könyvtárak nélkül.

ViewModel tesztelése Mockitóval

Tipikus forgatókönyv: a ViewModel meghívja az adattár metódusát és az eredményt UI állapottá alakítja. A Mockito helyettesíti az adattárat, a teszt pedig ellenőrzi, hogy a ViewModel helyesen kezeli-e a sikeres választ és a hibát. A Clean Architecture használatakor minden réteghez létrehoznak mockokat: DataSource, Repository és UseCase — ez lehetővé teszi az egyes rétegek elkülönített tesztelését.

• success case — when(repo.getData()).thenReturn(Result.success(data)) → ellenőrizzük a state = Success(data) értéket.
• error case — when(repo.getData()).thenReturn(Result.error(exception)) → ellenőrizzük a state = Error(message) értéket.
• loading state — verify, hogy a ViewModel beállította-e az isLoading = true értéket az adattár meghívása előtt.