Développement piloté par les tests

Introduction aux tests en Java

Maria Milusheva

Senior Software Engineer

Test-Driven Development

Jusqu'ici, nous n'avons écrit des tests qu'après le code de production.

Le Test-Driven Development (TDD) est une technique où les tests guident la conception
En TDD, on écrit les tests avant tout code de production
Pourquoi faire du TDD ?

Avantages du TDD

Le TDD mène à mieux respecter les exigences du projet
Vérification immédiate : tout code a déjà ses tests
Coder à partir des tests produit un code plus clair et mieux structuré

Les lois du TDD

1. Écrire un test en échec avant tout code de production

2. Écrire le test le plus court possible

3. N'écrire que le code de production suffisant pour faire réussir le test

Appliquer ces étapes = un cycle de TDD

Le développement progresse par cycles répétés de TDD

¹ https://blog.cleancoder.com/uncle-bob/2014/12/17/TheCyclesOfTDD.html

Tester les palindromes

Supposons que nous voulions écrire une méthode qui vérifie si un entier est un palindrome
Exemples d'entiers palindromes : 12321, 0, 3333

Écrire un test en échec avant tout code

@Test
public void isPalindrome_nonPalindromicInt_returnsFalse() {
    int number = 1234;

    assertFalse(isPalindrome(number)); // isPalindrome() n'est pas encore écrite
}

Un test est comme un rappel laissé à notre futur nous des exigences du projet.

Écrire le minimum pour faire passer le test

public boolean isPalindrome(int num) {
    return false; // Écrire le minimum pour satisfaire le test.
}

Le test réussit maintenant. Passons au cycle de TDD suivant.

Écrire un autre test

Nouveau test – nouvelle exigence pour la fonction :

@Test
public void isPalindrome_PalindromicInt_ReturnsTrue() {
    int number = 1234321; // Cas de test plus complexe.

    assertTrue(isPalindrome(number)); // À ce stade, isPalindrome() échouera.
}

Implémenter la méthode

public boolean isPalindrome(int num) {
    int inverted = 0;
    while (num != 0) {
        // À chaque itération, prendre le dernier chiffre avec % 10
        // et l'ajouter à inverted * 10.
        inverted = inverted * 10 + num % 10;
        // Comme le dernier chiffre est traité, l'éliminer avec / 10.
        num = num / 10;
    }
    return inverted;
}

Correction de bogue avec le TDD

Le TDD est excellent pour corriger les bogues !

La méthode que nous venons d'écrire retourne true pour number = -121. Ce n'est pas correct !

Nous écrivons un test unitaire pour illustrer le bogue :

@Test
public void isPalindrome_NegativeNumber_ReturnsFalse() {
    int number = -121; // Pas un palindrome, car -121 n'est pas égal à 121-.

    assertFalse(isPalindrome(number));
}

Correction de bogue avec le TDD

public boolean isPalindrome(int num) {
    if (num < 0) { 
        return false; // Ajouter une clause pour retourner false pour les valeurs négatives.
    }
    int inverted = 0;
    while (num != 0) {
        inverted = inverted * 10 + num % 10;
        num = num / 10;
    }
    return inverted;
}

Passons à la pratique !

Introduction aux tests en Java