Mockk für Kotlin: Vollständiges Tutorial mit Beispielen

Einführung in Mockk: Was ist das und warum wird es benötigt?

Mockk ist eine moderne Bibliothek zum Mocken (Erstellen von Objektimitationen) in der Programmiersprache Kotlin. Sie wurde speziell unter Berücksichtigung der Besonderheiten von Kotlin entwickelt: Nullability, Erweiterungsfunktionen, Coroutinen, Companion-Objekte und andere Funktionen, die in Java nicht vorhanden sind.

Wofür wird die Mockk-Bibliothek benötigt? Beim Schreiben von Unit-Tests stoßen wir oft auf Situationen, in denen die zu testende Klasse von anderen Klassen, Diensten, Datenbanken oder externen APIs abhängt. Um den zu testenden Code zu isolieren und Tests schnell, zuverlässig und unabhängig von externen Faktoren zu machen, erstellen wir "Mocks" (Mock-Objekte) – Platzhalterobjekte, die das Verhalten der realen Abhängigkeiten imitieren.

Die wichtigsten Funktionen von Mockk:

• Erstellung von Mocks für Klassen, Interfaces und Objekte
• Unterstützung von Annotationen (@MockK, @RelaxedMockK, @SpyK)
• Arbeit mit Coroutinen (coEvery, coVerify)
• Mocken von Erweiterungsfunktionen
• Mocken von statischen Methoden und Companion-Objekten
• Unterstützung von Slots und Argument-Capturing
• Unterstützung von partiellem Mocking (Spy)

Installation von Mockk

Mockk wird über Maven Central vertrieben. Fügen Sie die Abhängigkeit in Ihre build.gradle.kts-Datei ein (für Gradle mit Kotlin DSL):

// build.gradle.kts
dependencies {
    testImplementation("io.mockk:mockk:1.13.10")
}

Für Gradle mit Groovy DSL:

// build.gradle
dependencies {
    testImplementation "io.mockk:mockk:1.13.10"
}

Für Maven:

<dependency>
    <groupId>io.mockk</groupId>
    <artifactId>mockk</artifactId>
    <version>1.13.10</version>
    <scope>test</scope>
</dependency>

Wenn Sie Coroutinen verwenden, müssen Sie nichts zusätzlich einbinden – die Coroutinen-Unterstützung ist in Mockk integriert.

Schnellstart mit einem Code-Beispiel

Betrachten wir ein einfaches Beispiel. Angenommen, wir haben einen Service UserService, der von einem Repository UserRepository abhängt:

// Zu testende Klassen
class UserRepository {
    fun findById(id: Long): String {
        // Echte Implementierung greift auf die Datenbank zu
        return "Real User"
    }
}

class UserService(private val repository: UserRepository) {
    fun getUserName(id: Long): String {
        val user = repository.findById(id)
        return if (user.isNotEmpty()) user else "Unknown"
    }
}

Jetzt schreiben wir einen Test mit Mockk:

import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import org.junit.jupiter.api.Test

class UserServiceTest {

    @Test
    fun `getUserName sollte den Benutzernamen aus dem Repository zurückgeben`() {
        // 1. Erstellen eines Mocks für das Repository
        val mockRepository = mockk<UserRepository>()
        
        // 2. Definieren des Mock-Verhaltens
        every { mockRepository.findById(1L) } returns "John Doe"
        
        // 3. Erstellen des zu testenden Objekts mit dem Mock
        val service = UserService(mockRepository)
        
        // 4. Aufruf der zu testenden Methode
        val result = service.getUserName(1L)
        
        // 5. Überprüfen des Ergebnisses
        assert(result == "John Doe")
        
        // 6. Überprüfen, ob die Methode genau 1 Mal aufgerufen wurde
        verify(exactly = 1) { mockRepository.findById(1L) }
    }
}

Wichtige Methoden und Funktionen von Mockk

Betrachten wir 10 Schlüsselmethode der Bibliothek mit detaillierter Beschreibung und Beispielen.

1. mockk() – Erstellen eines Mock-Objekts

Was es tut: Erstellt ein Mock-Objekt für die angegebene Klasse oder das Interface. Alle Methoden des Mocks geben standardmäßig Standardwerte (null, 0, false) zurück und werfen eine Ausnahme, wenn kein Verhalten definiert ist.

Parameter:

• cls: KClass<T>