JUnit ErrorCollector @Regel med eksempel

I et normalt scenarie, når du identificerer en fejl under testudførelse, ville du stoppe testen, rette fejlen og køre testen igen.

Men JUnit har en lidt anderledes tilgang. Med JUnit Fejlindsamleren kan du stadig fortsætte med testen, selv efter at der er fundet et problem, eller testen mislykkes. Fejlindsamleren indsamler alle fejlobjekter og rapporterer dem kun én gang, efter at testen er afsluttet.

Hvorfor bruge Error Collector?

Når du skriver et testscript, skal du udføre alle testene, selvom en kodelinje fejler på grund af netværksfejl, assertionfejl eller andre årsager. I den situation kan du stadig fortsætte med at udføre testscriptet ved hjælp af en særlig funktion leveret af JUnit kendt som "fejlsamler".

For det, JUnit anvender @Regelanmærkning, som bruges til at oprette et objekt til fejlindsamleren. Når objektet til fejlindsamleren er oprettet, kan du nemt tilføje alle fejlene til objektet ved hjælp af metoden addError (Throwable error)Som du ved, Kan kastes er superklassen af undtagelse og Fejl klasser i JavaNår du tilføjer fejl på denne måde, vil disse fejl blive logget i JUnit testresultat.

Fordelen ved at tilføje alle fejl i en Error Collector er, at du kan verificere alle fejlene på én gang. Hvis scriptet fejler midtvejs, fortsætter udførelsen stadig til slutningen af ​​testmetoden.

BemærkHvis der anvendes en simpel assert- eller en try/catch-blok, vil det ikke være muligt at bruge error collector-metoden.

Prøvekode

For at forstå mere om Error Collector, se kodeeksemplet nedenfor, som demonstrerer, hvordan man opretter et Error Collector-objekt og tilføjer alle fejlene til det objekt. tracproblemet:

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

Bemærk: dette er et illustrativt eksempeltract, ikke en kompilerbar fil. Dens efterfølgende kommentar ombrydes til en anden linje uden en indledende //, og getResults() plus Hamcrest-matcherne vises ikke. Den komplette kørbare version følger under Eksempel ved hjælp af ErrorCollector.

Hvad er @Rule i JUnit?

JUnit tilbyder en særlig form for håndtering af tests, Test sag eller testsuite ved hjælp af @RegelanmærkningVed at bruge @Rule kan du nemt tilføje eller omdefinere testens funktionsmåde.

Der er flere indbyggede regler fastsat af JUnit API som en tester kan bruge, og du kan også skrive din egen regel. Et regelfelt skal være offentligt, ikke-statisk og af en type, der implementerer TestRule.

Se kodelinjen nedenfor, som viser, hvordan man bruger @Rule-annotationen sammen med Error Collector:

@Rule				
public ErrorCollector collector= new ErrorCollector();

JUnit 5-note: Jupiter erstattede regler med Extension API'en, så @Rule og ErrorCollector findes ikke i org.junit.jupiter. De nærmeste ækvivalenter er Assertions.assertAll() og AssertJ SoftAssertions. JUnit 4-koden vist her kører stadig gennem den gamle motor. Se JUnit anmærkninger vejledning til det fulde kortping.

Eksempel ved hjælp af ErrorCollector

For at forstå fejlopsamleren, lad os oprette en klasse og en regel til at indsamle alle fejlene. Du skal tilføje alle fejlene ved hjælp af addError(throwable) her.

Se koden nedenfor, som blot opretter en regel, der ikke er andet end et "Error Collector-objekt". Den bruges yderligere til at tilføje alle fejlene for at rapportere problemet til sidst:

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

Lad os tilføje ovenstående testklasse til en testrunner og udføre den for at indsamle alle fejlene. Se koden nedenfor:

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:

Se fiaskoen trace, hvilket tracalle fejlene på ét sted. JUnit visningen tæller én kørsel, men rapporterer to fejl og én fiasko, hver med sit eget linjenummer:

Fordele ved JUnit ErrorCollector

Du kan bruge en JUnit påstand til funktionel eller GUI-validering, for eksempel:

1. assertEquals(String message, Object expected, Object actual), som sammenligner, at to objekter er ens.
2. På samme måde hævder assertTrue (Boolesk betingelse) at en betingelse er sand.

Ved hjælp af assertions bliver valideringstestning nem. Men et stort problem er, at testudførelsen stopper, selv hvis en enkelt assertion fejler.

Testkontinuitet og håndtering af gendannelse er afgørende for succes med testautomatisering, og det er vigtigst på lang sigt. Selenium flows, hvor det er dyrt at genstarte en browser efter hver mislykket kontrol. Error Collector er den bedste måde at håndtere sådanne scenarier på.

Ofte Stillede Spørgsmål