TOC

Runners de test JUnit 4 personnalisés

Runers de test JUnit 4 personnalisés

1. Vue d'ensemble

Dans cet article rapide, nous allons nous concentrer sur la façon d'exécuter des tests JUnit à l'aide de lanceurs de tests personnalisés.

En termes simples, pour spécifier le coureur personnalisé, nous devons utiliser l'annotation@RunWith.

2. Préparation

Commençons par ajouter la dépendance standardJUnit dans nospom.xml: 


  junit
  junit
  4.12

3. Implémentation d'un Runner personnalisé

Dans l'exemple suivant, nous allons montrer comment écrire nos propresRunner personnalisés - et les exécuter en utilisant @RunWith.

A JUnit Runner is a class that extends JUnit’s abstract Runner class and it is responsible for running JUnit tests, utilisant généralement la réflexion.

Ici, nous implémentons des méthodes abstraites de la classeRunner: 

public class TestRunner extends Runner {

    private Class testClass;
    public TestRunner(Class testClass) {
        super();
        this.testClass = testClass;
    }

    @Override
    public Description getDescription() {
        return Description
          .createTestDescription(testClass, "My runner description");
    }

    @Override
    public void run(RunNotifier notifier) {
        System.out.println("running the tests from MyRunner: " + testClass);
        try {
            Object testObject = testClass.newInstance();
            for (Method method : testClass.getMethods()) {
                if (method.isAnnotationPresent(Test.class)) {
                    notifier.fireTestStarted(Description
                      .createTestDescription(testClass, method.getName()));
                    method.invoke(testObject);
                    notifier.fireTestFinished(Description
                      .createTestDescription(testClass, method.getName()));
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

La méthodegetDescription est héritée deDescribable et renvoie unDescription qui contient les informations qui sont ensuite exportées et peuvent être utilisées par divers outils.

Dans l'implémentation derun, nous invoquons les méthodes de test cibles à l'aide de la réflexion.

Nous avons défini un constructeur qui prend un argumentClass; c'est une exigence de JUnit. Au moment de l'exécution, JUnit passera la classe de test cible à ce constructeur.

RunNotifier est utilisé pour déclencher des événements contenant des informations sur la progression du test.

Utilisons le runner dans notre classe de test: 

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

@RunWith(TestRunner.class)
public class CalculatorTest {
    Calculator calculator = new Calculator();

    @Test
    public void testAddition() {
        Syste.out.println("in testAddition");
        assertEquals("addition", 8, calculator.add(5, 3));
    }
}

Le résultat que nous obtenons: 

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.example.junit.CalculatorTest
running the tests from MyRunner: class com.example.junit.CalculatorTest
in testAddition
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.002 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

4. Coureurs spécialisés

Au lieu d'étendre la classe de bas niveauRunner, comme nous l'avons fait dans le dernier exemple,we can extend one of the specialized subclasses of Runner: ParentRunner or BlockJUnit4Runner.

La classe abstraiteParentRunner exécute les tests de manière hiérarchique.

BlockJUnit4Runner est une classe concrète et si nous préférons personnaliser certaines méthodes, nous allons probablement étendre cette classe.

Voyons cela avec un exemple: 

public class BlockingTestRunner extends BlockJUnit4ClassRunner {
    public BlockingTestRunner(Class klass) throws InitializationError {
        super(klass);
    }

    @Override
    protected Statement methodInvoker(FrameworkMethod method, Object test) {
        System.out.println("invoking: " + method.getName());
        return super.methodInvoker(method, test);
    }
}

Annoter une classe avec@RunWith(JUnit4.class) invoquera toujours le runner JUnit 4 par défaut dans la version actuelle de JUnit; cette classe alias le coureur de classe JUnit 4 par défaut actuel: 

@RunWith(JUnit4.class)
public class CalculatorTest {
    Calculator calculator = new Calculator();

    @Test
    public void testAddition() {
        assertEquals("addition", 8, calculator.add(5, 3));
    }
}

5. Conclusion

JUnit Runners sont très adaptables et permettent au développeur de modifier la procédure d'exécution du test et l'ensemble du processus de test.

Si nous ne voulons apporter que des modifications mineures, c'est une bonne idée de jeter un œil aux méthodes protégées du runner deBlockJUnit4Class.

Certaines implémentations tierces populaires de coureurs à utiliser incluentSpringJUnit4ClassRunner, MockitoJUnitRunner, HierarchicalContextRunner,Cucumber Runner et bien plus encore.

L'implémentation de tous ces exemples et extraits de code peut être trouvée dans leGitHub project - il s'agit d'un projet Maven, il devrait donc être facile à importer et à exécuter tel quel.

Related