X
BLOG

Tutorial de JUnit: Configuración, escritura y ejecución de pruebas unitarias de Java

Tutorial de JUnit: Configuración, escritura y ejecución de pruebas unitarias de Java Tiempo de leer: 7 minutos
Hoy volveremos a los conceptos básicos de las pruebas unitarias con uno de los tutoriales JUnit más cortos (¡pero no menos útiles!) Sobre cómo configurar, escribir y ejecutar sus pruebas JUnit. ¿Qué es un JUnit y cómo empezar?

Comprenda los conceptos básicos y amplíe su práctica de pruebas unitarias como un profesional con este tutorial.

¿Qué son las pruebas unitarias?

Pero antes de profundizar demasiado en JUnits, hablemos un poco sobre las pruebas unitarias y las pruebas de regresión y por qué son importantes en general. Veremos algunos buenos ejemplos a medida que avancemos.

La prueba unitaria es una forma de prueba de caja blanca, en la que los casos de prueba se basan en la estructura interna. El probador elige entradas para explorar rutas particulares y determina la salida apropiada. El propósito de las pruebas unitarias es examinar los componentes individuales o piezas de métodos / clases para verificar la funcionalidad, asegurando que el comportamiento sea el esperado.

El alcance exacto de una “unidad” a menudo se deja a la interpretación, pero una buena regla general es que una unidad contenga la menor cantidad de código que realice una tarea independiente (por ejemplo, un solo método o clase). Hay una buena razón por la que limitamos el alcance cuando se realizan pruebas unitarias: si construimos una prueba que presenta múltiples aspectos de un proyecto, hemos cambiado el enfoque, de la funcionalidad de un solo método, a la interacción entre diferentes partes del código. Si la prueba falla, no sabemos por qué falló y nos quedamos preguntándonos si el punto de falla estaba dentro del método que nos interesaba o en las dependencias asociadas con ese método.

Pruebas de regresión

Como complemento de las pruebas unitarias, las pruebas de regresión aseguran que la última corrección, mejora o parche no rompió la funcionalidad existente, al probar los cambios que ha realizado en su código. Los cambios en el código son inevitables, ya sean modificaciones del código existente o agregar paquetes para nuevas funcionalidades ... su código ciertamente cambiará. Es en este cambio donde reside el mayor peligro, por lo que con eso en mente, las pruebas de regresión son imprescindibles.

Conceptos básicos de JUnit: Introducción a JUnit y uso de la automatización para crear pruebas unitarias

¿Qué es JUnit?

JUnit es un marco de pruebas unitarias de Java que es uno de los mejores métodos de prueba para las pruebas de regresión. Es un marco de código abierto que se utiliza para escribir y ejecutar pruebas automatizadas repetibles.

Como con cualquier otra cosa, el marco de prueba de JUnit ha evolucionado con el tiempo. El cambio principal a tener en cuenta es la introducción de anotaciones que vino junto con el lanzamiento de JUnit 4, que proporcionó un aumento en la organización y legibilidad de JUnits. El resto de esta publicación de blog se escribirá a partir de usos de Junit 4 y 5.

Cómo configurar las pruebas de JUnit

Así que vamos a sumergirnos de lleno. Estos son los pasos para configurar JUnit.

Los IDE más comunes, como Eclipse e IntelliJ, ya tendrán la integración de prueba JUnit instalada de forma predeterminada. Si uno no está usando un IDE y quizás se basa únicamente en un sistema de compilación como Maven o Gradle, la instalación de Junit 4/5 se maneja a través de pom.xml o build.gradle, respectivamente. Es importante tener en cuenta que Junit 5 se dividió en 3 módulos, uno de los cuales es un módulo antiguo que admite la anotación / sintaxis de Junit 4 y 3 (aunque el uso de Junit 3 es francamente pésimo y, por lo general, solo se ve en proyectos mucho más antiguos).

JUnit 4

Para agregar JUnit 4 a su Maven, cree lo siguiente en pom.xml. Tenga en cuenta la versión:

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>

Para Gradle, agregue lo siguiente a build.gradle:

apply plugin: 'java'

dependencies {
testCompile 'junit:junit:4.12'
}

JUnit 5

Agregar JUnit 5 es un poco diferente. Debido a la forma modular de JUnit 5, se utiliza una lista de materiales para importar todos los aspectos. Si solo se necesitan clases particulares, se pueden especificar grupos o artefactos individuales.

Para agregar JUnit 5 a Maven, agregue lo siguiente a pom.xml:

<dependency>
<groupId>org.junit</groupId>
<artifactId>junit-bom</artifactId>
<version>5.2.0</version>
<scope>test</scope>
</dependency>

Para Gradle, agregue lo siguiente a build.gradle:

apply plugin: 'java'

dependencies {
implementation 'org.junit:junit-bom:5.2.0'
}

Si necesita poner manualmente la ruta de clases para las pruebas de JUnit, Java necesita el archivo jar sin formato, aunque normalmente no es necesario. Git alberga el código para JUnit. JUnit 4 tiene el jar disponible para descargar directamente. Junit 5 (mientras estoy escribiendo esto) actualmente no tiene el archivo jar prefabricado, pero se puede compilar fácilmente el código y generar los archivos jar.

Mejore las pruebas unitarias para Java con automatización: mejores prácticas para desarrolladores de Java
Obtenga el libro electrónico gratis

Pruebas unitarias de escritura: la anatomía de un JUnit

Ahora que hemos hablado un poco sobre las pruebas y la configuración de JUnit, pasemos a la construcción y ejecución reales de estas pruebas. Para ilustrar mejor la creación de JUnits, queremos comenzar con algo básico. En la imagen de ejemplo de prueba JUnit a continuación, tenemos un método simple (izquierda) que convierte Fahrenheit a Celsius, y JUnit (derecho) asociado con nuestro método. He numerado nuestro JUnit y discutiré estas secciones en detalle a continuación.

Secciones 1 y 2

Estas son importaciones para las bibliotecas JUnit necesarias para aprovechar el marco de prueba. Las bibliotecas importadas se pueden especificar hasta una funcionalidad particular de JUnit, pero comúnmente se importan con asteriscos para tener acceso a todas las funcionalidades.

Sección 3

Esto tiene el comienzo de nuestra clase de prueba, lo importante a tener en cuenta aquí es la convención de nomenclatura para la clase, que sigue a ClassNameTest.

Sección 4

Aquí, vemos nuestra primera sintaxis específica de JUnit, una anotación. Las anotaciones son extremadamente importantes al crear JUnits. Así es como JUnit sabe qué hacer con la sección de procesamiento del código. En nuestro caso de ejemplo, tenemos una anotación @Test, que le dice a JUnit que el método public void al que está adjunto se puede ejecutar como un caso de prueba.

Hay muchas otras anotaciones, pero las más comunes son @Before (que ejecuta alguna declaración / condición previa antes de @Test, public void), @After (que ejecuta alguna declaración después de @Test, public void, por ejemplo, restablecer variables, eliminar archivos temporales, variables , etc.) y @Ignore (que ignora alguna declaración durante la ejecución de la prueba; tenga en cuenta que @BeforeClass y @AfterClass se utilizan para ejecutar declaraciones antes y después de todos los casos de prueba, public static void, respectivamente).

Sección 5:

La conclusión aquí es nuevamente la convención de nomenclatura. Tenga en cuenta la estructura, pruebeNombre del método.

Sección 6:

Aquí construimos una nueva instancia de nuestro objeto de clase. Esto es necesario para que podamos llamar al método que estamos probando en algo. Sin esta instancia de objeto, no podemos probar el método.

Sección 7:

Es necesario establecer las variables asociadas con el método, por lo que aquí declaramos las variables correspondientes a nuestro método. A estos se les deben dar valores significativos (nota: si un parámetro es un objeto, uno puede instanciarlo o simularlo), para que nuestra prueba tenga significado.

Sección 8:

Esta declaración de variable podría argumentarse como opcional, pero vale la pena por motivos de organización y legibilidad. Asignamos los resultados de nuestro método que se está probando a esta variable, usándola según sea necesario para afirmaciones y demás.

Sección 9:

Los métodos de aserción (que son parte de la clase org.junit.Assert) se utilizan para determinar el estado de pasa / falla de los casos de prueba. Solo se registran las afirmaciones fallidas. Al igual que con las anotaciones, hay muchas opciones de afirmación. En nuestro ejemplo JUnit anterior, usamos assertEquals (esperado, actual, delta). Esto toma en el gastos esperados, que el usuario define, el real, que es el resultado de la llamada al método, y el delta, que permite implementar una desviación permitida entre los valores esperados y reales. El propósito de una aserción es la validación. Aunque no es necesario para ejecutar su JUnit, si no se agregan aserciones, se podría decir que anula el propósito de la prueba. Sin afirmaciones, no tiene verificación y, como mucho, una prueba de humo, que brinda retroalimentación solo cuando se detectan errores de prueba.

Cómo ejecutar un JUnit

¡Elige tu propia aventura! Aquí, veremos tres formas de ejecutar JUnits: directamente desde la línea de comandos, desde el IDE (Eclipse e IntelliJ) y usando sistemas de compilación (Maven y Gradle).

Cómo ejecutar un JUnit desde la línea de comandos

Para ejecutar un JUnit directamente desde la línea de comando, necesita algunas cosas: JDK en su ruta, archivo jar de Junit sin procesar y los casos de prueba. El comando es el siguiente (este ejemplo es para Junit 4):

java -cp /path/to/junit.jar org.junit.runner.JUnitCore <test class name>

NOTA: Es poco probable que en un entorno profesional se ejecute una prueba manualmente desde la línea de comandos, sin algún sistema de compilación, pero la capacidad está ahí.

Cómo ejecutar un JUnit desde el IDE

eclipsar

Para ejecutar desde Eclipse, desde su Explorador de paquetes, ubique su prueba JUnit, en la carpeta que la haya designado. Haga clic con el botón derecho y baje hasta Ejecutar como prueba JUnit. Esto ejecutará su prueba y abrirá una nueva ventana JUnit si aún no está abierta.

IntelliJ

Ejecutar una prueba en IntelliJ es muy similar a Eclipse. En la ventana Proyecto, busque la prueba, haga clic con el botón derecho y seleccione Ejecutar 'testName'. Al igual que Eclipse, se abrirá una ventana JUnit con los resultados de la prueba.

Cómo ejecutar un JUnit usando sistemas de compilación

Maven

Maven ha simplificado la ejecución de pruebas. Asegúrese de estar en la ubicación adecuada desde su línea de comando y que el proyecto pom.xml esté configurado correctamente. Luego puede ejecutar lo siguiente para ejecutar sus JUnits:

Para ejecutar todo el conjunto de pruebas:

mvn test

Para ejecutar pruebas únicas / específicas:

mvn -Dtest=TestName test

Gradle

Gradle, como maven, ha simplificado la ejecución de pruebas.

Para ejecutar todo el conjunto de pruebas:

gradlew test

Para ejecutar pruebas únicas / específicas:

gradlew -Dtest.single=testName test

NOTA: Maven y Gradle son su propio monstruo; lo que se muestra aquí es mínimo para cubrir los conceptos básicos. Consulte su documentación si desea obtener más información.

Continuando con las pruebas unitarias

Nuestro ejemplo se ejecutó a través de un fragmento de código muy simple y, por supuesto, esto es solo el comienzo de las pruebas unitarias. Los métodos más complejos llaman a bases de datos u otros métodos, pero para asegurar la funcionalidad necesitamos aislamiento, lo cual logramos a través de burlón. Mocking nos ayuda a aislar unidades de código para enfocar nuestra validación (los marcos que se usan comúnmente para simular son Mockito y PowerMock). Para leer más sobre burlarse, lea la publicación de mi colega: Cómo automatizar una prueba unitaria de Java, incluidas las burlas y las afirmaciones.

Entonces, si las pruebas unitarias son tan asombrosas, ¿por qué no todos son geniales en ellas? Bueno, las pruebas unitarias no son fáciles de implementar. Se necesita mucha habilidad y tiempo de desarrollo, los desarrolladores tienden a no disfrutarlo mucho y se necesita compromiso y tiempo para mantener las suites de prueba.

Pero los beneficios de las pruebas unitarias son claros:

  • Aislamiento y pruebas enfocadas
  • Asegurar el comportamiento de métodos individuales o piezas de métodos.
  • Ayuda a asegurar que la adición o modificación de código no interrumpa la aplicación
  • Análisis de límites: comprobación de entradas incorrectas o no válidas
  • Pruebe todos los aspectos del método (cobertura)
  • Cobertura

Por lo tanto, es útil implementar potentes herramientas de prueba de unidades como Parasoft Jtest que puede solucionar muchos de los problemas asociados con JUnits y ahorrar a los desarrolladores un tiempo valioso. Parasoft Jtest's Asistente de prueba unitaria toma el dolor de cabeza del tiempo, reduciendo el tiempo de generación de pruebas JUnit al brindarle al usuario una guía para crear pruebas con acciones intuitivas de un solo clic. La capacidad de mantenimiento se aborda con recomendaciones automáticas que identifican aspectos como entornos de prueba inestables (y otros riesgos), recomendaciones de afirmación y más.

Para obtener más información sobre cómo aliviar el dolor y mejorar las pruebas de su unidad, descargue una prueba gratuita de Asistente de prueba unitaria de Parasoft Jtest. Es gratis, fácil de configurar y puedes seguir todos los tutoriales. Aquí para comenzar de manera eficiente.

Conceptos básicos de JUnit: Introducción a JUnit y uso de la automatización para crear pruebas unitarias
Escrito por

David Chacón

Reciba las últimas noticias y recursos sobre pruebas de software en su bandeja de entrada.

Prueba Parasoft