streamalism.org

1. Oversikt

I denne raske artikkelen skal vi fokusere på hvordan du kjører JUnit-tester ved hjelp av tilpassede testløpere.

Enkelt sagt, for å spesifisere den tilpassede løperen, må vi bruke @RunWith kommentar.

2. Forberedelse

La oss starte med å legge til standarden JUnit avhengighet i vår pom.xml:

 junit junit 4.12 

3. Implementere en tilpasset løper

I det følgende eksemplet viser vi hvordan vi kan skrive vår egen skikk Løper - og kjør den med @Kjør med.

En JUnit Runner er en klasse som utvider JUnits abstrakt Løper klasse og det er ansvarlig for å kjøre JUnit-tester, vanligvis ved hjelp av refleksjon.

Her implementerer vi abstrakte metoder for Løper klasse:

offentlig klasse TestRunner utvider Runner {private Class 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 ("kjører testene fra MyRunner:" + testClass); prøv {Object testObject = testClass.newInstance (); for (Method method: testClass.getMethods ()) {if (method.isAnnotationPresent (Test.class)) {notifier.fireTestStarted (Description .createTestDescription (testClass, method.getName ())); method.invoke (testObject); notifier.fireTestFinished (Beskrivelse .createTestDescription (testClass, method.getName ())); }}} fangst (Unntak e) {kast ny RuntimeException (e); }}}

De getDescription metoden er arvet fra Beskrivelig og returnerer a Beskrivelse som inneholder informasjonen som senere eksporteres og kan brukes av forskjellige verktøy.

I løpe implementering, påkaller vi måltestmetodene ved hjelp av refleksjon.

Vi har definert en konstruktør som tar en Klasse argument; dette er et krav fra JUnit. Ved kjøretid vil JUnit overføre måltestklassen til denne konstruktøren.

RunNotifier brukes til å skyte hendelser som har informasjon om testfremdriften.

La oss bruke løperen i testklassen vår:

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 ("tillegg", 8, calculator.add (5, 3)); }}

Resultatet får vi:

-------------------------------------------------- ----- TESTER -------------------------------------------- ----------- Kjører com.baeldung.junit.CalculatorTest som kjører testene fra MyRunner: klasse com.baeldung.junit.CalculatorTest i testAddition Tester kjører: 1, Feil: 0, Feil: 0, Hoppet over: 0, forløpt tid: 0,002 sek Resultater: Testkjøring: 1, Feil: 0, Feil: 0, Hoppet over: 0

4. Spesialiserte løpere

I stedet for å utvide lavnivået Løper klasse, som vi gjorde i forrige eksempel, vi kan utvide en av de spesialiserte underklassene til Løper: ParentRunner eller BlockJUnit4Runner.

Det abstrakte ParentRunner klasse kjører testene på en hierarkisk måte.

BlockJUnit4Runner er en konkret klasse, og hvis vi foretrekker å tilpasse visse metoder, vil vi sannsynligvis utvide denne klassen.

La oss se det med et eksempel:

public class BlockingTestRunner utvider BlockJUnit4ClassRunner {public BlockingTestRunner (Class klass) kaster InitializationError {super (klass); } @ Override protected Statement methodInvoker (FrameworkMethod method, Object test) {System.out.println ("invoking:" + method.getName ()); returner super.methodInvoker (metode, test); }}

Kommenterer en klasse med @RunWith (JUnit4.class) vil alltid påkalle standard JUnit 4-løper i den nåværende versjonen av JUnit; denne klassen aliaser den nåværende standard JUnit 4-klasseløperen:

@RunWith (JUnit4.class) offentlig klasse CalculatorTest {Calculator calculator = new Calculator (); @Test public void testAddition () {assertEquals ("addition", 8, calculator.add (5, 3)); }}

5. Konklusjon

JUnit Runners er svært tilpasningsdyktige og lar utvikleren endre testutførelsesprosedyren og hele testprosessen.

Hvis vi bare vil gjøre mindre endringer, er det lurt å se på de beskyttede metodene for BlockJUnit4Class løper.

Noen populære tredjepartsimplementeringer av løpere for bruk inkluderer SpringJUnit4ClassRunner, MockitoJUnitRunner, HierarchicalContextRunner, Agurkløper og mye mer.

Implementeringen av alle disse eksemplene og kodebitene finnes i GitHub-prosjektet - dette er et Maven-prosjekt, så det skal være enkelt å importere og kjøre som det er.