JUnit ErrorCollector @Regel med exempel

I ett normalt scenario, när du identifierar något fel under testkörningen, skulle du stoppa testet, åtgärda felet och köra testet igen.

Men JUnit har en något annorlunda strategi. Med JUnit felinsamlaren, du kan fortfarande fortsätta med testkörningen även efter att ett problem har upptäckts eller testet misslyckas. Felinsamlaren samlar in alla felobjekt och rapporterar dem endast en gång, efter att testkörningen är avslutad.

Varför använda Error Collector?

När du skriver ett testskript vill du köra alla tester även om någon kodrad misslyckas på grund av nätverksfel, assertionfel eller någon annan anledning. I den situationen kan du fortfarande fortsätta köra testskriptet med hjälp av en specialfunktion som tillhandahålls av JUnit känd som "felsamlare".

För detta, JUnit använder @Regelanteckning, som används för att skapa ett objekt för felinsamlaren. När objektet för felinsamlaren har skapats kan du enkelt lägga till alla fel i objektet med hjälp av metoden addError (Throwable error). Som du vet, Kastbar är superklassen av undantag och Fel klasser i JavaNär du lägger till fel på det här sättet loggas dessa fel i JUnit testresultat.

Fördelen med att lägga till alla fel i en felinsamlare är att du kan verifiera alla fel samtidigt. Om skriptet misslyckas mitt i processen fortsätter körningen till slutet av testmetoden.

AnmärkningarOm man använder en enkel assert- eller try/catch-block är det inte möjligt att använda error collector-metoden.

Exempelkod

För att förstå mer om Error Collector, se kodexemplet nedan, som visar hur man skapar ett Error Collector-objekt och lägger till alla fel till det objektet. track problemet:

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.		
    }		
}	

Obs: detta är ett illustrativt exempeltract, inte en kompilerbar fil. Dess efterföljande kommentar radbryts till en andra rad utan inledande //, och getResults() plus Hamcrest-matcharna visas inte. Den fullständiga körbara versionen följer nedan. Exempel med ErrorCollector.

Vad är @Rule i JUnit?

JUnit erbjuder en speciell typ av hantering av tester, Testfall eller testsviten med hjälp av @RegelanteckningMed hjälp av @Rule kan du enkelt lägga till eller omdefiniera testets beteende.

Det finns flera inbyggda regler som tillhandahålls av JUnit API som en testare kan använda, och du kan också skriva din egen regel. Ett regelfält måste vara publikt, icke-statiskt och av en typ som implementerar TestRule.

Se kodraden nedan, som visar hur man använder @Rule-annoteringen tillsammans med Error Collector:

@Rule				
public ErrorCollector collector= new ErrorCollector();

JUnit 5-notering: Jupiter ersatte regler med Extension API, så @Rule och ErrorCollector finns inte i org.junit.jupiter. De närmaste motsvarigheterna är Assertions.assertAll() och AssertJ SoftAssertions. JUnit 4-koden som visas här körs fortfarande genom den gamla motorn. Se JUnit annoteringar handledning för hela kartanping.

Exempel med ErrorCollector

För att förstå felinsamlaren, låt oss skapa en klass och en regel för att samla in alla fel. Du kommer att lägga till alla fel med hjälp av addError(throwable) här.

Se koden nedan, som helt enkelt skapar en regel som inte är något annat än ett "Error Collector-objekt". Den används vidare för att lägga till alla fel för att rapportera problemet i slutet:

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

Låt oss lägga till ovanstående testklass till en testkörare och köra den för att samla in alla fel. Se koden nedan:

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());							
   }		
}      

Produktion:

Se misslyckandet trace, vilket tracalla fel på ett ställe. Den JUnit vyn räknar en körning men rapporterar två fel och ett misslyckande, vart och ett med sitt eget radnummer:

Fördelar med JUnit ErrorCollector

Du kan använda en JUnit påstående för funktionell eller GUI-validering, till exempel:

1. assertEquals(String message, Object expected, Object actual), vilket jämför att två objekt är lika.
2. På liknande sätt hävdar assertTrue(Booleskt villkor) att ett villkor är sant.

Med hjälp av påståenden blir valideringstestning enkelt. Men ett stort problem är att testkörningen kommer att stoppas även om en enskild påstående misslyckas.

Testkontinuitet och hantering av återställning är avgörande för att testautomation ska lyckas, och det är allra viktigast på lång sikt. Selenium flöden där det är dyrt att starta om en webbläsare efter varje misslyckad kontroll. Error Collector är det bästa sättet att hantera sådana scenarier.

Vanliga frågor