Utilisation des assertions

Objectifs du chapitre :

• Comprendre l'importance des assertions dans les tests unitaires.
• Apprendre à utiliser les différentes méthodes de la classe Assert en JUnit.
• Découvrir comment vérifier diverses conditions dans vos tests à l'aide des assertions.

7.1 Importance des assertions dans les tests unitaires

Les assertions sont des méthodes utilisées dans les tests unitaires pour vérifier que le code se comporte comme prévu. Elles permettent de comparer les résultats obtenus avec les résultats attendus et de signaler les échecs lorsqu'il y a une divergence. Les assertions sont essentielles pour garantir que les fonctions et les méthodes produisent les résultats attendus et pour détecter les erreurs dans le code.

7.2 Méthodes d'assertion courantes

Voici une liste des méthodes d'assertion les plus couramment utilisées dans JUnit, disponibles dans les classes org.junit.Assert (JUnit 4) et org.junit.jupiter.api.Assertions (JUnit 5) :

1. assertEquals(expected, actual)

   • Vérifie que deux valeurs sont égales.
   • Exemple :

     assertEquals(5, calculator.add(2, 3));

2. assertNotEquals(unexpected, actual)

   • Vérifie que deux valeurs ne sont pas égales.
   • Exemple :

     assertNotEquals(4, calculator.add(2, 3));

3. assertTrue(condition)

   • Vérifie qu'une condition est vraie.
   • Exemple :

     assertTrue(user.isActive());

4. assertFalse(condition)

   • Vérifie qu'une condition est fausse.
   • Exemple :

     assertFalse(user.isInactive());

5. assertNull(object)

   • Vérifie qu'un objet est null.
   • Exemple :

     assertNull(order.getDeliveryDate());
     

6. assertNotNull(object)

   • Vérifie qu'un objet n'est pas null.
   • Exemple :

     assertNotNull(user.getUsername());
     

7. assertArrayEquals(expectedArray, actualArray)

   • Vérifie que deux tableaux sont égaux.
   • Exemple :

     assertArrayEquals(new int[]{1, 2, 3}, resultArray);
     

8. assertThrows(expectedType, executable)

   • Vérifie qu'un bloc de code lance une exception de type spécifié.
   • Exemple :

     assertThrows(IllegalArgumentException.class, () -> {
         calculator.divide(1, 0);
     });
     

9. assertTimeout(duration, executable)

   • Vérifie qu'un bloc de code s'exécute dans un délai spécifié.
   • Exemple :

     assertTimeout(Duration.ofSeconds(1), () -> {
         someService.performOperation();
     });
     

10. assertIterableEquals(expectedIterable, actualIterable)

    • Vérifie que deux collections itérables sont égales.
    • Exemple :

      List<String> expectedList = Arrays.asList("one", "two", "three");
      List<String> actualList = Arrays.asList("one", "two", "three");
      assertIterableEquals(expectedList, actualList);
      

7.3 Exemples détaillés d'utilisation des assertions

1. Utilisation de assertEquals :

@Test
void testAddition() {
    Calculator calculator = new Calculator();
    int result = calculator.add(2, 3);
    assertEquals(5, result); // , "Addition result should be 5"
}

2. Utilisation de assertNotEquals :

@Test
void testSubtraction() {
    Calculator calculator = new Calculator();
    int result = calculator.subtract(5, 3);
    assertNotEquals(3, result); // , "Subtraction result should not be 3"
}

3. Utilisation de assertTrue et assertFalse :

@Test
void testUserActiveStatus() {
    User user = new User();
    user.activate();
    assertTrue(user.isActive()); // , "User should be active"

    user.deactivate();
    assertFalse(user.isActive()); // , "User should be inactive"
}

4. Utilisation de assertNull et assertNotNull :

@Test
void testOrderDeliveryDate() {
    Order order = new Order();
    assertNull(order.getDeliveryDate()); // , "Delivery date should be null initially"

    order.setDeliveryDate(LocalDate.now());
    assertNotNull(order.getDeliveryDate()); // , "Delivery date should not be null after setting"
}

5. Utilisation de assertArrayEquals :

@Test
void testArrayEquality() {
    int[] expectedArray = {1, 2, 3};
    int[] actualArray = {1, 2, 3};
    assertArrayEquals(expectedArray, actualArray); // , "Arrays should be equal"
}

6. Utilisation de assertThrows :

@Test
void testExceptionThrowing() {
    Calculator calculator = new Calculator();
    assertThrows(IllegalArgumentException.class, () -> {
        calculator.divide(1, 0);
    }, "Division by zero should throw IllegalArgumentException");
}

7. Utilisation de assertTimeout :

@Test
void testOperationTimeout() {
    SomeService someService = new SomeService();
    assertTimeout(Duration.ofSeconds(1), () -> {
        someService.performOperation();
    }, "Operation should complete within 1 second");
}

Résumé du chapitre :

• Les assertions sont des outils cruciaux pour vérifier le comportement du code dans les tests unitaires.
• JUnit offre une variété de méthodes d'assertion pour tester différentes conditions et résultats.
• Utiliser les assertions appropriées permet de détecter et de corriger les erreurs efficacement.