Android Academy · Lektion

Mocking mit Mockito

Isolieren Sie Abhängigkeiten mit Mockito und MockK. Simulieren Sie Rückgabewerte, überprüfen Sie Interaktionen, erfassen Sie Argumente und verwenden Sie Spies für partielles Mocking.

Mocking mit Mockito ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Mocking?

Ein Mock ist ein Fake-Objekt, das in Tests eine echte Abhängigkeit ersetzt. Anders als ein Fake (eine funktionsfähige Implementierung im Speicher) wird ein Mock:

automatisch von einer Bibliothek erzeugt
aufzeichnen, welche Methoden mit welchen Argumenten aufgerufen wurden
alles zurückgeben, was Sie festlegen (Stubbing)
Ihnen ermöglichen, Interaktionen nach dem Test zu überprüfen

Mockito-Einrichtung

Fügen Sie Mockito und MockK (eine Kotlin-orientierte Alternative) zu app/build.gradle hinzu:

// app/build.gradle:
testImplementation 'org.mockito:mockito-core:5.10.0'
testImplementation 'org.mockito.kotlin:mockito-kotlin:5.2.1'

// MockK (Kotlin-idiomatic alternative to Mockito):
testImplementation 'io.mockk:mockk:1.13.10'

Mocks erstellen

Erstellen Sie Mocks mit mock() oder der Annotation @Mock:

import org.mockito.kotlin.*

interface UserApi {
    suspend fun fetchUsers(): List<User>
    suspend fun deleteUser(id: Int)
}

class RepositoryTest {

    // Option 1: create inline
    private val api: UserApi = mock()

    // Option 2: use annotation + MockitoJUnit4Runner
    @Mock lateinit var api2: UserApi

    @get:Rule
    val mockitoRule = MockitoJUnit.rule()
}

Stubbing — Rückgabewerte festlegen

Verwenden Sie whenever(mock.method()).thenReturn(value), um festzulegen, was ein Mock zurückgibt:

val api: UserApi = mock()

// Stub a return value:
whenever(api.fetchUsers()).thenReturn(
    listOf(User(1, "Alice"), User(2, "Bob"))
)

// Stub an exception:
whenever(api.fetchUsers()).thenThrow(RuntimeException("Network error"))

// Return different values on consecutive calls:
whenever(api.fetchUsers())
    .thenReturn(emptyList())           // first call
    .thenReturn(listOf(User(1, "Alice"))) // second call

verify() — Interaktionen überprüfen

Verwenden Sie verify(), um zu bestätigen, dass eine Methode aufgerufen wurde — und wie oft:

val api: UserApi = mock()
val repo = UserRepository(api)

repo.refreshUsers()

// Verify that fetchUsers() was called exactly once:
verify(api).fetchUsers()

// Verify called with specific argument:
repo.deleteUser(42)
verify(api).deleteUser(42)

// Verify called exactly 3 times:
verify(api, times(3)).fetchUsers()

// Verify never called:
verify(api, never()).deleteUser(any())

ArgumentCaptor

ArgumentCaptor fängt das an eine Mock-Methode übergebene Argument ab, damit Sie dessen Wert überprüfen können:

val api: UserApi = mock()
val captor = argumentCaptor<User>()

val repo = UserRepository(api)
repo.saveUser(User(1, "Alice"))

verify(api).saveUser(captor.capture())

val captured = captor.firstValue
assertEquals(1, captured.id)
assertEquals("Alice", captured.name)

MockK — Kotlin-orientiertes Mocking

MockK wurde für Kotlin entwickelt und unterstützt Erweiterungsfunktionen, Coroutines und Objekte nativ:

import io.mockk.*

val api = mockk<UserApi>()

// Stub:
every { api.fetchUsers() } returns listOf(User(1, "Alice"))

// Stub suspend function:
coEvery { api.fetchUsers() } returns listOf(User(1, "Alice"))

// Verify:
val repo = UserRepository(api)
runBlocking { repo.refresh() }
coVerify { api.fetchUsers() }

Coroutines mit MockK mocken

Verwenden Sie coEvery und coVerify für Suspend-Funktionen:

val api = mockk<UserApi>()

// Stub suspend function:
coEvery { api.fetchUsers() } returns listOf(User(1, "Alice"))
coEvery { api.deleteUser(any()) } just Runs  // returns Unit

// Test:
runTest {
    val repo = UserRepository(api)
    repo.refresh()
    coVerify(exactly = 1) { api.fetchUsers() }
    coVerify(exactly = 0) { api.deleteUser(any()) }
}

Spy — partielles Mocking

Ein spy umschließt ein echtes Objekt. Standardmäßig werden echte Methoden aufgerufen, sofern sie nicht überschrieben wurden:

// Mockito Spy:
val realList = mutableListOf("a", "b", "c")
val spyList = spy(realList)

// Real method called:
spyList.add("d")
assertEquals(4, spyList.size)   // real add() was called

// Override specific method:
doReturn(99).`when`(spyList).size
assertEquals(99, spyList.size)  // overridden

// MockK Spy:
val spyObj = spyk(RealService())
every { spyObj.expensiveCall() } returns "fake result"

Wann Mocks und wann Fakes verwenden?

Praktische Richtlinien:

Verwenden Sie einen Fake, wenn Sie eine funktionsfähige Implementierung im Speicher benötigen (DAO, Repository) — leichter lesbar, keine Bibliothek erforderlich
Verwenden Sie einen Mock, wenn Sie überprüfen müssen, ob eine bestimmte Methode mit bestimmten Argumenten aufgerufen wurde (Analytics-Ereignisse, API-Aufrufe)
Vermeiden Sie übermäßiges Mocking — wenn Sie alles mocken, überprüfen Ihre Tests die Mocks statt Ihrer Logik

Häufige Fehler

Diese Stolperfallen sollten Sie beim Mocking vermeiden:

Wertobjekte mocken — mocken Sie Schnittstellen oder Abstraktionen, nicht Datenklassen
Zu tief mocken — wenn Sie fünf Mocks in einem Test benötigen, ist der Code zu eng gekoppelt
Nicht überprüfen, wenn die Interaktion wichtig ist — führen Sie nicht nur Stubbing durch, sondern überprüfen Sie die Interaktion auch
Mockito und Kotlin-Standardwerte — Kotlin-Parameter sind standardmäßig nicht null; verwenden Sie mockito-kotlin oder MockK, um unerwartete Nullwerte zu vermeiden

Objekte und Companion-Objekte mocken

MockK kann Kotlin-Objekte und Companion-Objekte mocken — mit Mockito ist das nicht möglich:

object DateProvider {
    fun today(): String = "2024-01-01"
}

// In test:
mockkObject(DateProvider)
every { DateProvider.today() } returns "2099-12-31"

val result = DateProvider.today()
assertEquals("2099-12-31", result)

// Restore after test:
unmockkObject(DateProvider)

Kurze Überprüfung

Welchen Zweck erfüllt verify() in einem Mockito- oder MockK-Test?

Zusammenfassung: Mocking mit Mockito und MockK

Mocks ermöglichen es Ihnen, Verhalten zu isolieren und zu überprüfen:

mock() / mockk() — einen Mock aus einer Schnittstelle oder Klasse erstellen
whenever(...).thenReturn(...) / every { } returns ... — Rückgabewerte festlegen
coEvery / coVerify — für Kotlin-Suspend-Funktionen (MockK)
verify(mock).method(args) — bestätigen, dass die Methode aufgerufen wurde
ArgumentCaptor — Argumente abfangen und untersuchen
spy() / spyk() — partieller Mock eines echten Objekts
Für Daten Fakes bevorzugen; zum Überprüfen von Verhalten Mocks verwenden

Als Nächstes: UI-Tests mit Espresso.

Häufig gestellte Fragen

Ist die Lektion „Mocking mit Mockito“ kostenlos?

Ja — der vollständige Text von „Mocking mit Mockito“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Mocking mit Mockito“?

Isolieren Sie Abhängigkeiten mit Mockito und MockK. Simulieren Sie Rückgabewerte, überprüfen Sie Interaktionen, erfassen Sie Argumente und verwenden Sie Spies für partielles Mocking. Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Mocking mit Mockito“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Android Academy