Annotations utiles dans JUnit

4.1 @Désactivé

Examinons maintenant quelques annotations très utiles et populaires du framework JUnit. La première annotation vous permet de désactiver un test spécifique afin que JUnit ne l'appelle pas. Il est nécessaire dans les cas où vous remarquez que le test ne fonctionne pas correctement, ou si vous modifiez le code et que le test s'interrompt accidentellement.

Comme je l'ai écrit plus tôt, 99% des tests ne sont pris en charge par personne, ils s'avèrent donc tous être désactivés tôt ou tard. Par conséquent, cette annotation est la première de la liste des annotations utiles.

Considérez son exemple :

public class AppTest {

    @Disabled("Test is temporarily disabled. True, true")
    @Test
    void testOnDev(){
        System.setProperty("ENV", "DEV");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }

    @Test
    void testOnProd(){
     System.setProperty("ENV", "PROD");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }
}

Dans l'exemple ci-dessus, la méthode testOnDev()ne sera pas appelée. D'ailleurs, l'annotation @Disabledpeut être écrite juste avant la déclaration de classe, alors toutes ses méthodes seront ignorées.

@Disabled("Temporarily turned off the test, we will fix it by May 2001")
public class AppTest {
    @Test
    void testOnDev(){
        System.setProperty("ENV", "DEV");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }

    @Test
    void testOnProd(){
     System.setProperty("ENV", "PROD");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }
}

4.2 @Imbriqué

JUnit vous permet d'appeler des méthodes de test sur des classes imbriquées. Je veux dire des classes de test imbriquées. Ce n'est pas un fait que vous les rencontrerez souvent, mais il y a une telle possibilité, vous devez donc comprendre ce que c'est.

Pour appeler les méthodes d'une classe imbriquée avant sa déclaration, il faut écrire une annotation @Nested. Exemple:

public class AppTest {
    @Nested
    public class DevStagingEnvironment {
    @Test
        void testOnDev(){
            System.setProperty("ENV", "DEV");
            Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
        }
   }

    @Nested
    public class ProductionEnvironment {
        @Test
        void testOnProd(){
           System.setProperty("ENV", "PROD");
           Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
        }
   }
}

Plus de détails peuvent être trouvés dans la documentation officielle .

4.3 @ExtendWith

Une autre annotation utile est @ExtendWith. Vous la rencontrerez très probablement très souvent, alors regardons-la plus en détail.

JUnit est un framework puissant qui vous permet d'écrire divers plugins (extensions) pour une personnalisation flexible de votre travail. Certaines extensions peuvent collecter des statistiques sur les tests, d'autres peuvent émuler un système de fichiers en mémoire, d'autres peuvent émuler le travail à l'intérieur d'un serveur Web, etc.

Si votre code s'exécute dans un framework (par exemple, Spring), alors presque toujours ce framework gère la création et la configuration des objets dans votre code . Par conséquent, un plugin de test spécial est indispensable. Exemples:

Exemple 1. L'extension WebServerExtensionpasse à la méthode de test appelée URLpour fonctionner correctement.

@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());
}

C'est ainsi que les tests commencent généralement à tester le code qui fonctionne avec le framework Spring :

@ExtendWith(SpringExtension.class)
@ExtendWith(MockitoExtension.class)
class TestServiceTest {

    @MockBean
    TestService service;

    @Test
    void test() {
        assertNotNull(service); // Test succeeds
    }
}

SpringExtensioncrée une version de test du framework Spring, mais MockitoExtentionvous permet de créer de faux objets. Les faux objets sont un sujet très intéressant, nous y reviendrons certainement, mais un peu plus tard.

4.4 @Timeout

Terminons cette conférence par une petite annotation intéressante @Timeout. Il vous permet de définir l'heure d'exécution du test. Si le test a pris plus de temps que spécifié dans l'annotation, il est considéré comme ayant échoué.

class TimeoutDemo {
    @Test
    @Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
    void failsIfExecutionTimeExceeds100Milliseconds() {
        // test will fail if it takes more than 100 milliseconds
    }
}

Ceci conclut notre exposé.