Kotest pour Kotlin : guide complet avec exemples

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

Kotest (anciennement connu sous le nom de KotlinTest) est une bibliothèque de test puissante et flexible pour le langage Kotlin. Elle offre aux développeurs un ensemble d'outils riche pour les tests unitaires, d'intégration et fonctionnels. Contrairement à JUnit standard, Kotest propose de nombreux styles d'écriture de tests (du classique "xUnit" au Behavior-Driven Development), un support intégré pour les tests basés sur les propriétés (property-based testing), des matchers (assertions) puissants et une intégration avec des frameworks populaires comme Spring Boot, MockK et Arrow.

Pourquoi utiliser Kotest ? Dans le développement moderne en Kotlin, les tests ne sont pas une simple vérification du code, mais le fondement de la qualité. Kotest résout plusieurs problèmes clés :

• Flexibilité des styles : Vous pouvez écrire des tests en style "String Spec", "Fun Spec", "Behavior Spec" et bien d'autres, en choisissant celui qui convient le mieux à votre équipe.
• Matchers puissants : Les fonctions de vérification intégrées (shouldBe, shouldContain, shouldThrow) rendent le code des tests lisible et concis.
• Tests basés sur les propriétés : Permet de générer des milliers de données de test aléatoires, vérifiant les invariants de votre code, et pas seulement des valeurs spécifiques.
• Intégration avec les coroutines : Kotest fonctionne parfaitement avec les coroutines Kotlin, permettant de tester du code asynchrone sans boilerplate inutile.
• Extensibilité : Vous pouvez créer vos propres matchers, écouteurs et extensions.

Installation de Kotest

Kotest est distribué via Maven Central. Pour l'installer, vous devez ajouter les dépendances dans votre fichier build.gradle.kts (pour Gradle) ou pom.xml (pour Maven).

Installation avec Gradle (build.gradle.kts)

// Dans la section dependencies
dependencies {
    // Module principal (inclut les matchers de base et les styles)
    testImplementation("io.kotest:kotest-runner-junit5:5.9.1")
    // Module pour les tests basés sur les propriétés
    testImplementation("io.kotest:kotest-property:5.9.1")
    // Module pour l'intégration avec les frameworks (ex : Spring)
    testImplementation("io.kotest:kotest-extensions-spring:5.9.1")
}

Installation avec Maven (pom.xml)

<dependency>
    <groupId>io.kotest</groupId>
    <artifactId>kotest-runner-junit5</artifactId>
    <version>5.9.1</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>io.kotest</groupId>
    <artifactId>kotest-property</artifactId>
    <version>5.9.1</version>
    <scope>test</scope>
</dependency>

Remarque : La version 5.9.1 est la version actuelle au moment de la rédaction de cet article. Vérifiez toujours la dernière version sur MVNRepository.

Démarrage rapide avec un exemple de code

Écrivons un test simple pour une classe de calculatrice, en utilisant le style "Fun Spec" — l'un des plus populaires et intuitifs.

// Classe à tester
class Calculator {
    fun add(a: Int, b: Int): Int = a + b
    fun divide(a: Int, b: Int): Int {
        if (b == 0) throw ArithmeticException("Division par zéro")
        return a / b
    }
}

// Classe de test
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe
import io.kotest.matchers.shouldThrow

class CalculatorTest : FunSpec({
    // Initialisation de l'objet à tester
    val calculator = Calculator()

    test("addition de deux nombres positifs") {
        val result = calculator.add(2, 3)
        result shouldBe 5
    }

    test("la division par zéro doit lever une exception") {
        shouldThrow<ArithmeticException> {
            calculator.divide(10, 0)
        }
    }
})

Cet exemple illustre la structure de base : nous créons une classe qui hérite de FunSpec, définissons un objet calculator, puis utilisons les fonctions test pour décrire nos cas de test. Les matchers shouldBe et shouldThrow rendent les assertions claires et expressives.