JUnit-tests programmatisch uitvoeren vanuit een Java-applicatie

1. Overzicht

In deze tutorial laten we zien hoe u JUnit-tests rechtstreeks vanuit Java-code kunt uitvoeren - er zijn scenario's waarin deze optie van pas komt.

Als u nieuw bent bij JUnit, of als u wilt upgraden naar JUnit 5, kunt u enkele van de vele tutorials bekijken die we over dit onderwerp hebben.

2. Maven afhankelijkheden

We hebben een aantal basisafhankelijkheden nodig om zowel JUnit 4- als JUnit 5-tests uit te voeren:

  org.junit.jupiter junit-jupiter-engine 5.2.0 test org.junit.platform junit-platform-launcher 1.2.0 // voor JUnit 4 junit junit 4.12 test 

De nieuwste versies van JUnit 4, JUnit 5 en JUnit Platform Launcher zijn te vinden op Maven Central.

3. JUnit 4-tests uitvoeren

3.1. Testscenario

Voor zowel JUnit 4 als JUnit 5 zullen we een paar "placeholder" testklassen opzetten die voldoende zullen zijn om onze voorbeelden te demonstreren:

openbare klasse FirstUnitTest {@Test openbare leegte whenThis_thenThat () {assertTrue (true); } @Test openbare leegte whenSomething_thenSomething () {assertTrue (true); } @Test openbare leegte whenSomethingElse_thenSomethingElse () {assertTrue (true); }}
openbare klasse SecondUnitTest {@Test openbare leegte whenSomething_thenSomething () {assertTrue (true); } @Test openbare leegte whensomethingElse_thenSomethingElse () {assertTrue (true); }}

Bij het gebruik van JUnit 4, maken we testklassen toe te voegen @Test annotatie bij elke testmethode.

We kunnen ook andere handige annotaties toevoegen, zoals @Voordat of @Na, maar dat valt niet onder deze tutorial.

3.2. Een enkele testklasse uitvoeren

Om JUnit-tests uit te voeren vanuit Java-code, kunnen we de JUnitCore class (met een toevoeging van TextListener class, gebruikt om de uitvoer in System.out):

JUnitCore junit = nieuwe JUnitCore (); junit.addListener (nieuwe TextListener (System.out)); junit.run (FirstUnitTest.class);

Op de console zien we een heel eenvoudig bericht dat aangeeft dat de tests zijn geslaagd:

Eén testklasse uitvoeren: .. Tijd: 0,019 OK (2 tests)

3.3. Meerdere testklassen uitvoeren

Als we willen om meerdere testklassen te specificeren met JUnit 4 kunnen we dezelfde code gebruiken als voor een enkele klas, en gewoon de extra klassen toevoegen:

JUnitCore junit = nieuwe JUnitCore (); junit.addListener (nieuwe TextListener (System.out)); Resultaat resultaat = junit.run (FirstUnitTest.class, SecondUnitTest.class); resultReport (resultaat);

Merk op dat het resultaat wordt opgeslagen in een instantie van JUnit's Resultaat class, die we afdrukken met behulp van een eenvoudige hulpprogramma-methode:

public static void resultReport (Resultaat resultaat) {System.out.println ("Finished. Result: Failures:" + result.getFailureCount () + ". Ignored:" + result.getIgnoreCount () + ". Tests uitgevoerd:" + resultaat .getRunCount () + ". Tijd:" + resultaat.getRunTime () + "ms."); } 

3.4. Een testsuite uitvoeren

Als we enkele testklassen moeten groeperen om ze uit te voeren, kunnen we een Test pak. Dit is slechts een lege klasse waarin we alle klassen specificeren met behulp van JUnit-annotaties:

@RunWith (Suite.class) @ Suite.SuiteClasses ({FirstUnitTest.class, SecondUnitTest.class}) openbare klasse MyTestSuite {}

Om deze tests uit te voeren, gebruiken we opnieuw dezelfde code als voorheen:

JUnitCore junit = nieuwe JUnitCore (); junit.addListener (nieuwe TextListener (System.out)); Resultaat resultaat = junit.run (MyTestSuite.class); resultReport (resultaat);

3.5. Herhaalde tests uitvoeren

Een van de interessante kenmerken van JUnit is dat we dat kunnen herhaal tests door instanties van te maken Herhaalde test. Dit kan erg handig zijn als we willekeurige waarden testen of voor prestatiecontroles.

In het volgende voorbeeld zullen we de tests uitvoeren van MergeListsTest vijf keer:

Testtest = nieuwe JUnit4TestAdapter (FirstUnitTest.class); RepeatedTest repeatTest = nieuwe RepeatedTest (test, 5); JUnitCore junit = nieuwe JUnitCore (); junit.addListener (nieuwe TextListener (System.out)); junit.run (herhaalde test);

Hier gebruiken we JUnit4TestAdapter als wrapper voor onze testles.

We kunnen zelfs suites programmatisch maken door herhaaldelijk testen toe te passen:

TestSuite mySuite = nieuwe ActiveTestSuite (); JUnitCore junit = nieuwe JUnitCore (); junit.addListener (nieuwe TextListener (System.out)); mySuite.addTest (nieuwe RepeatedTest (nieuwe JUnit4TestAdapter (FirstUnitTest.class), 5)); mySuite.addTest (nieuwe RepeatedTest (nieuwe JUnit4TestAdapter (SecondUnitTest.class), 3)); junit.run (mySuite);

4. JUnit 5-tests uitvoeren

4.1. Testscenario

Met JUnit 5 gebruiken we dezelfde voorbeeldtestklassen als voor de vorige demo - FirstUnitTest en SecondUnitTest, met enkele kleine verschillen vanwege een andere versie van het JUnit-framework, zoals het pakket voor @Test en beweringsmethoden.

4.2. Een enkele testklasse uitvoeren

Om JUnit 5-tests vanuit Java-code uit te voeren, zullen we een instantie van LauncherDiscoveryRequest. Het gebruikt een builder-klasse waar we pakketkiezers en testklassenaamfilters moeten instellen om alle testklassen op te halen die we willen uitvoeren.

Dit verzoek wordt vervolgens gekoppeld aan een opstartprogramma en voordat we de tests uitvoeren, stellen we ook een testplan en een uitvoeringsluisteraar op.

Beide bieden informatie over de uit te voeren tests en de resultaten:

openbare klasse RunJUnit5TestsFromJava {SummaryGeneratingListener listener = nieuwe SummaryGeneratingListener (); openbare leegte runOne () {LauncherDiscoveryRequest-verzoek = LauncherDiscoveryRequestBuilder.request () .selectors (selectClass (FirstUnitTest.class)) .build (); Launcher launcher = LauncherFactory.create (); TestPlan testPlan = launcher.discover (verzoek); launcher.registerTestExecutionListeners (luisteraar); launcher.execute (verzoek); } // belangrijkste methode ...}

4.3. Meerdere testklassen uitvoeren

We kunnen selectors en filters instellen op het verzoek om meerdere testklassen uit te voeren.

Laten we eens kijken hoe we pakketkiezers en testklassenaamfilters kunnen instellen om alle testklassen te krijgen die we willen uitvoeren:

public void runAll () {LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request () .selectors (selectPackage ("com.baeldung.junit5.runfromjava")) .filters (includeClassNamePatterns (". * Test")) .build (); Launcher launcher = LauncherFactory.create (); TestPlan testPlan = launcher.discover (verzoek); launcher.registerTestExecutionListeners (luisteraar); launcher.execute (verzoek); } 

4.4. Test uitgang

In de hoofd() methode noemen we onze klasse, en we gebruiken ook de luisteraar om de details van het resultaat te krijgen. Dit keer wordt het resultaat opgeslagen als een TestExecutionSamenvatting.

De eenvoudigste manier om de informatie te extraheren, is door af te drukken naar een uitvoerstroom van een console:

openbare statische leegte hoofd (String [] args) {RunJUnit5TestsFromJava runner = nieuwe RunJUnit5TestsFromJava (); runner.runAll (); TestExecutionSummary samenvatting = runner.listener.getSummary (); summary.printTo (nieuwe PrintWriter (System.out)); }

Dit geeft ons de details van onze testrun:

Testrun voltooid na 177 ms [7 containers gevonden] [0 containers overgeslagen] [7 containers gestart] [0 containers afgebroken] [7 containers succesvol] [0 containers mislukt] [10 tests gevonden] [0 tests overgeslagen] [10 tests gestart ] [0 tests afgebroken] [10 tests succesvol] [0 tests mislukt]

5. Conclusie

In dit artikel hebben we laten zien hoe u JUnit-tests programmatisch kunt uitvoeren vanuit Java-code, zowel voor JUnit 4 als voor de recente JUnit 5-versie van dit testraamwerk.

Zoals altijd is de implementatie van de hier getoonde voorbeelden beschikbaar op GitHub voor zowel de JUnit 5-voorbeelden als JUnit 4.