junit test suite filtering test cases
Questo tutorial discuterà cos'è una suite di test JUnit, come creare una suite di test e come filtrare i casi di test in JUnit 4 vs JUnit 5:
Abbiamo imparato come saltare alcuni casi di test durante l'esecuzione nel nostro tutorial precedente. Abbiamo anche appreso delle diverse annotazioni utilizzate in JUnit 4 e JUnit 5 per farlo.
In questo tutorial impareremo:
- Cos'è una suite di test?
- Come creiamo una suite di test racchiudendo più casi di test in un gruppo ed eseguendo la suite utilizzando la classe JUnitCore?
=> Visita qui per l'esclusiva serie di tutorial di formazione JUnit.
Cosa imparerai:
- JUnit Test Suite
- Filtering Test Suite - JUnit 4 vs JUnit 5
- Conclusione
JUnit Test Suite
JUnit 4: @RunWith, @SuiteClasses Annotations
Il tutorial Diversi modi per eseguire i test JUnit illustrato come creare una suite di test in JUnit 4.
Le annotazioni @Corri con e @SuiteClasses ci ha aiutato a creare una suite di test raggruppando più classi di test JUnit. Successivamente, un file runner con classe JUnitCore.runclasses () ha richiamato l'esecuzione della suite di test creata.
Fare riferimento alla sezione menzionata per tutti i dettagli minuti sul flusso di lavoro insieme al codice effettivo per JUnit 4.
JUnit 5: @RunWith, @SelectClasses, @SelectPackages Annotazioni
La creazione di una suite di test in JUnit 5 è abbastanza simile a quello che abbiamo in JUnit 4. Allora, qual è la differenza allora?
# 1) Nel JUnit 4 , abbiamo Suite.class che viene passato come parametro all'annotazione @RunWith per supportare la creazione di una suite di test mentre JUnit 5 usa la stessa annotazione @RunWith ma con il parametro di input come JUnitPlatform.class invece di Suite.class .
Quindi, la riga di codice in JUnit 5 assomiglia @RunWith (JUnitPlatform.class). Questa è l'annotazione fornita con il tuo sottoprogetto JUnit Platform.
#Due) Nel JUnit 4 , noi usiamo @SuiteClasses per raggruppare più classi JUnit separate da una virgola mentre si è in JUnit 5 noi abbiamo:
- L'annotazione @SelectClasses che è equivalente a @SuiteClasses in JUnit 4 per raggruppare più classi JUnit.
- @SelectPackages l'annotazione viene utilizzata per raggruppare più test dai pacchetti. È necessario immettere un valore di matrice di stringhe che rappresenta il pacchetto che si desidera includere.
Quindi, in altre parole,
- Se nel caso in cui desideri raggruppare i casi di test da un singolo pacchetto, JUnit 5 ti consente di farlo.
- O nel caso in cui desideri raggruppare casi di test da più pacchetti, JUnit 5 ti supporta anche in questo. Una nota da ricordare qui è che i test in tutti i sotto-pacchetti del pacchetto menzionato vengono inclusi anche nella suite di test per impostazione predefinita.
JUnit 5: diversi scenari / esempi
Creazione di una suite di test che raggruppa più classi di test
Lo snippet del codice è mostrato di seguito:
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { }
Creazione di una suite di test per un singolo pacchetto
Lo snippet del codice è mostrato di seguito:
@RunWith(JUnitPlatform.class) @SelectPackages({“ demo.tests “}) public class JUnit5TestSuite { }
Nota :
- Dire demo.tests pacchetto ha un sottopacchetto demo.tests.subtests.
- Il codice @SelectPackages ({'demo.tests'}) includerà anche tutti i test sotto il sottopacchetto nella suite di test; per impostazione predefinita.
- Se tu avessi dichiarato @SelectPackages ({'demo.tests.subtests'}) , i casi di test nel sottopacchetto demo.tests.subtests sarà incluso solo nella suite di test mentre i test dal suo pacchetto genitore, ad es. demo.tests non sarebbe incluso.
Creazione di una suite di test per più pacchetti
Lo snippet di codice per creare una suite di test per più pacchetti separati da una virgola in JUnit 5 - apparirà come mostrato di seguito:
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests”, “demo1.tests”, “demo2.tests”}) public class JUnit5TestSuite { }
Filtering Test Suite - JUnit 4 vs JUnit 5
A volte, dobbiamo filtrare i casi di test ed eseguire un particolare set di test in base alle nostre esigenze. Ad esempio, potrebbe essere identificato un set di test per i test di regressione, un set separato per i test unitari e un set separato di test case per il test del fumo.
Dobbiamo escludere o includere casi di test da determinati pacchetti, classi o categorie. Filtrare o contrassegnare i test da un singolo pacchetto è l'unica opzione con JUnit4.
Rispetto a JUnit 4, JUnit 5 viene fornito con un buon set di funzionalità per supportare questa esigenza di filtrare i casi di test dal singolo pacchetto o più pacchetti e sotto-pacchetti in base alle mutevoli esigenze.
JUnit 4 - @Category, @IncludeCategory, @ExcludeCategory
I casi di test in JUnit 4 possono essere classificati in diverse categorie. Queste categorie possono essere escluse o incluse durante l'esecuzione della suite di test. Le annotazioni @Category, @IncludeCategory e @ExcludeCategory sono supportati da JUnit 4.12 e versioni successive.
I passaggi di alto livello per creare i filtri in base alla categoria o alle categorie sono i seguenti:
# 1) Crea un'interfaccia marker che svolga un ruolo nella categoria.
#Due) Annotare i metodi di test delle classi da includere nelle SuiteClasses con @Categoria e il nome della categoria.
# 3) Nel file della suite di test, usa l'annotazione @IncludeCategory con il nome della categoria per includere i test appartenenti a una categoria specifica.
# 4) Nel file della suite di test, usa l'annotazione @ExcludeCategory con il nome della categoria per escluderli.
# 5) L'annotazione @Category può essere utilizzata anche a livello di test o di classe. Se l'annotazione viene applicata a livello di test, quel test specifico viene etichettato con la categoria data mentre se l'annotazione è a livello di classe, tutti i test all'interno della classe vengono etichettati nella categoria data.
Diamo un'occhiata ad alcuni dettagli in più per comprendere l'implementazione pratica della categorizzazione dei test e del loro filtro per l'esecuzione:
Passo 1:
Inizieremo con la creazione di un file interfaccia marker che svolgerà il ruolo di a categoria per i metodi di prova. Qui creiamo una categoria denominata UnitTest . Il codice è molto semplice. Fare riferimento al codice sottostante.
Codice per UnitTest.java
package demo.tests; public interface UnitTest {}
Passo 2:
Contrassegneremo la categoria al livello del metodo di prova in classe JUnitTestCase1.java . Per aggiungere il test case junitMethod1 () nella categoria UnitTest, dobbiamo annotare il metodo di test con @Category (UnitTest.class) .
Questo aggiunge il metodo di test alla categoria UnitTest. Gli altri metodi di test (se presenti) non vengono contrassegnati nella categoria a meno che i metodi non siano annotati con una categoria.
Per fare in modo che l'annotazione @Category funzioni nel nostro codice, dobbiamo importare il pacchetto org.junit.experimental.categories.Category
Lo snippet di codice da JUnitTestCase1.java:
@Category(UnitTest.class) @Test public void junitMethod1(){ int Value2=9000; Assert. assertEquals (Value1, Value2); }
In alternativa, anche un metodo di prova può appartenere a più categorie Per esempio. : @Category (UnitTest.class, SmokeTest.class)
Passaggio 3:
Ora vorrei contrassegnare la categoria a livello di classe in classe JUnitTestCase2.java . La stessa istruzione aggiunta a livello di metodo di test nel passaggio precedente verrà aggiunta anche al file di classe corrente.
Nota che qui aggiungeremo la dichiarazione a livello di classe. In questo modo tutti i metodi di test nel file apparterranno al file UnitTest Categoria.
Lo snippet di codice da JUnitTestCase2.java:
@Category(UnitTest.class) @Test public class JUnitTestCase2 { public String stringValue='JUnit';
Passaggio 4:
come usare il comando find in unix
Ora che i nostri casi di test richiesti sono stati classificati nella categoria UnitTest, vedremo ora come aggiungerli alla suite di test filtrandoli in base alla categoria. Apporteremo alcune modifiche al codice nel file JUnitTestSuite.class per dimostrarlo.
- Categories.class verrà passato come parametro all'annotazione @RunWith.
- @ Suite.SuiteClasses prenderà l'array di stringhe delle classi di test.
- L'annotazione @ Categories.IncludeCategory avrà bisogno di UnitTest.class come parametro.
- Questa istruzione ci aiuterà a filtrare l'intera suite ed eseguire solo i casi di test dalla suite che appartiene alla categoria.
- Categories.class ha bisogno del pacchetto org.junit.experimental.categories.Categories da importare.
Lo snippet di codice per JunitTestSuite.java
@RunWith(Categories.class) @Categories.IncludeCategory(UnitTest.class) @Suite.SuiteClasses({JUnitTestCase1.class, JUnitTestCase2.class}) public class JUnitTestSuite {
L'annotazione @ Categories.IncludeCategory può anche essere scritto come @IncludeCategory. È inoltre possibile creare più interfacce (categorie) e annotare i metodi di classe / test con più categorie separate da una virgola. L'esempio seguente filtrerà i test appartenenti alla categoria: Categoria1 e Categoria2.
Esempio: @IncludeCategory ({Category1.class, Category2.class})
Regole simili vanno con @ Categories.ExcludeCategory / @ExcludeCategory per escludere i metodi di prova sotto la categoria o le categorie durante l'esecuzione del test.
JUnit 5 - @IncludeTags, @ExcludeTags, @IncludePackages, @ExcludePackages, @IncludeClassNamePatterns, @ExcludeClassNamePatterns
JUnit 5 viene fornito con più approcci per organizzare e filtrare i casi di test.
JUnit 5 - @IncludeTags, @ExcludeTags
# 1) Come JUnit 4 ha annotazioni @IncludeCategory e @ExcludeCategory per supportare il filtraggio dei casi di test per l'esecuzione.
#Due) JUnit 5 ha annotazioni @IncludeTags e @ExcludeTags per ottenere lo stesso scopo.
# 3) JUnit 4 si riferisce ai casi di test da organizzare in una categoria specifica mentre JUnit 5 si riferisce alla codifica dei casi di test con un tag specifico per abilitare il filtraggio dei casi di test per l'esecuzione.
I passaggi di alto livello per creare i filtri basati sui tag sono i seguenti:
- Annota i metodi di prova dei pacchetti da includere in @SelectPackages con @Etichetta e il nome del tag definito dall'utente. Una classe può avere tag diversi per diversi metodi di test.
- Puoi anche annotare @Tag a livello di classe in modo che tutti i test nella classe siano contrassegnati.
- Nel file della suite di test, usa l'annotazione @IncludeTags con il nome del tag per includere i test appartenenti a un tag specifico.
- Nel file della suite di test, usa l'annotazione @ExcludeTags con il nome del tag per escluderli dalla suite di test.
Vediamo ora un'illustrazione dettagliata su come implementare praticamente il filtro in JUnit 5.
Passo 1 : Stiamo contrassegnando un metodo di test in JUnit5TestCase1.java con il nome del tag 'Regression'
Lo snippet di codice da JUnit5TestCase1.java:
@Tag(“Regression”) @Test public void junitMethod1(){
Passo 2 : Stiamo contrassegnando un metodo di test in JUnit5TestCase2.java con il nome del tag 'SmokeTest'.
Lo snippet di codice da JUnit5TestCase2.java:
@Tag(“SmokeTest”) @Test public void junitMethod2(){
Passaggio 3: Ora che i metodi di test sono stati contrassegnati, aggiorneremo JUnit5TestSuite.java per aggiungere filtri appropriati per tag per i test. Il codice seguente include tutti i test contrassegnati come 'Regressione' ed esclude tutti quelli contrassegnati come 'SmokeTest'.
Lo snippet di codice da JUnit5TestSuite.java:
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { }
JUnit 5 - @IncludePackages, @ExcludePackages
Sappiamo già che quando passiamo un nome di pacchetto nel file @SelectPackages annotazione, anche i test nei sotto-pacchetti del pacchetto vengono aggiunti alla suite di test.
Potrebbero esserci alcuni sotto-pacchetti che vogliamo includere nella nostra suite di test mentre alcuni altri sotto-pacchetti che non vogliamo o potrebbero non essere rilevanti da includere nella nostra suite.
Ciò è facilitato dalle annotazioni @IncludePackages e @ExcludePackages in JUnit 5.
Supponiamo di avere un pacchetto 'demo.tests' che ha tre sotto-pacchetti, cioè subpackage1, subpackage2 e subpackage 3 con le sue classi di test in ciascuno dei pacchetti seguenti.
Vediamo uno snippet di codice di JUnit5TestSuite.java per visualizzare come includere ed escludere un pacchetto.
Scenario 1: Applica il filtro per includere i casi di test solo dal sottopacchetto1.
Il codice seguente include tutti i test di tutte le classi JUnit nel pacchetto demo.tests.subpackage1, tuttavia, esclude tutti i test direttamente sotto il pacchetto demo.test e quelli sotto il pacchetto subpackage2 e subpackage3.
Lo snippet di codice da JUnit5TestSuite.java:
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludePackages(“demo.tests.subpackage1”) public class JUnit5TestSuite { }
Scenario n. 2: Applica il filtro per escludere i casi di test solo dal sottopacchetto del pacchetto 3.
Il codice seguente esclude tutti i test dalle classi JUnit nel pacchetto - demo.tests.subpackage3 tuttavia la suite include tutti i test direttamente sotto il pacchetto demo.test e quelli sotto il pacchetto subpackage1 e subpackage2.
Lo snippet di codice da JUnit5TestSuite.java:
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludePackages(“demo.tests.subpackage3”) public class JUnit5TestSuite { }
JUnit 5 - @IncludeClassNamePatterns, @ExcludeClassNamePatterns
Quando si desidera includere o escludere determinate classi che corrispondono a un'espressione regolare specifica dal pacchetto, le annotazioni @ IncludeClassNamePatterns e @ ExcludeClassnamePatterns può essere utilizzato nel file di classe della suite di test.
Vediamo ora l'illustrazione attraverso l'aggiornamento del codice in JUnit5TestSuite.java
Scenario 1:
Il codice seguente include classi che terminano con 'Ctests' dal pacchetto demo.tests
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeClassNamePatterns({'^.*CTests?$'})
Scenario n. 2:
Ora escluderemo quelle classi that iniziato con 'STest' dal pacchetto demo.tests
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludeClassNamePatterns({'^STest.*$'})
Scenario n. 3:
È anche possibile passare più espressioni regolari come criteri di filtro. Il codice seguente indica due diverse espressioni regolari separate dal carattere ' O 'Operatore. La barra a fessura | è l'operatore OR qui.
domande e risposte all'intervista all'amministratore di salesforce
Il codice filtra le classi iniziando con Test ( Test.*) o finire con Test (*. Test?) e include quelle classi nella suite di test come annotazione @IncludeClassNamePatterns viene utilizzata.
Nota: Se il nome completo della classe corrisponde ad almeno un modello, la classe verrà recuperata in base all'annotazione @IncludeClassNamePatterns o @ExcludeClassNamePatterns.
@RunWith (JUnitPlatform.class)
@SelectPackages ({'demo.tests'})
@IncludeClassNamePatterns (. * Tests?) $ ')
Domande frequenti sui casi di test di filtro JUnit
Ecco una domanda che potrebbe essere stata nella tua mente per un bel po 'di tempo.
D # 1) Qual è la differenza tra disabilitare / ignorare un test e filtrare un test? Nessuna delle funzionalità può aiutare a servire allo stesso scopo di saltare i casi di test durante l'esecuzione?
Risposta: La domanda è davvero genuina e vale la pena rispondere.
- Con la funzione di filtraggio dei test, puoi escludere anche includere test a seconda della categoria contrassegnata. Considerando che, con la disabilitazione, si può decidere solo di escludere e non includere i test per l'esecuzione.
- Filtrare i casi di test è una sorta di caso di test che salta condizionatamente mentre, nel caso di test ignorati, questi vengono saltati senza condizioni.
- Un'altra differenza significativa tra i due è che quando esegui i casi di test con i test annotati con @Ignore o @Disabled, i test ignorati vengono visualizzati nei risultati del test sotto il SALTO contare
- Quando si eseguono i test filtrati, non vengono visualizzati affatto nei risultati del test.
Conclusione
In questo tutorial, abbiamo imparato come filtrare i test aggiungendo una categoria / tag ai test.
In JUnit 4 abbiamo appreso che abbiamo @Category, @IncludeCategory e @ExcludeCategory per filtrare i casi di test mentre JUnit 5 ha @IncludeTags e @ExcludeTags per fare lo stesso.
Inoltre, 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 classe. Più stiamo esplorando; ci rendiamo conto che c'è ancora molto altro da esplorare.
=> Guarda qui la semplice serie di formazione JUnit.
Lettura consigliata
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Test JUnit: come scrivere casi di test JUnit con esempi
- Elenco delle annotazioni JUnit: JUnit 4 Vs JUnit 5
- Tutorial JUnit per principianti - Che cos'è il test JUnit
- Che cos'è un dispositivo di prova JUnit: tutorial con esempi di JUnit 4
- Diversi modi per eseguire i test JUnit
- Scarica, installa e configura JUnit in Eclipse
- Introduzione a JUnit Framework e al suo utilizzo in Selenium Script - Selenium Tutorial # 11