Récemment, en travaillant avec Deezer sur un projet Kotlin/Multiplatform, nous sommes tombés sur plusieurs tests unitaires écrits dans src/androidTest/kotlin, c'est-à-dire qu'ils ne s'exécutaient que sur Android. En cherchant pourquoi ce choix avait été fait, la réponse est devenue évidente : il n'existe aucun système de mocking sur Kotlin/Multiplatform, et MockK ne prend en charge que la JVM & Android.
Sans librairie de mocking, il ne reste qu'une option : écrire chaque mock à la main, et remplir nos classes de fausses données un champ à la fois. C'est fastidieux, répétitif et, soyons honnêtes, un peu déprimant. Nous voulions écrire des tests, pas du boilerplate.

Mocker avec la réflexivité
La réflexivité de la JVM est une API remarquablement puissante, qui permet aux librairies d'instrumenter des classes existantes et de créer de nouvelles implémentations à l'exécution. Quand vous écrivez :
val repo = mockk<Repository>()
every { repo.getUser(id = any()) } returns fakeUser()
assertEquals(fakeUser(), repo.getUser(42))…la librairie de mocking :
- Crée une nouvelle implémentation du type
Repository - Définit le comportement de la méthode
getUserde ce mock pour qu'elle renvoie un fauxUser, quelle que soit la valeur du paramètreid.
De plus, un framework de mocking pour la JVM sait créer des « faux objets » à la demande :
val repo = mockk<Repository>(relaxed = true)
assertEquals("", repo.getUser(42).name)Tout cela se fait à l'exécution, en instrumentant la JVM, ce qui est impossible sur deux des trois cibles de Kotlin/Multiplatform (Kotlin/JS & Kotlin/Native).
Un Kotlin Symbol Processor
Google KSP permet d'inspecter du code Kotlin à la compilation. En substance, c'est une API de réflexivité disponible à la compilation (plutôt qu'à l'exécution).
KSP permet aussi de générer du code Kotlin en fonction du code inspecté. C'est de la métaprogrammation : écrire du code qui génère du code en fonction du code.
Avec un Kotlin Symbol Processor, nous pouvons générer à la compilation des implémentations d'interfaces, et déléguer leur comportement à un mocker.
Voici MocKMP
Le projet MocKMP se compose de plusieurs éléments qui vous permettent de générer et de configurer facilement des mocks :
- Un runtime qui fournit l'API du mocker
- Un Kotlin Symbol Processor qui génère des mocks configurables
- Une librairie d'aide aux tests, pour rendre l'utilisation des mocks aussi simple que possible
- Un plugin Gradle pour faire fonctionner ensemble toutes ces pièces
Quand nous avons commencé à travailler sur MocKMP, nous avons défini une exigence importante, indispensable à nos yeux pour rendre cette librairie aussi simple que possible à utiliser : conserver une API de mocking « standard ».
Le mocking est une tâche très courante quand on écrit des tests unitaires, et nous avons estimé que conserver la sémantique d'une API établie rendrait le portage des tests unitaires vers Kotlin/Multiplatform aussi facile que possible.
Inutile de réinventer une API alors qu'il en existe déjà une depuis des années, largement acceptée comme un standard.
La déclaration suivante fonctionne comme prévu dans MocKMP :
// Configures repo.getUser mock method
every { repo.getUser(isAny()) } returns fakeUser()
// Calls the repo.getUser mock method
assertEquals(fakeUser(), repo.getUser(42))
// Verifies that the repo.getUser mock method has been called
verify { repo.getUser(42) }Mocks et fakes
Comme MocKMP fonctionne sans instrumentation à l'exécution, nous avons dû introduire quelques définitions et restrictions de plus que ne le fait une librairie de mocking « classique ».
Un mock est une implémentation d'une interface dont le comportement peut être configuré ensuite et dont les appels peuvent être vérifiés.
Vous ne pouvez mocker que des interfaces, des classes abstraites ou ouvertes. C'est parce qu'il est impossible, en Kotlin, de créer à la compilation une implémentation d'une classe qui n'est pas open. Nous vous encourageons à utiliser des interfaces autant que possible.
Un fake est une instance de classe concrète remplie de données sans conséquence :
- Les nullables valent null
- Les booléens valent false
- Les numériques valent 0
- Les chaînes valent ""
- Les énumérations valent leur première valeur déclarée
Vous ne pouvez faker que des structures de données concrètes (c'est-à-dire des classes concrètes qui ne contiennent que des classes concrètes). En règle générale, seules les data class devraient être fakées. C'est parce que créer un fake ne demande aucun contexte, alors que créer un mock demande un mocker.
Injecter des mocks et des fakes
Cet article n'ira pas dans le détail de l'utilisation de MocKMP. Si cela vous intéresse, vous pouvez lire sa documentation, plutôt rapide et simple à comprendre. Analysons plutôt un cas d'usage :
class MyTests : TestsWithMocks() { // 1
override fun setUpMocks() = injectMocks(mocker) // 2
@Mock lateinit var view: View // 3
@Fake lateinit var model: Model // 4
val controller by withMocks { Controller(view = view, firstModel = model) } // 5
@Test fun controllerTest() {
every { view.render(isAny()) } returns true // 6
controller.start() // 7
verify { view.render(model) } // 8
}
}- Héritage
TestsWithMocksoptionnel.
Héritez deTestsWithMockset vos tests bénéficient d'un peu de sucre syntaxique, ce qui les rend plus faciles à écrire et à lire. C'est entièrement optionnel : la documentation montre comment obtenir toutes les fonctionnalités sans cela. - Implémentation de
setUpMocks.
Quand votre classe a des propriétés annotées avec@Mockou@Fake, le processeur génère pour elle une fonction d'extensioninjectMocks(ici,MyTests.injectMocks). Comme cette fonction est générée et diffère pour chaque classe,TestsWithMocksne peut pas l'appeler d'elle-même : vous lui indiquez comment en surchargeantsetUpMocks. - Injection d'un mock.
La classeTestsWithMocksenregistre un hook@BeforeTestqui injecte un nouveau mock deViewpour chaque test. La propriété estlateinitparce qu'elle sera injectée avant chaque test (et non une seule fois à l'initialisation). - Injection d'un fake.
Même mécanisme pour le fake deModel: un nouveau est injecté avant chaque test, d'où lelateinit. - Injection de types dépendant de mocks et de fakes.
Les propriétés construites à partir de mocks et de fakes utilisent le déléguéwithMocks. Dans cet exemple, un nouveauControllersera créé avec uneviewet unmodelneufs avant l'exécution de chaque nouveau test. - Configuration du comportement d'un mock.
Pour définir le comportement d'une méthode d'instance d'un mock dans un test, utilisez la syntaxeevery. Chacun des arguments de la méthode doit définir une contrainte d'argument. Ici,isAny()signifie « quelle que soit la valeur » : aucune contrainte sur l'argument. - Utilisation des mocks et des fakes.
Ici, nous supposons qu'en appelantcontroller.start, le controller utilisera le mockviewqui lui a été passé en paramètre de constructeur. - Vérification des appels d'un mock.
Supposer ne suffit pas : il faut vérifier que les appels ont bien eu lieu. Ici, nous vérifions queview.rendera été appelée avec le paramètremodel; le test échoue si elle n'a pas été appelée, ou si elle l'a été avec autre chose.
Un processeur pour Multiplatform
Alors, si nous ne pouvons pas utiliser la réflexivité, comment ça marche ?
En gros, tout ce qu'il nous faut, c'est un moyen de dire au système « cette méthode a été appelée, avec cette contrainte d'argument ».
Si l'on considère l'interface View :
interface View {
fun render(model: Model)
}La classe MockView générée pour elle ressemble alors à ceci :
internal class MockView(private val mocker: Mocker) : View {
override fun render(model: Model) =
mocker.register(this, "render(com.mybusiness.Model)", model)
}Avec ce comportement généré, nous informons le Mocker (l'objet qui gère le mocking et la vérification) que la méthode render a été appelée, et nous lui laissons le soin de gérer le comportement réel et la valeur de retour.
En substance, le processeur génère un proxy.
Il génère aussi des méthodes pour créer des fakes :
internal fun fakeModel() =
Model(
user = fakeUser(), // Fakes can contain fakes
lasUpdate = 0, // numerics are 0
state = null // nullables are null
)Enfin, il génère une fonction d'extension injectMocks pour chaque classe qui contient des annotations d'injection :
internal fun MyTests.injectMocks(mocker: Mocker) {
view = MockView(mocker)
model = fakeModel()
}Des changements d'API réfléchis
Nous nous sommes permis de modifier légèrement l'API de MocKMP pour la distinguer des frameworks de mocking « traditionnels » comme MockK ou Mockito-Kotlin. Nous aimerions attirer votre attention sur ces particularités de l'API de MocKMP :
- Toutes les contraintes d'argument commencent par
is.
Au lieu de :every { view.render(any()) } returns true,
écrivez :every { view.render(isAny()) } returns true.
Cela favorise la découvrabilité. Pour trouver toutes les contraintes disponibles dans votre IDE, tapezissuivi du raccourci de complétion (ctrl+spacedans IDEA) et vous les trouverez toutes (isAny,isEqual,isNotEqual,isSame,isNotSame,isNull,isNotNull). - Il n'existe pas de
every { foo.bar() } just Runs. C'est du Kotlin : aucune fonction ne « s'exécute simplement ». Une fonction a toujours une valeur de retour. Si elle renvoieUnit, écrivez-le, comme pour n'importe quelle autre :every { foo.bar() } returns Unit. - La fonction
verifyest exhaustive par défaut.
Cela signifie queverify {}vérifie en réalité qu'aucun appel n'a été fait sur aucune instance de mock.
Vous pouvez le désactiver avecverify(exhaustive = false). - La fonction
verifyest ordonnée par défaut.
Cela signifie queverify { m.foo() ; m.bar() }vérifie quefooetbaront été appelées surmdans cet ordre.
Vous pouvez le désactiver avecverify(inOrder = false).
Conclusion
Pas de réflexivité, pas de problème : comme deux des trois cibles de Kotlin/Multiplatform ne peuvent pas instrumenter la JVM, nous générons les mocks à la compilation, et nous avons gardé une API familière pour que le portage des tests de Deezer réservés à Android reste aussi indolore que possible. Si vous essayez MocKMP, nous serons ravis de savoir ce que vous en pensez.
Ces articles pourraient vous plaire
Tutoriels, retours d'expérience et bonnes pratiques autour de KOSI et de l'écosystème Kotlin, par ceux qui maintiennent les librairies.
17/11/2026
Inara n’a rien de magique : lisez le code qu’elle écrit
Dans la plupart des frameworks de DI, un module est un sac anonyme de bindings, et les dépendances sont recherchées par type. Inara donne une identité aux modules. Ouvrons le capot et lisons le code qu'elle génère : aucun tour de magie, seulement du Kotlin ordinaire que vous pouvez parcourir d'un Cmd+clic.
Lire plus
09/11/2026
LARPing enthusiasm : le spectre du désengagement
Je peux confier le travail à l'IA, pas le jugement ni le sens du produit. Récit d'un glissement vers le désengagement, et d'une reconquête en cours.
Lire plus
02/11/2026
Inara : injectez vos dépendances à la compilation
J'ai créé Kodein, et pourtant je crois aujourd'hui qu'il nuit à l'écosystème Kotlin Multiplatform. Voici Inara, un Kotlin Symbol Processor qui résout vos dépendances à la compilation, et découvrez pourquoi nous mettons Kodein en fin de vie.
Lire plus
26/10/2026
Les agents de code ont tué les frameworks multiplateformes !
Avec les agents, écrire deux fois du code natif ne coûte presque plus rien : le multiplateforme est-il mort ? Pas vraiment : c'est la question qui a changé. Partagez ce qui doit être identique, et vérifiez-le une seule fois.
Lire plus
19/10/2026
LARPing enthusiasm : la frénésie créative de l’IA
L'IA me permet de construire en quelques semaines ce qui demandait des années, et c'est grisant comme une drogue. Est-ce que je crée vraiment, ou est-ce que je joue l'enthousiasme ? Une réflexion personnelle sur la volonté, l'agentivité et le code partagé.
Lire plus
04/09/2025
Utiliser Swift dans une librairie Kotlin/Multiplatform
Besoin d'utiliser une API iOS réservée à Swift, comme CryptoKit, dans votre librairie Kotlin/Multiplatform ? Salomon montre comment la relier via Objective-C et le cinterop de Kotlin/Native, avec du code testé.
Lire plus