junit test execution order
Questo tutorial spiega come impostare l'ordine di esecuzione per i casi di test JUnit. Imparerai a conoscere le annotazioni e le classi per impostare l'ordine di esecuzione del test JUnit in JUnit 4 rispetto a JUnit 5:
Abbiamo imparato come creare una suite di test, come aggiungere una categoria o un tag ai casi di test e come filtrare i test (escludere o includere i casi di test) in base alla categoria o al tag nel nostro precedente tutorial.
Inoltre, abbiamo imparato che in JUnit 4, abbiamo @Category, @IncludeCategory, e @ExcludeCategory per filtrare i casi di test mentre JUnit 5 ha @IncludeTags e @ExcludeTags fare lo stesso.
JUnit 5 ha opzioni di filtro aggiuntive utilizzando le annotazioni @IncludePackages, @ExcludePackages, e anche annotazioni per includere o escludere classi utilizzando modelli di nomi di classi.
=> Controlla qui per vedere i tutorial di formazione dalla A alla Z di JUnit .
Cosa imparerai:
Ordine di esecuzione del test JUnit
In questo tutorial impareremo come impostare un ordine per ogni test case in modo che vengano eseguiti nell'ordine stabilito. Impareremo come ordinare i test in JUnit 4 così come in JUnit 5.
I metodi di test non seguono un ordine specifico per impostazione predefinita.I casi di test non devono necessariamente essere eseguiti nell'ordine in cui sono stati scritti.
Esistono diversi modi o modalità per impostare l'ordine di esecuzione dei casi di test. Approfondiremo anche il modo in cui JUnit 4 varia nell'ordinare i casi di test rispetto a JUnit 5.
JUnit 4: @FixedMethodOrder, Class MethodSorters
A partire da JUnit 4.11, abbiamo l'annotazione @FixMethodOrder e MethodSorters.class supportare la facilità di impostare un ordine per l'esecuzione di un test.
Il pacchetto org.junit.runners. * deve essere importato per includere la classe MethodSorter . Questa classe decide come ordinare i casi di test. MethodSorter avere tre enum valori.
Di seguito sono riportati i valori enum della classe insieme allo scopo che ciascuno dei valori serve:
MethodSorters.DEFAULT | Questo valore enum ordina l'esecuzione del test in un ordine specifico. Tuttavia, non è mai prevedibile in quale ordine potrebbe eseguire i casi di test. |
Questo è il motivo per cui hai il controllo sulla tua decisione su quale testcase dovrebbe essere eseguito per primo e quale dovrebbe seguire dopo. | |
Ho osservato che una classe con più metodi ordinati con enumerazione DEFAULT quando viene eseguita, l'ordine rimane lo stesso ogni volta durante l'esecuzione del test. | |
Tuttavia, non c'è modo di prevedere o capire il modo in cui è stato impostato l'ordine. | |
MethodSorters.JVM | L'ordine di esecuzione del test con JVM enum è come il nome implica è determinato dalla JVM. |
In questo caso, ogni volta che si esegue la classe, i test verranno eseguiti non nello stesso ma in ordine casuale. | |
In altre parole, l'ordine dei test cambia durante ogni esecuzione. | |
MethodSorters.NAME_ASCENDING | Questo enum ordina i metodi di prova in base all'ordine lessicografico del nome del metodo. Quindi, puoi essere certo che questo è il modo più prevedibile per ordinare l'esecuzione del test. |
Puoi quindi decidere in anticipo la sequenza dei test in base all'ordine lessicografico del nome che hai impostato. |
L'annotazione @FixedMethodOrder accetta il parametro di input di MethodSorter con il suo valore enum. Il pacchetto necessario per l'annotazione è org.junit.FixedMethodOrder.
Vediamo come viene implementato tramite il codice.
Implementazione del codice per MethodSorters.DEFAULT
Creiamo un file di classe JUnit ' Junit4TestOrder.java ' dove useremo MethodSorters.DEFAULT
Il codice per Junit4TestOrder.java
@FixMethodOrder(MethodSorters.DEFAULT) public class JUnit4TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } }
Eseguiamo la classe tre volte e vediamo lo stesso ordine di test eseguiti come di seguito, tuttavia, i casi di test possono o non possono essere eseguiti nell'ordine ordinato.
La finestra della console mostrava i risultati come di seguito: l'ordine di esecuzione del test è TestCase_3, TestCase_1 e TestCase_2 e l'ordine non cambia con il numero di esecuzioni.
Implementazione del codice per MethodSorter. JVM
Ora aggiorneremo 'Junit4TestOrder.java' per avere MethodSorters.JVM
Lo snippet di codice per Junit4TestOrder.java
@FixMethodOrder(MethodSorters . JVM ) public class JUnit4TestOrder {
Eseguiamo la classe due volte e l'ordine di esecuzione dei test cambia a ogni esecuzione.
La finestra della console per primo run è come mostrato di seguito:
La finestra della console per secondo run è come mostrato di seguito:
Osserva attentamente il cambiamento nell'ordine in cui i test vengono eseguiti in entrambe le prove. L'ordine dei test nelle due serie è stato diverso.
Implementazione del codice per MethodSorters.NAME_ASCENDING
Ora aggiorneremo 'Junit4TestOrder.java' per avere MethodSorters.NAME_ASCENDING
Lo snippet di codice per Junit4TestOrder.java
@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class JUnit4TestOrder {
Eseguiamo la classe due volte, l'ordine dei test eseguiti rimane lo stesso e viene eseguito in base all'ordine crescente del nome del metodo.
La finestra della console mostra il risultato dei test eseguiti nell'ordine TestCase_1, TestCase_2 e TestCase_3.
JUnit 5: @TestMethodOrder, @Order, Interface MethodOrderer
Per controllare l'ordine di esecuzione dei test, le entità seguenti aiutano a fare lo stesso:
- L'annotazione @TestMethodOrder
- L'annotazione @Order
- Le classi che appartengono alle interfacce MethodOrderer
Le classi MethodOrderer incorporate ei loro dettagli sono i seguenti:
MethodOrderer è integrato nella classe | Dal pacchetto | Dettagli |
---|---|---|
Alfanumerico | org.junit.jupiter.api.MethodOrderer.Alphanumeric | Ordina i metodi di prova in modo alfanumerico in base ai loro nomi |
OrderAnnotation | org.junit.jupiter.api.MethodOrderer.OrderAnnotation | Ordina numericamente i metodi di test in base ai valori passati all'annotazione @Order |
Casuale | org.junit.jupiter.api.MethodOrderer.Random | Ordina i metodi di test in modo casuale proprio come nel caso MethodSorters.JVM in JUnit 4 |
Vediamo ora la dimostrazione di ciascuna di queste strategie di ordinamento:
Implementazione del codice per Alphanumeric.class
Creiamo un file di classe JUnit 5 denominato JUnit5TestOrder.java uguale a JUnit4TestOrder.java e usiamo l'annotazione con Alphanumeric.class per ordinare i test in ordine alfanumerico.
Il codice per Junit5TestOrder.java
@TestMethodOrder(Alphanumeric.class) public class JUnit5TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } }
Abbiamo eseguito la classe tre volte e continuiamo a vedere lo stesso ordine di test eseguiti nell'ordine alfanumerico del nome del metodo di test.
Dopo l'esecuzione del file di classe, l'ordine di esecuzione del test:
- Testcase_1,
- Testcase_2 e
- Testcase_3
Nota: La strategia di ordinamento alfanumerico fa distinzione tra maiuscole e minuscole quindi nel caso avessimo un altro caso di test con il nome testcase_1.
L'ordine di esecuzione sarebbe:
- Testcase_1,
- Testcase_2,
- Testcase_3,
- testcase_1.
Quindi, le lettere maiuscole hanno la priorità sui nomi dei metodi in minuscolo.
Implementazione del codice per Random.class
Aggiorneremo ora la classe JUnit 5 JUnit5TestOrder.java per utilizzare l'annotazione con Random.class
Lo snippet di codice per Junit5TestOrder.java
@TestMethodOrder (Random.class) public class JUnit5TestOrder {
Abbiamo eseguito la classe due volte e abbiamo visto che ogni volta che abbiamo eseguito la classe, l'ordine di esecuzione del test era ordinato in modo casuale.
Dopo l'esecuzione del file di classe per prima volta , l'ordine di esecuzione del test era:
- Testcase_2,
- Testcase_1
- Testcase_3
L'ordine di esecuzione quando viene eseguito per il secondo il tempo ha mostrato:
- Testcase_2,
- Testcase_3
- Testcase_1 .
Implementazione del codice per OrderAnnotation.class
Aggiorneremo ora la classe JUnit 5 JUnit5TestOrder.java per utilizzare l'annotazione con OrderAnnotation.class. L'annotazione @Ordine svolgerà anche un ruolo importante nella definizione delle priorità dei metodi di prova qui.
Lo snippet di codice per Junit5TestOrder.java
@TestMethodOrder(OrderAnnotation.class) public class JUnit5TestOrder { @Test @Order(1) public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test @Order(2) public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test @Order(3) public void Testcase_2() { System.out.println('Testcase_2 executes '); } }
Quindi, in questa strategia di impostazione dell'ordine per l'esecuzione del test, l'annotazione @Order impone l'esecuzione dei metodi di test secondo valore dell'ordine essere pronto per questo.
Più basso è il valore di @Order per un metodo di test, maggiore è la sua priorità durante l'esecuzione.
Dopo l'esecuzione, l'ordine dei test è stato eseguito come segue:
- Testcase_3,
- Testcase_1
- Testcase_2 perché l'ordine impostato per i casi di test è rispettivamente 1,2 e 3.
Questo è il motivo per cui non importa se i casi di test sono scritti in ordine. Inoltre, non importa se i nomi dei metodi sono o meno in ordine alfanumerico.
JUnit 5: creazione di un ordine personalizzato
Inoltre, le classi Order integrate, JUnit 5 supporta anche ordini personalizzati implementando l'interfaccia MethodOrderer . A partire da JUnit 5 versione 5.4, è supportato l'ordinamento personalizzato.
Vediamo rapidamente come creare e implementare un ordine personalizzato in base alla lunghezza del metodo.
Passo 1: Creata una classe di ordine personalizzata che implementa l'interfaccia MethodOrderer e denominata la classe TestCaseLengthOrder
Il codice per TestCaseLengthOrder.java
public class TestCaseLengthOrder implements MethodOrderer { @Override public void orderMethods(MethodOrdererContext context) { MethodDescriptor md1; MethodDescriptor md2; context.getMethodDescriptors().sort((md1, md2)-> md1.getMethod().getName().length().compareTo(md2.getMethod().getName().length())); } }
Spiegazione del codice TestCaseLengthOrder:
- Una classe di ordine personalizzata viene creata implementando l'interfaccia MethodOrderer.
- void orderMethods (MethodOrderContext context) {} metodo che è il metodo integrato implementato dall'interfaccia MethodOrderer. Qui è dove si definisce l'implementazione della logica di ordinamento dei test.
- MethodDescriptor è un'interfaccia che racchiude i dettagli su un metodo:
- Il metodo MethodDescriptor.getMethod () ottiene il nome del metodo per questo descrittore.
- Il nome del metodo viene convertito in String con il metodo getName (), ovvero MethodDescriptor.getMethod (). GetName () e
- Il metodo length () recupera la lunghezza del metodo (proprio come string.length () recupera la lunghezza di un valore stringa).
- Tutti i nomi dei metodi vengono confrontati tra loro utilizzando il metodo compareTo ().
- Il metodo getMethodDescriptors () ottiene l'elenco di tutti i descrittori di metodo in una classe.
- Il metodo sort () ordina gli oggetti MethodDescriptor.
Ora che abbiamo compreso chiaramente ogni API di MethodOrderer, speriamo che sia facile interpretare il codice sopra.
Passo 2 : Usa la classe di ordine personalizzato come usi qualsiasi ordine incorporato nella classe di test.
Come input per l'annotazione @TestMethodOrder.
Il codice per JUnit_CustomOrder.java
@TestMethodOrder(TestCaseLengthOrder.class) class JUnit_CustomOrder{ @Test public void subt(){ } @Test public void add(){ } @Test public void multiply(){ } @Test public void divide(){ }
Passaggio 3:
Dopo l'esecuzione di JUnit_CustomOrder.class , l'ordine di esecuzione del test è il seguente in base all'ordine crescente della lunghezza del nome dei casi di test:
- Inserisci(),
- subt (),
- dividere ()
- moltiplicare()
Conclusione
Per concludere questo tutorial su JUnit Test Execution Order.
- Abbiamo imparato come impostare l'ordine dei casi di test utilizzando annotazioni specifiche e classi specifiche.
- Abbiamo anche imparato vari modi per ordinare i test per JUnit 4 e JUnit 5, in base ai quali sono cambiate le strategie di ordinamento.
- Inoltre, abbiamo imparato come in JUnit 5, potremmo anche creare una classe di ordinamento personalizzata e usarla per ordinare i casi di test durante la loro esecuzione.
=> Dai un'occhiata alla guida per principianti di JUnit qui.
Lettura consigliata
- Test JUnit: come scrivere casi di test JUnit con esempi
- Elenco delle annotazioni JUnit: JUnit 4 Vs JUnit 5
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- JUnit Test Suite e test case di filtraggio: JUnit 4 Vs JUnit 5
- Che cos'è un dispositivo di prova JUnit: tutorial con esempi di JUnit 4
- Tutorial JUnit per principianti - Che cos'è il test JUnit
- Diversi modi per eseguire i test JUnit
- Come eseguire l'esecuzione su larga scala di test Appium in parallelo