Skapa JUnit Testa Suite med exempel: @RunWith @SuiteClasses

In JUnit, en testsvit låter oss aggregera alla testfall från flera klasser på ett ställe och köra dem tillsammans.

För att köra suite-testet måste du annotera en klass med hjälp av nedanstående annoteringar:

1. @RunWith(Suite.class)
2. @SuiteClasses(test1.klass, test2.klass…) eller @Suite.SuiteClasses({test1.klass, test2.klass…})

Med ovanstående annoteringar kommer alla testklasser i sviten att börja köras en efter en. Själva sviten förblir tom: den är bara en hållare för annoteringarna, och löparen läser dessa annoteringar för att bestämma vad som ska köras.

Steg för att skapa Test Suite och Test Runner

De fyra stegen nedan bygger den minsta sviten som faktiskt körs: två vanliga testklasser, en sviteklass som namnger dem och en runner som startar sviten från en main-metod.

Steg 1) Skapa en enkel testklass (t.ex. MyFirstClassTest) och lägg till en metod kommenterad med @Testa.

Den första klassen innehåller en enda tom testmetod, vilket är tillräckligt för att bevisa att sviten plockar upp den:

Steg 2) Skapa en annan testklass att lägga till (t.ex. MySecondClassTest) och skapa en metod kommenterad med @Test.

Den andra klassen följer exakt samma form, så sviten har två separata klasser att aggregera:

Steg 3) För att skapa en testSuite måste du först annotera klassen med @RunWith(Suite.class) och @SuiteClasses(class1.class, class2.class…).

Observera att suite-klassen TestSuiteExample inte deklarerar någon egen testmetod — de två annoteringarna innehåller all information:

Steg 4) Skapa en Test Runner-klass för att köra vår testsvit enligt nedan:

Löparen är en slät Java klass med en main-metod som överlämnar suite-klassen till JUnitKärna:

Code Förklaring:

• Code Linje 8: Deklarera huvudmetoden för klassen Test som kommer att köra vår JUnit testet.
• Code Linje 9: Exekvera testfall med hjälp av JUnitCore.runClasses som tar testklassnamnet som en parameter (i exemplet ovan använder du TestSuiteExample.class som visas i steg 3).
• Code Linje 11: Bearbetar resultatet med en for-loop och skriver ut det misslyckade resultatet.
• Code Linje 13: Skriver ut det lyckade resultatet.

Produktion: Här är resultatet som visar ett lyckat test utan fel trace enligt nedan:

Den gröna stapeln bekräftar vad en svit är till för: en start, en resultatvy och båda klasserna rapporteras under svitnoden snarare än i två separata körningar.

JUnit Exempel på testsvit

Tänk dig ett mer komplext exempel, där klasserna inuti sviten faktiskt hävda något istället för att hålla en tom metod.

JunitTest.java

JunitTest.java är en enkel klass kommenterad med @Spring med och @Svit anteckningar. Du kan lista valfritt antal klasser i sviten som parametrar, enligt nedan:

package guru99.junit;		
import org.junit.runner.RunWith;		
import org.junit.runners.Suite;		

@RunWith(Suite.class)				
@Suite.SuiteClasses({				
  SuiteTest1.class,
  SuiteTest2.class,  			
})		

public class JunitTest {				
			// This class remains empty, it is used only as a holder for the above annotations		
}

SuiteTest1.java

SuiteTest1.java är en testklass som har testmetoder som skriver ut ett meddelande, enligt nedan. Du kommer att använda den här klassen som en svitmedlem i klassen som nämns ovan. Den förlitar sig på en hjälpklass med namnet JUnitMeddelande, som definieras på annan plats i samma paket och inte återges här.

package guru99.junit;		

import static org.junit.Assert.assertEquals;				

import org.junit.Test;		

public class SuiteTest1 {				

    public String message = "Saurabh";							

    JUnitMessage junitMessage = new JUnitMessage(message);							

    @Test(expected = ArithmeticException.class)					
    public void testJUnitMessage() {					

        System.out.println("Junit Message is printing ");					
        junitMessage.printMessage();			

    }		

    @Test		
    public void testJUnitHiMessage() {					
        message = "Hi!" + message;							
        System.out.println("Junit Hi Message is printing ");					
        assertEquals(message, junitMessage.printHiMessage());					
        System.out.println("Suite Test 2 is successful " + message);							
    }		
}		

SuiteTest2.java

SuiteTest2.java är en annan testklass, liknande SuiteTest1.java, med en testmetod för att skriva ut ett meddelande enligt nedan. Du kommer att använda den här klassen som en svitmedlem i JunitTest.java.

package guru99.junit;		

import org.junit.Assert;		
import org.junit.Test;		

public class SuiteTest2 {				
   	

    @Test		
    public void createAndSetName() {					
        		

        String expected = "Y";					
        String actual = "Y";					

        Assert.assertEquals(expected, actual);					
        System.out.println("Suite Test 1 is successful " + actual);							
    }		

}		

Produktion

Efter att ha utförts JunitTest.java, som innehåller en svit som innehåller SuiteTest1.java och SuiteTest2.java, får du utdata nedan. Konsolen skriver ut meddelandena som produceras av båda klasserna:

Ocuco-landskapet JUnit visa poster samma körning som tre godkända testmetoder grupperade under suite-klassen:

Obs: Konsoletiketterna i det här exemplet är överstrukna — strängen som skrivs ut av SuiteTest1 lyder "Suite Test 2" och den som skrivs ut av SuiteTest2 lyder "Suite Test 1". De ursprungliga listningarna reproduceras oförändrade, så etiketterna förblir som författaren skrev dem; läs klassnamnet i JUnit vyn snarare än den utskrivna etiketten när du matchar utdata med källan.

Hur man skapar en testsvit i JUnit 5

JUnit 5 tar bort runners helt och hållet, så @RunWith(Suite.class) finns inte i org.junit.jupiter-paketen. Suites flyttades till JUnit Plattform, som skickar dem i en separat artefakt som kallas junit-plattforms-svit-motorLägg till det beroendet och annotera sedan en klass med @Suite och en av selektorannoteringarna.

import org.junit.platform.suite.api.SelectClasses;
import org.junit.platform.suite.api.Suite;
import org.junit.platform.suite.api.SuiteDisplayName;

@Suite
@SuiteDisplayName("Guru99 suite")
@SelectClasses({ SuiteTest1.class, SuiteTest2.class })
public class JunitTest {
    // Empty holder, exactly as in JUnit 4
}

Selektorannoteringarna ersätter den enda @SuiteClasses-listan med en liten familj av alternativ:

Ytterligare två skillnader spelar roll i praktiken. JUnit 5-svitklassen kan deklarera @BeforeSuite- och @AfterSuite-metoderna, som körs en gång runt hela sviten, och JUnit 4 exempel ovan körs fortfarande på JUnit Plattformen genom den gamla motorn, så att originalkoden på den här sidan inte behöver skrivas om för att fortsätta fungera.

Fördelar och begränsningar med JUnit Testsviter

En svit är en gruppping mekanism, inte en testramverk av sig själv, och det formar både vad den gör bra och var den slutar vara användbar.

Fördelar

• En uppskjutning kör relaterade klasser tillsammans, så en rökuppsättning eller en regression set startas med ett enda kommando.
• Resultatvyn grupperar varje klass under en svitnod, vilket gör det lättare att upptäcka ett delat fel.
• Medlemslistan finns i kod, så den granskas och versioneras som vilken annan källfil som helst.
• Samma svitklass kan startas från en IDE, från en runner som t.ex. JUnitKärna, eller från ett byggverktyg.

Begränsningar

• @SuiteClasses är en hårdkodad lista, så en ny testklass utelämnas tyst tills någon redigerar sviten.
• Sviten ger ingen ordningsgaranti utöver den ordning i vilken klasserna listas.
• Ingenting delas mellan medlemsklasserna, så en svit är inte en ersättning för en fixtur eller en basklass.
• Byggverktyg identifierar redan testklasser genom namngivningskonventioner, vilket gör en svit överflödig i många projekt.

Vanliga fel när man skapar en JUnit Test svit

De flesta problem i sviterna ger ett kort, ohjälpsamt meddelande. Tabellen kopplar de meddelanden du sannolikt kommer att stöta på till deras orsak och åtgärda dem.

Att skriva sviten en gång och hållaping Det är korrekt om det är det verkliga arbetet. Om listan avviker från klasserna på disken, rapporteras sviten grönt medan en del av enhetstest set körs aldrig alls, ett av de tystaste fellägena i mjukvarutestning.

Vanliga frågor