Exercices sur les test Unitaire

Exercices pour le Chapitre sur les Tests Unitaires avec JUnit

Les objectifs du chapitre sont d'apprendre à écrire des tests unitaires simples, exécuter ces tests et interpréter les résultats, ainsi que se familiariser avec les outils et les bonnes pratiques pour les tests unitaires. Voici quelques exercices pratiques pour chaque section.

Exercice 1: Écrire des tests unitaires simples

Objectif:

Écrire des tests unitaires pour différentes méthodes d'une classe simple.

Classe à tester:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero is not allowed.");
        }
        return a / b;
    }
}

Classe de test pour JUnit 4:

package com.example;

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;

public class CalculatorTest {

    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result);
    }

    @Test
    public void testSubtract() {
        Calculator calculator = new Calculator();
        int result = calculator.subtract(5, 3);
        assertEquals(2, result);
    }

    @Test
    public void testMultiply() {
        Calculator calculator = new Calculator();
        int result = calculator.multiply(2, 3);
        assertEquals(6, result);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDivideByZero() {
        Calculator calculator = new Calculator();
        calculator.divide(1, 0);
    }

    @Test
    public void testDivide() {
        Calculator calculator = new Calculator();
        int result = calculator.divide(6, 3);
        assertEquals(2, result);
    }
}

Exercice 2: Exécuter les tests

Objectif:

Exécuter les tests dans différents environnements et interpréter les résultats.

Étapes:

1. Visual Studio Code :

   • Ouvrez le fichier de test.
   • Cliquez sur l'icône de test à côté de la méthode de test ou utilisez la palette de commandes (Ctrl+Shift+P) pour sélectionner Java: Run Tests.
   • Interprétez les résultats dans la fenêtre de sortie.

2. Ligne de commande avec Maven :

   • Exécutez la commande mvn test dans le répertoire du projet.
   • Interprétez les résultats affichés dans le terminal et les rapports générés dans le répertoire target/surefire-reports.

Exercice 3: Interpréter les résultats des tests

Objectif:

Comprendre et interpréter les résultats des tests unitaires.

Instructions:

• Exécutez les tests en utilisant l'une des méthodes décrites dans l'Exercice 2.
• Notez les résultats pour chaque test, y compris ceux qui ont réussi et ceux qui ont échoué.
• Pour les tests échoués, notez les détails des erreurs et comprenez pourquoi ils ont échoué.
• Examinez les rapports de test générés par Maven ou votre IDE pour obtenir une vue d'ensemble des résultats.

Exercice 4: Bonnes pratiques pour les tests unitaires

Objectif:

Appliquer les bonnes pratiques pour écrire des tests unitaires efficaces et maintenables.

Instructions:

1. Nommer les tests de manière descriptive :

   • Renommez les méthodes de test pour qu'elles décrivent clairement ce qu'elles vérifient.
   • Exemple : testAddWithPositiveNumbers au lieu de testAdd.

2. Isoler les tests :

   • Assurez-vous que chaque test est indépendant et ne dépend pas des autres tests.
   • Utilisez des configurations de test appropriées pour réinitialiser l'état entre les tests.

3. Utiliser des assertions appropriées :

   • Utilisez des assertions spécifiques pour vérifier les résultats des méthodes.
   • Exemple : Utilisez assertThrows pour vérifier qu'une exception est lancée.

4. Tester les cas limites :

   • Ajoutez des tests pour les cas limites et les scénarios exceptionnels.
   • Exemple : Tester la méthode add avec des valeurs négatives et nulles.

5. Exécuter les tests fréquemment :

   • Intégrez l'exécution des tests dans votre cycle de développement quotidien.
   • Exécutez les tests après chaque changement de code pour détecter rapidement les régressions et les erreurs.

Résumé du Chapitre :

1. Écrire des tests unitaires simples :

   • Créez des classes de test et des méthodes de test avec des assertions pour vérifier le comportement du code.

2. Exécuter les tests :

   • Utilisez des IDE comme IntelliJ IDEA et Visual Studio Code, ou des outils en ligne de commande comme Maven pour exécuter les tests.

3. Interpréter les résultats des tests :

   • Comprenez les résultats des tests pour identifier les tests réussis et échoués, et les raisons des échecs.

4. Bonnes pratiques pour les tests unitaires :

   • Utilisez des noms descriptifs pour les tests, isolez les tests, utilisez des assertions appropriées, testez les cas limites et exécutez les tests fréquemment pour garantir des tests efficaces et maintenables.