Le but d'un test unitaire est d'identifier les erreurs dans une application dès que vous le pouvez. Bien que plusieurs canaux puissent vous mener au même objectif, vous devez vous efforcer d'utiliser l'itinéraire le plus efficace.
Une suite de tests JUnit peut avoir plusieurs classes de test qui ont besoin des mêmes données, mais vous ne pouvez pas réutiliser les données de test. Dans les versions précédentes de JUnit, une bonne approche consistait à créer une méthode utilitaire, puis à appeler cette méthode chaque fois qu'une classe de test avait besoin de ses données.
JUnit 5 propose une approche plus efficace de ce problème: l'injection de dépendances (DI).
Qu'est-ce que l'injection de dépendance ?
DI est un modèle de conception où un objet fournit les dépendances d'un autre objet. Lorsque vous construisez une application Java, vous pouvez avoir une classe qui dépend d'un objet qu'une autre classe crée pour exécuter sa fonction.
Avant l'injection de dépendance, pour utiliser un objet d'une classe différente, vous devez créer une nouvelle instance de cet objet dans la classe qui en dépend. Donc, si vous aviez plusieurs classes qui dépendent du même objet, vous devriez en créer plusieurs instances dans les classes dépendantes.
DI vous permet d'utiliser un objet dans une classe dépendante, sans en créer une nouvelle instance dans cette classe.
Injection de dépendance dans JUnit 5
JUnit 5 vous permet d'injecter des dépendances dans les méthodes de test et les constructeurs. Ceci est important car les versions précédentes du framework ne permettaient pas aux méthodes de test ou aux constructeurs d'avoir des paramètres.
JUnit 5 vous permet d'injecter autant de paramètres que vous le souhaitez. Le seul problème est que l'API ParameterResolver doit être capable de résoudre chaque paramètre au moment de l'exécution. JUnit possède actuellement trois résolveurs de paramètres intégrés qu'il utilise automatiquement. Pour utiliser un autre résolveur, vous devez l'enregistrer explicitement à l'aide de l'annotation @ExtendWith.
Injecter des dépendances dans JUnit
Cet exemple de programme utilise l'un des paramètres intégrés de JUnit (le TestInfoParameterResolver), pour montrer comment vous pouvez injecter une dépendance dans un Test JUnit 5. Le TestInfoParameterResolver résout les objets qui appartiennent à l'interface TestInfo. Ainsi, JUnit 5 fournira une instance de l'interface TestInfo à toute méthode ou constructeur qui l'utilise.
importerstatique org.junit.jupiter.api. Assertions.* ;
importer org.junit.jupiter.api. Afficher un nom;
importer org.junit.jupiter.api. Test;
importer org.junit.jupiter.api. TestInfo ;classeInfoTestInterfaceTest{
// Injecter un objet testInfo dans le constructeur InfoTestInterfaceTest
InfoTestInterfaceTest (TestInfo testInfo) {
assertEquals("InfoTestInterfaceTest", testInfo.getDisplayName());
}// Injecter un objet testInfo dans les méthodes
@Test
annulertestMethodNametestMethodName(TestInfo testInfo){
assertEquals("testMethodName (TestInfo)", testInfo.getDisplayName());
}
@Test
@Afficher un nom("méthode utilisant la @Afficher un nom annotation")
annulertestMethodNameTwo(TestInfo testInfo){
assertEquals("méthode utilisant la @Afficher un nom annotation", testInfo.getDisplayName());
}
}
Le test JUnit ci-dessus montre comment injecter un objet dans un constructeur et deux méthodes. Le JUnit TestInfo interface a quatre méthodes que vous pouvez utiliser avec son objet.
La méthode getDisplayName() est la plus utile. Il renvoie le nom d'affichage de la méthode de test ou du constructeur actuel. Par défaut, ce nom est basé sur la classe. Mais si vous utilisez l'annotation @DisplayName, la méthode getDisplayName() renverra ce texte à la place.
La classe de test ci-dessus génère le rapport de test suivant :
Utiliser DI dans les méthodes @Before et @After
Il existe quatre autres types de méthodes annotées JUnit qui prennent en charge les dépendances. Il s'agit des annotations @BeforeAll, @BeforeEach, @AfterAll et @AfterEach. Comme la méthode @Test, tout ce que vous avez à faire est de passer un objet à l'une des méthodes avant ou après en tant que paramètre, et vous êtes prêt à partir.
Les annotations @Before et @After sont importantes, car elles vous aident également à développer un code de test plus efficace. Avoir la possibilité d'injecter également des dépendances dans ces méthodes améliorera encore votre code de test.
