Utilisation de JUnit 5 avec Gradle

1. Vue d'ensemble

Dans ce tutoriel, nous allons exécuter des tests sur la nouvelle plate-forme JUnit 5 avec l'outil de construction Gradle.

Nous allons configurer un projet qui prend en charge à la fois l'ancienne et la nouvelle version.

N'hésitez pas à lire A Guide to JUnit 5 pour plus d'informations sur la nouvelle version. Ou l'Introduction à Gradle pour des informations détaillées sur l'outil de construction.

2. Configuration de Gradle

Tout d'abord, nous vérifions si la version 4.6 ou supérieure de l'outil de construction est installée car il s'agit de la version la plus ancienne qui fonctionne avec JUnit 5.

Le moyen le plus simple est d'exécuter simplement la commande gradle -v :

$> gradle -v ------------------------------------------------------------ Gradle 4.10.2 ------------------------------------------------------------

Et, si nécessaire, nous pouvons suivre les étapes d'installation pour obtenir la bonne version.

Une fois que nous avons tout installé, nous devons configurer Gradle en utilisant le fichier build.gradle .

Nous pouvons commencer par fournir la plateforme de test unitaire à l'outil de construction:

test { useJUnitPlatform() } 

Maintenant que nous avons spécifié la plate-forme, nous devons fournir les dépendances JUnit. C'est là que nous voyons une différence notable entre JUnit 5 et les versions antérieures.

Voir, avec les versions antérieures, nous n'avions besoin que d'une seule dépendance. Dans JUnit 5, cependant, l'API est séparée du runtime, ce qui signifie deux dépendances.

L'API est manifeste avec junit-jupiter-api . Le moteur d'exécution est junit-jupiter-engine pour JUnit 5 et junit-vintage-engine pour JUnit 3 ou 4.

Nous fournirons ces deux dans testImplementation et timeRuntimeOnly , respectivement:

dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1' }

3. Création de tests

Écrivons notre premier test. Cela ressemble aux versions précédentes:

@Test public void testAdd() { assertEquals(42, Integer.sum(19, 23)); }

Maintenant, nous pouvons exécuter le test en exécutant la commande gradle clean test .

Pour vérifier que nous utilisons JUnit 5, nous pouvons examiner les importations. Les importations pour @Test et assertEquals doivent avoir un package commençant par org.junit.jupiter.api:

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

Ainsi, dans le dernier exemple, nous avons créé un test avec une «ancienne» fonctionnalité qui fonctionne depuis des années. Nous allons maintenant créer un autre exemple qui utilise certaines des nouvelles fonctionnalités de JUnit 5:

@Test public void testDivide() { assertThrows(ArithmeticException.class, () -> { Integer.divideUnsigned(42, 0); }); }

assertThrows est une nouvelle assertion dans JUnit5 qui remplace l'ancien style de @Test (attendu = ArithmeticException.class).

4. Configuration des tests JUnit 5 avec Gradle

Ensuite, nous explorerons une intégration plus profonde entre Gradle et JUnit5.

Disons que nous avons deux types de tests dans notre suite: de longue durée et de courte durée. Nous pourrions utiliser l' annotation JUnit 5 @Tag :

public class CalculatorJUnit5Test { @Tag("slow") @Test public void testAddMaxInteger() { assertEquals(2147483646, Integer.sum(2147183646, 300000)); } @Tag("fast") @Test public void testDivide() { assertThrows(ArithmeticException.class, () -> { Integer.divideUnsigned(42, 0); }); } }

Ensuite, nous indiquons à l'outil de construction lesquels exécuter. Dans notre cas, exécutons simplement les tests courts (rapides):

test { useJUnitPlatform { includeTags 'fast' excludeTags 'slow' } }

5. Activation de la prise en charge des anciennes versions

Désormais, il est toujours possible de créer des tests JUnit 3 et 4 avec le nouveau moteur Jupiter. De plus, nous pouvons les mélanger avec la nouvelle version dans le même projet, par exemple dans un scénario de migration.

Pour commencer, nous ajoutons des dépendances à la configuration de construction existante:

testCompileOnly 'junit:junit:4.12' testRuntimeOnly 'org.junit.vintage:junit-vintage-engine:5.3.1'

Notez comment notre projet a maintenant à la fois junit-jupiter-engine et junit-vintage-engine.

Maintenant, nous créons une nouvelle classe et copions- collons la méthode testDivide que nous avons créée précédemment. Ensuite, nous ajoutons les importations pour @Test et assertEquals . Cependant, cette fois, nous nous assurons d'utiliser les anciens packages de la version 4 en commençant par org.junit:

import static org.junit.Assert.assertEquals; import org.junit.Test; public class CalculatorJUnit4Test { @Test public void testAdd() { assertEquals(42, Integer.sum(19, 23)); } }

6. Conclusion

Dans ce tutoriel, nous avons intégré Gradle à JUnit 5. De plus, nous avons également ajouté la prise en charge des versions 3 et 4.

Nous avons vu que l'outil de construction fournit un excellent support pour les anciennes et nouvelles versions. Par conséquent, nous pouvons utiliser les nouvelles fonctionnalités dans un projet existant sans avoir besoin de modifier tous nos tests existants.

L'exemple de code complet est disponible dans le projet GitHub. N'hésitez pas à l'utiliser comme point de départ pour votre propre projet.