Annotazioni utili in JUnit

4.1 @Disabilitato

Ora diamo un'occhiata ad alcune annotazioni molto utili e popolari del framework JUnit. La prima annotazione consente di disattivare un test specifico in modo che JUnit non lo chiami. È necessario nei casi in cui si nota che il test non funziona correttamente o si modifica il codice e il test si interrompe accidentalmente.

Come ho scritto prima, il 99% dei test non è supportato da nessuno, quindi prima o poi si rivelano tutti disabilitati. Pertanto, questa annotazione è la prima nell'elenco di quelle utili.

Considera il suo esempio:

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")));
    }
}

Nell'esempio precedente, il metodo testOnDev()non verrà chiamato. A proposito, l'annotazione @Disabledpuò essere scritta immediatamente prima della dichiarazione di classe, quindi tutti i suoi metodi verranno ignorati.

@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 @Nidificato

JUnit consente di chiamare metodi di test su classi nidificate. Intendo classi di test nidificate. Non è un dato di fatto che li incontrerai spesso, ma esiste una tale possibilità, quindi devi capire di cosa si tratta.

Per chiamare i metodi di una classe nidificata prima della sua dichiarazione, è necessario scrivere un'annotazione @Nested. Esempio:

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")));
        }
   }
}

Maggiori dettagli possono essere trovati nella documentazione ufficiale .

4.3 @ExtendWith

Un'altra annotazione utile è @ExtendWith. Molto probabilmente la incontrerai molto spesso, quindi diamo un'occhiata a lei in modo più dettagliato.

JUnit è un potente framework che ti consente di scrivere vari plugin (estensioni) per una personalizzazione flessibile del tuo lavoro. Alcune estensioni possono raccogliere statistiche sui test, altre possono emulare un file system in memoria, altre possono emulare il lavoro all'interno di un server web e così via.

Se il tuo codice è in esecuzione all'interno di un framework (ad esempio, Spring), quasi sempre questo framework gestisce la creazione e la configurazione degli oggetti nel tuo codice . Pertanto, è indispensabile uno speciale plug-in di test. Esempi:

Esempio 1. L'estensione WebServerExtensionpassa al metodo di test chiamato URLper funzionare correttamente.

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

Questo è il modo in cui i test di solito iniziano a testare il codice che funziona con il framework Spring:

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

    @MockBean
    TestService service;

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

SpringExtensioncrea una versione di prova del framework Spring, ma MockitoExtentionconsente di creare oggetti falsi. Gli oggetti falsi sono un argomento molto interessante, lo toccheremo sicuramente, ma un po 'più tardi.

4.4 @Timeout

Concludiamo questa lezione con una piccola e interessante annotazione @Timeout. Consente di impostare l'ora in cui eseguire il test. Se il test ha richiesto più tempo di quanto specificato nell'annotazione, viene considerato fallito.

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

Questo conclude la nostra lezione.