Inleiding tot JUnitParams

1. Overzicht

In dit artikel zullen we de JUnitParams bibliotheek en het gebruik ervan. Simpel gezegd, deze bibliotheek biedt eenvoudige parametrisering van testmethoden in JUnit testen.

Er zijn situaties waarin het enige dat tussen meerdere tests verandert, de parameters zijn. JUnit zelf heeft een parametriseringsondersteuning, en JUnitParams aanzienlijk verbetert op die functionaliteit.

2. Maven Afhankelijkheid

Gebruiken JUnitParams in ons project moeten we het toevoegen aan ons pom.xml:

 pl.pragmatists JUnitParams 1.1.0 

De laatste versie van de bibliotheek is hier te vinden.

3. Testscenario

Laten we een klasse maken die de veilige toevoeging van twee gehele getallen doet. Dit zou moeten terugkeren Geheel getal.MAX_VALUE als het overstroomt, en Geheel getal.MIN_VALUE als het onderstroomt:

openbare klasse SafeAdditionUtil {openbare int safeAdd (int a, int b) {lang resultaat = ((lang) a) + b; if (result> Integer.MAX_VALUE) {return Integer.MAX_VALUE; } else if (result <Integer.MIN_VALUE) {return Integer.MIN_VALUE; } return (int) resultaat; }}

4. Het construeren van een eenvoudige testmethode

We zullen de implementatie van de methode moeten testen voor verschillende combinaties van invoerwaarden, om er zeker van te zijn dat de implementatie waar is voor alle mogelijke scenario's. JUnitParams biedt meer dan één manier om de geparametriseerde testcreatie te bereiken.

Laten we de basisbenadering nemen met een minimale hoeveelheid codering en kijken hoe het wordt gedaan. Daarna kunnen we zien wat de andere mogelijke manieren zijn om de testscenario's met JUnitParams te implementeren:

@RunWith (JUnitParamsRunner.class) openbare klasse SafeAdditionUtilTest {privé SafeAdditionUtil serviceUnderTest = nieuwe SafeAdditionUtil (); @Test @Parameters ({"1, 2, 3", "-10, 30, 20", "15, -5, 10", "-5, -10, -15"}) public void whenWithAnnotationProvidedParams_thenSafeAdd (int a , int b, int verwachteValue) {assertEquals (verwachteValue, serviceUnderTest.safeAdd (a, b)); }}

Laten we nu eens kijken hoe deze testklasse verschilt van een gewone JUnit test klasse.

Het eerste dat opvalt, is dat er is eenverschillende testrunner in de klasannotatie - JUnitParamsRunner.

Als we verder gaan met de testmethode, zien we dat de testmethode is geannoteerd met @Parameters annotatie met een reeks invoerparameters. Het geeft verschillende testscenario's aan die zullen worden gebruikt om onze servicemethode te testen.

Als we de test uitvoeren met Maven, zullen we dat zien we voeren vier testcases uit en niet één. De uitvoer zou er ongeveer als volgt uitzien:

-------------------------------------------------- ----- TESTEN -------------------------------------------- ----------- Uitvoeren van com.baeldung.junitparams.SafeAdditionUtilTest Tests uitgevoerd: 4, fouten: 0, fouten: 0, overgeslagen: 0, verstreken tijd: 0,068 sec - in com.baeldung.junitparams.SafeAdditionUtilTest Resultaten: uitgevoerde tests: 4, fouten: 0, fouten: 0, overgeslagen: 0

5. Verschillende soorten parametrisering van testmethoden

Testparameters rechtstreeks in de annotatie aanbieden is zeker niet de meest leesbare manier als we veel mogelijke scenario's hebben die moeten worden getest. JUnitParams biedt een reeks verschillende benaderingen die we kunnen gebruiken om de geparametriseerde tests te maken:

  • Direct in het @Parameters annotatie (gebruikt in het bovenstaande voorbeeld)
  • Gebruikmakend van een benoemde testmethode die is gedefinieerd in de annotatie
  • Met behulp van een methode die is toegewezen aan de naam van de testmethode
  • Een benoemde testklasse die is gedefinieerd in de annotatie
  • Met behulp van een CSV-bestand

Laten we de benaderingen een voor een bekijken.

5.1. Direct in het @Parameters Annotatie

We hebben deze benadering al gebruikt in het voorbeeld dat we hebben geprobeerd. Wat we in gedachten moeten houden, is dat we een reeks parameterreeksen moeten leveren. Binnen de parametertekenreeks wordt elke parameter gescheiden door een komma.

De array zou bijvoorbeeld de vorm hebben van { “1, 2, 3”, “-10, 30, 20”} en een set parameters wordt weergegeven als “1, 2, 3”.

De beperking van deze benadering is dat we alleen primitieven en kunnen leveren Draads als testparameters. Het is niet mogelijk om objecten ook als testmethode-parameters in te dienen.

5.2. Parameter Methode

We kunnen de parameters van de testmethode leveren met een andere methode binnen de klas. Laten we eerst een voorbeeld bekijken:

@Test @Parameters (method = "parametersToTestAdd") openbare leegte whenWithNamedMethod_thenSafeAdd (int a, int b, int verwachteValue) {assertEquals (verwachteValue, serviceUnderTest.safeAdd (a, b)); } private Object [] parametersToTestAdd () {return new Object [] {new Object [] {1, 2, 3}, new Object [] {-10, 30, 20}, new Object [] {Integer.MAX_VALUE, 2 , Geheel getal.MAX_VALUE}, nieuw object [] {Geheel getal.MIN_VALUE, -8, Geheel getal.MIN_VALUE}}; }

De testmethode wordt geannoteerd over de methode parametersToAdd (), en het haalt de parameters op door de methode waarnaar wordt verwezen uit te voeren.

De specificatie van de providermethode moet een array van Voorwerps als resultaat. Als een methode met de opgegeven naam niet beschikbaar is, mislukt de testcase met de fout:

java.lang.RuntimeException: Kan methode niet vinden: bogusMethodName, dus er zijn geen parameters gebruikt.

5.3. Methode toegewezen aan de naam van de testmethode

Als we niets specificeren in het @Parameters annotatie, JUnitParams probeert een testgegevensprovidersmethode te laden op basis van de naam van de testmethode. De naam van de methode is opgebouwd als "ParametersFor" +:

@Test @Parameters openbare ongeldige whenWithnoParam_thenLoadByNameSafeAdd (int a, int b, int verwachteValue) {assertEquals (verwachteValue, serviceUnderTest.safeAdd (a, b)); } privé-object [] parametersForWhenWithnoParam_thenLoadByNameSafe () {retourneer nieuw object [] {nieuw object [] {1, 2, 3}, nieuw object [] {-10, 30, 20}, nieuw object [] {Geheel getal.MAX_VALUE, 2 , Geheel getal.MAX_VALUE}, nieuw object [] {Geheel getal.MIN_VALUE, -8, Geheel getal.MIN_VALUE}}; }

In het bovenstaande voorbeeld is de naam van de testmethode whenWithnoParam_shouldLoadByNameAbdSafeAdd ().

Daarom zoekt het, wanneer de testmethode wordt uitgevoerd, naar een gegevensprovidersmethode met de naam parametersForWhenWithnoParam_shouldLoadByNameAbdSafeAdd ().

Aangezien die methode bestaat, worden er gegevens uit geladen en wordt de test uitgevoerd. Als een dergelijke methode niet overeenkomt met de vereiste naam, mislukt de test zoals in het bovenstaande voorbeeld.

5.4. Genoemde testklasse gedefinieerd in de annotatie

Vergelijkbaar met de manier waarop we in een vorig voorbeeld naar een gegevensprovidersmethode verwezen, kunnen we naar een aparte klasse verwijzen om de gegevens voor onze test te leveren:

@Test @Parameters (bron = TestDataProvider.class) openbare leegte whenWithNamedClass_thenSafeAdd (int a, int b, int verwachteValue) {assertEquals (verwachteValue, serviceUnderTest.safeAdd (a, b)); } openbare klasse TestDataProvider {openbaar statisch object [] offerBasicData () {retourneer nieuw object [] {nieuw object [] {1, 2, 3}, nieuw object [] {-10, 30, 20}, nieuw object [] { 15, -5, 10}, nieuw object [] {-5, -10, -15}}; } openbaar statisch object [] offerEdgeCaseData () {retourneer nieuw object [] {nieuw object [] {Geheel getal.MAX_VALUE, 2, Geheel getal.MAX_VALUE}, nieuw object [] {Geheel getal.MIN_VALUE, -2, Geheel getal.MIN_VALUE},} ; }}

We kunnen een onbeperkt aantal testgegevensproviders in een klasse hebben, aangezien de naam van de methode begint met "bieden". Als dat het geval is, kiest de uitvoerder die methoden en retourneert de gegevens.

Als geen enkele klassemethode aan die vereiste voldoet, ook al retourneren die methoden een array van Voorwerps, worden deze methoden genegeerd.

5.5. Met behulp van een CSV-bestand

We kunnen een extern CSV-bestand gebruiken om de testgegevens te laden. Dit helpt als het aantal mogelijke testgevallen behoorlijk groot is, of als testgevallen vaak worden gewijzigd. De wijzigingen kunnen worden aangebracht zonder de testcode te beïnvloeden.

Laten we zeggen dat we een CSV-bestand hebben met testparameters als JunitParamsTestParameters.csv:

1,2,3 -10, 30, 20 15, -5, 10 -5, -10, -15

Laten we nu eens kijken hoe dit bestand kan worden gebruikt om testparameters te laden in de testmethode:

@Test @FileParameters ("src / test / resources / JunitParamsTestParameters.csv") openbare leegte whenWithCsvFile_thenSafeAdd (int a, int b, int verwachteValue) {assertEquals (verwachte waarde, serviceUnderTest.safeAdd (a, b)); }

Een beperking van deze benadering is dat het niet mogelijk is om complexe objecten te passeren. Alleen primitieven en Draads zijn geldig.

6. Conclusie

In deze tutorial hebben we gekeken hoe we de functionaliteiten van JUnitParams in een notendop.

We hebben ook verschillende benaderingen besproken die de bibliotheek ons ​​biedt om testparameters voor onze testmethoden te leveren - veel verder dan wat JUnit zelf kan doen.

Zoals altijd is de broncode te vinden op GitHub.