junit test execution order
Acest tutorial explică cum să setați ordinea de execuție pentru cazurile de testare JUnit. Veți afla despre Adnotări și clase pentru a seta ordinea de execuție a testului JUnit în JUnit 4 vs JUnit 5:
Am învățat cum să creăm o suită de teste, cum să adăugăm o categorie sau o etichetă la cazurile de testare și cum să filtrăm testele (excludem sau includem cazurile de testare) pe baza categoriei sau etichetei din tutorialul nostru anterior.
În plus, am aflat că în JUnit 4, avem @Categorie, @IncludeCategorie, și @ExcludeCategory pentru filtrarea cazurilor de test în timp ce JUnit 5 are @IncludeTags și @ExcludeTags să facă la fel.
JUnit 5 are opțiuni suplimentare de filtrare folosind adnotări @IncludePackages, @ExcludePackages, și, de asemenea, adnotări pentru a include sau exclude clase folosind modele de nume de clasă.
=> Verificați aici pentru a vedea tutorialele de instruire J-Unit .
Ce veți învăța:
Ordinul de executare a testului JUnit
În acest tutorial, vom învăța cum să setăm o comandă pentru fiecare caz de testare, astfel încât să ruleze în ordinea setată. Vom învăța cum să comandăm teste în JUnit 4, precum și în JUnit 5.
Metodele de testare nu respectă în mod prestabilit o anumită comandă.Testele nu trebuie să se execute neapărat în ordinea în care au fost scrise.
Există diferite moduri sau moduri de a seta ordinea de execuție pentru cazurile de testare. De asemenea, ne vom scufunda profund în modul în care variază JUnit 4 în ordonarea cazurilor de test în comparație cu JUnit 5.
JUnitatea 4: @FixedMethodOrder, Class MethodSorters
Începând cu JUnit 4.11, avem adnotarea @FixMethodOrder și MethodSorters.class sprijinirea facilității de stabilire a unei comenzi pentru executarea unui test.
Pachetul org.junit.runners. * trebuie importat pentru a include clasa MethodSorters . Această clasă decide cum trebuie ordonate cazurile de testare. MethodSorters avea Trei enum valori.
Dat mai jos sunt valorile enum ale clasei, împreună cu scopul pe care fiecare valoare îl servește:
| MethodSorters.DEFAULT | Această valoare enumerată sortează execuția testului într-o ordine specifică. Cu toate acestea, nu este niciodată previzibil cu privire la ordinea în care ar putea rula cazurile de testare. |
| Acesta este motivul pentru care aveți controlul asupra deciziei dvs. cu privire la ce testcase ar trebui să ruleze primul și care ar trebui să urmeze în continuare. | |
| Am observat că o clasă cu mai multe metode sortate cu DEFAULT enum atunci când este executată, ordinea rămâne aceeași de fiecare dată în timpul executării testului. | |
| Cu toate acestea, nu există nicio modalitate prin care aș putea prezice sau afla modul în care a fost stabilită comanda. | |
| MethodSorters.JVM | Ordinea de execuție a testului cu enumerarea JVM este după cum sugerează și numele este determinată de JVM. |
| În acest caz, de fiecare dată când rulați clasa, testele vor fi executate nu în aceeași ordine, ci în ordine aleatorie. | |
| Cu alte cuvinte, ordinea testelor se schimbă în timpul fiecărei runde. | |
| MethodSorters.NAME_ASCENDING | Această enumerare sortează metodele de testare în ordinea lexicografică a numelui metodei. Prin urmare, puteți fi sigur că acesta este cel mai previzibil mod de a ordona executarea testului. |
| Prin urmare, puteți decide în prealabil succesiunea testelor pe baza ordinii lexicografice a numelui pe care l-ați setat. |
Adnotarea @FixedMethodOrder preia parametrul de intrare al MethodSorters cu valoarea sa enumerată. Pachetul necesar adnotării este org.junit.FixedMethodOrder.
Să vedem cum este implementat prin cod.
Implementarea codului pentru MethodSorters.DEFAULT
Să creăm un fișier de clasă JUnit „ Junit4TestOrder.java ' unde vom folosi MethodSorters.DEFAULT
Codul pentru 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 '); } } Executăm clasa de trei ori și vedem aceeași ordine de teste care se execută ca mai jos, totuși, cazurile de testare pot sau nu să fie executate în ordinea sortată.
Fereastra consolei a arătat rezultatele după cum urmează - ordinea de execuție a testului este TestCase_3, TestCase_1 și TestCase_2, iar ordinea nu se modifică cu numărul de rulări.
Implementarea codului pentru MethodSorters. JVM
Acum vom actualiza „Junit4TestOrder.java” pentru a avea MethodSorters.JVM
Fragmentul de cod pentru Junit4TestOrder.java
@FixMethodOrder(MethodSorters . JVM ) public class JUnit4TestOrder {Rulăm clasa de două ori și ordinea de execuție a testelor se modifică cu fiecare rulare.
Fereastra consolei pentru primul rularea este așa cum se arată mai jos:
Fereastra consolei pentru al doilea rula este așa cum se arată mai jos:
Observați cu atenție schimbarea în ordinea în care testele sunt executate în ambele curse. Ordinea testelor în cele două probe a diferit.
Implementarea codului pentru MethodSorters.NAME_ASCENDING
Acum vom actualiza „Junit4TestOrder.java” pentru a avea MethodSorters.NAME_ASCENDING
Fragmentul de cod pentru Junit4TestOrder.java
@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class JUnit4TestOrder { Rulăm clasa de două ori, ordinea testelor executate rămâne aceeași și se execută conform ordinii crescătoare a numelui metodei.
Fereastra consolei arată rezultatul testelor executate în ordinea TestCase_1, TestCase_2 și TestCase_3.
JUnitatea 5: @TestMethodOrder, @Order, Interface MethodOrderer
Pentru a controla ordinea de executare a testelor, entitățile de mai jos ajută la același lucru:
- Adnotarea @TestMethodOrder
- Adnotarea @Order
- Clasele care aparțin interfețelor MethodOrderer
Clasele încorporate MethodOrderer și detaliile acestora sunt după cum urmează:
| MethodOrderer este construit în clasă | Din pachet | Detalii |
|---|---|---|
| Alfanumeric | org.junit.jupiter.api.MethodOrderer.Alfanumeric | Sortează metodele de testare alfanumeric pe baza numelor lor |
| Notă de comandă | org.junit.jupiter.api.MethodOrderer.OrderAnnotation | Sortează metodele de testare numeric pe baza valorilor transmise adnotării @Order |
| Aleatoriu | org.junit.jupiter.api.MethodOrderer.Random | Sortează metodele de testare la întâmplare la fel ca în cazul MethodSorters.JVM în JUnit 4 |
Să vedem acum demonstrația fiecăreia dintre aceste strategii de ordonare:
Implementarea codului pentru Alphanumeric.class
Să creăm un fișier de clasă JUnit 5 numit JUnit5TestOrder.java la fel ca JUnit4TestOrder.java și să folosim adnotarea cu Alphanumeric.class pentru a ordona testele alfanumeric.
Codul pentru 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 '); } } Am rulat clasa de trei ori și vedem în continuare aceeași ordine de teste în ordinea alfanumerică a numelui metodei de testare.
Post executarea fișierului de clasă, ordinea executării testului:
- Testcase_1,
- Testcase_2 și
- Testcase_3
Notă: Strategia de sortare alfanumerică este sensibil la majuscule și minuscule deci, în cazul în care am avut un alt caz de testare cu numele testcase_1.
Ordinea de execuție ar fi:
- Testcase_1,
- Testcase_2,
- Testcase_3,
- testcase_1.
Prin urmare, majusculele au prioritate față de numele metodelor minuscule.
Implementarea codului pentru Random.class
Acum vom actualiza clasa JUnit 5 JUnit5TestOrder.java pentru a utiliza adnotarea cu Random.class
Fragmentul de cod pentru Junit5TestOrder.java
@TestMethodOrder (Random.class) public class JUnit5TestOrder {Am condus clasa de două ori și am văzut că de fiecare dată, am condus clasa, ordinea executării testului a fost ordonată aleatoriu.
Post executarea fișierului de clasă pentru prima data , ordinea de execuție a testului a fost:
- Testcase_2,
- Testcase_1
- Testcase_3
Ordinea de execuție când s-a executat pentru al doilea timpul a arătat:
- Testcase_2,
- Testcase_3
- Testcase_1 .
Implementarea codului pentru OrderAnnotation.class
Acum vom actualiza clasa JUnit 5 JUnit5TestOrder.java pentru a utiliza adnotarea cu OrderAnnotation.class. Adnotarea @Ordin va juca, de asemenea, un rol important în stabilirea priorității metodelor de testare aici.
Fragmentul de cod pentru 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 '); } }Deci, în această strategie de configurare a ordinii de execuție a testului, adnotarea @Order aplică metodele de testare pentru a rula valoarea comenzii fiind stabilit pentru aceasta.
Cu cât valoarea comenzii @ este mai mică pentru o metodă de testare, cu atât este mai mare prioritatea sa în timpul execuției.
După executare, ordinea testelor a funcționat după cum urmează:
- Testcase_3,
- Testcase_1
- Testcase_2 deoarece ordinea setată pentru cazurile de testare este 1,2 și respectiv 3.
Acesta este motivul pentru care nu contează dacă cazurile de testare sunt scrise în ordine. În plus, nu contează dacă numele metodelor sunt sau nu în ordine alfanumerică.
JUnitatea 5: Crearea unei comenzi personalizate
În plus, clasele de comenzi încorporate, JUnit 5 acceptă și comenzi personalizate prin implementarea interfeței MethodOrderer . Începând cu JUnit 5 versiunea 5.4, sortarea personalizată este acceptată.
Să vedem rapid cum să creați și să implementați o comandă personalizată după lungimea metodei.
Pasul 1: A creat o clasă de comandă personalizată care implementează interfața MethodOrderer și a numit clasa ca TestCaseLengthOrder
Codul pentru 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())); } }TestCaseLengthOrder explicație cod:
- O clasă de comandă personalizată este creată prin implementarea interfeței MethodOrderer.
- void orderMethods (context MethodOrderContext) {} metodă care este metoda încorporată implementată din Interface MethodOrderer. Aici definiți implementarea logicii de ordonare a testelor.
- MethodDescriptor este o interfață care conține detalii despre o metodă:
- Metoda MethodDescriptor.getMethod () obține numele metodei pentru acest descriptor.
- Numele metodei este convertit în String cu metoda getName () adică MethodDescriptor.getMethod (). GetName () și
- Metoda length () preluează lungimea metodei (la fel ca string.length () preluează lungimea unei valori de șir).
- Toate numele metodelor sunt comparate între ele folosind metoda compareTo ().
- Metoda getMethodDescriptors () obține lista tuturor descriptorilor metodei dintr-o clasă.
- Metoda sort () sortează obiectele MethodDescriptor.
Acum, că am înțeles în mod clar fiecare API al MethodOrderer, sperăm că este ușor să interpretăm codul de mai sus.
Pasul 2 : Utilizați clasa de comandă personalizată așa cum utilizați orice ordine încorporată în clasa de testare.
Ca intrare în adnotarea @TestMethodOrder.
Codul pentru 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(){ } Pasul 3:
Post executare a JUnit_CustomOrder.class , ordinea de execuție a testului este următoarea, pe baza ordinii crescătoare a lungimii numelui cazurilor de testare:
- adăuga(),
- subt(),
- divide ()
- multiplica()
Concluzie
Pentru a încheia acest tutorial despre ordinea de execuție a testului JUnit.
- Am învățat cum să setăm ordinea cazurilor de testare folosind adnotări specifice, precum și clase specifice.
- De asemenea, am învățat diferite moduri de a comanda teste pentru JUnit 4 și JUnit 5, pe baza cărora s-au schimbat strategiile de comandă.
- În plus, am învățat cum în JUnit 5 am putea crea și o clasă de sortare personalizată și să o folosim pentru ordonarea cazurilor de test în timpul execuției lor.
=> Aruncați o privire la Ghidul pentru începători JUnit aici.
Lectură recomandată
- Teste JUnit: Cum se scriu cazuri de testare JUnit cu exemple
- Lista adnotărilor JUnit: JUnit 4 Vs JUnit 5
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- JUnit Test Suite și filtrarea cazurilor de testare: JUnit 4 Vs JUnit 5
- Ce este un dispozitiv de testare JUnit: Tutorial cu exemple JUnit 4
- JUnit Tutorial pentru începători - Ce este testarea JUnit
- Mai multe moduri de a executa teste JUnit
- Cum se execută executarea pe scară largă a testelor Appium în paralel