junit test suite filtering test cases
Este tutorial analizará qué es un conjunto de pruebas JUnit, cómo crear un conjunto de pruebas y cómo filtrar casos de prueba en JUnit 4 vs JUnit 5:
Aprendimos cómo omitir ciertos casos de prueba durante la ejecución en nuestro tutorial anterior. También aprendimos sobre las diferentes anotaciones que se utilizan en JUnit 4 y JUnit 5 para hacerlo.
En este tutorial, aprenderemos:
- ¿Qué es una suite de pruebas?
- ¿Cómo creamos un conjunto de pruebas al incluir varios casos de prueba en un grupo y ejecutar el conjunto usando la clase JUnitCore?
=> Visite aquí para ver la serie exclusiva de tutoriales de capacitación de JUnit.
Lo que vas a aprender:
- Conjunto de pruebas JUnit
- Conjunto de pruebas de filtrado: JUnit 4 vs JUnit 5
- Conclusión
Conjunto de pruebas JUnit
JUnit 4: @RunWith, @SuiteClasses Anotaciones
El tutorial Varias formas de ejecutar pruebas JUnit ilustró cómo crear un conjunto de pruebas en JUnit 4.
Las anotaciones @Corre con y @SuiteClasses nos ayudó a crear un conjunto de pruebas agrupando varias clases de prueba JUnit. Posteriormente, un archivo corredor con clase JUnitCore.runclasses () invocaba la ejecución de la suite de pruebas creada.
Consulte la sección mencionada para conocer todos los detalles del flujo de trabajo junto con el código real para JUnit 4.
JUnit 5: @RunWith, @SelectClasses, @SelectPackages Anotaciones
La creación de una suite de pruebas en JUnit 5 es bastante similar a lo que tenemos en JUnit 4. Entonces, ¿dónde está la diferencia entonces?
#1) En JUnit 4 , tenemos Suite.class que se pasa como un parámetro a la anotación @RunWith para admitir la creación de una suite de prueba mientras que JUnit 5 usa la misma anotación @RunWith pero con el parámetro de entrada como JUnitPlatform.class en vez de Suite.class .
Entonces, la línea de código en JUnit 5 parece @RunWith (JUnitPlatform.class). Esta es la anotación que viene empaquetada con su subproyecto JUnit Platform.
#2) En JUnit 4 , usamos @SuiteClasses para agrupar varias clases JUnit separadas por una coma mientras está en JUnit 5 tenemos:
- La anotación @SeleccionarClases que es equivalente a @SuiteClasses en JUnit 4 para agrupar varias clases de JUnit.
- @SeleccionarPaquetes La anotación se utiliza para agrupar varias pruebas de los paquetes. Debe ingresar un valor de matriz de cadenas que represente el paquete que desea incluir.
Así, en otras palabras,
- Si en caso de que quiera agrupar casos de prueba de un solo paquete, JUnit 5 le permite hacerlo.
- O en caso de que desee agrupar casos de prueba de varios paquetes, JUnit 5 también le permite hacerlo. Una nota para recordar aquí es que las pruebas de todos los subpaquetes del paquete mencionado también se incluyen en el conjunto de pruebas de forma predeterminada.
JUnit 5: diferentes escenarios / ejemplos
Creación de una suite de pruebas que agrupa varias clases de pruebas
El fragmento del código se muestra a continuación:
|_+_|Creación de una suite de pruebas para un solo paquete
El fragmento del código se muestra a continuación:
|_+_|Nota :
- Decir demo.tests el paquete tiene un subpaquete demo.tests.subtests.
- El código @SelectPackages ({“demo.tests“}) también incluirá todas las pruebas del subpaquete en la suite de pruebas; por defecto.
- Si hubieras dicho @SelectPackages ({“demo.tests.subtests“}) , los casos de prueba bajo el subpaquete demo.tests.subtests solo se incluirán en el conjunto de pruebas, mientras que las pruebas de su paquete principal, es decir, demo.tests no se incluiría.
Creación de un conjunto de pruebas para varios paquetes
El fragmento de código para crear un conjunto de pruebas para varios paquetes separados con una coma en JUnit 5 - se verá como se muestra a continuación:
|_+_|Conjunto de pruebas de filtrado: JUnit 4 vs JUnit 5
A veces, necesitamos filtrar los casos de prueba y ejecutar un conjunto particular de pruebas según nuestras necesidades. Por ejemplo, podría haber un conjunto de pruebas identificadas para pruebas de regresión, un conjunto separado para pruebas unitarias y un conjunto separado de casos de prueba para pruebas de humo.
Necesitamos excluir o incluir casos de prueba de ciertos paquetes, clases o categorías. Filtrar o etiquetar las pruebas de un solo paquete es la única opción con JUnit4.
En comparación con JUnit 4, JUnit 5 viene con un buen conjunto de características para respaldar esta necesidad de filtrar sus casos de prueba desde el paquete único o múltiples paquetes y subpaquetes según sus requisitos cambiantes.
JUnit 4 - @Category, @IncludeCategory, @ExcludeCategory
Los casos de prueba en JUnit 4 se pueden clasificar en diferentes categorías. Estas categorías se pueden excluir o incluir mientras se ejecuta su conjunto de pruebas. Las anotaciones @Category, @IncludeCategory y @ExcludeCategory son compatibles con JUnit 4.12 y posteriores.
Los pasos de alto nivel para crear los filtros basados en la categoría o categorías son los siguientes:
#1) Cree una interfaz de marcador que desempeñe un papel en la categoría.
#2) Anote los métodos de prueba de las clases que se incluirán en las SuiteClasses con @Categoría y el nombre de la categoría.
#3) En el archivo de la suite de prueba, use la anotación @IncludeCategoría con el nombre de la categoría para incluir las pruebas que pertenecen a una categoría específica.
#4) En el archivo de la suite de prueba, use la anotación @ExcludeCategoría con el nombre de la categoría para excluirlos.
#5) La anotación @Category también se puede usar a nivel de prueba o de clase. Si la anotación se aplica en el nivel de la prueba, entonces esa prueba específica se etiqueta con la categoría dada, mientras que si la anotación está en el nivel de la clase, todas las pruebas dentro de la clase se etiquetan en la categoría dada.
Veamos algunos detalles más para comprender la implementación práctica de categorizar las pruebas y filtrarlas para su ejecución:
Paso 1:
Empezaremos por la creación de un interfaz de marcador que jugará el papel de un categoría para métodos de prueba. Aquí, creamos una categoría llamada Prueba de unidad . El código es muy simple. Consulte el código a continuación.
Código para UnitTest.java
|_+_|Paso 2:
Marcaremos la categoría en el nivel del método de prueba en la clase JUnitTestCase1.java . Para agregar el caso de prueba junitMethod1 () en la categoría UnitTest, necesitamos anotar el método de prueba con @Category (UnitTest.class) .
Esto agrega el método de prueba a la categoría UnitTest. Los otros métodos de prueba (si los hay) no se etiquetan en la categoría a menos que los métodos estén anotados con una categoría.
Para que la anotación @Category funcione en nuestro código, necesitamos importar el paquete org.junit.experimental.categories.Category
El fragmento de código de JUnitTestCase1.java:
|_+_|Alternativamente, un método de prueba también puede pertenecer a varias categorías P.ej. : @Category (UnitTest.class, SmokeTest.class)
Paso 3:
Ahora, marcaría la categoría a nivel de clase en la clase JUnitTestCase2.java . La misma declaración que se agregó al nivel del método de prueba en el paso anterior también se agregará en el archivo de clase actual.
Tenga en cuenta que aquí agregaremos la declaración a nivel de clase. Hacer esto hará que todos los métodos de prueba en el archivo pertenezcan al Prueba de unidad Categoría.
El fragmento de código de JUnitTestCase2.java:
|_+_|Paso 4:
es una clave de seguridad de red lo mismo que una contraseña
Ahora que nuestros casos de prueba requeridos se han categorizado en la categoría UnitTest, ahora veremos cómo agregarlos al conjunto de pruebas al filtrarlos según la categoría. Realizaremos ciertos cambios de código en el JUnitTestSuite.class para demostrar esto.
- Categorías.clase se pasará como parámetro a la anotación @RunWith.
- @ Suite.SuiteClasses tomará la matriz de cadenas de clases de prueba.
- La anotación @ Categorías.IncluirCategoría necesitará UnitTest.class como parámetro.
- Esta declaración nos ayudará a filtrar toda la suite y ejecutar solo los casos de prueba de la suite que pertenece a la categoría.
- Paquete de necesidades de categorías. org.junit.experimental.categories.Categories para ser importado.
El fragmento de código de JunitTestSuite.java
|_+_|La anotación @ Categorías.IncluirCategoría también se puede escribir como @IncludeCategory. También puede crear múltiples interfaces (categorías) y anotar la clase / métodos de prueba con múltiples categorías separadas por una coma. El siguiente ejemplo filtrará las pruebas que pertenecen a la categoría - Categoría1 y Categoría2.
Ejemplo: @IncludeCategory ({Category1.class, Category2.class})
Reglas similares van con @ Categories.ExcludeCategory / @ExcludeCategoría para excluir los métodos de prueba en la categoría o categorías durante la ejecución de la prueba.
JUnit 5 - @IncludeTags, @ExcludeTags, @IncludePackages, @ExcludePackages, @IncludeClassNamePatterns, @ExcludeClassNamePatterns
JUnit 5 viene empaquetado con múltiples enfoques para organizar y filtrar los casos de prueba.
JUnit 5 - @IncludeTags, @ExcludeTags
#1) Como JUnit 4 tiene anotaciones @IncludeCategory y @ExcludeCategory para admitir el filtrado de casos de prueba para su ejecución.
#2) JUnit 5 tiene anotaciones @IncludeTags y @ExcludeTags para lograr el mismo propósito.
#3) JUnit 4 se refiere a los casos de prueba que se organizarán en una categoría específica, mientras que JUnit 5 se refiere a etiquetar los casos de prueba con una etiqueta específica para permitir filtrar los casos de prueba para su ejecución.
Los pasos de alto nivel para crear los filtros basados en las etiquetas son los siguientes:
- Anote los métodos de prueba de los paquetes que se incluirán en @SelectPackages con @Etiqueta y el nombre de etiqueta definido por el usuario. Una clase puede tener diferentes etiquetas para diferentes métodos de prueba.
- También puede anotar @Tag a nivel de clase para que todas las pruebas de la clase estén etiquetadas.
- En el archivo de la suite de prueba, use la anotación @IncluirEtiquetas con el nombre de la etiqueta para incluir las pruebas que pertenecen a una etiqueta específica.
- En el archivo de la suite de prueba, use la anotación @ExcluirEtiquetas con el nombre de la etiqueta para excluirlos del conjunto de pruebas.
Veamos ahora una ilustración detallada sobre cómo implementar prácticamente el filtrado en JUnit 5.
Paso 1 : Estamos etiquetando un método de prueba en JUnit5TestCase1.java con el nombre de etiqueta 'Regresión'.
El fragmento de código de JUnit5TestCase1.java:
|_+_|Paso 2 : Estamos etiquetando un método de prueba en JUnit5TestCase2.java con el nombre de etiqueta 'SmokeTest'.
El fragmento de código de JUnit5TestCase2.java:
|_+_|Paso 3: Ahora que los métodos de prueba han sido etiquetados, actualizaremos JUnit5TestSuite.java para agregar filtros apropiados por etiquetas para las pruebas. El siguiente código incluye todas las pruebas que están etiquetadas como 'Regresión' y excluye todas las etiquetadas como 'SmokeTest'.
El fragmento de código de JUnit5TestSuite.java:
|_+_|JUnit 5 - @IncludePackages, @ExcludePackages
Ya sabemos que cuando pasamos un nombre de paquete en el @SeleccionarPaquetes anotación, las pruebas en los subpaquetes del paquete también se agregan al conjunto de pruebas.
Podría haber ciertos subpaquetes que queramos incluir en nuestro conjunto de pruebas, mientras que algunos otros subpaquetes que no queremos o que podrían no ser relevantes para ser incluidos en nuestro conjunto.
Esto se facilita a través de las anotaciones. @IncludePackages y @ExcludePackages en JUnit 5.
Supongamos que tenemos un paquete 'demo.tests' que tiene tres subpaquetes, es decir, subpaquete1, subpaquete2 y subpaquete 3 con sus clases de prueba en cada uno de los siguientes paquetes.
Veamos un fragmento de código de JUnit5TestSuite.java para visualizar cómo incluir y excluir un paquete.
Escenario 1: Aplicar filtro para incluir casos de prueba del subpaquete1 solamente.
El siguiente código incluye todas las pruebas de todas las clases JUnit en el paquete demo.tests.subpackage1, sin embargo, excluye todas las pruebas directamente debajo del paquete demo.test y las del paquete subpackage2 y subpackage3.
El fragmento de código de JUnit5TestSuite.java:
|_+_|Escenario n. ° 2: Aplicar filtro para excluir casos de prueba solo del subpaquete del paquete 3.
El siguiente código excluye todas las pruebas de las clases JUnit en el paquete - demo.tests.subpackage3, sin embargo, la suite incluye todas las pruebas directamente en el paquete demo.test y las del paquete subpackage1 y subpackage2.
El fragmento de código de JUnit5TestSuite.java:
|_+_|JUnit 5 - @IncludeClassNamePatterns, @ExcludeClassNamePatterns
Cuando desee incluir o excluir ciertas clases que coincidan con una expresión regular específica del paquete, las anotaciones @ IncludeClassNamePatterns y @ ExcludeClassnamePatterns se puede utilizar en el archivo de clase del conjunto de pruebas.
Veamos ahora la ilustración a través de la actualización del código en JUnit5TestSuite.java
Escenario 1:
El siguiente código incluye clases que terminan con 'Ctests' del paquete demo.tests
|_+_|Escenario n. ° 2:
Ahora excluiremos aquellas clases que iniciado con 'STest' del paquete demo.tests
|_+_|Escenario n. ° 3:
También se pueden pasar varias expresiones regulares como criterios de filtro. El siguiente código establece dos expresiones regulares diferentes separadas por ' O ”Operador. La barra de hendidura | es el operador OR aquí.
programas de entrevistas en java y respuestas para experimentados
El código filtra las clases iniciando con Prueba ( Prueba.*) o finalizando con Pruebas (*. ¿Pruebas?) e incluye esas clases en el conjunto de pruebas como se utiliza la anotación @IncludeClassNamePatterns.
Nota: Si el nombre de la clase totalmente calificado coincide con al menos un patrón, entonces la clase se obtendrá según la anotación @IncludeClassNamePatterns o @ExcludeClassNamePatterns.
@RunWith (JUnitPlatform.class)
@SelectPackages ({“demo.tests“})
@IncludeClassNamePatterns (. * ¿Pruebas?) $ ”)
Preguntas frecuentes sobre casos de prueba de filtrado de JUnit
Aquí hay una pregunta que podría haber estado persistiendo en su mente durante bastante tiempo.
P # 1) ¿Cuál es la diferencia entre deshabilitar / ignorar una prueba y filtrar una prueba? ¿Ninguna de las funciones puede ayudar a cumplir el mismo propósito de omitir casos de prueba durante la ejecución?
Respuesta: La pregunta es realmente genuina y vale la pena responderla.
- Con la función de prueba de filtrado, puede excluir así como incluir pruebas dependiendo de la categoría etiquetada. Considerando que, con la desactivación, puede decidir solo excluir y no incluir pruebas para su ejecución.
- Filtrar los casos de prueba es una especie de caso de prueba que se salta condicionalmente, mientras que, en el caso de las pruebas ignoradas, se omiten sin condiciones.
- Otra diferencia significativa entre los dos es que cuando ejecuta los casos de prueba con pruebas anotadas con @Ignore o @Disabled, las pruebas ignoradas se muestran en los resultados de la prueba debajo de la SALTADO contar
- Cuando ejecuta las pruebas filtradas, no aparecen en absoluto en el resultado de la prueba.
Conclusión
En este tutorial, aprendimos cómo filtrar las pruebas agregando una categoría / etiqueta a las pruebas.
Aprendimos en JUnit 4, que tenemos @Category, @IncludeCategory y @ExcludeCategory para filtrar los casos de prueba, mientras que JUnit 5 tiene @IncludeTags y @ExcludeTags para hacer lo mismo.
Además, JUnit 5 tiene opciones de filtrado adicionales usando anotaciones @IncludePackages, @ExcludePackages, y también anotaciones para incluir o excluir clases usando patrones de nombre de clase. Cuanto más estamos explorando; nos damos cuenta de que aún queda mucho por explorar.
=> Mire aquí la serie de entrenamiento simple JUnit.
Lectura recomendada
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Pruebas JUnit: Cómo escribir casos de prueba JUnit con ejemplos
- Lista de anotaciones de JUnit: JUnit 4 Vs JUnit 5
- Tutorial de JUnit para principiantes: ¿Qué son las pruebas de JUnit?
- ¿Qué es un dispositivo de prueba JUnit? Tutorial con ejemplos de JUnit 4
- Múltiples formas de ejecutar pruebas JUnit
- Descargar, instalar y configurar JUnit en Eclipse
- Introducción a JUnit Framework y su uso en Selenium Script - Tutorial de Selenium n. ° 11