junit test execution order
Denna handledning förklarar hur man ställer in utförandebeställningen för JUnit-testfall. Du kommer att lära dig mer om anteckningar och klasser för att ställa JUnit Test Execution Order i JUnit 4 vs JUnit 5:
Vi lärde oss hur man skapar en testsvit, hur man lägger till en kategori eller tagg i testfallet och hur man filtrerar bort test (exkluderar eller inkluderar testfall) baserat på kategorin eller taggen i vår tidigare handledning.
Dessutom fick vi veta att i JUnit 4 har vi gjort det @Category, @IncludeCategory, och @ExcludeCategory för att filtrera testfallet medan JUnit 5 har @IncludeTags och @ExcludeTags att göra detsamma.
JUnit 5 har ytterligare filtreringsalternativ med hjälp av anteckningar @IncludePackages, @ExcludePackages, och även anteckningar för att inkludera eller utesluta klasser med hjälp av klassnamnmönster.
=> Kolla här för att se A-Z av JUnit-utbildningar .
Vad du kommer att lära dig:
JUnit Test utförande order
I den här handledningen lär vi oss hur man ställer in en order för varje testfall så att de körs i den inställda ordningen. Vi lär oss hur man beställer tester i JUnit 4 såväl som i JUnit 5.
Testmetoderna följer inte en specifik ordning som standard.Testfallet behöver inte nödvändigtvis utföras i den ordning de skrivits.
Det finns olika sätt eller sätt att ställa in ordningsföljd för testfall. Vi kommer också att fördjupa oss i hur JUnit 4 varierar när vi beställer testfall jämfört med JUnit 5.
JUnit 4: @FixedMethodOrder, Class MethodSorters
Från och med JUnit 4.11 har vi anteckningen @FixMethodOrder och MethodSorters.class stödja möjligheten att ange en order för testets utförande.
Förpackningen org.junit.runners. * måste importeras för att inkludera klassen MetoderSorterare . Denna klass bestämmer hur testfallet måste beställas. MetoderSorterare ha tre enum värden.
Nedan anges klassens enumvärden tillsammans med syftet som varje värde tjänar:
| MethodSorters.DEFAULT | Detta enumvärde sorterar testkörningen i en specifik ordning. Det är dock aldrig förutsägbart i vilken ordning det kan köra testfallet. |
| Det är därför du har kontroll över ditt beslut om vilken testkassa som ska köras först och vilken som ska följa nästa. | |
| Jag har observerat att en klass med flera metoder sorterade med DEFAULT enum när den körs, förblir ordern densamma varje gång under testkörningen. | |
| Det finns dock inget sätt jag kunde förutsäga eller räkna ut hur ordern sattes. | |
| MethodSorters.JVM | Ordningen på testutförande med JVM-enum är som namnet antyder bestäms av JVM. |
| I det här fallet, varje gång du kör klassen, utförs testerna inte i samma men i slumpmässig ordning. | |
| Med andra ord ändras testordningen i varje körning. | |
| MethodSorters.NAME_ASCENDING | Detta nummer sorterar testmetoderna i lexikografisk ordning av metodnamnet. Därför kan du vara säker på att detta är det mest förutsägbara sättet att beställa ditt testkörning. |
| Du kan därför bestämma i förväg provsekvensen baserat på den lexikografiska ordningen på namnet du ställer in. |
Anteckningen @FixedMethodOrder tar in ingångsparametern för MetoderSorterare med dess enumvärde. Paketet som behövs för anteckningen är org.junit.FixedMethodOrder.
Låt oss se hur den implementeras genom koden.
Kodimplementering för MethodSorters.DEFAULT
Låt oss skapa en JUnit-klassfil ' Junit4TestOrder.java ' där vi ska använda MethodSorters.DEFAULT
Koden för 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 '); } } Vi kör klassen tre gånger och ser att samma ordning av test körs som nedan, men testfall kan exekveras eller inte i den sorterade ordningen.
Konsolfönstret visade resultaten enligt nedan - ordningen för testkörningen är TestCase_3, TestCase_1 och TestCase_2 och ordningen ändras inte med antalet körningar.
Kodimplementering för MethodSorters. JVM
Vi kommer nu att uppdatera 'Junit4TestOrder.java' att ha MethodSorters.JVM
Kodavsnittet för Junit4TestOrder.java
@FixMethodOrder(MethodSorters . JVM ) public class JUnit4TestOrder {Vi kör klassen två gånger och ordningen på testens utförande ändras för varje körning.
Konsolfönstret för först körning är som visas nedan:
Konsolfönstret för andra körning är som visas nedan:
Observera noga förändringen i den ordning i vilken testerna utförs i båda körningarna. Testordningen i de två körningarna har varierat.
Kodimplementering för MethodSorters.NAME_ASCENDING
Vi kommer nu att uppdatera 'Junit4TestOrder.java' att ha MethodSorters.NAME_ASCENDING
Kodavsnittet för Junit4TestOrder.java
@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class JUnit4TestOrder { Vi kör klassen två gånger, ordningen på de utförda testerna är densamma och utförs enligt den stigande ordningen på metodnamnet.
Konsolfönstret visar resultatet av de test som utförts i ordningen TestCase_1, TestCase_2 och TestCase_3.
JUnit 5: @TestMethodOrder, @Order, Interface MethodOrderer
För att kontrollera ordningen för utförande av tester hjälper nedanstående enheter att göra detsamma:
- Anteckningen @ TestMethodOrder
- Anteckningen @ Beställ
- Klasserna som tillhör MethodOrderer-gränssnitt
De inbyggda MethodOrderer-klasserna och deras detaljer är som nedan:
| Metod Beställning byggd i klassen | Från paketet | Detaljer |
|---|---|---|
| Alfanumerisk | org.junit.jupiter.api.MethodOrderer.Alphanumeric | Sorterar testmetoder alfanumeriskt baserat på deras namn |
| OrderAnnotation | org.junit.jupiter.api.MethodOrderer.OrderAnnotation | Sorterar testmetoder numeriskt baserat på de värden som skickas till anteckningen @ Order |
| Slumpmässig | org.junit.jupiter.api.MethodOrderer.Random | Sorterar testmetoder slumpmässigt precis som i fallet MethodSorters.JVM i JUnit 4 |
Låt oss nu titta på demonstrationen av var och en av dessa beställningsstrategier:
Kodimplementering för Alphanumeric.class
Låt oss skapa en JUnit 5-klassfil med namnet JUnit5TestOrder.java samma som JUnit4TestOrder.java och låt oss använda kommentaren med Alphanumeric.class för att beställa testerna alfanumeriskt.
Koden för 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 '); } } Vi körde klassen tre gånger och ser fortfarande att samma testordning körs i alfanumeriskt sorterad ordning på testmetodens namn.
Efter körning av klassfilen, ordningen på testkörningen:
- Testcase_1,
- Testcase_2 och
- Testcase_3
Notera: Den alfanumeriska sorteringsstrategin är skiftlägeskänslig så om vi hade ett nytt testfall med namnet testcase_1.
Ordern för avrättningen skulle vara:
- Testcase_1,
- Testcase_2,
- Testcase_3,
- testcase_1.
Därför prioriteras versaler över små bokstäver.
Kodimplementering för slumpmässig klass
Vi kommer nu att uppdatera JUnit 5-klass JUnit5TestOrder.java för att använda kommentaren med Random.class
Kodavsnittet för Junit5TestOrder.java
@TestMethodOrder (Random.class) public class JUnit5TestOrder {Vi körde klassen två gånger och vi såg att varje gång vi körde klassen ordnade testkörningen slumpmässigt.
Efter genomförande av klassfilen för första gången , ordningen för utförande av test var:
- Testcase_2,
- Testcase_1
- Testcase_3
Ordningen för utförande när den sprang för andra tiden visade:
- Testcase_2,
- Testcase_3
- Testcase_1 .
Kodimplementering för OrderAnnotation.class
Vi kommer nu att uppdatera JUnit 5-klass JUnit5TestOrder.java att använda kommentaren med OrderAnnotation.class. Anteckningen @Ordning kommer också att spela en viktig roll i prioriteringen av testmetoderna här.
Kodavsnittet för 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 '); } }Så, i den här strategin för att ställa in ordern för testkörning, tvingar @ Order-anteckningen testmetoderna att köras per beställningsvärde är inställd på det.
Ju lägre värdet på @ Order för en testmetod, desto högre är dess prioritet under körning.
Efter utförandet gick testordningen enligt följande:
- Testcase_3,
- Testcase_1
- Testcase_2 eftersom orderuppsättningen för testfallet är 1,2 respektive 3.
Det är därför det spelar ingen roll om testfallet skrivs i ordning. Dessutom spelar det ingen roll om metodnamnen är eller inte är i alfanumerisk ordning.
JUnit 5: Skapa anpassad beställning
Dessutom stöder JUnit 5 de inbyggda orderklasserna även anpassade order genom att implementera gränssnittet MetodBeställning . Från och med JUnit 5 version 5.4 stöds den anpassade sorteringen.
Låt oss snabbt se hur man skapar och implementerar en anpassad beställning efter metodlängd.
Steg 1: Skapade en anpassad orderklass som implementerar MethodOrderer-gränssnittet och namngav klassen som TestCaseLengthOrder
Koden för 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())); } }TestCaseLength Beställningskodförklaring:
- En anpassad orderklass skapas genom att implementera MethodOrderer-gränssnittet.
- void orderMethods (MethodOrderContext context) {} metod som är den inbyggda metoden implementerad från Interface MethodOrderer. Här definierar du implementeringen av testbeställningslogiken.
- MethodDescriptor är ett gränssnitt som innehåller detaljer om en metod:
- Metoden MethodDescriptor.getMethod () får metodnamnet för denna deskriptor.
- Metodnamnet konverteras till sträng med metoden getName () dvs. MethodDescriptor.getMethod (). GetName () och
- Metodlängden () hämtar metodens längd (precis som string.length () hämtar längden på ett strängvärde).
- Alla metodnamnen jämförs med varandra med jämförelsen CompareTo ().
- Metoden getMethodDescriptors () får listan över alla metodbeskrivare i en klass.
- Metoden sort () sorterar MethodDescriptor-objekten.
Nu, när vi har förstått varje API för MethodOrderer tydligt, hoppas vi att det är lätt att tolka ovanstående kod.
Steg 2 : Använd den anpassade orderklassen som om du använder vilken inbyggd ordning som helst i testklassen.
Som en ingång till anteckningen @ TestMethodOrder.
Koden för 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(){ } Steg 3:
Efter genomförande av JUnit_CustomOrder.class är ordningen för utförande av test enligt följande baserat på stigande ordning på längden på testfallets namn:
- Lägg till(),
- subt (),
- dela upp ()
- multiplicera()
Slutsats
För att avsluta denna handledning om JUnit Test Execution Order.
- Vi lärde oss att ställa in ordningen på testfall med hjälp av specifika anteckningar såväl som specifika klasser.
- Vi lärde oss också olika sätt att beställa tester för JUnit 4 och JUnit 5, baserat på vilka beställningsstrategierna förändrades.
- Dessutom lärde vi oss hur vi i JUnit 5 också kunde skapa en anpassad sorteringsklass och använda den för att beställa testfall under deras körning.
=> Ta en titt på JUnit nybörjarguiden här.
Rekommenderad läsning
- JUnit-tester: Hur man skriver JUnit-testfall med exempel
- Lista över JUnit-kommentarer: JUnit 4 Vs JUnit 5
- JUnit Ignorera testfall: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- JUnit Test Suite & Filtering Test Cases: JUnit 4 Vs JUnit 5
- Vad är en JUnit Test Fixture: Handledning med JUnit 4-exempel
- JUnit-handledning för nybörjare - Vad testas JUnit
- Flera sätt att utföra JUnit-tester
- Hur man kör storskaliga utförande av appiumtester parallellt