Introduzione alle annotazioni JUnit
JUnit è uno dei framework di test più potenti, basati su Java e open source disponibili gratuitamente sul mercato. Aiuta nella creazione semplice e rapida di casi di test e nell'esecuzione di casi di test in base ai requisiti con l'aiuto di annotazioni. Le annotazioni forniscono sostanzialmente informazioni aggiuntive sulle classi e sui metodi utilizzati nel codice Java. Aiuta a eseguire test di ogni singolo componente dell'unità, che si tratti di metodi, classi, pacchetti e variabili. È comunemente usato per test unitari di applicazioni. L'ultimo aggiornamento di JUnit è JUnit5. Supporta il driver web Selenium per i test di automazione di applicazioni Web e mobili. org. Junit è il pacchetto che contiene tutte le interfacce e le classi per i test tramite JUnit.
Annotazioni JUnit s con esempio
Di seguito sono riportate alcune delle annotazioni JUnit:
1. @Prima
Esistono scenari in cui è necessario creare alcuni casi di test o dati di test prima dell'esecuzione del test case effettivo. In tal caso, @Before sono apparse nell'immagine. L'annotazione di qualsiasi metodo pubblico con questa annotazione consente l'esecuzione del codice / metodo prima di ogni metodo @test effettivo. Nel caso dell'ereditarietà, vengono chiamati prima i metodi @before della superclasse e poi i metodi @before della classe corrente.
2. @Dopo
È esattamente l'opposto dell'annotazione @Before. Viene utilizzato nei casi in cui è necessario eseguire alcune azioni come il rilascio di risorse, la pulizia della memoria, la stampa di qualsiasi cosa sulla console dopo l'esecuzione del metodo @test (dopo l'esecuzione di ogni caso di test). C'è un punto importante che dovrebbe essere notato per l'annotazione @After è che verrà eseguito anche nel caso in cui i metodi @test o @before generino un'eccezione. Nel caso della relazione tra sottoclasse e superclasse, il metodo @after della sottoclasse / classe corrente viene eseguito prima del metodo @after della superclasse.
3. @BeforeClass
Questa annotazione viene utilizzata negli scenari in cui è necessario eseguire alcune azioni prima dell'esecuzione di qualsiasi caso di test di una determinata classe come la creazione di una connessione con il database, la creazione di una voce in un database, la voce nei registri, ecc. Quando @BeforeClass l'annotazione viene utilizzata prima di qualsiasi metodo, quel metodo viene eseguito prima di qualsiasi metodo di test in una classe. Il suo funzionamento è simile alla sola differenza dell'annotazione @Before, poiché @Before esegue il metodo prima dell'esecuzione di ogni metodo @test mentre @BeforeClass esegue una sola volta, ovvero prima dell'esecuzione di qualsiasi metodo @test in una classe.
4. @AfterClass
Tutte le risorse allocate nel metodo @BeforeClass devono essere rilasciate dopo l'esecuzione di tutti i metodi @test della classe corrente. Questa deallocazione di risorse o qualsiasi attività importante che deve essere eseguita dopo l'esecuzione dell'intera classe viene eseguita con il metodo @AfterClass. In termini semplici, il metodo @AfterClass viene eseguito dopo l'esecuzione di tutto il metodo @test della classe corrente. Viene eseguito una sola volta. I metodi @AfterClass sono obbligatori anche se i metodi @BeforeClass generano un'eccezione.
Come il metodo @After, il funzionamento del metodo @AfterClass è simile, ad eccezione del fatto che il metodo @After viene eseguito dopo ogni metodo @test della classe mentre il metodo @AfterClass viene eseguito una volta dopo l'esecuzione di tutti i metodi @test di una classe.
5. @Test
Questa annotazione specifica che il metodo pubblico in questa annotazione fa parte del caso di test principale che deve essere eseguito. Il metodo sotto @test definisce il caso di test come superato o fallito a seconda che si verifichino eccezioni / errori nell'esecuzione.
Può anche essere utilizzato in 2 modi:
- @Test (timeout = 500): accetta il parametro come timeout che accetta i valori in millisecondi. Considera il caso di test come fallito quando l'esecuzione richiede più tempo del previsto e passa quando viene eseguita correttamente entro il limite di tempo specificato.
- @Test (previsti = Exception.class): ci sono situazioni in cui vogliamo che alcuni metodi generino un'eccezione specifica. Il caso di test fallisce se il metodo non genera alcuna eccezione o la suddetta eccezione.
6. @Ignore
Ci sono scenari in cui vogliamo ignorare alcuni casi di test e non vogliamo eseguirli. @Ignore aiuta per lo stesso. I metodi nelle annotazioni @Ignore non vengono eseguiti e vengono ignorati durante l'esecuzione del codice. Anche nei report generati da TestNG mostra il conteggio dei casi di test che vengono ignorati e il numero di casi di test passati.
Esempio
Facciamo un esempio delle annotazioni JUnit
package demo;
import org.junit.*;
public class JUnitAnnotationTest (
// Run once, before any @test method in the class are executed
@BeforeClass
public static void bClass() (
System.out.println("BeforeClass method is called”);
)
// Run once after all the @test methods of the class are executed
@AfterClass
public static void aClass() (
System.out.println("AfterClass method is called");
)
// Run before every @test method of a class is executed
@Before
public void bMethod() (
System.out.println("before method is called");
)
// Run after every @test method of class is executed
@After
public void aMethod() (
System.out.println("after method is called");
)
// Test method which has actual test case
@Test
public void testMethod() (
System.out.println("Test method is called");
)
)
Produzione:
Vantaggi delle annotazioni JUnit
Di seguito sono riportati alcuni dei vantaggi delle annotazioni JUnit:
- JUnit fornisce un modo semplice per eseguire i casi di test in un modo specifico in base alle esigenze dell'utente.
- È facile eseguire parallelamente più casi di test utilizzando JUnit combinandoli in una suite di test.
- Le annotazioni JUnit utilizzate per automatizzare i casi di test in Selenium forniscono all'utente un rapporto grafico molto dettagliato e interattivo che è anche molto intuitivo.
- JUnit permette di passare i parametri nel metodo usando un modo molto semplice.
- L'annotazione JUnit aiuta a eseguire una codifica pulita che è molto facile da capire sia per i tester che per i programmatori.
Conclusione
La spiegazione sopra descrive chiaramente l'importanza del framework JUnit e l'ordine in cui vengono invocate varie annotazioni di JUnit. È molto importante comprendere le varie annotazioni prima di usarle in un programma in modo che non crei alcun problema nel controllo del flusso di esecuzione.
Articoli consigliati
Questa è una guida alle annotazioni JUnit. Qui discutiamo l'introduzione e le annotazioni di JUnit con l'esempio che include @ Before, @ After, @ Test e @Ignore, ecc. Puoi anche consultare gli altri articoli suggeriti per saperne di più -
- Test unitari
- Test su scatola bianca
- Selenium Architecture
- Collaudare l'imbragatura