streamalism.org

1. Overzicht

In dit korte artikel gaan we ons concentreren op het uitvoeren van JUnit-tests met aangepaste testlopers.

Simpel gezegd, om de aangepaste runner te specificeren, moeten we de @Rennen met annotatie.

2. Voorbereiding

Laten we beginnen met het toevoegen van de standaard JUnit afhankelijkheid van onze pom.xml:

 junit junit 4.12 

3. Implementeren van een Custom Runner

In het volgende voorbeeld laten we zien hoe we onze eigen gewoonte kunnen schrijven Loper - en voer het uit met @Rennen met.

Een JUnit Runner is een klasse die de samenvatting van JUnit uitbreidt Loper class en het is verantwoordelijk voor het uitvoeren van JUnit-tests, meestal met behulp van reflectie.

Hier implementeren we abstracte methoden van Loper klasse:

openbare klasse TestRunner breidt Runner {privéklasse testClass uit; openbare 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 ("de tests uitvoeren vanuit MyRunner:" + testClass); probeer {Object testObject = testClass.newInstance (); voor (Method method: testClass.getMethods ()) {if (method.isAnnotationPresent (Test.class)) {notifier.fireTestStarted (Description .createTestDescription (testClass, method.getName ())); method.invoke (testObject); notifier.fireTestFinished (Beschrijving .createTestDescription (testClass, method.getName ())); }}} catch (uitzondering e) {gooi nieuwe RuntimeException (e); }}}

De getDescription methode wordt geërfd van Beschrijfbaar en retourneert een Omschrijving die de informatie bevat die later wordt geëxporteerd en die door verschillende tools kan worden gebruikt.

In de rennen implementatie, roepen we de doeltestmethoden op met behulp van reflectie.

We hebben een constructor gedefinieerd die een Klasse argument; dit is een vereiste van JUnit. Tijdens runtime geeft JUnit de doeltestklasse door aan deze constructor.

RunNotifier wordt gebruikt voor het afvuren van evenementen met informatie over de voortgang van de test.

Laten we de hardloper gebruiken in onze testklasse:

openbare klasse Calculator {public int add (int a, int b) {return a + b; }} @RunWith (TestRunner.class) openbare klasse CalculatorTest {Calculator calculator = nieuwe Calculator (); @Test openbare ongeldige testAddition () {Syste.out.println ("in testAddition"); assertEquals ("toevoeging", 8, calculator.add (5, 3)); }}

Het resultaat dat we krijgen:

-------------------------------------------------- ----- TESTEN -------------------------------------------- ----------- Uitvoeren van com.baeldung.junit.CalculatorTest het uitvoeren van de tests vanuit MyRunner: class com.baeldung.junit.CalculatorTest in testAddition Uitgevoerde tests: 1, fouten: 0, fouten: 0, overgeslagen: 0, Verstreken tijd: 0,002 sec Resultaten: uitgevoerde tests: 1, fouten: 0, fouten: 0, overgeslagen: 0

4. Gespecialiseerde hardlopers

In plaats van het lage niveau uit te breiden Loper klasse, zoals we deden in het laatste voorbeeld, we kunnen een van de gespecialiseerde subklassen van Loper: ParentRunner of BlockJUnit4Runner.

Het abstracte ParentRunner class voert de tests op een hiërarchische manier uit.

BlockJUnit4Runner is een concrete klasse en als we er de voorkeur aan geven bepaalde methoden aan te passen, zullen we deze klasse waarschijnlijk uitbreiden.

Laten we dat eens bekijken met een voorbeeld:

openbare klasse BlockingTestRunner breidt BlockJUnit4ClassRunner {openbare BlockingTestRunner (klasse klass) uit gooit InitializationError {super (klass); } @Override protected Statement methodInvoker (FrameworkMethod-methode, Objecttest) {System.out.println ("aanroepen:" + method.getName ()); retourneer super.methodInvoker (methode, test); }}

Een klas annoteren met @RunWith (JUnit4.class) zal altijd de standaard JUnit 4-runner aanroepen in de huidige versie van JUnit; deze klasse aliassen de huidige standaard JUnit 4 class runner:

@RunWith (JUnit4.class) openbare klasse CalculatorTest {Calculator calculator = nieuwe Calculator (); @Test openbare ongeldige testAddition () {assertEquals ("toevoeging", 8, calculator.add (5, 3)); }}

5. Conclusie

JUnit Runners zijn zeer flexibel en laten de ontwikkelaar de testuitvoeringsprocedure en het hele testproces wijzigen.

Als we alleen kleine wijzigingen willen aanbrengen, is het een goed idee om eens te kijken naar de beschermde methoden van BlockJUnit4Class loper.

Enkele populaire implementaties van hardlopers door derden voor gebruik zijn onder meer SpringJUnit4ClassRunner, MockitoJUnitRunner, HierarchicalContextRunner, Komkommer Runner en veel meer.

De implementatie van al deze voorbeelden en codefragmenten is te vinden in het GitHub-project - dit is een Maven-project, dus het moet gemakkelijk te importeren en uit te voeren zijn zoals het is.