Blog ENI : Toute la veille numérique !
Offre estivale️ ☀️ : de -20% à -30% sur les livres en ligne et vidéos, avec le code PLAGE Cliquez ici !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Java Spring
  3. Les tests et Spring
Extrait - Java Spring Le socle technique des applications Jakarta EE (5e édition)
Extraits du livre
Java Spring Le socle technique des applications Jakarta EE (5e édition) Revenir à la page d'achat du livre

Les tests et Spring

Introduction

Les pratiques centrées sur les tests jouent un rôle crucial dans le développement de logiciels modernes. Voici une explication approfondie de ces pratiques et de leur intégration avec Spring :

Le Test-Driven Development (TDD) est une méthode de développement logiciel où les tests unitaires sont écrits avant le code source. Cette approche garantit que le code développé répond précisément aux exigences définies par les tests.

Le Behavior Driven Development (BDD) est une évolution du TDD. Il se concentre sur la description des comportements et des fonctionnalités du logiciel à travers des phrases lisibles et descriptives, souvent écrites en langage naturel (français, anglais, etc.). Des outils comme Cucumber et Karate sont utilisés pour interpréter ces descriptions en tests exécutables.

L’Acceptance Test-Driven Development (ATDD) implique la transcription des critères d’acceptation en tests, assurant ainsi que le logiciel répond aux attentes des utilisateurs finaux.

Spring propose des API facilitant la mise en œuvre des tests unitaires et d’intégration. Ces API permettent de simuler les contextes d’exécution, de modifier la configuration des objets Spring en mémoire, et de tester avec des jeux d’essais utilisant une base...

Objets mock(és)

Les objets mock(és) appelés « mocks » servent à simuler les comportements des objets avec lesquels la classe testée interagit. En remplaçant ces objets réels par des mocks, on peut facilement contrôler les entrées et les sorties, tester différentes conditions et vérifier les interactions sans avoir à configurer un environnement complet. Spring propose un ensemble complet de mocks destinés à faciliter les tests. Ces mocks sont conçus pour être plus simples d’utilisation par rapport à des outils comme EasyMock et MockObjects.

Spring s’intègre souvent avec le framework Mockito (http://site.mockito.org/), un outil populaire pour la création de mocks en Java. Mockito facilite la création et la gestion des mocks, offrant une syntaxe intuitive pour définir les comportements attendus et vérifier les interactions. Mockito s’utilise souvent conjointement avec PowerMock. PowerMock est une extension de frameworks de tests comme Mockito et EasyMock qui permet de simuler des comportements et de tester du code difficilement testable, tel que les classes statiques, les méthodes finales, les constructeurs et d’autres parties du code qui ne supportent pas les Mocks.

Liste des mocks et leur utilité :

Mock

Utilité

MockMvc

Pour tester les contrôleurs MVC de Spring, permettant de simuler des requêtes HTTP et de vérifier les réponses.

MockRestServiceServer

Pour tester les interactions REST, en simulant des serveurs REST pour tester les clients REST.

MockEnvironment

Permet de simuler un environnement Spring avec des propriétés configurables pour les tests.

MockHttpSession et MockHttpServletRequest/Response

Pour simuler des objets de requête et de session HTTP, utiles dans les tests de composants web.

ApplicationContext Mocks

Pour simuler le contexte d’application Spring, permettant de tester des beans sans avoir besoin de charger le contexte complet.

Ces mocks sont conçus pour couvrir différents aspects du développement avec Spring, allant du web au REST, en passant par l’environnement de l’application. Ils permettent aux développeurs de tester efficacement leurs composants Spring de manière isolée, ce qui est essentiel pour des tests unitaires...

Configuration des contextes de tests

Les contextes de tests sont configurables à travers des annotations et des fichiers. 

1. @ContextConfiguration

L’utilisation d’initialiseurs de contexte dans les tests est possible en annotant la classe de test avec @ContextConfiguration. Vous pouvez annoter la classe de test avec @ContextConfiguration et utiliser l’attribut initializers pour spécifier un tableau de classes qui implémentent ApplicationContextInitializer. Ces initialiseurs sont utilisés pour configurer le ConfigurableApplicationContext avant le déroulement des tests.

L’ordre dans lequel ces initialiseurs sont appelés peut être contrôlé en implémentant l’interface Ordered, ou en utilisant les annotations @Order ou @Priority sur les classes initialiseurs.

Imaginons que vous ayez une classe d’initialiseur de contexte personnalisée :

public class MyContextInitializer implements 
  ApplicationContextInitializer<ConfigurableApplicationContext>, 
  Ordered { 
 
  @Override 
  public void initialize(ConfigurableApplicationContext 
                             applicationContext) { 
    // Configuration personnalisée du contexte 
  } 
 
  @Override 
  public int getOrder() { 
    return 1; // Définir l'ordre d'exécution 
  } 
} 

Vous pouvez ensuite utiliser cette classe initialiseur dans votre classe de test :

@ExtendWith(SpringExtension.class) 
@ContextConfiguration(initializers 
   = MyContextInitializer.class) 
public class MySpringTest { 
 
  @Test 
  public void someTest() { 
    // Votre logique de test ici 
  } 
} 

MyContextInitializer est un initialiseur personnalisé qui est appelé pour configurer le contexte Spring avant l’exécution des tests. L’utilisation de @ExtendWith(SpringExtension.class) intègre Spring avec JUnit 5. L’ordre d’exécution de l’initialiseur...

Points clés

Points à retenir :

  • Les tests sont faciles à implémenter avec Spring.

  • Il faut faire tous les tests nécessaires pour une maintenance facilitée.

  • Spring permet de tester dans un environnement très léger.

  • Les tests Spring sont très performants.