Usando JUnit 5 con Gradle

1. Información general

En este tutorial, realizaremos pruebas en la nueva plataforma JUnit 5 con la herramienta de compilación Gradle.

Configuraremos un proyecto que admita tanto la versión antigua como la nueva.

No dude en leer Una guía de JUnit 5 para obtener más información sobre la nueva versión. O la Introducción a Gradle para obtener información detallada sobre la herramienta de compilación.

2. Configuración de Gradle

Primero, verificamos si la versión 4.6 o superior de la herramienta de compilación está instalada, ya que es la versión más antigua que funciona con JUnit 5.

La forma más sencilla es simplemente ejecutar el comando gradle -v :

$> gradle -v ------------------------------------------------------------ Gradle 4.10.2 ------------------------------------------------------------

Y, si es necesario, podemos seguir los pasos de instalación para obtener la versión correcta.

Una vez que hayamos instalado todo, necesitamos configurar Gradle usando el archivo build.gradle .

Podemos comenzar proporcionando la plataforma de prueba unitaria a la herramienta de compilación:

test { useJUnitPlatform() } 

Ahora que hemos especificado la plataforma, necesitamos proporcionar las dependencias de JUnit. Aquí es donde vemos una diferencia notable entre JUnit 5 y versiones anteriores.

Mira, con versiones anteriores, solo necesitábamos una dependencia. En JUnit 5, sin embargo, la API está separada del tiempo de ejecución, es decir, dos dependencias.

La API se manifiesta con junit-jupiter-api . El tiempo de ejecución es junit-jupiter-engine para JUnit 5 y junit-vintage-engine para JUnit 3 o 4.

Proporcionaremos estos dos en testImplementation y timeRuntimeOnly , respectivamente:

dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1' }

3. Creación de pruebas

Escribamos nuestra primera prueba. Se parece a las versiones anteriores:

@Test public void testAdd() { assertEquals(42, Integer.sum(19, 23)); }

Ahora, podemos ejecutar la prueba mediante la ejecución del ensayo limpio Gradle comando .

Para verificar que estamos usando JUnit 5, podemos mirar las importaciones. Las importaciones para @Test y assertEquals deben tener un paquete que comience con org.junit.jupiter.api:

import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals;

Entonces, en el último ejemplo, creamos una prueba con una funcionalidad 'antigua' que ha estado funcionando durante años. Ahora crearemos otro ejemplo que utiliza algunas de las nuevas funciones de JUnit 5:

@Test public void testDivide() { assertThrows(ArithmeticException.class, () -> { Integer.divideUnsigned(42, 0); }); }

assertThrows es una nueva aserción en JUnit5 que reemplaza el antiguo estilo de @Test (esperado = ArithmeticException.class).

4. Configuración de pruebas de JUnit 5 con Gradle

A continuación, exploraremos una integración más profunda entre Gradle y JUnit5.

Digamos que tenemos dos tipos de pruebas en nuestra suite: de ejecución larga y de ejecución corta. Podríamos usar la anotación JUnit 5 @Tag :

public class CalculatorJUnit5Test { @Tag("slow") @Test public void testAddMaxInteger() { assertEquals(2147483646, Integer.sum(2147183646, 300000)); } @Tag("fast") @Test public void testDivide() { assertThrows(ArithmeticException.class, () -> { Integer.divideUnsigned(42, 0); }); } }

Luego, le decimos a la herramienta de construcción cuáles ejecutar. En nuestro caso, ejecutemos las pruebas de ejecución corta (rápidas):

test { useJUnitPlatform { includeTags 'fast' excludeTags 'slow' } }

5. Habilitación de la compatibilidad con versiones anteriores

Ahora, todavía es posible crear pruebas JUnit 3 y 4 con el nuevo motor Jupiter. Es más, podemos mezclarlos con la nueva versión en el mismo proyecto, digamos, en un escenario de migración.

Para comenzar, agregamos algunas dependencias a la configuración de compilación existente:

testCompileOnly 'junit:junit:4.12' testRuntimeOnly 'org.junit.vintage:junit-vintage-engine:5.3.1'

Observe cómo nuestro proyecto ahora tiene tanto junit-jupiter-engine como junit-vintage-engine.

Ahora creamos una nueva clase y copiamos y pegamos el método testDivide que creamos anteriormente. Luego, agregamos las importaciones para @Test y assertEquals . Sin embargo, esta vez nos aseguramos de utilizar los paquetes de la versión 4 anterior, comenzando por org.junit:

import static org.junit.Assert.assertEquals; import org.junit.Test; public class CalculatorJUnit4Test { @Test public void testAdd() { assertEquals(42, Integer.sum(19, 23)); } }

6. Conclusión

En este tutorial, integramos Gradle con JUnit 5. Aún más, también agregamos soporte para las versiones 3 y 4.

Hemos visto que la herramienta de compilación proporciona un excelente soporte para las versiones antiguas y nuevas. Por lo tanto, podemos usar las nuevas funciones en un proyecto existente sin la necesidad de cambiar todas nuestras pruebas existentes.

El ejemplo de código completo está disponible en el proyecto GitHub. Siéntase libre de usarlo como punto de partida para su propio proyecto.