mockito tutorial mockito framework
Una guía completa de Mockito Framework: tutoriales prácticos de Mockito
¿Dónde está la clave de seguridad en un enrutador?
La prueba unitaria es una técnica simple pero efectiva para ganar un buen nivel de confianza en el código que se enviará.
Además, evita problemas de regresión con cada fragmento de código que se registra.
Con el tipo de arquitectura de microservicios (e incluso para estructuras simples que involucran llamadas básicas de bases de datos), las pruebas unitarias sencillas no son suficientes. Lo que necesitamos es burlarnos de las dependencias y probar la lógica real del método bajo prueba.
Lista de TODOS los tutoriales de Mockito en esta serie:
Tutorial #1: Marco de Mockito para simulacros en pruebas unitarias (Este tutorial)
Tutorial #2: Creando simulacros y espías en Mockito
Tutorial #3: Diferentes tipos de comparadores proporcionados por Mockito
Tutorial #4: Burlarse de métodos privados, estáticos y vacíos usando Mockito
Tutorial #5: Las 12 preguntas principales de la entrevista de Mockito
**********************************************************************
Descripción general de los tutoriales de esta serie Mockito
| Tutorial # | Lo que vas a aprender |
|---|---|
| Tutorial #1: | Marco de Mockito para simulacros en pruebas unitarias Aprenda a burlarse con Mockito: un tutorial completo de Mockito para principiantes con ejemplos de código. Aprenda el marco simulado para simular pruebas unitarias. |
| Tutorial #2: | Creando simulacros y espías en Mockito Los simulacros y los espías son tipos de pruebas dobles, que son útiles para escribir pruebas unitarias. Ambos se explican en este tutorial de Mockito Spy con ejemplos de código. |
| Tutorial #3: | Diferentes tipos de comparadores proporcionados por Mockito Aprenda a usar diferentes tipos de comparadores proporcionados por Mockito. Los comparadores son como comodines donde, en lugar de una entrada / salida específica, especificas un rango de entrada. El argumento y la verificación son los dos tipos de coincidencias en Mockito que se explican en detalle aquí. |
| Tutorial #4: | Burlarse de métodos privados, estáticos y vacíos usando Mockito Aprenda métodos falsos privados, estáticos y vacíos en Mockito con ejemplos. Aprenda a simular métodos privados y estáticos mediante el marco de pruebas unitarias PowerMockito. |
| Tutorial #5: | Las 12 preguntas principales de la entrevista de Mockito Entrevista de Mockito Preguntas y respuestas con ejemplos de código de muestra. Esto le ayudará a descifrar con éxito cualquier entrevista de Mockito Mocking Framework. |
¡Comencemos con el primer tutorial de esta serie!
Lo que vas a aprender:
- Burlarse de las pruebas unitarias
- Tipos / categorías de dobles de prueba
- Diferentes marcos de burla
- Código fuente
- Conclusión
- Lectura recomendada
Burlarse de las pruebas unitarias
Mocks / Stubs es un término que la gente suele escuchar al crear pruebas unitarias en particular.
Entonces, ¿qué es esencialmente burlarse? En términos simples, no es más que proporcionar una instancia controlada o implementación de dependencia de la que depende el código bajo prueba para probar su lógica central.
La razón por la que lo mencioné como instancia controlada es que el comportamiento de la dependencia se puede programar o controlar según se desee para el método o sistema bajo prueba.
Para explicarlo en forma de diagrama, tomemos un ejemplo de cualquier aplicación comercial o de comercio electrónico. Casi todos los tipos de aplicaciones tienen principalmente 3 capas, es decir, Interfaz de usuario, capa empresarial y capa de acceso a datos (que habla con el almacén de datos subyacente)
Refiriéndose al diagrama anterior, la capa empresarial tiene 3 dependencias, a saber, la capa de acceso a datos y otros 2 servicios que son el servicio 1 y el servicio 2.
Mírelo de esta manera: una aplicación como Google Maps puede tener dependencias en un
- Almacenes de datos reales como MySQL o cualquier otra base de datos sin SQL que almacene datos de mapas.
- Un servicio externo como CoordinateService que proporciona latitudes y longitudes de una ubicación.
- Un servicio externo como el servicio de tráfico que proporciona información de tráfico en tiempo real para un par de coordenadas determinado.
Por lo tanto, si alguien está tratando de validar la lógica empresarial central mediante la prueba unitaria, hasta que, ya menos que tenga implementaciones funcionales de estas dependencias, las pruebas no se podrían ejecutar.
Los simulacros vienen al rescate en estas situaciones, donde no importa si su dependencia está en funcionamiento o no, siempre tiene la garantía de ejecutar su lógica de negocios con una respuesta programada para la dependencia que se llama desde el código bajo prueba.
Tipos / categorías de dobles de prueba
Mock es esencialmente un tipo de 'prueba doble': es una jerga tecnológica. 'Prueba doble' significa esencialmente un objeto que se reemplaza por una instancia o dependencia de objeto real equivalente.
Hay diferentes tipos de pruebas dobles como se menciona a continuación:
# 1) Falsificaciones:
Una falsificación es una implementación funcional similar a una dependencia real, excepto por el hecho de que es local para el sistema bajo prueba.
Ejemplo: En lugar de llegar a una base de datos de producción real, la prueba usa una colección simple / en memoria para almacenar datos.
# 2) Talones:
Los stubs son respuestas preconfiguradas cuando se llama a una dependencia desde el sistema bajo prueba.
# 3) Espías:
Como sugiere el nombre, en realidad es la llamada de función real (dependencia) con algún mecanismo de observación. Publique la llamada, se puede verificar si la llamada se activó realmente o no junto con los parámetros.
# 4) Mocks:
Los simulacros son instancias especiales de objetos, en los que se pueden especificar respuestas Stubbed / preconfiguradas. El hecho de que se haya llamado al simulacro se puede verificar como una afirmación en la prueba.
Por ejemplo:
Hay una función de generación de informes que envía un correo electrónico a una dirección específica durante la ejecución.
Como no queremos enviar un correo electrónico real, una y otra vez, durante la prueba, se simula el servicio de correo electrónico (y el método de correo electrónico que envía el correo electrónico está configurado para no hacer nada cuando se llama). Al final de la prueba, podemos verificar que el método de envío de correo electrónico del servicio de correo electrónico fue llamado a través del objeto simulado.
Diferentes marcos de burla
Casi todos los lenguajes proporcionan diferentes tipos de marcos de burla. Escribiremos un código de muestra utilizando Mockito, que es un marco de simulación de código abierto para Java.
Anatomía de una prueba unitaria simple con dependencia simulada. Supongamos que estamos intentando realizar una prueba unitaria de una aplicación que calcula la puntuación total de un estudiante en todas las materias y la escribe en DB.
|_+_|Ahora bien, si queremos escribir una prueba unitaria para el método, calculateSumAndStore, es posible que no tengamos una implementación real de una base de datos para almacenar el total. En ese caso, nunca podremos realizar una prueba unitaria de esta función.
Pero con los simulacros en su lugar, simplemente podemos pasar un Mock para el servicio de base de datos y validar el resto de la lógica.
Prueba de muestra como se muestra a continuación:
|_+_|Como vimos en la prueba anterior, hemos proporcionado un objeto mockDatabase a la clase principal (para el método bajo prueba) y hemos configurado una respuesta de código auxiliar para el objeto mockedDatabase - Línea # 6 arriba (Mockito.doNothing (). When (mockDatabase) .updateScores ('estudiante1', 220);)
Los puntos importantes a tener en cuenta de lo anterior son:
#1) El objeto simulado necesita configurar respuestas stubped para todos los métodos que serán llamados durante la ejecución de la función.
#2) Los parámetros especificados durante la creación de stub pueden ser específicos o genéricos.
Ejemplo en el caso anterior, hemos especificado los parámetros para el método updateScores como “student1” y 220 porque sabemos que estas son las entradas exactas con las que se llamará a nuestro método.
# 3) Durante la verificación, estamos validando lo siguiente:
- Se llamó al método mockDatabase.updateScores.
- Los argumentos fueron 'estudiante1' y 220 respectivamente.
- El método updateScores se llamó 1 vez.
Ahora intentemos cambiar un poco este código de prueba y veamos qué sucede:
Cambiaré el argumento en la configuración simulada de 'student1' a anyString (Mockito proporciona un comparador estándar llamado anyString ()) y 220 a anyInteger (Mockito proporciona un comparador estándar llamado anyInt () y coincide con cualquier valor entero)
|_+_|Intente ejecutar la prueba nuevamente y la prueba aún debería ser verde.
(Ahora intentemos cambiar la verificación / afirmaciones y cambiar cualquiera de los argumentos.
Cambiemos 220 a 230. Ahora, la expectativa es que la prueba falle ya que este no es el argumento esperado con el que se debe haber llamado a databaseUpdate.
|_+_|Después de ejecutar la prueba, consulte los registros de errores como se muestra a continuación (menciona claramente que los argumentos reales no coinciden con los esperados).
¡Los argumentos son diferentes! Querido:
mockDatabase.updateScores ('estudiante1', 230);
-> en com.mocking.sampleMocks.StudentScoreUpdatesUnitTests.calculateSumAndStore_withValidInput_shouldCalculateAndUpdateResultInDb (StudentScoreUpdatesUnitTests.java:37)
La invocación real tiene diferentes argumentos:
mockDatabase.updateScores ('estudiante1', 220);
Código fuente
Interfaz - IDatabase.java
|_+_|Clase bajo prueba - StudentScoreUpdates.java
|_+_|Clase de pruebas unitarias - StudentScoreUpdatesUnitTests.java
|_+_|Conclusión
Lo que vimos hasta ahora es un ejemplo muy básico y sencillo de configuración Mock utilizando el marco Mockito de Java.
Para casi el 60-70% de las pruebas unitarias que involucran simulacros, las pruebas deben tener una estructura similar. Mockito proporciona una gran cantidad de configuración / soporte avanzado para necesidades de simulación extensas, inyectando instancias simuladas mediante inyección de dependencia, proporciona a los espías espiar una llamada de método real y verificar las llamadas.
Nuestro próximo tutorial explicará más sobre el concepto de simulacros y espías en Mockito.
Lectura recomendada
- Las 12 preguntas principales de la entrevista de Mockito (entrevista de marco de burla)
- Tutoriales detallados de Eclipse para principiantes
- Cómo configurar el marco de prueba de Node.js: Tutorial de Node.js
- Escribir pruebas unitarias con Spock Framework
- Las diferencias entre pruebas unitarias, pruebas de integración y pruebas funcionales
- Mejores herramientas de prueba de software 2021 (Herramientas de automatización de pruebas de control de calidad)
- Tutorial de pruebas destructivas y no destructivas
- Pruebas funcionales versus pruebas no funcionales