Comment pouvez-vous implémenter un mécanisme de réexécution pour les tests JUnit ayant échoué afin d'améliorer la stabilité de la suite de tests ?

Exécuter des tests JUnit ayant échoué : une solution de réexécution

La réexécution immédiate des tests JUnit ayant échoué peut améliorer la stabilité des suites de tests automatisés, en particulier lorsqu'il s'agit de pannes intermittentes. Cet article explore deux approches pour mettre en œuvre un tel mécanisme.

1. Utilisation d'une TestRule

Une TestRule fournit un moyen flexible de modifier le flux d'exécution des tests. Pour implémenter des réexécutions à l'aide d'une TestRule, définissez :

<code class="java">public class Retry implements TestRule {

    private int retryCount;

    public Retry(int retryCount) {
        this.retryCount = retryCount;
    }

    public Statement apply(Statement base, Description description) {
        return statement(base, description);
    }

    private Statement statement(final Statement base, final Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                Throwable caughtThrowable = null;

                // Retry loop
                for (int i = 0; i < retryCount; i++) {
                    try {
                        base.evaluate();
                        return;
                    } catch (Throwable t) {
                        caughtThrowable = t;
                        System.err.println(description.getDisplayName() + ": run " + (i+1) + " failed");
                    }
                }
                System.err.println(description.getDisplayName() + ": giving up after " + retryCount + " failures");
                throw caughtThrowable;
            }
        };
    }
}

Annotez les tests qui nécessitent des tentatives avec la règle Retry :

<code class="java">@Rule
public Retry retry = new Retry(3);

@Test
public void test1() {
}

2. Création d'un TestRunner personnalisé

Vous pouvez également définir un TestRunner personnalisé pour gérer les réexécutions de tests pour une suite spécifique. Étendez BlockJUnit4ClassRunner et remplacez la méthode runChild() :

<code class="java">public class CustomTestRunner extends BlockJUnit4ClassRunner {

    private int retryCount;

    public CustomTestRunner(Class<?> testClass) {
        super(testClass);
    }

    @Override
    protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
        for (int i = 0; i < retryCount; i++) {
            try {
                super.runChild(method, notifier);
                return;
            } catch (Throwable t) {
                System.err.println(method.getName() + ": run " + (i+1) + " failed");
            }
        }
        System.err.println(method.getName() + ": giving up after " + retryCount + " failures");
        throw new RuntimeException();
    }
}</code>

Ajoutez l'annotation TestRunner à la classe de suite :

<code class="java">@RunWith(CustomTestRunner.class)
public class TestSuite {

    @BeforeClass
    public static void setUp() { ... }

    @AfterClass
    public static void tearDown() { ... }

    @Test
    public void test1() { ... }

    @Test
    public void test2() { ... }
}</code>

Les deux approches permettent un contrôle flexible des réexécutions de tests, offrant ainsi un mécanisme précieux pour gérer les échecs intermittents dans les tests JUnit.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!