Het doel van een unit-test is om de fouten in een applicatie zo snel mogelijk te identificeren. Hoewel verschillende kanalen u naar hetzelfde doel kunnen leiden, moet u ernaar streven de meest efficiënte route te gebruiken.
Een JUnit-testsuite kan verschillende testklassen hebben die dezelfde gegevens nodig hebben, maar u kunt testgegevens niet opnieuw gebruiken. In eerdere versies van JUnit was het een goede aanpak om een utility-methode te maken en die methode vervolgens aan te roepen elke keer dat een testklasse zijn gegevens nodig had.
JUnit 5 biedt een efficiëntere aanpak van dit probleem: afhankelijkheidsinjectie (DI).
Wat is afhankelijkheidsinjectie?
DI is een ontwerppatroon waarbij een object de afhankelijkheden van een ander object levert. Wanneer u een Java-toepassing bouwt, hebt u mogelijk een klasse die afhankelijk is van een object dat een andere klasse maakt om zijn functie uit te voeren.
Om een object uit een andere klasse te gebruiken, moet u vóór de afhankelijkheidsinjectie een nieuwe instantie van dat object maken binnen de klasse die ervan afhankelijk is. Dus als u meerdere klassen had die afhankelijk zijn van hetzelfde object, zou u er meerdere instanties van moeten maken binnen de afhankelijke klassen.
Met DI kunt u een object in een afhankelijke klasse gebruiken, zonder er een nieuwe instantie van te maken in die klasse.
Afhankelijkheidsinjectie in JUnit 5
Met JUnit 5 kunt u afhankelijkheden in zowel testmethoden als constructors injecteren. Dit is belangrijk omdat de vorige versies van het framework geen testmethoden of constructors toestonden om parameters te hebben.
Met JUnit 5 kunt u zoveel parameters injecteren als u wilt. Het enige addertje onder het gras is dat de ParameterResolver API elke parameter tijdens runtime moet kunnen oplossen. JUnit heeft momenteel drie ingebouwde parameterresolvers die automatisch worden gebruikt. Als u een andere resolver wilt gebruiken, moet u deze expliciet registreren met de annotatie @ExtendWith.
Afhankelijkheden injecteren in JUnit
Dit voorbeeldprogramma gebruikt een van de ingebouwde parameters van JUnit (de TestInfoParameterResolver), om aan te tonen hoe u een afhankelijkheid in een JUnit 5-test. De TestInfoParameterResolver lost objecten op die bij de TestInfo-interface horen. JUnit 5 levert dus een instantie van de TestInfo-interface aan elke methode of constructor die deze gebruikt.
importerenstatisch org.junit.jupiter.api. Beweringen.*;
importeren org.junit.jupiter.api. Weergavenaam;
importeren org.junit.jupiter.api. Test;
importeren org.junit.jupiter.api. Testinfo;klasInfoTestInterfaceTest{
// Een testInfo-object injecteren in de InfoTestInterfaceTest-constructor
InfoTestInterfaceTest (TestInfo testInfo) {
assertEquals("InfoTestInterfaceTest", testInfo.getDisplayName());
}// Een testInfo-object in methoden injecteren
@Test
leegtetestMethodeNaam(TestInfo testInfo){
assertEquals("testMethodName (TestInfo)", testInfo.getDisplayName());
}
@Test
@Weergavenaam("methode met behulp van de @Weergavenaam annotatie")
leegtetestMethodeNaamTwee(TestInfo testInfo){
assertEquals("methode met behulp van de @Weergavenaam annotatie", testInfo.getDisplayName());
}
}
De JUnit-test hierboven laat zien hoe een object in een constructor moet worden geïnjecteerd en twee methoden. De JUnit-testinfo interface heeft vier methoden die u met zijn object kunt gebruiken.
De methode getDisplayName() is het nuttigst. Het retourneert de weergavenaam van de huidige testmethode of constructor. Deze naam is standaard gebaseerd op de klasse. Maar als je gebruikt de annotatie @DisplayName, retourneert de methode getDisplayName() die tekst.
De bovenstaande testklasse genereert het volgende testrapport:
Gebruik DI in @Before- en @After-methoden
Er zijn vier andere typen JUnit-geannoteerde methoden die afhankelijkheden ondersteunen. Dit zijn de annotaties @BeforeAll, @BeforeEach, @AfterAll en @AfterEach. Net als bij de @Test-methode hoef je alleen maar een object door te geven aan een van de voor- of na-methoden als parameter, en je bent klaar om te gaan.
De annotaties @Before en @After zijn belangrijk, omdat ze u ook helpen om efficiëntere testcode te ontwikkelen. De mogelijkheid hebben om ook afhankelijkheden in deze methoden te injecteren, zal uw testcode verder verbeteren.
