Android Academy · Leçon

Simulation avec Mockito

Isolez les dépendances avec Mockito et MockK. Simulez les valeurs de retour, vérifiez les interactions, capturez les arguments et utilisez des espions pour une simulation partielle.

Simulation avec Mockito est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Qu’est-ce que le mocking ?

Un mock est un objet fictif qui remplace une dépendance réelle dans les tests. Contrairement à un faux objet (une implémentation fonctionnelle en mémoire), un mock :

Est généré automatiquement par une bibliothèque
Enregistre les méthodes appelées et leurs arguments
Renvoie ce que vous lui demandez de renvoyer (simulation)
Vous permet de vérifier les interactions après le test

Configuration de Mockito

Ajoutez Mockito et MockK (alternative conçue en priorité pour Kotlin) à app/build.gradle :

// 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'

Créer des mocks

Créez des mocks avec mock() ou l’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()
}

Simulation — définir les valeurs de retour

Utilisez whenever(mock.method()).thenReturn(value) pour définir ce que renvoie un mock :

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() — vérifier les interactions

Utilisez verify() pour vérifier qu’une méthode a été appelée, ainsi que le nombre d’appels :

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 capture l’argument transmis à une méthode mock afin que vous puissiez vérifier sa valeur :

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 — mocking conçu pour Kotlin

MockK est conçu pour Kotlin et gère nativement les fonctions d’extension, les coroutines et les objets :

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() }

Mocker des coroutines avec MockK

Utilisez coEvery et coVerify pour les fonctions suspendues :

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 — mocking partiel

Un spy enveloppe un objet réel. Les méthodes réelles sont appelées par défaut, sauf si elles sont remplacées :

// 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"

Quand utiliser des mocks ou des faux objets

Conseils pratiques :

Utilisez un faux objet lorsque vous avez besoin d’une implémentation fonctionnelle en mémoire (DAO, dépôt) : plus facile à lire et sans bibliothèque nécessaire
Utilisez un mock lorsque vous devez vérifier qu’une méthode précise a été appelée avec des arguments précis (événements d’analyse, appels d’API)
Évitez l’excès de mocking : si vous mockez tout, vos tests vérifient les mocks, pas votre logique

Erreurs courantes

Pièges à éviter avec le mocking :

Mocker des objets valeur — mockez les interfaces et abstractions, pas les classes de données
Mocker trop profondément — si vous avez besoin de 5 mocks dans un seul test, le code est trop couplé
Ne pas vérifier lorsque l’interaction est importante : ne vous contentez pas de simuler, vérifiez également
Mockito et les valeurs par défaut de Kotlin — les paramètres Kotlin sont non nuls par défaut : utilisez mockito-kotlin ou MockK pour éviter les valeurs null inattendues

Mocker des objets et des objets compagnons

MockK peut mocker les objets Kotlin et les objets compagnons, ce qui est impossible avec Mockito :

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)

Vérification rapide

Quel est le rôle de verify() dans un test Mockito ou MockK ?

Récapitulatif : mocking avec Mockito et MockK

Les mocks permettent d’isoler et de vérifier le comportement :

mock() / mockk() — créer un mock à partir d’une interface ou d’une classe
whenever(...).thenReturn(...) / every { } returns ... — simuler les valeurs de retour
coEvery / coVerify — pour les fonctions Kotlin suspendues (MockK)
verify(mock).method(args) — vérifier que la méthode a été appelée
ArgumentCaptor — capturer et examiner les arguments
spy() / spyk() — mock partiel d’un objet réel
Privilégiez les faux objets pour les données et utilisez les mocks pour vérifier le comportement

Ensuite : les tests d’interface utilisateur avec Espresso.

Questions Fréquemment Posées

La leçon « Simulation avec Mockito » est-elle gratuite ?

Oui — le texte complet de « Simulation avec Mockito » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Simulation avec Mockito » ?

Isolez les dépendances avec Mockito et MockK. Simulez les valeurs de retour, vérifiez les interactions, capturez les arguments et utilisez des espions pour une simulation partielle. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Simulation avec Mockito » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy