Menú

Múltiples formas de ejecutar pruebas JUnit

multiple ways execute junit tests

Pruebe Nuestro Instrumento Para Eliminar Los Problemas

Este tutorial muestra varias formas de ejecutar pruebas JUnit, como Ejecutar como prueba JUnit, Usar teclas de acceso directo o Ejecutar prueba JUnit desde la línea de comandos, etc.

Vimos cómo escribir los casos de prueba básicos de JUnit y tener un enfoque de accesorio de prueba como una de las buenas prácticas de programación para JUnit en nuestro tutorial anterior.

En este tutorial, echemos un vistazo a las diferentes formas que podemos utilizar para ejecutar pruebas para JUnit. Se sorprenderá al ver la cantidad de opciones disponibles para ejecutar estos casos de prueba.

=> Mire aquí la serie de entrenamiento simple JUnit.

Múltiples formas de ejecutar pruebas JUnit

Lo que vas a aprender:

Diferentes formas de ejecutar pruebas JUnit

Para ejecutar las pruebas JUnit, existen ciertas formas en las que puede ejecutar un archivo de clase única con uno o varios métodos de prueba a través de las siguientes opciones:

  1. Opción 'Ejecutar como prueba JUnit'.
  2. Ejecute la última prueba JUnit ejecutada a través de la opción de menú.
  3. Ejecutar usando las teclas de método abreviado.
  4. Ejecute solo un método de prueba en una clase.
  5. Ejecuta la línea de comando.
  6. Ejecutar usando el archivo de clase Testrunner.
  7. Ejecute el uso de Maven también.

Nota: La ejecución de la prueba JUnit a través de Maven se contemplará en un tutorial separado para JUnit Maven.

Reiterando el punto, en este tutorial, aprenderemos cómo se pueden agrupar varias pruebas en una suite de pruebas y cómo se puede ejecutar la suite de diferentes maneras. Además, detallará cierta información adicional relevante y relacionada.

# 1) Ejecutar como prueba JUnit

La forma más sencilla de ejecutar las pruebas JUnit es:

Método 1:

  1. Haga clic derecho en el archivo de clase en la vista Script
  2. Seleccione Ejecutar como -> Prueba JUnit
  3. Se ejecuta el archivo de clase.

Método 2:

  1. Del mismo modo, puede seleccionar el archivo de clase de la vista Explorador de paquetes
  2. Haga clic derecho en el archivo
  3. Seleccione Ejecutar como -> Prueba JUnit
  4. Se ejecuta el archivo de clase.

Nota: De esta manera, podría ejecutar un archivo de clase a la vez.

Ejecutar como prueba JUnit

# 2) Ejecute la última prueba de JUnit ejecutada a través de la opción de menú

Puede ejecutar un archivo de clase JUnit manteniendo un archivo de clase abierto en el editor. Vaya al menú superior del Eclipse => Seleccione Ejecutar => Ejecutar . La opción Ejecutar -> Ejecutar básicamente significa volver a ejecutar la última prueba que ejecutó.

Consideremos una clase JUnit con múltiples métodos / pruebas para tener una mejor claridad sobre cómo Ejecutar-> Ejecutar trabajos:

  • escenario 1 : Si hubiera ejecutado un método único con @Test, luego, al hacer clic en Ejecutar-> Ejecutar , el método único que se ejecutó por última vez solo se ejecutaría esta vez y no toda la clase JUnit.
  • Escenario 2 :Considerando que habías ejecutado el toda la clase previamente, Ejecutar-> Ejecutar volvería a ejecutar todo el archivo de clase.

Ahora que sabemos Ejecutar-> Ejecutar ejecuta la última prueba que ejecutó, esto nos lleva a un pregunta si puede cambiar la preferencia de la opción Ejecutar-> Ejecutar?

La respuesta a la pregunta es Sí, la preferencia de la opción Ejecutar-> Ejecutar se puede cambiar. Hay una cierta configuración adjunta a Ejecutar-> Ejecutar.

Así es como puede hacerlo:

a) La configuración de ejecución de Eclipse básicamente predeterminada es ejecutar el recurso seleccionado o el editor activo si está disponible .

Entonces, ¿cuál es la configuración predeterminada? 'Ejecutar el recurso seleccionado o el editor activo si es ejecutable'

La respuesta a esto es que no ejecutará la última aplicación que inició, sino que seguirá la repetición de la última aplicación lanzada por el editor activo .

b) Entonces, ¿cómo se cambia la preferencia predeterminada?

La respuesta a esto es que puede cambiar la preferencia predeterminada en Eclipse para ejecutar la última aplicación que lanzó independientemente del editor activo tú tienes.

A continuación se muestra cómo cambia la preferencia de la opción Ejecutar usando Ejecutar -> Ejecutar:

  • Navegar a Windows => Preferencias => Ejecutar / Depurar => Lanzamiento
  • 'Launch Operation' tiene un botón de opción predeterminado: ‘ Inicie la aplicación lanzada anteriormente ' seleccionado en la segunda opción ' Inicie el recurso seleccionado o el editor activo. Si no se puede iniciar :’.
  • Es posible que deba cambiar esta preferencia al primer botón de opción, es decir, ‘ Inicie siempre la aplicación iniciada anteriormente '.

2. Ejecute la última prueba JUnit ejecutada a través de la opción de menú

# 3) Ejecutar usando teclas de acceso directo

Puede seleccionar el archivo de clase desde la vista Script o la vista Explorador de paquetes, y usar las siguientes teclas de acceso directo para ejecutar las pruebas JUnit:

  1. Presione las teclas ALT + MAYÚS + X, T para ejecutar el archivo de clase JUnit.
  2. Una alternativa a esto sería la prensa. ALT + R y luego CTRL + F11 para ejecutar un archivo de clase JUnit. ALT + R y luego CTRL + F11 es el atajo para la opción del menú Ejecutar -> Ejecutar

# 4) Ejecute solo un método de prueba en una clase

A veces, es posible que desee ejecutar un solo método de prueba JUnit.

En caso de que haya más de un método dentro del archivo de clase JUnit:

  1. Puede seleccionar o colocar el cursor sobre el nombre del método dentro de la vista de secuencia de comandos.
  2. Utilice las teclas de método abreviado mencionadas anteriormente o las opciones proporcionadas anteriormente para ejecutar solo el método que acaba de seleccionar.

Nota: ALT + MAYÚS + X, T puede ejecutar los métodos seleccionados como se esperaba. Sin embargo, si desea ejecutar un método específico en una clase JUnit, debe ser un caso de prueba anotado con @Test; de lo contrario, muestra un error de inicialización.

En otras palabras, si selecciona métodos en @Before o @After (cualquier anotación que no sea @Test), la ejecución del método específico produciría un error.

# 5) Ejecute pruebas JUnit desde la línea de comandos

Al igual que ejecuta cualquier archivo de clase Java a través de la línea de comando, también puede compilar y ejecutar archivos de clase JUnit a través de la línea de comando.

Cubriremos los subtemas a continuación aquí para comprender cómo podemos ejecutar pruebas JUnit a través de la línea de comando:

  1. ¿Cómo compilar una prueba JUnit en la línea de comandos?
  2. ¿Cómo ejecutar una prueba JUnit en la línea de comandos?
  3. Información adicional sobre la ejecución de la línea de comandos.
    • ¿Cómo corregir un error de comando no reconocido para el comando javac?
    • Ventajas de ejecutar pruebas usando la línea de comandos.

# 5.1) ¿Cómo compilar una prueba JUnit en la línea de comandos?

La condición previa para compilar y ejecutar un archivo de clase JUnit a través del símbolo del sistema es:

  1. Primero agregue los archivos jar de JUnit relevantes en la ruta de clase.
  2. Establezca las variables de entorno como se mencionó en el Configuración de JUnit tutorial.
  3. Luego compile un archivo de clase JUnit.
  4. La sintaxis para compilar un archivo de clase JUnit a través de la línea de comando es:
|_+_|

Aquí, javac es el compilador de Java que usa la opción -cp.

El comando javac -cp busca los siguientes parámetros:

  1. El archivo jar de JUnit va seguido de un punto y coma.
  2. La ruta del directorio en el que se encuentra el archivo de origen.
  3. El nombre del archivo de clase

En la sintaxis dada anteriormente, ¿qué implica el punto (.)?

Hemos mencionado un punto en el lugar de la ruta completa del directorio.

El punto implica que:

  1. La ruta de clase ya incluye el directorio actual para los archivos fuente de Java.
  2. La JVM (Java Virtual Machine) asume automáticamente que el directorio actual es donde se colocan los archivos de origen.
  3. Luego, JVM busca el nombre de archivo JUnit mencionado allí. El nombre del archivo es el último parámetro dado en el comando de compilación.

Puede verificar los parámetros que entran en -cp mediante los siguientes pasos:

  1. Abra el símbolo del sistema.
  2. Escriba javac y presione ENTER.
  3. Se muestran todas las opciones relevantes, incluido -cp. Encontrará que -cp va con un parámetro donde la ruta es la ruta de los archivos de clase que busca JVM.

Captura de pantalla a continuación:

compila una prueba JUnit en la línea de comandos

¿Cómo compilar varios archivos a la vez?

Se pueden compilar varios archivos de prueba JUnit a la vez separando los nombres de los archivos con espacios.

A continuación se muestra un ejemplo de dónde compila archivos java JUnitProgram y demoTest:

|_+_|

# 5.2) ¿Cómo ejecutar una prueba JUnit desde la línea de comandos?

Al igual que javac es el compilador de Java utilizado, de manera similar java -cp se utiliza para ejecutar los archivos de clases de Java, incluidas las clases de JUnit.

A continuación se muestra la sintaxis que podría seguir:

|_+_|

Este comando ejecuta los archivos JUnitProgram.java y demoTest.java uno tras otro.

# 5.3) Información adicional sobre 'ejecución de línea de comandos'.

preguntas y respuestas de entrevistas html para experimentados

Aquí hay información adicional sobre cómo corregir un error con el comando javac y por qué usar la opción de ejecución de la línea de comandos

# 5.3.1) ¿Cómo soluciono el error de comando no reconocido para el comando javac?

La mayoría de nosotros encontraríamos este problema al intentar ejecutar el javac comando a través de la línea de comando. Esto ha sucedido a mí también; así que pensamos en escribirlo aquí.

a) Ingresamos el comando javac y presionado Ingresar en el símbolo del sistema.

b) El mensaje de error - javac no se reconoce como un comando interno o externo, programa operable o archivo por lotes apareció de la siguiente manera:

Mensaje de error

Aquí es donde comienza la compilación de los archivos de clases de Java desde la línea de comandos. Por lo tanto, el error es motivo de preocupación y no se puede ignorar.

Para solucionar el problema, siga los pasos a continuación y ¡¡¡Listo!!! ves que el error se ha ido:

  • Hagamos una demostración de este proceso utilizando un archivo Java básico. El primer paso que puede hacer es crear una clase básica de Java P.ej. : 'Calculadora.java'
  • Localizaremos Calculate.java desde el Explorador de Windows y copiaremos la ruta.

Calculate.java desde el Explorador de Windows

  • Cambie el directorio en el símbolo del sistema a la ruta que copió (la ruta del archivo de origen). Utilice cd para cambiar el directorio.

3. Cambie el directorio en el símbolo del sistema a la ruta que copió.

  • Ahora establezca la RUTA en la carpeta jdk bin usando el comando.

SET PATH = y presione ENTER.

  • Aquí, la ruta jdk es C: Archivos de programa Java jdk1.8.0_181 bin. Por lo tanto, hemos establecido el camino en consecuencia. El resultado no muestra nada al presionar ENTER después del comando.

El resultado no muestra nada al presionar ENTER

  • Ahora, verifique si la JVM reconoce el comando javac ingresando el comando javac y presionando ENTER.
    1. Si reconoce el comando, se muestra un conjunto de opciones válidas para javac como resultado.
    2. De lo contrario, el error volverá a aparecer.

A continuación se muestra una captura de pantalla que muestra que nos deshicimos del error con éxito.

comando javac

No intentemos eludir una pregunta esencial aquí:

¿Por qué la JVM reconoció el comando javac después de establecer la ruta a la carpeta bin jdk?

Estamos seguros de que también tendrá esta pregunta en mente. A continuación se da la respuesta.

  • La carpeta jdk bin tiene todas las bibliotecas para el comando javac. Por lo tanto, esta es la razón por la que, cuando establece la ruta en consecuencia, la JVM ahora puede reconocer el comando javac sin ningún problema.
  • Ver el carpeta javac debajo del contenedor jdk en la imagen de abajo.

carpeta javac debajo del contenedor jdk

  • A continuación, puede ejecutar el comando 'compilar y ejecutar Java' mediante la línea de comandos. Además, recuerde también configurar la variable CLASSPATH de manera apropiada. Variable JAVA_HOME y JUNIT_HOME para archivos Java y archivos JUnit, respectivamente.

# 5.3.2) Ventaja de ejecutar pruebas usando la línea de comandos:

Analicemos rápidamente la ventaja sobre la ejecución de casos de prueba de Java / JUnit a través de la línea de comandos.

Como ya sabe, no existe una regla estricta y rápida sobre la ejecución de los archivos de clase a través de la línea de comandos. Es solo una forma alternativa, sobre cómo puede administrar la compilación y ejecución de los archivos de clase.

Si pregunta si hay una ventaja especial en tener conocimientos sobre la ejecución de las pruebas JUnit a través de la línea de comandos, entonces, diríamos 'Ciertamente, sí'.

El motivo de un 'Sí' se da a continuación:

  1. Toda esta serie de pasos que seguimos anteriormente; podría agregarse al bloc de notas y convertirse en un archivo por lotes.
  2. Ahora, cuando ejecuta este archivo por lotes con un doble clic, podría desencadenar la compilación y ejecución de varios archivos de prueba JUnit nombrados en el archivo por lotes.

¿Cuál es el beneficio de tener un archivo por lotes para compilar y ejecutar los archivos Java?

  1. Un archivo por lotes / jar podría actuar como una utilidad fácil de usar que podría permitir a cualquiera que no conozca la lógica interna del código y ejecutar múltiples casos de prueba con mucha facilidad.
  2. Esto puede eliminar la necesidad de tener un desarrollador especializado o QA para realizar estos trabajos de ejecución de prueba. La tarea de ejecución se puede delegar a cualquier recurso sin preocuparse por las limitaciones de habilidades.

En la siguiente opción alternativa, veremos otra forma ventajosa y encomiable de ejecutar nuestros casos de prueba JUnit.

# 6) Ejecute Test Suite usando Testrunner Class

En escenarios en tiempo real, ejecutar un caso de prueba a la vez es la opción menos preferida.

  • Tenemos casos en los que necesitamos ejecutar un grupo de casos de prueba relacionados / no relacionados.
  • Por ejemplo, es posible que necesitemos crear y ejecutar conjuntos de pruebas de regresión o conjuntos de pruebas de humo.

Ahora aprenderemos sobre la implementación de diferentes anotaciones utilizadas para crear suites de prueba y ejecutar la suite.

El proceso general de ejecución del conjunto de pruebas con Test Runner se realiza según el siguiente flujo de trabajo:

  1. Cree JUnit clase 1, JUnit clase 2,…. JUnit clase n.
  2. Cree un archivo de clase de conjunto de pruebas agrupando los casos de prueba.
  3. Cree un archivo de clase Testrunner para invocar el conjunto de pruebas creado.
  4. Ejecute la clase Testrunner.

La estructura de los programas a través de los cuales demostraremos la creación de la suite de pruebas y la ejecución del archivo de ejecución se muestra en la siguiente imagen:

Banco de pruebas

Aquí, cubriremos los subtemas:

  1. Creación de clases JUnit
  2. Creación de conjuntos de pruebas
  3. Crear un archivo Testrunner y ejecutar las suites de prueba usándolo.
  4. Información adicional sobre el funcionamiento de la anotación @RunWith.

#6.1) Creación de clases JUnit

Comencemos creando dos archivos de clase JUnit simples:

  1. JUnitTestCase1.java - Incluye el código para verificar un valor numérico esperado - la variable Valor1 coincide con un valor real de la variable Valor 2.
  2. JUnitTestCase2.java - Incluye el código para verificar si la variable de cadena esperada strValue y variable de cadena real estrActual partidos.

Estos son básicamente dos casos de prueba que intentaremos incluir en una agrupación lógica llamada suite de pruebas y hacer que se ejecute uno tras otro.

Código para JUnitTestCase1.java

|_+_|

Código para JUnitTestCase2.java

|_+_|

#6.2) Creando Test Suite:

Esta sección y la siguiente juegan un papel destacado en todo el proceso de creación y ejecución de un conjunto de pruebas. En esta sección, intentaremos comprender cómo agrupar varias clases de prueba JUnit y vincularlas en un conjunto de pruebas .

Según la imagen estructural anterior, creemos un conjunto de pruebas que agrupe JUnitTestCase1.java y JUnitTestCase2.java y nombre el conjunto como JUnitTestSuite.java

Las dos anotaciones que nos ayudan a lograr la creación de un conjunto de pruebas son:

  1. @RunWith y
  2. @SuiteClasses

Paquetes necesarios para las anotaciones:

  1. Deberá importar el paquete org.junit.runner.RunWith; para la inclusión de la anotación @RunWith.
  2. Necesitará el paquete org.junit.runners.Suite.SuiteClasses para que @SuiteClasses funcione.
  3. Además, también necesitará importar el paquete org.junit.runners.Suite para pasar un parámetro Suite.class a la anotación @RunWith.

¡Revisemos el código para comprenderlo mejor!

Código para JUnitTestSuite.java

|_+_|

Comprensión del código de JUnitTestSuite.java:

  1. @RunWith ayuda a la JVM a comprender qué tipo de clase de corredor debería ejecutar P.ej. Suite.class o Pepino.class
  2. Aquí, el parámetro de @RunWith es Suite.class . Ayuda a JVM a reconocer que el archivo actual donde se usa @RunWith (Suite.class) juega un papel en el conjunto de pruebas.
  3. Los nombres de las clases de prueba JUnit que se unirán en una suite deben pasarse como una matriz de cadenas en forma de parámetros para @SuiteClasses, cada uno separado por una coma.
  4. Esto permite a JVM saber cuáles son todos los casos de prueba que deben agruparse en la suite.
  5. El nombre de la suite será el nombre del archivo de la clase JUnit anotado con @RunWith y @SuiteClasses, que en este caso es JUnitTestSuite.

#6.3) Cree el archivo Test Runner y ejecute JUnit Test suite usando Test Runner

El último paso nos ayudará a ejecutar el conjunto de pruebas que acabamos de crear en la sección anterior utilizando un archivo Testrunner.

  1. Ahora crearemos un archivo Java llamado SuiteRunnerFile.
  2. Este SuiteRunnerFile.java no es una clase JUnit sino un archivo Java habitual con el método principal en él.

Veamos el código y luego intentemos entenderlo.

Código para SuiteRunnerFile.java

|_+_|

Paquetes necesarios para la anotación

  1. Necesita importar el paquete org.junit.runner.JunitCore para incluir el JUnitCore clase en el código.
  2. Debe importar el paquete org.junit.runner.notification.Failure y org.junit.runner. Resultado para incluir la clase Fallo y Resultado en el código, respectivamente.

Comprensión del código de SuiteRunnerFile.java

  1. Para crear un archivo de corredor para la ejecución de la suite de pruebas, el JUnitCore la clase juega un papel importante.
  2. los runClasses () método de JUnitCore class toma el nombre de clase de la suite de pruebas como parámetro de entrada, por lo tanto, tenemos la declaración JUnitCore. runClasses (JUnitTestSuite. clase ).
  3. El tipo de retorno de esta declaración es el Resultado objeto de clase que almacena el estado de éxito resultante y el estado de error de cada archivo de caso de prueba; post-ejecución. Por eso tenemos un resultado como el Resultado objeto de clase en el código.
  4. Luego imprimimos los fallos de los casos de prueba, si los hay. Al igual que el método getFailures (), también puede obtener el recuento de fallos y el recuento de ejecuciones utilizando el método getFailureCount () y getRunCount (), respectivamente.
  5. Ahora SuiteRunnerFile está listo para ejecutarse,
    1. Seleccione el archivo del Explorador de paquetes y
    2. Haga clic derecho y seleccione Ejecutar como -> Java, el programa se ejecuta.

A continuación se muestra la captura de pantalla de la ventana de la consola.

Ventana de consola

Explicación de los resultados en la consola:

La consola de arriba muestra que:

  1. El archivo de clase JUnitTestSuite se ha ejecutado a través de SuiteRunnerFile.
  2. El método printMe () bajo la anotación @BeforeClass se ejecutó primero y
  3. Luego, los casos de prueba en el conjunto de pruebas se ejecutaron uno tras otro. Así es como se puede crear y ejecutar el conjunto de pruebas como un paquete.

#6.4) Información adicional - ¿Cómo funciona @RunWith?

  • @RunWith es una API JUnit que básicamente toma solo un elemento como parámetro de entrada que es un nombre de archivo de clase de corredor.
  • El marco JUnit invoca la clase especificada como un corredor de pruebas.

El siguiente fragmento de RunWith.java lo ayudará a comprender:

|_+_|

Comprender el código de interfaz RunWith anterior:

  1. El especificado valor elemento debe ser una clase derivada del Corredor clase . Aquí se utiliza el concepto de reflexión.
  2. Un muy buen ejemplo de una clase de corredor de este tipo ya está implementado en nuestro código, es decir, @RunWith (Suite.class) donde un grupo de casos de prueba se une para crear un conjunto de pruebas.
  3. De manera similar, otro buen ejemplo del uso de una clase Runner con @RunWith podría ser @RunWith (Cucumber.class), que es un marco de desarrollo impulsado por negocios (BDD) para la automatización de pruebas usando Selenium en Java. Esto ayuda al marco a ejecutar los casos de prueba basados ​​en Cucumber.

Nota:

  • Las anotaciones y los parámetros utilizados para crear y ejecutar el conjunto de pruebas JUnit en este tutorial eran específicos de JUnit 4.
  • Hay una forma ligeramente diferente de crear un JUnit Test Suite y ejecutar el archivo de ejecución en JUnit 5.

Pronto tendremos una comprensión enfocada de todos los aspectos de JUnit 4 vs JUnit 5 en nuestros próximos tutoriales.

# 7) Ejecute casos de prueba JUnit usando Maven

También puede tener un proyecto de Maven que consta de pruebas JUnit y ejecutar las pruebas a través de Maven, que se tratará en un tutorial separado.

Conclusión

  1. Aprendimos todas las diferentes opciones para ejecutar las pruebas JUnit: pruebas únicas y múltiples agrupadas en conjuntos de pruebas.
  2. Obtuvimos conocimientos adicionales sobre cómo actualizar la preferencia de la opción Ejecutar, cómo corregir el error de javac y cómo podría ayudarnos la ejecución de la línea de comandos.
  3. Además, también aprendimos cómo funciona la anotación @RunWith.

Por lo tanto, hay más para seguir en los próximos tutoriales. 'Stand By' hasta entonces !!!

=> Visite aquí para aprender JUnit desde cero.

Lectura recomendada

^