Brugerdefinerede JUnit 4 testløbere

1. Oversigt

I denne hurtige artikel vil vi fokusere på, hvordan man kører JUnit-tests ved hjælp af brugerdefinerede testløbere.

Kort sagt, for at specificere den brugerdefinerede løber skal vi bruge @RunWith kommentar.

2. Forberedelse

Lad os starte med at tilføje standarden JUnit afhængighed af vores pom.xml:

 junit junit 4.12 

3. Implementering af en brugerdefineret løber

I det følgende eksempel viser vi, hvordan vi skriver vores egen brugerdefinerede Løber - og kør det ved hjælp af @Kør med.

En JUnit Runner er en klasse, der udvider JUnits abstrakt Løber klasse og det er ansvarligt for at køre JUnit-tests, typisk ved hjælp af refleksion.

Her implementerer vi abstrakte metoder til Løber klasse:

offentlig klasse TestRunner udvider Runner {privat klasse testClass; offentlig TestRunner (Class testClass) {super (); this.testClass = testClass; } @Override public Description getDescription () {return Description .createTestDescription (testClass, "My runner description"); } @ Override public void run (RunNotifier notifier) ​​{System.out.println ("kører testene fra MyRunner:" + testClass); prøv {Object testObject = testClass.newInstance (); for (Metodemetode: testClass.getMethods ()) {if (method.isAnnotationPresent (Test.class)) {notifier.fireTestStarted (Beskrivelse .createTestDescription (testClass, method.getName ())); method.invoke (testObject); notifier.fireTestFinished (Beskrivelse .createTestDescription (testClass, method.getName ())); }}} fange (Undtagelse e) {smid ny RuntimeException (e); }}}

Det getDescription metoden arves fra Beskrivelig og returnerer a Beskrivelse der indeholder de oplysninger, der senere eksporteres og kan bruges af forskellige værktøjer.

I løb implementering påkalder vi måltestmetoderne ved hjælp af refleksion.

Vi har defineret en konstruktør, der tager en Klasse argument; dette er et krav fra JUnit. Ved kørsel videregiver JUnit måltestklassen til denne konstruktør.

RunNotifier bruges til fyring af begivenheder, der har information om testforløbet.

Lad os bruge løberen i vores testklasse:

public class Calculator {public int add (int a, int b) {return a + b; }} @RunWith (TestRunner.class) offentlig klasse CalculatorTest {Calculator calculator = new Calculator (); @Test offentlig ugyldig testAddition () {Syste.out.println ("i testAddition"); assertEquals ("addition", 8, calculator.add (5, 3)); }}

Resultatet får vi:

-------------------------------------------------- ----- TESTER -------------------------------------------- ----------- Kører com.baeldung.junit.CalculatorTest kører testene fra MyRunner: klasse com.baeldung.junit.CalculatorTest i testAddition Testkørsel: 1, Fejl: 0, Fejl: 0, springet over: 0, forløbet tid: 0,002 sek Resultater: Testkørsel: 1, Fejl: 0, Fejl: 0, Springet over: 0

4. Specialiserede løbere

I stedet for at udvide det lave niveau Løber klasse, som vi gjorde i sidste eksempel, vi kan udvide en af ​​de specialiserede underklasser af Løber: ParentRunner eller BlockJUnit4Runner.

Det abstrakte ParentRunner klasse kører testene på en hierarkisk måde.

BlockJUnit4Runner er en konkret klasse, og hvis vi foretrækker at tilpasse bestemte metoder, udvider vi sandsynligvis denne klasse.

Lad os se det med et eksempel:

offentlig klasse BlockingTestRunner udvider BlockJUnit4ClassRunner {offentlig BlockingTestRunner (klasse klass) kaster InitializationError {super (klass); } @ Override-beskyttet ErklæringsmetodeInvoker (FrameworkMethod-metode, Objekttest) {System.out.println ("påkaldelse:" + method.getName ()); returner super.methodInvoker (metode, test); }}

Annotering af en klasse med @RunWith (JUnit4.class) vil altid påberåbe sig standard JUnit 4-løber i den aktuelle version af JUnit; denne klasse kaldes den aktuelle standard JUnit 4 klasseløber:

@RunWith (JUnit4.class) offentlig klasse CalculatorTest {Calculator calculator = new Calculator (); @Test offentlig ugyldig testAddition () {assertEquals ("tilføjelse", 8, calculator.add (5, 3)); }}

5. Konklusion

JUnit Runners er meget tilpasningsdygtige og lader udvikleren ændre testudførelsesproceduren og hele testprocessen.

Hvis vi kun vil foretage mindre ændringer, er det en god idé at se på de beskyttede metoder til BlockJUnit4Class løber.

Nogle populære tredjepartsimplementeringer af løbere til brug inkluderer SpringJUnit4ClassRunner, MockitoJUnitRunner, HierarchicalContextRunner, Agurk Runner og meget mere.

Implementeringen af ​​alle disse eksempler og kodestykker findes i GitHub-projektet - dette er et Maven-projekt, så det skal være let at importere og køre, som det er.