TOC

Utilisation de JUnit 5 avec Gradle

Utilisation de JUnit 5 avec Gradle

1. Vue d'ensemble

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

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

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

2. Configuration 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 commandegradle -v: 

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

Et, si nécessaire, nous pouvons suivre les étapesinstallation pour obtenir la bonne version.

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

Nous pouvons commencer par fournir la plate-forme 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 constatons une différence notable entre JUnit 5 et les versions antérieures.

Vous voyez, avec les versions précédentes, nous n’avions besoin que d’une seule dépendance. In JUnit 5, though, the API is separated from the runtime, meaning two dependencies.

L'API est manifeste avecjunit-jupiter-api. Le temps d'exécution estjunit-jupiter-engine pour JUnit 5 etjunit-vintage-engine pour JUnit 3 ou 4.

Nous fournirons ces deux entestImplementation andtimeRuntimeOnly, respectivement: 

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

3. Créer des tests

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

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

Maintenant,we can run the test by executing the gradle clean test command.

Pour vérifier que nous utilisons JUnit 5, nous pouvons examiner les importations. The imports for @Test and assertEquals should have a package starting with 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(expected=ArithmeticException.class).

4. Configuration des tests JUnit 5 avec Gradle

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

Supposons que nous ayons 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);
        });
    }
}

Then, we tell the build tool which ones to execute. 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

Now, it’s still possible to create JUnit 3 and 4 tests with the new Jupiter engine. Encore 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 foisjunit-jupiter-engine as etjunit-vintage-engine.

Maintenant, nous créons une nouvelle classe et copions-collons la méthodetestDivide que nous avons créée précédemment. Ensuite, nous ajoutons les importations pour@Test etassertEquals. Cependant, cette fois, nous nous assurons d'utiliser les anciens packages de la version 4 en commençant parorg.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. Encore plus, nous avons également ajouté le support pour les versions 3 et 4.

Nous avons vu que l’outil de création offre un excellent support pour les anciennes et les nouvelles versions. Par conséquent, nous pouvons utiliser les nouvelles fonctionnalités d'un projet existant sans avoir à modifier tous nos tests existants.

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

Related