JUnit ErrorCollector @Rule met voorbeeld
In een normaal scenario zou u, telkens wanneer u een fout constateert tijdens de uitvoering van de test, de test stoppen, de fout herstellen en de test opnieuw uitvoeren.
Maar JUnit heeft een iets andere aanpak. Met JUnit error collector, kunt u nog steeds doorgaan met de uitvoering van de test, zelfs nadat er een probleem is gevonden of de test is mislukt. Error Collector verzamelt alle foutobjecten en rapporteert deze slechts één keer nadat de testuitvoering is voltooid.
Waarom Error Collector gebruiken?
Terwijl u een testscript schrijft, wilt u alle tests uitvoeren, zelfs als een coderegel mislukt vanwege een netwerkstoring, een mislukte bewering of een andere reden. In die situatie kunt u nog steeds doorgaan met het uitvoeren van het testscript met behulp van een speciale functie van JUnit bekend als ‘foutverzamelaar’.
Voor deze, JUnit toepassingen @Regelannotatie die wordt gebruikt om een object van foutverzamelaar te maken. Zodra het object voor de foutenverzamelaar is gemaakt, kunt u eenvoudig alle fouten aan het object toevoegen met behulp van method addError (werpbare fout). Zoals je weet, dat Gooibaar is de superklasse van uitzondering en Fout klasse in Java. Wanneer u op deze manier fouten toevoegt, worden deze fouten ingelogd JUnit testresultaat .
Het voordeel van het toevoegen van alle fouten in een Error Collector is dat u alle fouten in één keer kunt verifiëren. Ook als het script halverwege mislukt, kan het nog steeds doorgaan met de uitvoering ervan
Note: Als u een eenvoudig assert- of try/catch-blok gebruikt, is het gebruik van de foutverzamelaarmethode niet mogelijk.
Voorbeeldcode
Om meer te begrijpen over Error Collector, zie het onderstaande codevoorbeeld waarin wordt gedemonstreerd hoe u een Error Collector-object kunt maken en alle fouten in dat object kunt toevoegen om het probleem op te sporen:
package guru99.junit; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ErrorCollector; public class ErrorCollectorExample { @Rule public ErrorCollector collector = new ErrorCollector(); @Test public void example() { collector.addError(new Throwable("There is an error in first line")); collector.addError(new Throwable("There is an error in second line")); collector.checkThat(getResults(), not(containsString("here is an error"))); // all lines of code will execute and at the end a combined failure will be logged in. } }
Wat is @Rule in jUnit?
JUnit biedt een speciale manier van omgaan met tests, Testgeval of testsuite met behulp van @regel annotatie. Met @rule kunt u eenvoudig het gedrag van de test toevoegen of opnieuw definiëren.
Er zijn verschillende ingebouwde regels voorzien door JUnit API die een tester kan gebruiken, of u kunt zelfs onze eigen regel schrijven.
Zie onderstaande coderegel, die laat zien hoe u @rule-annotatie samen met Error Collector kunt gebruiken:
@Rule public ErrorCollector collector= new ErrorCollector();
Voorbeeld met ErrorCollector
Om de foutenverzamelaar te begrijpen, gaan we een klasse en een regel maken om alle fouten te verzamelen. U voegt hier alle fouten toe met behulp van addError(throwable).
Zie onderstaande code die eenvoudigweg een regel creëert die niets anders is dan het creëren van een “Error Collector-object.” Die verder wordt gebruikt om alle fouten toe te voegen om het probleem aan het einde te rapporteren:
ErrorCollectorExample.java
package guru99.junit; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ErrorCollector; public class ErrorCollectorExample { @Rule public ErrorCollector collector = new ErrorCollector(); @Test public void example() { collector.addError(new Throwable("There is an error in first line")); collector.addError(new Throwable("There is an error in second line")); System.out.println("Hello"); try { Assert.assertTrue("A " == "B"); } catch (Throwable t) { collector.addError(t); } System.out.println("World!!!!"); } }
TestRunner.java
Laten we bovenstaande testklasse toevoegen aan een testrunner en deze uitvoeren om alle fouten te verzamelen. Zie onderstaande code:
package guru99.junit; import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.notification.Failure; public class TestRunner { public static void main(String[] args) { Result result = JUnitCore.runClasses(ErrorCollectorExample.class); for (Failure failure : result.getFailures()) { System.out.println(failure.toString()); } System.out.println("Result=="+result.wasSuccessful()); } }
Output:
Bekijk de fouttracering die alle fouten op één plek traceert:
Voordelen van JUnit ErrorCollector
Je kunt gebruiken JUnit bewering voor functionele of GUI-validatie, bijv
- assertEquals(String message, Object verwacht, Object actual) die vergelijken dat twee objecten gelijk zijn.
- Op dezelfde manier beweert assertTrue(Booleaanse voorwaarde) dat een voorwaarde waar is.
Met behulp van assertiviteit wordt de validatietest eenvoudig. Maar een groot probleem is dat de uitvoering van tests stopt, zelfs als een enkele bewering mislukt.
Testcontinuïteit en herstelafhandeling zijn cruciaal voor het succes van testautomatisering. Error Collector is de beste manier om met dit soort scenario's om te gaan.
Samenvatting
- Junit error collector zorgt ervoor dat een test door kan gaan, zelfs nadat het eerste probleem is gevonden en de test aan het einde mislukt
- Errorcollector verzamelt alle foutobjecten en rapporteert pas nadat de testuitvoering voorbij is
- Het voordeel van het toevoegen van alle fouten in een Error Collector is dat u alle fouten in één keer kunt verifiëren
- Error Collector voegt eenvoudigweg fouten toe met behulp van de methode addError(throwable err) van ErrorCollector.java.