web-dev-qa-db-fra.com

Poursuite de l'exécution du test dans junit4 même lorsque l'une des assertions échoue

Mon infrastructure existante est construite à l'aide de Jfunc, ce qui permet de continuer à exécuter une exection même lorsque l'une des affirmations du scénario de test échoue. Jfunc utilise le framework Junit 3.x. Mais maintenant nous migrons vers junit4, je ne peux donc plus utiliser Jfunc et je l’ai remplacé par jar 4.10 jar. 
Maintenant, le problème vient du fait que nous avons largement utilisé jfunc dans notre framework, et avec junit 4, nous voulons que notre code continue l’exécution même lorsque l’une des assertations échoue dans un scénario de test.
Quelqu'un a-t-il une suggestion ou une idée à cet égard, je sais qu'au début, les tests doivent être plus atomiques, c'est-à-dire une assertion par cas de test, mais nous ne pouvons pas le faire dans notre cadre pour une raison quelconque.

javajunit4
43
user85

Vous pouvez le faire en utilisant un ErrorCollector rule.

Pour l'utiliser, commencez par ajouter la règle en tant que champ dans votre classe de test:

public class MyTest {
    @Rule
    public ErrorCollector collector = new ErrorCollector();

    //...tests...
}

Remplacez ensuite vos assertions par des appels à collector.checkThat(...).

par exemple.

@Test
public void myTest() {
    collector.checkThat("a", equalTo("b"));
    collector.checkThat(1, equalTo(2));
}
58
Chris B

J'utilise aussi ErrorCollector, mais aussi assertThat et les place dans un bloc catch catch. 

import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;

@Rule
public ErrorCollector collector = new ErrorCollector();

@Test
public void calculatedValueShouldEqualExpected() {
    try {
        assertThat(calculatedValue(), is(expected));
    } catch (Throwable t) {
        collector.addError(t);
        // do something
    }
}
15
StatusQuo

Vous pouvez également utiliser assertj - soft assertion

@Test
public void testCollectErrors(){
   SoftAssertions softly = new SoftAssertions();
   softly.assertThat(true).isFalse();
   softly.assertThat(false).isTrue();
   // Don't forget to call SoftAssertions global verification !
   softly.assertAll();
}

Il existe également une autre façon de l'utiliser sans appeler manuellement softly.assertAll ();

  1. avec règle
  2. avec autoclosable
  3. Utilisation de la méthode statique assertSoftly
3
marok

Utilisez try/finally block. Cela a fonctionné dans mon cas:

...
try {
    assert(...)
} finally {
    // code to be executed after assert
}
...
1
Danut M

Try - catch, dans "try", utilisez l'assertion, dans "catch", ajoutez l'erreur possible à collection . Ensuite, jetez l'exception à la fin du test, dans tearDown () ./error in assert, il sera intercepté et le test se poursuivra . (la collection dans l'exemple est statique, vous pouvez également créer une nouvelle instance dans setUp () pour chaque @Test)

    public static List<String> errors = new ArrayList<>();


    try {
        //some assert...
    }
    catch (AssertionError error) {
        errors.add(error.toString());
    }



    @After
    public void tearDown() {

        try {
            if (!errors.isEmpty()) {
                throw new AssertionError(errors);
            }
        }
        finally {
            //empty list because it's static, alternatively make instance for each test in setUp()
            errors.clear();
        }
    }
0
Radek Sip