Créer des tests unitaires dans IntelliJ

Les tests unitaires sont un élément critique et essentiel du développement logiciel. Chaque fonction doit faire l'objet de tests couvrant l'ensemble des scénarios d'utilisation possibles. Bien que ceci puisse paraître lourd, il est important d'y penser en amont. Vos fonctions feront partie de bibliothèques logicielles et seront réutilisées dans des contextes différents de celui pour lequel vous les avez initialement conçues.

Dans un projet Kotlin, le code de production et le code de test sont séparés dans deux dossiers distincts :

src/
├── main/
│   └── kotlin/
│       └── Calculatrice.kt
└── test/
    └── kotlin/
        └── CalculatriceTest.kt

• Le dossier src/main/kotlin contient le code de l’application, incluant les fonctions et les classes que vous développez.

• Le dossier src/test/kotlin contient exclusivement le code servant à tester l’application.

Exemple simple - fonction division

Étape 1 : Définir la fonction à tester

À l'intérieur d'un fichier intitulé Calculatrice.kt, définissez une fonction permettant de faire une division entre deux nombres entiers. Voici sa définition en Kotlin :

fun division(a: Int, b: Int): Int? { // Notez le type de retour Int? : on autorise un retour null
    if (b == 0) {
        return null // Une division par zéro n'est pas autorisée
    }
    return a / b
}

L’objectif de cette fonction est d’offrir une version sécurisée de la division entière. Elle évite une erreur d’exécution lorsque le diviseur vaut zéro en retournant null plutôt que de laisser le programme planter.

Les tests unitaires de cette fonction devront couvrir les principaux scénarios suivants :

• a est divisible par b : le quotient est exact, par exemple division(10, 5) retourne 2.
• a n’est pas divisible par b : puisque la fonction effectue une division entière, la partie décimale est retirée. Par exemple, division(10, 6) retourne 1.
• b vaut 0 : la fonction doit retourner null afin d’indiquer qu’une division par zéro ne peut pas être effectuée.

Étape 2 : Créer la classe de tests

Dans src/test/kotlin, ajoutez un nouveau fichier Kotlin en respectant la nomenclature [NomDeLaClasse]Test. Dans cet exemple, créez le fichier CalculatriceTest.kt. Il contiendra la classe CalculatriceTest.

Étape 3 : Définir les tests unitaires

Chaque scénario d’utilisation important doit être représenté par une fonction de test distincte.

Chaque test doit :

1. Porter un nom descriptif qui indique le comportement vérifié.
2. Être précédé de l’annotation @Test. Cette annotation indique à JUnit que la fonction est un test unitaire à exécuter.
3. Respecter, autant que possible, le modèle AAA :

• Arrange (Arranger) : Préparer les données dont nous avons besoin pour exécuter le test.
• Act (Agir) : On exécute la méthode à tester
• Assert (Auditer) : On s'assure que le résultat est conforme à celui qui était attendu.

4. Vérifier un seul comportement précis.

Votre classe de tests devrait donc ressembler à ceci :

// CalculatriceTest.kt
import org.gagneleroux.division // Adaptez cet import au paquetage de votre projet.
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNull

class CalculatriceTest {

    @Test
    fun divisionNormaleRetourneLeQuotient() {
        // Arrange
        val a = 10
        val b = 2
        val resultatAttendu = 5

        // Act
        val resultat = division(a, b)

        // Assert
        assertEquals(resultatAttendu, resultat)
    }

    @Test
    fun divisionParZeroRetourneNull() {
        // Arrange
        val a = 10
        val b = 0

        // Act
        val resultat = division(a, b)

        // Assert
        assertNull(resultat)
    }

    @Test
    fun divisionEntiereTronqueLeResultat() {
        // Arrange
        val a = 7
        val b = 2
        val resultatAttendu = 3

        // Act
        val resultat = division(a, b)

        // Assert
        assertEquals(resultatAttendu, resultat)
    }
}

Étape 4 : Exécuter les tests

Pour exécuter un test dans IntelliJ :

• Cliquez sur l’icône verte ▶ située à gauche de la fonction de test pour n’exécuter que ce test.

• Cliquez sur l’icône verte ▶ située à gauche de la classe pour exécuter tous les tests de cette classe.

• Cliquez avec le bouton droit sur src/test/kotlin, puis choisissez Run Tests pour exécuter tous les tests du projet.

Plan de test

Attention ! Un test réussi ne prouve pas que le programme est entièrement exempt d’erreurs. Il confirme seulement que, pour le scénario précis testé, le comportement obtenu correspond au comportement attendu.

C’est pourquoi il faut identifier plusieurs scénarios : cas normal, cas limite, valeurs invalides, etc.

Voici un exemple d'un plan de test que vous devrez inclure dans vos projets.