Kotlin Academy · Leçon

Écrire des tests avec JUnit5

Structurer les tests

Écrire des tests avec JUnit5 est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Qu’est-ce que JUnit5 ?

JUnit5 (JUnit Jupiter) est le cadre de test standard pour la JVM et Kotlin. Il fournit des annotations permettant de marquer et de structurer le code de test.

Les tests se trouvent dans src/test/kotlin
Chaque test est une fonction
L’exécuteur les lance et présente les résultats

Ajouter la dépendance

Ajoutez JUnit Jupiter à votre configuration de test et activez la plateforme JUnit.

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
}

tasks.test {
    useJUnitPlatform()
}

Votre premier test

Annotez une fonction avec @Test. Un test vérifie une propriété de votre code.

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals

class MathTest {
    @Test
    fun addsTwoNumbers() {
        assertEquals(4, 2 + 2)
    }
}

Des noms de test descriptifs

Utilisez @DisplayName pour obtenir des rapports de test lisibles sans donner de longs noms aux fonctions.

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.DisplayName

class OrderTest {
    @Test
    @DisplayName("total includes tax")
    fun totalWithTax() {
        // ...
    }
}

Configuration avec @BeforeEach

@BeforeEach s’exécute avant chaque test, ce qui est idéal pour disposer de données de test vierges. @AfterEach s’exécute après chaque test pour effectuer le nettoyage.

import org.junit.jupiter.api.BeforeEach

class CartTest {
    private lateinit var cart: MutableList<String>
    @BeforeEach
    fun setUp() {
        cart = mutableListOf()
    }
}

Configuration au niveau de la classe

@BeforeAll et @AfterAll s’exécutent une seule fois pour toute la classe. En Kotlin, ils nécessitent un objet compagnon avec @JvmStatic (ou un cycle de vie par classe).

import org.junit.jupiter.api.BeforeAll

class DbTest {
    companion object {
        @BeforeAll
        @JvmStatic
        fun connect() {
            // open shared connection
        }
    }
}

Préparer-Agir-Vérifier

Structurez chaque test en trois phases claires :

Préparer — configurez les entrées et l’état
Agir — appelez le code testé
Vérifier — vérifiez le résultat

Ainsi, les tests restent lisibles et ciblés.

Tests imbriqués

@Nested regroupe les tests associés et produit un rapport en forme d’arbre qui documente le comportement.

import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test

class StackTest {
    @Nested
    inner class WhenEmpty {
        @Test fun isEmpty() { /* ... */ }
    }
}

Tests paramétrés

Exécutez le même test avec plusieurs entrées à l’aide de @ParameterizedTest et d’une source de valeurs.

import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.junit.jupiter.api.Assertions.assertTrue

class NumberTest {
    @ParameterizedTest
    @ValueSource(ints = [2, 4, 6])
    fun isEven(n: Int) {
        assertTrue(n % 2 == 0)
    }
}

Désactiver et étiqueter les tests

Ignorez temporairement un test avec @Disabled, et regroupez les tests avec @Tag afin de pouvoir les inclure ou les exclure lors des exécutions en intégration continue.

import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

class FlakyTest {
    @Test
    @Disabled("fix later")
    @Tag("slow")
    fun pending() { }
}

Un exemple autonome

Voici une fonction simple et pure en Kotlin, ainsi que l’idée qui sous-tend son test (le test lui-même s’exécute sous JUnit).

fun add(a: Int, b: Int): Int = a + b

fun main() {
    val result = add(2, 3)
    println(if (result == 5) "PASS" else "FAIL")
}

Vérification rapide

Vous avez besoin d’une liste vide et vierge avant chaque méthode de test. Quelle annotation convient ?

Récapitulatif

Vous savez structurer des tests JUnit5 :

@Test marque les tests et @DisplayName leur donne un nom
@BeforeEach / @BeforeAll gèrent la configuration
Préparer-Agir-Vérifier permet de garder des tests clairs
@Nested et @ParameterizedTest organisent les tests et facilitent leur extension

Ensuite : les assertions.

Questions Fréquemment Posées

La leçon « Écrire des tests avec JUnit5 » est-elle gratuite ?

Oui — le texte complet de « Écrire des tests avec JUnit5 » 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Écrire des tests avec JUnit5 » ?

Structurer les tests Tu pratiques Kotlin 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 Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin 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 1 sur 4.

Combien de temps prend la leçon « Écrire des tests avec JUnit5 » ?

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 Kotlin Academy ?

Oui. Chaque leçon Kotlin 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 à Kotlin Academy