Zatrzymanie JUnit pakiet szczególności jeśli test nie powiedzie

Question

Mam zestaw testów JUnit w postaci:

@RunWith(Suite.class) 
@Suite.SuiteClasses({ xx.class, yy.cass }) 

public class AllTests { 

public static Test suite() { 
    TestSuite suite = new TestSuite(AllTests.class.getName()); 
    //$JUnit-BEGIN$ 

    //$JUnit-END$ 
    return suite; 
} 
} 

To wywołuje wanilii testy takie jak ten:

public class xxx { 

@Test 
public void test() throws { 
    ... 

Mam sytuacji gdzie ja jak zatrzymać resztę zestawu testów, jeśli wystąpił błąd lub niepowodzenie w pierwszym teście. Ale błędy/niepowodzenia w innych są w porządku, a pakiet powinien wykonać jak najwięcej innych testów. Zasadniczo pierwsze niepowodzenie testu wskazuje, że nie jest bezpiecznie uruchomić resztę.

Czy to możliwe?

Answer 1

Co jest nie tak z dzwonieniem pod numer System.exit()?

Answer 2

Czy przeprowadzasz testy za pomocą mrówki?

Możesz napisać niestandardowy testowiec. Możesz ustawić to w ant http://ant.apache.org/manual/Tasks/junit.html (enableTestListenerEvents).

Answer 3

Jeśli to jest test najpierw, rozważ przemieszczenie jego walidacji do @BeforeClass i wyrzuć wyjątek, jeśli się nie powiedzie. Wówczas tylko metoda @AfterClass byłaby uruchomiona w przypadku tego wyjątku.

Oczywiście w ten sposób brakuje wszystkich artefaktów urządzeń utworzonych w metodach konfiguracji testów.

Answer 4

Na podstawie odpowiedzi z Hiro2k (dzięki!) Skorzystałem z następującego rozwiązania. To trochę hack, ale działa.

Test, który może uniemożliwić wykonywanie innych testów, znajduje się na górze listy @ Suite.SuiteClasses. Że badanie ma wówczas następujący:

private static boolean shouldStopRestOfSuite = false; 

    @Test 
    public void test() throws Throwable { 
    try { 
      ... run some test code... 
    } 
    catch (Throwable e) { 
     shouldStopRestOfSuite = true; 
     throw e; 
    } 
} 

Uwaga powyższa nie trzeba złapać Throwable (nie wyjątek), więc łapie błędy twierdzenie. Ponownie generuje błąd, więc jest on rejestrowany przez JUnit do analizy.

Potem jest inna metoda badania:

@Test 
public void testKillIfNeeded() throws Exception { 
    if (!shouldStopRestOfSuite) { 
     return; 
    } 

    System.out.println ("Test suite killed due to dangerous error/failure"); 
    System.exit(1); 
} 

Powyższy prowadzony jest drugi i zabije proces JUnit.

Przy użyciu tej metody test JUnit nie zakończy się niepowodzeniem/błędem, jeśli wystąpi problem, ale błąd/błąd zostanie zarejestrowany do analizy przez JUnit i nie będą przeprowadzane żadne dalsze testy.

Nie jest zbyt ładne, ale spełnia swoje zadanie :)

Answer 5

jak odpowiedź, ale stosując @Before w teście integracyjnym, zrobiłem coś takiego:

public class FooTest { 

    private static boolean bar; 

    @BeforeClass 
    public static void setUpBeforeClass() throws Exception { 
     bar = false; 
    } 

    @Before 
    public void setUp() throws Exception { 
     assertTrue(bar); 
    } 

    @Test 
    public void test() { 
     System.out.println("something"); 
     assertTrue(true); 
    } 

    @Test 
    public void test1() { 
     System.out.println("Something2"); 
     assertTrue(true); 
    } 
} 

Pozdrawiam!

Answer 6

Najpierw trzeba junit RunListener:

import org.junit.runner.notification.Failure; 
import org.junit.runner.notification.RunListener; 
import org.junit.runner.notification.RunNotifier; 

public class FailureListener extends RunListener { 

    private RunNotifier runNotifier; 

    public FailureListener(RunNotifier runNotifier) { 
     super(); 
     this.runNotifier=runNotifier; 
    } 

    @Override 
    public void testFailure(Failure failure) throws Exception { 
     super.testFailure(failure); 
     this.runNotifier.pleaseStop(); 
    } 
} 

Następnie przygotować Suite:

public class StopOnFailureSuite extends Suite { 

    public StopOnFailureSuite(Class<?> klass, Class<?>[] suiteClasses) throws InitializationError { 
     super(klass, suiteClasses); 
    } 

    public StopOnFailureSuite(Class<?> klass) throws InitializationError { 
     super(klass, klass.getAnnotation(SuiteClasses.class).value()); 
    } 

    @Override 
    public void run(RunNotifier runNotifier) { 
     runNotifier.addListener(new FailureListener(runNotifier)); 
     super.run(runNotifier); 
    } 
} 

i uruchomić pakiet:

@RunWith(StopOnFailureSuite.class) 
@Suite.SuiteClasses({ 
    FirstTestClass.class, 
    SecondTestClass.class, 
    ... 
}) 

Answer 7

Po pierwsze należy złapać błąd i sprawdź tak samo, zanim wykonasz drugi test.

@Rule 
public ErrorCollector collector = new ErrorCollector(); 

1. Dodać błąd.

collector.addError(new Throwable("first thing went wrong")); 

2. Sprawdź przed biegiem zależnej.

collector.checkThat(getResult(), not(containsString("ERROR!"))); 

Reference - ErrorCollector