Esecuzione di test JUnit a livello di programmazione, da un'applicazione Java

1. Panoramica

In questo tutorial, mostreremo come eseguire i test JUnit direttamente dal codice Java : ci sono scenari in cui questa opzione è utile.

Se sei nuovo in JUnit o se desideri eseguire l'upgrade a JUnit 5, puoi controllare alcuni dei molti tutorial che abbiamo sull'argomento.

2. Dipendenze di Maven

Avremo bisogno di un paio di dipendenze di base per eseguire entrambi i test JUnit 4 e JUnit 5:

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

Le ultime versioni di JUnit 4, JUnit 5 e JUnit Platform Launcher sono disponibili su Maven Central.

3. Esecuzione di test JUnit 4

3.1. Scenario di prova

Sia per JUnit 4 che per JUnit 5, imposteremo alcune classi di test "segnaposto" che saranno sufficienti per dimostrare i nostri esempi:

public class FirstUnitTest { @Test public void whenThis_thenThat() { assertTrue(true); } @Test public void whenSomething_thenSomething() { assertTrue(true); } @Test public void whenSomethingElse_thenSomethingElse() { assertTrue(true); } }
public class SecondUnitTest { @Test public void whenSomething_thenSomething() { assertTrue(true); } @Test public void whensomethingElse_thenSomethingElse() { assertTrue(true); } }

Quando si utilizza JUnit 4, creiamo classi di test aggiungendo l' annotazione @Test a ogni metodo di test.

Possiamo anche aggiungere altre utili annotazioni, come @Before o @After , ma non è nell'ambito di questo tutorial.

3.2. Esecuzione di una singola classe di prova

Per eseguire i test JUnit dal codice Java, possiamo utilizzare la classe JUnitCore (con un'aggiunta della classe TextListener , utilizzata per visualizzare l'output in System.out ):

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

Sulla console, vedremo un messaggio molto semplice che indica i test riusciti:

Running one test class: .. Time: 0.019 OK (2 tests)

3.3. Esecuzione di più classi di test

Se vogliamo specificare più classi di test con JUnit 4, possiamo utilizzare lo stesso codice di una singola classe e aggiungere semplicemente le classi aggiuntive:

JUnitCore junit = new JUnitCore(); junit.addListener(new TextListener(System.out)); Result result = junit.run( FirstUnitTest.class, SecondUnitTest.class); resultReport(result);

Nota che il risultato è memorizzato in un'istanza della classe Result di JUnit , che stiamo stampando utilizzando un semplice metodo di utilità:

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

3.4. Esecuzione di una suite di test

Se dobbiamo raggruppare alcune classi di test per eseguirle, possiamo creare una TestSuite . Questa è solo una classe vuota in cui specifichiamo tutte le classi usando le annotazioni JUnit:

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

Per eseguire questi test, utilizzeremo di nuovo lo stesso codice di prima:

JUnitCore junit = new JUnitCore(); junit.addListener(new TextListener(System.out)); Result result = junit.run(MyTestSuite.class); resultReport(result);

3.5. Esecuzione di test ripetuti

Una delle caratteristiche interessanti di JUnit è che possiamo ripetere i test creando istanze di RepeatedTest . Questo può essere davvero utile quando testiamo valori casuali o per i controlli delle prestazioni.

Nel prossimo esempio, eseguiremo i test da MergeListsTest cinque volte:

Test test = new JUnit4TestAdapter(FirstUnitTest.class); RepeatedTest repeatedTest = new RepeatedTest(test, 5); JUnitCore junit = new JUnitCore(); junit.addListener(new TextListener(System.out)); junit.run(repeatedTest);

Qui, stiamo usando JUnit4TestAdapter come wrapper per la nostra classe di test.

Possiamo persino creare suite in modo programmatico, applicando test ripetuti:

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

4. Esecuzione di test JUnit 5

4.1. Scenario di prova

Con JUnit 5, utilizzeremo le stesse classi di test di esempio della demo precedente: FirstUnitTest e SecondUnitTest , con alcune piccole differenze dovute a una versione diversa del framework JUnit, come il pacchetto per @Test e i metodi di asserzione.

4.2. Esecuzione di una classe di prova singola

Per eseguire i test JUnit 5 dal codice Java, configureremo un'istanza di LauncherDiscoveryRequest . Utilizza una classe builder in cui dobbiamo impostare i selettori di pacchetti e testare i filtri dei nomi delle classi, per ottenere tutte le classi di test che vogliamo eseguire.

Questa richiesta viene quindi associata a un launcher e, prima di eseguire i test, configureremo anche un piano di test e un ascoltatore di esecuzione.

Entrambi offriranno informazioni sui test da eseguire e sui risultati:

public class RunJUnit5TestsFromJava { SummaryGeneratingListener listener = new SummaryGeneratingListener(); public void runOne() { LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request() .selectors(selectClass(FirstUnitTest.class)) .build(); Launcher launcher = LauncherFactory.create(); TestPlan testPlan = launcher.discover(request); launcher.registerTestExecutionListeners(listener); launcher.execute(request); } // main method... }

4.3. Esecuzione di più classi di test

Possiamo impostare selettori e filtri sulla richiesta per eseguire più classi di test.

Vediamo come possiamo impostare i selettori di pacchetti e testare i filtri dei nomi delle classi, per ottenere tutte le classi di test che vogliamo eseguire:

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(request); launcher.registerTestExecutionListeners(listener); launcher.execute(request); } 

4.4. Uscita di prova

Nel metodo main () , chiamiamo la nostra classe e usiamo anche il listener per ottenere i dettagli del risultato. Questa volta il risultato viene archiviato come TestExecutionSummary .

Il modo più semplice per estrarne le informazioni è semplicemente stampare su un flusso di output della console:

public static void main(String[] args) { RunJUnit5TestsFromJava runner = new RunJUnit5TestsFromJava(); runner.runAll(); TestExecutionSummary summary = runner.listener.getSummary(); summary.printTo(new PrintWriter(System.out)); }

Questo ci darà i dettagli della nostra esecuzione di prova:

Test run finished after 177 ms [ 7 containers found ] [ 0 containers skipped ] [ 7 containers started ] [ 0 containers aborted ] [ 7 containers successful ] [ 0 containers failed ] [ 10 tests found ] [ 0 tests skipped ] [ 10 tests started ] [ 0 tests aborted ] [ 10 tests successful ] [ 0 tests failed ]

5. conclusione

In questo articolo, abbiamo mostrato come eseguire test JUnit a livello di codice dal codice Java, coprendo JUnit 4 e la recente versione JUnit 5 di questo framework di test.

Come sempre, l'implementazione degli esempi mostrati qui è disponibile su GitHub sia per gli esempi JUnit 5, sia per JUnit 4.