Test en Kotlin : frameworks et outils pour développeurs

Test en Kotlin : frameworks et outils pour écrire du code fiable

Kotlin est un langage moderne activement utilisé pour le développement d'applications Android, de solutions serveur (Ktor, Spring Boot) et de projets multiplateformes. La qualité du code dépend directement de la couverture de tests. Dans cet article, nous examinerons les principaux outils de test en Kotlin : les frameworks pour écrire des tests, les bibliothèques de simulation (mocking) et les utilitaires pour vérifier les coroutines.

1. JUnit 5 — la base des tests

JUnit 5 est le framework standard pour les tests unitaires en Java/Kotlin. Il fournit les annotations @Test, @BeforeEach, @AfterEach et un mécanisme d'extensions (Extensions). En Kotlin, les tests sont concis :

import org.junit.jupiter.api.Testimport org.junit.jupiter.api.Assertions.*

class CalculatorTest {    private val calculator = Calculator()

    @Test    fun `addition should work correctly`() {        assertEquals(4, calculator.add(2, 2))    }

    @Test    fun `division by zero throws exception`() {        assertThrows<ArithmeticException> {            calculator.divide(10, 0)        }    }}

Particularités de l'utilisation de JUnit 5 avec Kotlin :

• Les noms de tests peuvent être écrits entre guillemets inversés — cela améliore la lisibilité.
• Fonctionne avec toutes les coroutines via @Test et l'extension kotlinx-coroutines-test.
• Prend en charge les tests paramétrés (@ParameterizedTest).

2. Kotest — un puissant framework pensé pour Kotlin

Kotest (anciennement KotlinTest) est un framework complet développé spécifiquement pour Kotlin. Il propose plusieurs styles d'écriture de tests : String Spec, Fun Spec, Describe Spec et autres. Exemple utilisant le développement piloté par le comportement (BDD) :

import io.kotest.core.spec.style.StringSpecimport io.kotest.matchers.shouldBe

class UserServiceTest : StringSpec({    "user should be created with correct name" {        val user = UserService().createUser("Alice")        user.name shouldBe "Alice"        user.isActive shouldBe true    }})

Avantages de Kotest :

• Matchers (vérifications) intégrés pour les collections, chaînes de caractères, nombres.
• Prise en charge des coroutines, des fournisseurs de données (@TestFactory) et des délais d'attente.
• Configuration flexible des tests via projectConfig.
• Intégration avec Gradle et Maven.

3. MockK — simulation (mocking) pour Kotlin

MockK est une bibliothèque pour créer des objets simulés (mocks) qui prend en compte les spécificités de Kotlin : les fonctions suspend, les fonctions d'extension, les classes sealed et les singletons object. Exemple d'utilisation :

import io.mockk.*import org.junit.jupiter.api.Test

class UserServiceTest {    @Test    fun `should call repository when saving user`() {        val repo = mockk<UserRepository>()        every { repo.save(any()) } returns Unit

        val service = UserService(repo)        service.saveUser("Bob")

        verify { repo.save(any()) }    }}

Fonctionnalités clés de MockK :

• mockk() — création d'un mock, spyk() — mock partiel d'un objet réel.
• coEvery et coVerify pour travailler avec les coroutines.
• Vérification de l'ordre des appels (verifyOrder), capture d'arguments (slot).
• Prise en charge des annotations @MockK et @RelaxedMockK.

4. Test des coroutines : kotlinx-coroutines-test

Lors du test de code asynchrone avec des coroutines, il est important de contrôler le temps. La bibliothèque kotlinx-coroutines-test fournit runTest et TestCoroutineDispatcher :

import ko