Extension du cycle JUNIT

L'ordre d'exécution des tests en JUnit

Il est possible de modifier l'ordre d'exécution des tests (toutefois je ne le recommande pas)

Soit, vous modifiez l'ordre par annotation comme dans :

@TestMethodOrder(OrderAnnotation.class)
class OrderedTestsDemo {

    @Test
    @Order(1)
    void nullValues() {
        // perform assertions against null values
    }

    @Test
    @Order(2)
    void emptyValues() {
        // perform assertions against empty values
    }

    @Test
    @Order(3)
    void validValues() {
        // perform assertions against valid values
    }
}

Il existe plusieurs annotations pour exécuter par nom de méthode, nom de test, aléatoire etc. Se rapporter à la Documentation de JUnit

L'exécution conditionnelle des tests

Avec JUnit 5, il est possible d'activer/désactiver des tests conditionnellement.
Exemple présence d'une base de donnée active sur un certain port. Sinon les tests sont désactivés. Cela permet d'éviter de jouer avec @Disabled

Exemple d'exécution conditionnelle

@Test
@EnabledOnOs(MAC)
void onlyOnMacOs() {
    // ...
}

@TestOnMac
void testOnMac() {
    // ...
}


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Test
@EnabledOnOs(MAC)
@interface TestOnMac {
}

Annotations disponibles

JUnit 5 offre plusieurs possibilités d'activation conditionnelle :

• Basé sur l'OS : @EnabledOnOs
• Basé sur la version du JRE @EnabledOnJre
• Basé sur la présence de propriété systèmes @EnabledIfSystemProperty
• Basé sur la présence de variables d'environnement @EnabledIfEnvironmentVariable
• Basé sur des conditions personnalisables
• Pour toute annotation @Enabled, il existe aussi @Disabled...

Exemple de conditions "custom"

package example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIf;

class ExternalCustomConditionDemo {

    @Test
    @EnabledIf("example.ExternalCondition#customCondition")
    void enabled() {
        // ...
    }

}

class ExternalCondition {

    static boolean customCondition() {
        return true;
    }

}

Le cycle de vie des tests

Par défaut, JUnit créé une nouvelle instance pour chaque test avant d'exécuter la méthode concernée.

Il est primordial que le test soit exécuté de manière isolée et ainsi d'éviter les effets de bord liés à l'exécution des autres tests.

Le comportement de création d'une instance par méthode est le comportement par défaut de JUnit et compatible avec les versions précédentes.

Ce type de comportement peut être changé via l'utilisation de l'annotation @TestInstance

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class PersonsTest {
  ../..
}

Il ne faut pas oublier de nettoyer les champs d'instances avec @BeforeEach / @AfterEach

Il est possible de modifier globalement ce comportement en ajoutant la propriété à junit-platform.properties

junit.jupiter.testinstance.lifecycle.default = per_class

Le modèle d'extensions de JUnit

Les concepts de Runner, TestRule, et MethodRule de JUnit 4 ont été remplacé par une API unique , l'API Extension.

Il est possible de déclarer une extension en :

• déclaration en utilisant @ExtendWith
• programmatiquement en utilisant RegisterExtension
• automatiquement via le service ServiceLoader de Java

  @Test
  @ExtendWith(WebServerExtension.class)
  void getProductList(@WebServerUrl String serverUrl) {
      WebClient webClient = new WebClient();
      // Use WebClient to connect to web server using serverUrl and verify response
      assertEquals(200, webClient.get(serverUrl + "/products").getResponseStatus());
  }

class WebServerDemo {

    @RegisterExtension
    static WebServerExtension server = WebServerExtension.builder()
        .enableSecurity(false)
        .build();

    @Test
    void getProductList() {
        WebClient webClient = new WebClient();
        String serverUrl = server.getServerUrl();
        // Use WebClient to connect to web server using serverUrl and verify response
        assertEquals(200, webClient.get(serverUrl + "/products").getResponseStatus());
    }
}

Le système de découverte de tests