Mockk Kotlin : méthodes, exemples, installation

Introduction à Mockk : qu'est-ce que c'est et pourquoi l'utiliser

Mockk est une bibliothèque moderne de simulation (création d'objets factices) pour le langage de programmation Kotlin. Elle a été spécialement conçue pour tirer parti des spécificités de Kotlin : la nullabilité, les fonctions d'extension, les coroutines, les objets compagnons et d'autres fonctionnalités absentes en Java.

Pourquoi utiliser la bibliothèque Mockk ? Lors de l'écriture de tests unitaires, nous rencontrons souvent des situations où la classe testée dépend d'autres classes, services, bases de données ou API externes. Pour isoler le code testé et rendre les tests rapides, fiables et indépendants des facteurs externes, nous créons des "mocks" (objets simulés) — des objets factices qui imitent le comportement des dépendances réelles.

Principales fonctionnalités de Mockk :

Création de mocks pour les classes, interfaces et objets
Prise en charge des annotations (@MockK, @RelaxedMockK, @SpyK)
Gestion des coroutines (coEvery, coVerify)
Simulation des fonctions d'extension
Simulation des méthodes statiques et des objets compagnons
Prise en charge des slots et de la capture d'arguments
Prise en charge de la simulation partielle (spy)

Installation de Mockk

Mockk est distribué via Maven Central. Pour l'ajouter à votre projet, incluez la dépendance dans le fichier build.gradle.kts (pour Gradle avec Kotlin DSL) :

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

Pour Gradle avec Groovy DSL :

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

Pour Maven :

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

Si vous utilisez les coroutines, aucune dépendance supplémentaire n'est nécessaire — la prise en charge des coroutines est intégrée dans Mockk.

Démarrage rapide avec un exemple de code

Prenons un exemple simple. Supposons que nous ayons un service UserService qui dépend d'un dépôt UserRepository :

// Classes à tester
class UserRepository {
    fun findById(id: Long): String {
        // L'implémentation réelle accède à la base de données
        return "Utilisateur réel"
    }
}

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

Écrivons maintenant un test avec Mockk :

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

class UserServiceTest {

    @Test
    fun `getUserName doit retourner le nom d'utilisateur depuis le dépôt`() {
        // 1. Créer un mock pour le dépôt
        val mockRepository = mockk<UserRepository>()
        
        // 2. Définir le comportement du mock
        every { mockRepository.findById(1L) } returns "Jean Dupont"
        
        // 3. Créer l'objet testé avec le mock
        val service = UserService(mockRepository)
        
        // 4. Appeler la méthode testée
        val result = service.getUserName(1L)
        
        // 5. Vérifier le résultat
        assert(result == "Jean Dupont")
        
        // 6. Vérifier que la méthode a été appelée exactement 1 fois
        verify(exactly = 1) { mockRepository.findById(1L) }
    }
}

Méthodes et fonctions principales de Mockk

Découvrons les 10 méthodes clés de la bibliothèque avec des descriptions détaillées et des exemples.

1. mockk() — création d'un objet mock

Fonction : Crée un objet mock pour la classe ou l'interface spécifiée. Par défaut, toutes les méthodes du mock retournent des valeurs par défaut (null, 0, false) et lèvent une exception si le comportement n'est pas défini.

Paramètres :