Una guía para principiantes sobre JUnit 5

Tutoriales

JUnit

JUnit 5 es un marco de pruebas de software utilizado por los desarrolladores para realizar pruebas unitarias de su código. Es un marco basado en Java que permite escribir y ejecutar pruebas en la plataforma Java, incluyendo un reportero integrado que muestra los resultados de las pruebas.

JUnit se puede utilizar para pruebas de automatización con dos propósitos principales:

Probar que el software funciona como se espera que funcione
Encontrar y reportar errores en el código y corregirlos lo más rápido posible

En este blog, nos centraremos en aprender sobre la configuración, configuración y métodos básicos utilizados en JUnit 5.

¿Qué es JUnit 5?

JUnit 5 es la última versión del marco de pruebas JUnit. Soporta Java 8 y versiones más recientes, acomoda diferentes estilos de prueba y ofrece una base moderna para pruebas del lado del desarrollador en la JVM.

El principal beneficio de usar JUnit es su modularidad, ya que contiene múltiples módulos que permiten a los desarrolladores probar diferentes componentes del software fácilmente. También se puede utilizar para probar clases individuales de la aplicación en lugar de toda la aplicación.

Características de JUnit 5

Las siguientes son algunas de las características populares e importantes de JUnit 5 que lo distinguen de otros marcos de pruebas unitarias.

Feature	Description	Annotations/Method
Suites de Pruebas	Las suites de pruebas son básicamente un grupo de pruebas, como Smoke, Sanity, o un grupo de pruebas relacionadas con una característica particular. JUnit 5 permite la creación de suites de pruebas que se pueden ejecutar juntas.	Para usar Suites de Pruebas, necesitamos agregar una dependencia de Suite de Plataforma JUnit y usar las siguientes anotaciones. `@SelectPackages`, `@SelectClasses`, `@Suite`
Afirmaciones	Las afirmaciones se utilizan para verificar el comportamiento esperado del software. JUnit 5 proporciona métodos de afirmación incorporados que pueden ayudar a realizar fácilmente las afirmaciones.	Existen múltiples métodos de afirmación disponibles en la clase `import org.junit.jupiter.api.Assertions;`. Algunos de los métodos se enumeran a continuación: `assertTrue()`, `assertFalse()`, `assertEquals()`, `assertAll()`, `assertNotEquals()`
Orden de Ejecución de Pruebas	Personaliza el orden de ejecución de las pruebas. Permite al desarrollador tomar control de la ejecución de las pruebas y ejecutarlas en un orden específico según sea necesario.	`@TestMethodOrder`, `@Order`, `@TestClassOrder`
Pruebas de Excepción	Realiza pruebas de excepción que verifican que se arroje la excepción requerida en la prueba.	Se utiliza el siguiente método de la `import org.junit.jupiter.api.Assertions;` clase: `assertThrows()`
Dependencias de Prueba	Las dependencias de prueba permiten pruebas secuenciales proporcionando la capacidad de permitir que los métodos de prueba dependan entre sí. Esto significa que el siguiente método de prueba, que depende del método de prueba anterior, no se ejecutará a menos que el anterior pase. Esta es una característica útil al escribir pruebas de integración.	@TestInstance
Deshabilitar Pruebas	Deshabilita pruebas o clases de prueba.	@Disabled
Tiempo de Espera	Falla una prueba si su tiempo de ejecución excede una duración especificada.	@Timeout
Informes	Proporciona un reportero integrado para analizar los resultados de las pruebas y muestra información detallada. Genera un archivo `.html` con los resultados de la ejecución de las pruebas.	N/A

JUnit 4 vs. JUnit 5

Con el lanzamiento de la última versión de JUnit, es decir, JUnit 5, se han agregado múltiples cambios y nuevas características al marco. Las diferencias entre las dos versiones se enumeran en la tabla a continuación:

criteria	JUNIT4	JUNIT5
Arquitectura	Todo estaba empaquetado en un solo archivo JAR.	Dividido en 3 subproyectos: – JUnit Platform – JUnit Jupiter – JUnit Vintage
Requisitos de versión de JDK	Requiere Java 5 o superior	Requiere Java 8 o superior
Integración de terceros	No hay soporte de integración de terceros para complementos e IDEs	Subproyecto dedicado (JUnit Platform) para integraciones de terceros
Soporte para pruebas anidadas	No se proporciona anotación para escribir pruebas anidadas	Proporciona la anotación `@Nested` para escribir pruebas anidadas
Soporte para registrar extensiones personalizadas	No hay soporte para extensiones personalizadas	Proporciona la anotación `@ExtendWith` para registrar extensiones personalizadas
Cambios realizados en anotaciones comúnmente usadas	– `@BeforeClass` – `@AfterClass` – `@Before` – `@After` – `@Ignore`	– `@BeforeAll` – `@AfterAll` – `@BeforeEach` – `@AfterEach` – `@Disabled`
Cambios en anotaciones para etiquetar y filtrar	Se utiliza la anotación `@Category`	Se utiliza la anotación `@Tag`
Conjuntos de pruebas	Se utilizaron las anotaciones `@RunWith` y `@Suite`	Las anotaciones `@Suite`, `@SelectPackages` y `@SelectClasses` se utilizan

Comenzando con JUnit 5

En esta sección, aprenderemos cómo escribir casos de prueba de JUnit 5 usando el IDE IntelliJ. Como ya viene incluido con JUnit 5, no es necesario realizar una instalación adicional para usarlo.

Es necesario crear un nuevo proyecto Maven, agregar las dependencias de JUnit 5 y comenzar a escribir los tests inmediatamente.

Agregando las Dependencias de JUnit en el Proyecto Maven

Las siguientes dependencias de JUnit 5 deben ser añadidas en el archivo pom.xml:

Motor Júpiter de JUnit
API Júpiter de JUnit
Suite de Plataforma JUnit (Agregador)
Parámetros Júpiter de JUnit

XML

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-engine</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-api</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.platform</groupId>

    <artifactId>junit-platform-suite</artifactId>

    <version>1.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-params</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

Aquí está el archivo completo de pom.xml

XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

​

    <groupId>io.github.mfaisalkhatri</groupId>

    <artifactId>junit-basic</artifactId>

    <version>1.0-SNAPSHOT</version>

    <packaging>jar</packaging>

​

    <name>junit-basic</name>

    <url>http://maven.apache.org</url>

​

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    </properties>

​

    <dependencies>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-engine</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-api</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.platform</groupId>

            <artifactId>junit-platform-suite</artifactId>

            <version>1.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-params</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

</project>

Después de añadir las dependencias, estamos listos para escribir el test. Pero, antes de continuar escribiendo los tests usando JUnit 5, primero comprendamos las anotaciones básicas que pueden ayudarnos a configurar eficientemente el conjunto de pruebas y ejecutar los tests según sea necesario.

Anotaciones Básicas Usadas en JUnit 5

Las siguientes son las anotaciones básicas que son más utilizadas por los desarrolladores al escribir los tests usando JUnit 5.

Anotación @BeforeAll

La anotación @BeforeAll indica que el método anotado debe ejecutarse antes de cualquier método @Test, @RepeatedTest, @ParameterizedTest o @TestFactory en la clase actual. Debe ser un método estático en la clase de prueba.

@BeforeAll sirve como el reemplazo de la anotación @BeforeClass utilizada en JUnit 4.x

Sintaxis:

Java

public class BasicTest {

​

   @BeforeAll

   public static void beforeAllTest() {

​

       System.out.println("Before All method called!!");

   }

​

//..

}

Anotación @BeforeEach

La anotación @BeforeEach indica que el método anotado debe ejecutarse antes de cada invocación de @Test, @RepeatedTest, @ParameterizedTest o @TestFactory en la clase actual.

Es parte de los métodos del ciclo de vida de las pruebas y reemplaza la anotación @Before utilizada en JUnit 4.

Sintaxis:

Java

public class BasicTest {

​

   @BeforeEach

   public void beforeEachTest() {

       System.out.println("Before Each method called!!");

   }

//...

}

Anotación @AfterAll

La anotación @AfterAll indica que el método anotado debe ser llamado después de que se hayan ejecutado todas las pruebas en la clase actual. Debe ser un método estático y se utiliza como un método de limpieza en la clase de prueba.

La anotación @AfterAll es el reemplazo de la anotación @AfterClass en JUnit 4.

Sintaxis:

Java

public class BasicTest {

​

//...

​

@AfterAll

public static void afterAllMethod() {

   System.out.println("After All method called!!");

   }

}

Anotación @AfterEach

La anotación @AfterEach indica que el método anotado debe ejecutarse después de cada método @Test, @RepeatedTest, @ParameterizedTest o @TestFactory en la clase actual.

Sirve como reemplazo de JUnit 5 para la anotación @After utilizada en JUnit 4.

Sintaxis:

Java

public class BasicTest {

​

//...

​

@AfterEach

public void afterEachMethod() {

   System.out.println("After Each method called!!");

   }

}

Anotación @Test

La anotación @Test indica que el método anotado es un método de prueba. El método de prueba no debe ser un método privado o estático y no debe devolver ningún valor.

Sintaxis:

Java

public class BasicTest {

​

//.. 

@Test

public void testMethod() {
   System.out.println("Test Method Called!!");
  }
}

Anotación @DisplayName

La anotación @DisplayName se utiliza para especificar un nombre personalizado para la clase de prueba o método anotado. Estos nombres personalizados pueden incluir espacios, caracteres especiales e incluso emojis y se utilizan típicamente en los informes de prueba generados por IDE y herramientas de compilación.

Sintaxis:

Java

@DisplayName("Demo Test class")
public class BasicTest {
​
//...
​
@DisplayName("This is a demo test")
@Test
public void testMethod() {
   System.out.println("Test Method Called!!");
   }
}

Anotación @Disabled

La anotación @Disabled en JUnit 5 se utiliza para excluir el método de prueba o clase de prueba de la suite de pruebas para la ejecución.

Cuando se aplica a una clase de prueba, todos los métodos dentro de la clase de prueba se consideran automáticamente deshabilitados. Esta anotación tiene un parámetro opcional que permite especificar la razón para deshabilitar la prueba.

Sintaxis:

Java

public class BasicTest {
​
@Disabled("Test method disabled")
public void testMethod() {
   System.out.println("Test Method Called!!");
 }
//...
}

Cómo Escribir Casos de Prueba Automatizados Utilizando JUnit 5

Es hora de adentrarnos en el código y ensuciarnos las manos con JUnit 5. Crearemos una nueva clase Java, BasicTest.

Java

public class BasicTest {
//..
}

Se cubrirán todas las anotaciones básicas que discutimos como parte de la demostración.

Agreguemos métodos en la clase BasicTest para demostrar el uso de las anotaciones @BeforeAll, @BeforeEach, @AfterAll, @AfterEach, @Test, @DisplayName y @Disabled disponibles en JUnit 5.

Java

@DisplayName("Demo Test class")
public class BasicTest {
​
   @BeforeAll
   public static void beforeAllTest() {
​
       System.out.println("Before All method called!!");
   }
​
   @BeforeEach
   public void beforeEachTest() {
       System.out.println("Before Each method called!!");
   }
​
   @DisplayName("This is a demo test")
   @Test
   public void testMethodOne() {
       System.out.println("Test Method One Called!!");
   }
​
   @Test
   @Disabled("This test is disabled to demo disable annotation")
   public void disabledTest() {
       System.out.println("This is a disabled test!!");
   }
​
   @Test
   public void testMethodTwo() {
       System.out.println("Test Method Two Called!!");
​
   }
​
   @AfterEach
   public void afterEachMethod() {
       System.out.println("After Each method called!!");
   }
​
   @AfterAll
   public static void afterAllMethod() {
       System.out.println("After All method called!!");
   }
}

Recorrido del Código

La anotación @DisplayName sobre la clase de prueba mostrará el nombre de la prueba como “Clase de prueba de demostración” en los resultados cuando se ejecute la prueba.

El método beforeAllTest() se ejecutará antes de que se ejecuten las pruebas y mostrará el texto “¡¡Antes de que se llame a todos los métodos!!”. A continuación, el método beforeEachTest() se ejecutará antes de cada prueba y mostrará el texto “¡¡Antes de que se llame a cada método!!”.

Hay tres métodos de prueba en esta clase, a saber, testMethodOne(), testMethodTwo() y disabledTest(). Los tres métodos de prueba tienen la @Test annotation sobre ellos, lo que indica que son métodos de prueba.

El método disabledTest() no se ejecutará ya que tiene la anotación @Disabled colocada sobre él.

Después de que se complete la ejecución de cada prueba, se ejecutará el método afterEachTestMethod() ya que tiene la anotación @AfterEach colocada sobre él.

Finalmente, después de que se ejecuten todas las pruebas, se ejecutará el método afterAllMethod() ya que tiene la anotación @AfterAll colocada sobre él.

Ejecución de Pruebas

Las pruebas se pueden ejecutar haciendo clic derecho en la clase de prueba y seleccionando Ejecutar ‘<Nombre de la clase de prueba>’(“BasicTest” en nuestro caso).

Otra forma es hacer clic en el ícono de reproducción de color verde al lado de la declaración de la clase de prueba, como se muestra en la captura de pantalla a continuación:

La siguiente captura de pantalla de IntelliJ IDE muestra que las pruebas se ejecutaron con éxito.

Se puede ver en la captura de pantalla anterior que se ha impreso el nombre visible de la clase de prueba, también se puede ver la prueba deshabilitada y la razón de la prueba deshabilitada se imprime en la consola.

El resto de los métodos de prueba, incluidos los beforetest y aftertest, se ejecutaron con éxito, y los resultados respectivos se imprimieron en la consola.

Resumen

JUnit 5 es un potente marco de pruebas utilizado por los desarrolladores para realizar pruebas unitarias del código. También es utilizado por los ingenieros de automatización de pruebas para escribir y ejecutar scripts de automatización de pruebas. Tiene características ricas que permiten a los desarrolladores y probadores escribir los scripts de prueba y realizar pruebas unitarias del código.

También proporciona múltiples métodos para realizar afirmaciones y verificaciones que son útiles al escribir pruebas automatizadas. Junto con la escritura y ejecución de los scripts de prueba, también proporciona un informe de prueba que se puede utilizar para demostrar los resultados de la ejecución de pruebas a las partes interesadas y mostrar la cobertura de pruebas.

¡Feliz prueba!

Source:
https://dzone.com/articles/beginners-guide-to-junit-5