Développement piloté par les tests avec JUnit5 et Mockito

Test Driven Development (TDD) est une méthodologie de développement logiciel dans laquelle les tests sont écrits avant le code réel. TDD a attiré une attention considérable en raison de l'accent mis sur la qualité et la maintenabilité du code. Cet article explique comment implémenter efficacement TDD à l'aide de JUnit5 et Mockito, deux frameworks puissants de l'écosystème Java.

Qu'est-ce que le développement piloté par les tests ?

Le développement piloté par les tests est un processus de développement itératif. Les développeurs écrivent d'abord des cas de test pour de nouvelles fonctions ou fonctionnalités, puis écrivent la quantité minimale de code pour réussir le test, et enfin refactorisent le code pour l'optimiser. Cette approche améliore la conception, réduit les erreurs et améliore la maintenabilité globale du code.

Comprendre JUnit5 et Mockito

JUnit5 est la dernière version de JUnit, un framework de tests unitaires largement utilisé en Java. Il introduit plusieurs nouvelles fonctionnalités et améliorations qui augmentent la facilité et la flexibilité des tests en Java.

Mockito, quant à lui, est un framework moqueur permettant de créer des objets fictifs et de définir leur comportement, utile pour tester du code avec des dépendances externes.

Développement piloté par les tests avec JUnit5 et Mockito

Étape 1 : Écrivez un test d'échec

La première étape de TDD consiste à écrire un test qui échoue. Pour cela, dans JUnit5 nous définissons une méthode annotée avec @Test -

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class ExampleTest {

   @Test
   void shouldReturnTrueWhenNumberIsEven() {
       Example example = new Example();
       boolean result = example.isNumberEven(3);
       assertTrue(result);
   }
}

Ce test échouera initialement car nous n'avons pas implémenté la méthode isNumberEven dans la classe Exemple.

Après l'échec d'un test, nous écrivons juste assez de code pour réussir le test. Par exemple -

class Example {

   boolean isNumberEven(int num) {
       return num % 2 == 0;
   }
}

Réexécutez le test et nous devrions voir que le test réussit car la méthode isNumberEven vérifie désormais correctement si un nombre est pair.

Étape 3 : Refactoriser le code

La dernière étape consiste à affiner et optimiser le code sans changer son comportement. Bien que notre exemple soit très simple et ne nécessite pas de refactorisation, dans des cas plus complexes, cette étape peut impliquer de réduire la redondance, d'améliorer la lisibilité ou d'optimiser les performances.

Mocking with Mockito

Utilisez Mockito pour les tests de simulation

Utilisez Mockito pour créer des objets fictifs lorsque la méthode à tester implique des dépendances externes. Cela permet de tester les méthodes de manière isolée −

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

class ExampleTest {

   @Test
   void shouldCallDependency() {
       // Arrange
       Dependency dependency = Mockito.mock(Dependency.class);
       Example example = new Example(dependency);

       // Act
       example.performAction();
		
       // Assert
       verify(dependency, times(1)).action();
   }
}

Dans ce test, nous créons un objet de dépendance simulé et vérifions que lorsque nous appelons la méthode performAction sur l'objet Exemple, sa méthode d'action est appelée une fois.

Conclusion

Le développement piloté par les tests, combiné à JUnit5 et Mockito, fournit une base solide pour écrire du code maintenable de haute qualité. En comprenant le cycle TDD et en utilisant efficacement ces frameworks, les développeurs peuvent améliorer considérablement leurs compétences en tests et la qualité du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!