Test Runners 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 runner personnalisé, nous devrons utiliser l' annotation @RunWith .

2. Préparation

Commençons par ajouter la dépendance JUnit standard dans notre pom.xml :

 junit junit 4.12 

3. Implémentation d'un Runner personnalisé

Dans l'exemple suivant, nous montrerons comment écrire notre propre Runner personnalisé - et l'exécuter en utilisant @ RunWith .

Un JUnit Runner est une classe qui étend la classe abstraite Runner de JUnit et il est responsable de l'exécution des tests JUnit , généralement en utilisant la réflexion.

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

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éthode getDescription est héritée de Describable et renvoie une Description qui contient les informations qui sont ensuite exportées et peuvent être utilisées par divers outils.

Dans la course mise en œuvre, nous invoquant les méthodes d'essai de cible en utilisant la réflexion.

Nous avons défini un constructeur qui prend un argument de classe ; 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.baeldung.junit.CalculatorTest running the tests from MyRunner: class com.baeldung.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 Runner de bas niveau , comme nous l'avons fait dans le dernier exemple, nous pouvons étendre l'une des sous-classes spécialisées de Runner : ParentRunner ou BlockJUnit4Runner .

La classe abstraite ParentRunner 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) appellera 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

Les JUnit Runners sont hautement adaptables et permettent au développeur de modifier la procédure d'exécution des tests 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 coup d'œil aux méthodes protégées du runner BlockJUnit4Class .

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

L'implémentation de tous ces exemples et extraits de code se trouve dans le projet GitHub - il s'agit d'un projet Maven, il devrait donc être facile à importer et à exécuter tel quel.