Syftet med ett enhetstest är att identifiera felen i en applikation så snart du kan. Även om flera kanaler kan leda dig till samma mål, bör du sträva efter att använda den mest effektiva vägen.
En JUnit-testsvit kan ha flera testklasser som behöver samma data, men du kan inte återanvända testdata. I tidigare versioner av JUnit var ett bra tillvägagångssätt att skapa en verktygsmetod och sedan anropa den metoden varje gång en testklass behövde dess data.
JUnit 5 ger ett mer effektivt tillvägagångssätt för detta problem: beroendeinjektion (DI).
Vad är beroendeinjektion?
DI är ett designmönster där ett objekt tillhandahåller beroenden för ett annat objekt. När du bygger ett Java-program kan du ha en klass som beror på ett objekt som en annan klass skapar för att utföra sin funktion.
Innan beroendeinjektion, för att använda ett objekt från en annan klass, måste du skapa en ny instans av det objektet inom klassen som beror på det. Så om du hade flera klasser som är beroende av samma objekt, måste du skapa flera instanser av det inom de beroende klasserna.
DI låter dig använda ett objekt i en beroende klass, utan att skapa en ny instans av det i den klassen.
Beroendeinjektion i JUnit 5
JUnit 5 låter dig injicera beroenden i både testmetoder och konstruktörer. Detta är viktigt eftersom de tidigare versionerna av ramverket inte tillät att testmetoder eller konstruktörer hade parametrar.
JUnit 5 låter dig injicera så många parametrar du vill. Den enda haken är att ParameterResolver API måste kunna lösa varje parameter vid körning. JUnit har för närvarande tre inbyggda parameterupplösare som den använder automatiskt. För att använda någon annan resolver måste du registrera den explicit genom att använda @ExtendWith-kommentaren.
Injicerande beroenden i JUnit
Detta exempelprogram använder en av JUnits inbyggda parametrar (TestInfoParameterResolver) för att visa hur du kan injicera ett beroende i en JUnit 5 test. TestInfoParameterResolver löser objekt som hör till TestInfo-gränssnittet. Så, JUnit 5 kommer att leverera en instans av TestInfo-gränssnittet till vilken metod eller konstruktör som helst som använder den.
importerastatisk org.junit.jupiter.api. Påståenden.*;
importera org.junit.jupiter.api. DisplayName;
importera org.junit.jupiter.api. Testa;
importera org.junit.jupiter.api. TestInfo;klassInfoTestInterfaceTest{
// Injicera ett testInfo-objekt i InfoTestInterfaceTest-konstruktorn
InfoTestInterfaceTest (TestInfo testInfo) {
assertEquals("InfoTestInterfaceTest", testInfo.getDisplayName());
}// Injicera ett testInfo-objekt i metoder
@Testa
tomhettestmetodnamn(TestInfo testInfo){
assertEquals("testMethodName (TestInfo)", testInfo.getDisplayName());
}
@Testa
@Visningsnamn("metod som använder @Visningsnamn anteckning")
tomhettestMethodNameTwo(TestInfo testInfo){
assertEquals("metod som använder @Visningsnamn annotation", testInfo.getDisplayName());
}
}
JUnit-testet ovan visar hur man injicerar ett objekt i en konstruktor och två metoder. De JUnit TestInfo gränssnittet har fyra metoder som du kan använda med dess objekt.
Metoden getDisplayName() är den mest användbara. Det returnerar visningsnamnet för den aktuella testmetoden eller konstruktören. Som standard är detta namn baserat på klassen. Men om du använder @DisplayName-kommentaren, kommer metoden getDisplayName() att returnera den texten istället.
Testklassen ovan genererar följande testrapport:
Använd DI i @Before och @After Methods
Det finns fyra andra typer av JUnit-kommenterade metoder som stöder beroenden. Dessa är kommentarerna @BeforeAll, @BeforeEach, @AfterAll och @AfterEach. Precis som @Test-metoden är allt du behöver göra att skicka ett objekt till någon av före- eller eftermetoderna som en parameter, och du är klar.
@Före- och @Efter-kommentarerna är viktiga, eftersom de också hjälper dig att utveckla mer effektiv testkod. Att ha möjligheten att även injicera beroenden i dessa metoder kommer att förbättra din testkod ytterligare.
