Benutzerdefinierte JUnit 4-Testläufer

1. Übersicht

In diesem kurzen Artikel konzentrieren wir uns darauf, wie JUnit-Tests mit benutzerdefinierten Testläufern ausgeführt werden.

Einfach ausgedrückt, um den benutzerdefinierten Läufer anzugeben, müssen wir die Annotation @RunWith verwenden .

2. Vorbereitung

Beginnen wir mit dem Hinzufügen der Standard- JUnit- Abhängigkeit in unsere pom.xml :

 junit junit 4.12 

3. Implementieren eines benutzerdefinierten Runners

Im folgenden Beispiel zeigen wir, wie Sie unseren eigenen benutzerdefinierten Runner schreiben und ihn mit @ RunWith ausführen .

Ein JUnit Runner ist eine Klasse, die die abstrakte Runner- Klasse von JUnit erweitert und für die Ausführung von JUnit-Tests verantwortlich ist , normalerweise unter Verwendung von Reflektion.

Hier implementieren wir abstrakte Methoden der Runner- Klasse:

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); } } }

Die Methode getDescription wird von Describable geerbt und gibt eine Beschreibung zurück , die die Informationen enthält, die später exportiert werden und von verschiedenen Tools verwendet werden können.

In der Run- Implementierung rufen wir die Zieltestmethoden mithilfe von Reflection auf.

Wir haben einen Konstruktor definiert, der ein Klassenargument verwendet . Dies ist eine Anforderung von JUnit. Zur Laufzeit übergibt JUnit die Zieltestklasse an diesen Konstruktor.

RunNotifier wird zum Auslösen von Ereignissen verwendet, die Informationen zum Testfortschritt enthalten .

Verwenden wir den Läufer in unserer Testklasse:

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)); } }

Das Ergebnis erhalten wir:

------------------------------------------------------- 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. Spezialisierte Läufer

Anstatt die Runner- Klasse auf niedriger Ebene wie im letzten Beispiel zu erweitern, können wir eine der speziellen Unterklassen von Runner erweitern : ParentRunner oder BlockJUnit4Runner .

Die abstrakte ParentRunner- Klasse führt die Tests hierarchisch aus.

BlockJUnit4Runner ist eine konkrete Klasse. Wenn wir bestimmte Methoden anpassen möchten, werden wir diese Klasse wahrscheinlich erweitern.

Lassen Sie uns das anhand eines Beispiels sehen:

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); } }

Wenn Sie eine Klasse mit @RunWith (JUnit4.class) kommentieren, wird immer der Standard-JUnit 4-Runner in der aktuellen Version von JUnit aufgerufen . Diese Klasse aliasiert den aktuellen Standard-JUnit 4-Klassenläufer:

@RunWith(JUnit4.class) public class CalculatorTest { Calculator calculator = new Calculator(); @Test public void testAddition() { assertEquals("addition", 8, calculator.add(5, 3)); } }

5. Schlussfolgerung

JUnit Runners sind sehr anpassungsfähig und ermöglichen es dem Entwickler, das Testausführungsverfahren und den gesamten Testprozess zu ändern.

Wenn wir nur geringfügige Änderungen vornehmen möchten, ist es eine gute Idee, sich die geschützten Methoden von BlockJUnit4Class Runner anzusehen .

Einige beliebte Implementierungen von Läufern von Drittanbietern zur Verwendung umfassen SpringJUnit4ClassRunner, MockitoJUnitRunner, HierarchicalContextRunner, Cucumber Runner und vieles mehr.

Die Implementierung all dieser Beispiele und Codefragmente finden Sie im GitHub-Projekt - dies ist ein Maven-Projekt, daher sollte es einfach zu importieren und auszuführen sein, wie es ist.