1. Información general
En este artículo rápido, nos centraremos en cómo ejecutar pruebas JUnit utilizando corredores de prueba personalizados.
En pocas palabras, para especificar el corredor personalizado, necesitaremos usar la anotación @RunWith .
2. Preparación
Comencemos agregando la dependencia JUnit estándar en nuestro pom.xml :
junit junit 4.12 3. Implementación de un corredor personalizado
En el siguiente ejemplo, mostraremos cómo escribir nuestro propio Runner personalizado y ejecutarlo usando @ RunWith .
Un JUnit Runner es una clase que extiende la clase abstracta Runner de JUnit y es responsable de ejecutar las pruebas de JUnit , generalmente usando la reflexión.
Aquí, estamos implementando métodos abstractos de la clase 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); } } }El método getDescription se hereda de Describable y devuelve una Descripción que contiene la información que luego se exporta y puede ser utilizada por varias herramientas.
En el plazo de ejecución, estamos invocando los métodos de ensayo de destino mediante la reflexión.
Hemos definido un constructor que toma un argumento Class ; este es un requisito de JUnit. En tiempo de ejecución, JUnit pasará la clase de prueba de destino a este constructor.
RunNotifier se utiliza para activar eventos que tienen información sobre el progreso de la prueba.
Usemos el corredor en nuestra clase de prueba:
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)); } }El resultado que obtenemos:
------------------------------------------------------- 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: 04. Corredores especializados
En lugar de extender la clase Runner de bajo nivel , como hicimos en el último ejemplo, podemos extender una de las subclases especializadas de Runner : ParentRunner o BlockJUnit4Runner .
La clase abstracta ParentRunner ejecuta las pruebas de forma jerárquica.
BlockJUnit4Runner es una clase concreta y si preferimos personalizar ciertos métodos, probablemente extenderemos esta clase.
Veamos eso con un ejemplo:
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); } }Anotar una clase con @RunWith (JUnit4.class) siempre invocará el corredor JUnit 4 predeterminado en la versión actual de JUnit; esta clase alias del corredor de clase JUnit 4 predeterminado actual:
@RunWith(JUnit4.class) public class CalculatorTest { Calculator calculator = new Calculator(); @Test public void testAddition() { assertEquals("addition", 8, calculator.add(5, 3)); } }5. Conclusión
Los JUnit Runners son altamente adaptables y permiten que el desarrollador cambie el procedimiento de ejecución de la prueba y todo el proceso de prueba.
Si solo queremos hacer cambios menores, es una buena idea echar un vistazo a los métodos protegidos del corredor BlockJUnit4Class .
Algunas implementaciones populares de terceros de corredores para su uso incluyen SpringJUnit4ClassRunner, MockitoJUnitRunner, HierarchicalContextRunner, Cucumber Runner y mucho más.
La implementación de todos estos ejemplos y fragmentos de código se puede encontrar en el proyecto GitHub; este es un proyecto de Maven, por lo que debería ser fácil de importar y ejecutar tal como está.