Cuando está escribiendo un conjunto de pruebas unitarias, puede haber algunas actividades no relacionadas con las pruebas que deba realizar. Estas actividades pueden tomar cualquier forma. Es posible que deba conectarse a una base de datos o recopilar recursos antes de realizar una prueba. Después de que se ejecute cada caso de prueba, es posible que deba liberar algunos recursos.
Realizar cualquiera de estas actividades no relacionadas con la prueba fuera del alcance de una clase de prueba unitaria puede ser tedioso, si no imposible. La ejecución exitosa de su clase de prueba puede depender de estas actividades, por lo que JUnit proporciona dos pares de anotaciones para abordar este problema.
La anotación @BeforeAll
Una clase de prueba JUnit puede tener uno o más métodos de prueba. La anotación @BeforeAll indica que un método específico debe ejecutarse antes que todos los métodos de prueba en una clase de prueba. El método asociado con esta anotación solo se ejecuta una vez (al comienzo de la prueba), independientemente de la cantidad de métodos de prueba en la clase de prueba.
Cualquier método que use la anotación @BeforeAll debe seguir algunas estipulaciones. Estos métodos deben tener un tipo de retorno nulo, deben ser públicos y no deben ser privados. La anotación @BeforeAll es ideal para establecer una conexión a una base de datos o creando un nuevo archivo. Este artículo usa una clase de prueba de calculadora para mostrar cómo puede usar la anotación @BeforeAll.
La clase de calculadora
paquete com.aplicación;
públicoclaseCalculadora{
públicoestáticoEn tagregar(En t número1, En t número2){
devolver num1 + num2;
}
públicoestáticoEn tsustraer(En t número1, En t número2){
devolver número1 - número2;
}
públicoestáticoEn tmultiplicar(En t número1, En t número2){
devolver num1 * num2;
}
públicoestáticoEn tdividir(En t número1, En t número2){
devolver num1 / num2;
}
}La clase CalculatorTest
importarestáticoorganización.junit.Júpiter.api.Afirmaciones.*;
importarorganización.junit.Júpiter.api.Antes de todo;
importarorganización.junit.Júpiter.api.Prueba;
importarorganización.junit.Júpiter.api.Nombre para mostrar;@DisplayName("Clase de prueba que demuestra cómo usar la antes deydespués anotaciones.")
claseCalculadoraPrueba{
@Antes de todo
públicoestáticovacíopowerOnCalculator(){
Sistema.fuera.println("la calculadora esta encendida");
}@Prueba
@Nombre para mostrar("Método de prueba que suma dos valores enteros.")
públicovacíopruebaAñadir(){
afirmarIgual(7, Calculadora.agregar(3, 4));
}@Prueba
@Nombre para mostrar("Método de prueba que resta un valor entero de otro.")
públicovacíopruebaRestar(){
afirmarIgual(6, Calculadora.sustraer(9, 3));
}@Prueba
@Nombre para mostrar("Método de prueba que multiplica dos valores enteros")
públicovacíoprobarMultiplicar(){
afirmarIgual(10, Calculadora.multiplicar(5, 2));
}
@Prueba
@Nombre para mostrar("Método de prueba que divide un valor entero por otro")
públicovacíopruebadivide(){
afirmarIgual(2, Calculadora.dividir(4, 2));
}
}
En esta clase, la anotación @BeforeAll funciona con el método powerOnCalculator(), que imprime "La calculadora está encendida" antes de ejecutar cualquier prueba. La ejecución exitosa de la prueba imprime el siguiente informe de prueba:
Como puede ver, el método asociado con la anotación @BeforeAll no aparece en el informe de prueba. Sin embargo, si hay un error en el método de anotación @BeforeAll, los resultados del informe de prueba lo indicarán como un error.
La anotación @BeforeEach
Al igual que el método anotado @BeforeAll, el método anotado @BeforeEach no aparecerá en el informe de prueba. El método anotado @BeforeEach se ejecuta antes de cada método de prueba en una clase de prueba. Entonces, si una clase de prueba contiene dos métodos de prueba, la anotación @BeforeEach se ejecutará dos veces.
importarestáticoorganización.junit.Júpiter.api.Afirmaciones.*;
importarorganización.junit.Júpiter.api.Antes de todo;
importarorganización.junit.Júpiter.api.antes de cada;
importarorganización.junit.Júpiter.api.Prueba;
@DisplayName("Clase de prueba que demuestra cómo usar la antes deydespués anotaciones.")
claseCalculadoraPrueba{
@Antes de todo
públicoestáticovacíopowerOnCalculator(){
Sistema.fuera.println("la calculadora esta encendida");
}
@AntesDeCada
públicovacíoborrarCalculadora(){
Sistema.fuera.println("la calculadora esta lista");
}
@Prueba
@Nombre para mostrar("Método de prueba que suma dos valores enteros.")
públicovacíopruebaAñadir(){
afirmarIgual(7, Calculadora.agregar(3, 4));
}
@Prueba
@Nombre para mostrar("Método de prueba que resta un valor entero de otro.")
públicovacíopruebaRestar(){
afirmarIgual(6, Calculadora.sustraer(9, 3));
}
@Prueba
@Nombre para mostrar("Método de prueba que multiplica dos valores enteros")
públicovacíoprobarMultiplicar(){
afirmarIgual(10, Calculadora.multiplicar(5, 2));
}
@Prueba
@Nombre para mostrar("Método de prueba que divide un valor entero por otro")
públicovacíopruebadivide(){
afirmarIgual(2, Calculadora.dividir(4, 2));
}
}
Agregar la anotación @BeforeEach a la clase CalculatorTest produce el siguiente resultado:
El método asociado con la anotación @BeforeEach se ejecuta cuatro veces, una vez antes de cada método de prueba. Debe tener en cuenta que el método @BeforeEach no es estático, tiene un tipo de retorno nulo y no es privado, ya que estas son estipulaciones obligatorias. También es importante tener en cuenta que el método asociado con la anotación @BeforeEach se ejecuta después del método @BeforeAll.
La anotación @AfterAll
Un método con la anotación @AfterAll se ejecutará después de que todos los métodos de prueba en la clase de prueba completen su ejecución. La anotación @AfterAll es ideal para operaciones basicas de archivos, como cerrar un archivo o desconectarse de una base de datos. La anotación @AfterAll es la contraparte de la anotación @BeforeAll. Al igual que la anotación @BeforeAll, la anotación @AfterAll debe ser estática, debe devolverse nula y no ser privada.
@Después de todo
públicoestáticovacíopowerOffCalculator(){
Sistema.fuera.println("la calculadora esta apagada");
}Agregar el método anotado @AfterAll a la clase CalculatorTest existente imprime el siguiente resultado en la consola:
Tenga en cuenta que el método powerOffCalculator(), que usa la anotación @AfterAll, se imprime al final de la clase de prueba, después de que se ejecutan todos los métodos de prueba.
La anotación @AfterEach
La anotación @AfterEach es la contraparte de la anotación @BeforeEach. Tienen las mismas estipulaciones obligatorias, que son ligeramente diferentes a las de las anotaciones @BeforeAll y @AfterAll. Lo que distingue a la anotación @AfterEach de la anotación @BeforeEach (aparte de sus nombres) es que el método @AfterEach se ejecuta después de cada método de prueba.
@Después de cada
públicovacíovolverResultados(){
Sistema.fuera.println("los resultados estan listos");
}Ejecutar la clase CalculatorTest imprime el siguiente resultado en la consola:
El resultado muestra que el método asociado con la anotación @AfterEach (returnResults) se imprime cuatro veces. Cada ejecución del método returnResults() solo ocurre después de la ejecución de cada prueba unitaria. Esto es evidente por el hecho de que la salida del método returnResults() aparece después de cada salida del método asociado con la anotación @BeforeEach.
Pula sus suites de prueba usando anotaciones
JUnit le permite manejar procesos no relacionados con pruebas utilizando las anotaciones de pares anteriores y posteriores. Estas cuatro anotaciones pertenecen a una lista de otras anotaciones que agregan valor a sus pruebas. Otra de las anotaciones de JUnit es @DisplayName.
Los dos ejemplos de código que muestran la clase CalculatorTest completa usan la anotación @DisplayName. La anotación @DisplayName lo ayuda a crear nombres más significativos para sus clases y métodos de prueba.
