different types matchers provided mockito
Ups conceptos en c # con ejemplos
Una introducción a los diferentes tipos de comparadores en Mockito.
Simulacros y espías en Mockito se explicaron en detalle en nuestro tutorial anterior de información detallada Serie de entrenamiento Mockito .
¿Qué son los Matchers?
Los comparadores son como expresiones regulares o comodines en los que, en lugar de una entrada (yo salida) específica, usted especifica un rango / tipo de entrada / salida en función de qué stubs / spies pueden estar en reposo y se pueden verificar las llamadas a stubs.
Todos los comparadores de Mockito son parte de ' Mockito ' clase estática.
Los comparadores son una herramienta poderosa, que permite una forma abreviada de configurar stubs, así como verificar las invocaciones en los stubs al mencionar las entradas de argumentos como tipos genéricos para valores específicos según el caso de uso o escenario.
Lo que vas a aprender:
Tipos de Matchers en Mockito
En general, hay 2 tipos de comparadores en Mockito o en términos de uso, los comparadores se pueden utilizar para las 2 categorías siguientes:
- Coincidentes de argumentos durante la configuración del código auxiliar
- Verification Matchers para verificar las llamadas reales a los talones
Para ambos tipos de comparadores, es decir, argumento y verificación, Mockito proporciona un gran conjunto de comparadores (haga clic en aquí para obtener una lista completa de los emparejadores).
Coincidentes de argumentos
A continuación se enumeran los más utilizados:
Para todo lo siguiente, consideremos probar una IntegerList:
|_+_|#1) any (): acepta cualquier objeto (incluido null).
|_+_|#2) cualquiera (clase de idioma java) -
Ejemplo : any (ClassUnderTest.class): esta es una variante más específica de any () y solo aceptará objetos del tipo de clase que se menciona como parámetro de plantilla.
|_+_|#3) anyBoolean (), anyByte (), anyInt (), anyString (), anyDouble (), anyFloat (), anyList () y muchos más: todos aceptan cualquier objeto del tipo de datos correspondiente, así como valores nulos.
|_+_|#4) Argumentos específicos: en los casos en que los argumentos reales se conocen de antemano, siempre se recomienda usarlos, ya que brindan más confianza en comparación con los tipos de argumentos genéricos.
Ejemplo:
|_+_|Coincidentes de verificación
Hay algunos comparadores especializados que están disponibles para esperar / afirmar cosas como no. de invocaciones en el simulacro.
Para todos los comparadores siguientes, consideremos la misma lista de ejemplos que hemos usado antes.
|_+_|# 1) Simulacros de invocaciones
(I) La invocación simple en Mock verifica si el método simulado fue llamado / interactuado o no configurando el tamaño de la lista simulada en 5.
|_+_|(ii) El recuento específico de interacciones con un método simulado verifica el recuento de no. muchas veces se esperaba que se llamara al simulacro.
|_+_|Para verificar 0 interacciones, simplemente cambie el valor de 1 a 0 como argumento para el comparador times ().
|_+_|En caso de fallas, devuelve las siguientes excepciones:
a) Cuando las invocaciones esperadas son menores que las invocaciones reales:
Ejemplo: Buscado 2 veces, pero invocado 3 veces, luego Mockito regresa - ' verificación.TooManyActualInvocations ”
Código de ejemplo:
|_+_|b) Cuando las invocaciones esperadas son más que las invocaciones reales:
Ejemplo: Se buscó 2 veces, pero se invocó 1 vez, luego Mockito regresa - ' verificación.TooLittleActualInvocations ”
|_+_|(iii) Sin interacciones con el método específico del objeto simulado.
|_+_|(iv) Verificar el orden de las interacciones simuladas: esto es particularmente útil cuando desea asegurar el orden en el que se llamaron los métodos en los objetos simulados.
Ejemplo: Operaciones similares a bases de datos en las que una prueba debe verificar el orden en el que se realizaron las actualizaciones de la base de datos.
Para ilustrar esto con un ejemplo - Continuemos con la misma lista de ejemplos.
Ahora supongamos que el orden de las llamadas a los métodos de la lista estaba en secuencia, es decir, get (5), size (), get (2). Por lo tanto, el orden de verificación también debería ser el mismo.
|_+_|En caso de una secuencia de verificación incorrecta, Mockito lanza una excepción, es decir, ' verificación.VerificationInOrderFailure ”.
Entonces, en el ejemplo anterior, si cambio el orden de verificación intercambiando las últimas 2 líneas, comenzaré a recibir la excepción VerificationInOrderFailure.
|_+_|(v) Verifique que la interacción haya ocurrido al menos / como máximo número de veces.
(a) por lo menos:
Ejemplo: atleast (3) - Verifica que el objeto simulado fue invocado / interactuado con al menos tres veces durante la prueba. Por lo tanto, cualquiera de las interacciones 3 o más de 3 debería hacer que la verificación sea exitosa.
|_+_|En caso de errores, es decir, cuando las invocaciones reales no coinciden, se lanza la misma excepción que con el comparador times (), es decir, ' verificación.TooLittleActualInvocations '
(b) como máximo:
Ejemplo: atmost (3): verifica si el objeto simulado se invocó / interactuó con al menos tres veces durante la prueba. Entonces, cualquiera de las interacciones 0,1,2 o 3 con el simulacro debería hacer que la verificación sea exitosa.
|_+_|# 2) Coincidencia de argumentos
En la invocación anterior, los comparadores se pueden combinar con los comparadores de argumentos para validar los argumentos con los que se llamó al simulacro.
cuál es el mejor descargador de música mp3
- alguna()
- Valores específicos: verifique con los valores específicos cuando los argumentos se conozcan de antemano.
- Otros comparadores de argumentos como: anyInt (), anyString (), etc.
consejos y trucos
# 1) Uso de captura de argumentos durante la verificación
La verificación de captura de argumentos suele ser útil cuando el argumento utilizado por algún método stubped no se pasa directamente a través de una llamada al método, sino que se crea internamente cuando se llama al método bajo prueba.
Esto es esencialmente útil cuando su método depende de uno o más colaboradores cuyo comportamiento ha sido eliminado. Los argumentos que se pasan a estos colaboradores son un objeto interno o un conjunto de argumentos completamente nuevo.
Validar el argumento real con el que se habría llamado a los colaboradores garantiza mucha confianza en el código que se está probando.
Mockito proporciona ArgumentCaptor que se puede usar con verificación y luego, cuando se llama a “AgumentCaptor.getValue ()”, podemos afirmar el argumento capturado real contra el esperado.
Para ilustrar esto, consulte el siguiente ejemplo:
En el método siguiente, calculatePrice es el modelo con la clase InventoryModel que se crea dentro del cuerpo del método que luego es utilizado por InventoryService para la actualización.
Ahora, si desea escribir una prueba para validar con qué argumento se llamó el servicio de inventario, simplemente puede usar el objeto ArgumentCaptor del tipo de clase InventoryModel.
Método bajo prueba:
|_+_|Código de prueba: Mire el paso de verificación en el que se verifica InventoryService, el objeto argumentCaptor se sustituye por el argumento que debe coincidir.
Luego, simplemente afirme el valor invocando el método getValue () en el objeto ArgumentCaptor.
Ejemplo: ArgumentCaptorObject.getValue ()
|_+_|Sin ArgumentCaptor no habría forma de identificar con qué argumento se realizó la llamada de servicio. Lo mejor es utilizar 'any ()' o 'any (InventoryModel.class)' para verificar los argumentos.
# 2) Excepciones / errores comunes al usar Matchers
Al usar Matchers, hay ciertas convenciones que deben seguirse, que si no se siguen, dan como resultado una excepción. El más común con el que me encontré es mientras comprobaba y verificaba.
Si está utilizando cualquier argumentMatchers y si el método stubbed tiene más de un argumento (s), entonces todos los argumentos deben mencionarse con los matchers, de lo contrario, ninguno de ellos debería tenerlos. ¿Ahora, que significa esto?
cuál es el mejor correo electrónico para tener
Intentemos comprender esto con un escenario (y luego un ejemplo de código para este escenario)
- Suponga que el método bajo prueba tiene una firma como:
concatenateString (String arg1, String arg2) - Ahora, al hacer stubbing, suponga que conoce el valor de arg1, pero arg2 es desconocido, por lo que decide usar un comparador de argumentos como - any () o anyString () y especifica un valor para el primer argumento como un texto 'hola'.
- Cuando se implementa el paso anterior y se ejecuta la prueba, la prueba arroja una excepción llamada 'InvalidUseOfMatchersException'
Intentemos entender esto con un ejemplo:
Código de prueba:
|_+_|Clase bajo prueba:
|_+_|Cuando se ejecuta la prueba anterior, regresa en ' InvalidUseOfMatchersException ”
Ahora bien, ¿cuál es el motivo de esta excepción?
Es el stubbing usando comparadores de partes y cadenas de partes fijas, es decir, hemos mencionado un comparador de argumentos como 'hola' y el segundo como anyString (). Ahora hay 2 formas de deshacerse de este tipo de excepciones (también tenga en cuenta que este comportamiento se aplica tanto a las configuraciones Mock como al comportamiento).
# 1) Use Argument Matchers para todos los argumentos:
|_+_|# 2) Use eq () como Argument Matcher donde se conoce el argumento. Entonces, en lugar de especificar el argumento como 'hola', especifíquelo como 'eq (' hola ') y esto debería hacer que el stubbing sea exitoso.
|_+_|Conclusión
En este artículo, vimos cómo usar diferentes tipos de comparadores proporcionados por Mockito.
Aquí, cubrimos los más utilizados. Para consultar la lista completa, la documentación de la biblioteca Mockito es una buena fuente de referencia.
Consulte nuestro próximo tutorial para obtener más información sobre los métodos privados, estáticos y nulos de burlarse.
PREV Tutorial | SIGUIENTE Tutorial
Lectura recomendada
- Creando simulacros y espías en Mockito con ejemplos de código
- Tutorial de Mockito: Mockito Framework para simular en pruebas unitarias
- Tipos de riesgos en proyectos de software
- Tipos de datos de Python
- Tipos de datos C ++
- Las 12 preguntas principales de la entrevista de Mockito (entrevista de marco de burla)
- Burlarse de métodos privados, estáticos y vacíos usando Mockito
- Tipos de herencia en C ++