El marco Mockito proporciona una variedad de métodos como simulacro (), verificar (), cuando (), etc., que se utilizan para probar aplicaciones Java. El uso de estos métodos predefinidos hace que las pruebas sean muy sencillas.

La breve descripción de los métodos de Mockito se proporciona a continuación:

cómo desactivar el modo desarrollador en android

Método Mockito simulacro()

Se utiliza para crear objetos simulados de una clase o interfaz determinada. Mockito contiene cinco imitar() métodos con diferentes argumentos. Cuando no asignamos nada a los simulacros, devolverán valores predeterminados. Los cinco métodos realizan la misma función de burlarse de los objetos.

Los siguientes son los métodos simulados() con diferentes parámetros:

método simulado() con Clase:Se utiliza para crear objetos simulados de una clase concreta o una interfaz. Toma una clase o un nombre de interfaz como parámetro.
Sintaxis: simulacro(Clase classToMock)método simulado() con respuesta:Se utiliza para crear objetos simulados de una clase o interfaz con un procedimiento específico. Es un método simulado avanzado que se puede utilizar cuando se trabaja con sistemas heredados. Toma Respuesta como parámetro junto con el nombre de la clase o interfaz. La respuesta es una enumeración de respuestas simuladas preconfiguradas.
Sintaxis: simulado (clase claseToMock, respuesta respuesta predeterminada)Método simulado() con MockSettings:Se utiliza para crear objetos simulados con algunas configuraciones no estándar. Toma MockSettings como parámetro de configuración adicional junto con el nombre de la clase o interfaz. MockSettings permite la creación de objetos simulados con configuraciones adicionales.
Sintaxis: simulado(Clase claseToMock, MockSettings simulacroConfiguraciones)método simulado() con ReturnValues:Permite la creación de objetos simulados de una clase o interfaz determinada. Ahora está en desuso, ya que ReturnValues ​​se reemplaza por Answer.
Sintaxis: simulado (Clase classToMock, ReturnValues ​​returnValues)método simulado () con cadena:Se utiliza para crear objetos simulados especificando los nombres simulados. En la depuración, nombrar objetos simulados puede ser útil, mientras que es una mala elección usarlos con código grande y complejo.
Sintaxis: simulado (clase claseToMock, nombre de cadena)

El siguiente fragmento de código muestra cómo utilizar imitar() método:

 ToDoService doService = mock(ToDoService.class); 

Método Mockito cuando ()

Permite métodos de trozos. Debe usarse cuando queremos simular que se devuelven valores específicos cuando se llaman a métodos particulares. En lenguaje sencillo, ' Cuando se llama al método XYZ(), entonces volver ABC.' Se utiliza principalmente cuando hay alguna condición que ejecutar.

Sintaxis: cuando (método TLlamar)

El siguiente fragmento de código muestra cómo utilizar el método when():

 when(mock.someCode ()).thenReturn(5); 

En el código anterior, luegoRetorno() se utiliza principalmente con el cuando() método.

Método de verificación de Mockito ()

El verificar() El método se utiliza para comprobar si se llaman o no algunos métodos específicos. En términos simples, valida cierto comportamiento que ocurrió una vez en una prueba. Se utiliza en la parte inferior del código de prueba para garantizar que se llamen a los métodos definidos.

El marco Mockito realiza un seguimiento de todas las llamadas a métodos con sus parámetros para simular objetos. Después de burlarnos, podemos verificar que las condiciones definidas se cumplan o no utilizando el método verificar(). Este tipo de prueba a veces se conoce como pruebas de comportamiento. Comprueba que se llame a un método con los parámetros correctos en lugar de verificar el resultado de una llamada a un método.

El método verificar() también se utiliza para probar el número de invocaciones. Entonces podemos probar el número exacto de invocaciones usando el método de tiempos, método de al menos una vez, y como máximo método por un método burlado.

Hay dos tipos de métodos de verificación() disponibles en la clase Mockito, que se detallan a continuación:

método verificar():Verifica que cierto comportamiento ocurrió una vez.
Sintaxis: verificar (T simulado)método verificar() con VerificationMode:Verifica que algún comportamiento ocurrió al menos una vez, el número exacto de veces o nunca.
Sintaxis: verificar (T simulado, modo VerificationMode)

Método espía Mockito()

Mockito proporciona un método para burlarse parcialmente de un objeto, que se conoce como espiar método. Cuando se utiliza el método de espionaje, existe un objeto real y se crean espías o resguardos a partir de ese objeto real. Si no bloqueamos un método usando spy, llamará al comportamiento del método real. La función principal del método spy() es anular los métodos específicos del objeto real. Una de las funciones del método spy() es verificar la invocación de un determinado método.

Hay dos tipos de métodos spy() disponibles en la clase Mockito:

método espía():Crea un espía del objeto real. El método espía llama a los métodos reales a menos que estén bloqueados. Deberíamos utilizar a los espías reales con cuidado y de vez en cuando, por ejemplo, cuando tratamos con el código heredado.
Sintaxis: espía (objeto T)método spy() con Clase:Crea un objeto espía basado en una clase en lugar de un objeto. El método espía (objeto T) es particularmente útil para espiar clases abstractas porque no se pueden crear instancias de ellas.
Sintaxis: espía (clase clase para espiar)

El siguiente fragmento de código muestra cómo utilizar el método spy():

 List spyArrayList = spy(ArrayList.class); 

Método de reinicio de Mockito()

El método Mockito reset() se utiliza para restablecer los simulacros. Se utiliza principalmente para trabajar con simulacros inyectados en contenedores. Normalmente, el método reset() da como resultado un código largo y pruebas deficientes. Es mejor crear nuevos simulacros en lugar de utilizar el método reset(). Es por eso que el método reset() rara vez se utiliza en las pruebas.

La firma del método reset() es:

atajos de Linux

 public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } 

Método Mockito verificarNoMoreInteractions()

Se utiliza para comprobar que cualquiera de los simulacros dados tenga interacciones no verificadas. Podemos usar este método después de verificar todos los simulacros, para asegurarnos de que no se haya invocado nada más en los simulacros. También detecta las invocaciones no verificadas que ocurren antes del método de prueba, por ejemplo, en setup(), el método @Before o el constructor. Es un método opcional y no es necesario utilizarlo en todas las pruebas.

La firma del método verificarNoMoreInteractions() es:

 public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Método Mockito verificarZeroInteractions()

Verifica que no se haya producido ninguna interacción en los simulacros dados. También detecta las invocaciones que han ocurrido antes del método de prueba, por ejemplo, en setup(), el método @Before o el constructor.

La firma del método verificarZeroInteractions() es:

 public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Método Mockito doThrow()

Se utiliza cuando se elimina un método nulo para generar una excepción. Crea una nueva instancia de excepción para cada invocación de método. Hay dos tipos de métodos doThrow() disponibles en la clase Mockito con diferentes parámetros, como se muestra a continuación:

Método doThrow() con Throwable:Este método se utiliza cuando queremos descartar un método nulo con una excepción. Sintaxis: doThrow(Lanzable paraBeThrown)
La firma del método doThrow() es:

 public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } 

Método doThrow() con Clase:Este método se usa cuando queremos crear un método nulo para generar una excepción de una clase específica.
Sintaxis: doThrow(Clase para ser lanzado)
La firma del método doThrow() es:

 public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } 

Método Mockito doCallRealMethod()

Se utiliza cuando queremos llamar a la implementación real de un método. En otras palabras, se utiliza para crear simulacros parciales de un objeto. Se utiliza en situaciones raras, como para llamar a métodos reales. Es similar al método spy() y la única diferencia es que genera un código complejo.

La firma del método doCallRealMethod() es:

 public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } 

Método Mockito doAnswer()

Se utiliza cuando queremos crear un método nulo con un tipo de respuesta genérico. La firma del método doAnswer() es:

 public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } 

Método Mockito no hacer nada()

Se utiliza para configurar métodos nulos para que no hagan nada. El método doNothing() se utiliza en situaciones excepcionales. De forma predeterminada, los métodos void en instancias simuladas no hacen nada, es decir, no se realiza ninguna tarea.

La firma del método doNothing() es:

 public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } 

Método Mockito doReturn()

Se usa en esas raras ocasiones en las que no podemos usar Mockito.when(object). El método Mockito.when(object) siempre se sugiere para el stubbing porque tiene argumentos de tipo seguro y es más legible en comparación con el método doReturn().

La firma del método doReturn() es:

 public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } 

Método Mockito inOrder()

Se utiliza para crear objetos que permitan la verificación de simulacros en un orden específico. La verificación realizada en orden es más flexible ya que no tenemos que verificar todas las interacciones. Necesitamos verificar solo aquellas interacciones que estén interesadas en probar (en orden). También podemos usar el método inOrder() para crear un objeto inOrder pasando simulacros que sean relevantes para la verificación en orden.

La firma del método Mockito.inOrder() es:

 public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } 

Método Mockito ignoreStubs()

Se utiliza para ignorar los métodos descartados de simulacros determinados para su verificación. Es útil con los métodos verificarNoMoreInteractions() o verificación inOrder(). También ayuda a evitar la verificación redundante de llamadas cortadas.

La firma del método ignoreStubs() es:

cómo emparejar auriculares beats

 public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } 

Método Mockito times()

Se utiliza para verificar el número exacto de invocaciones de métodos, lo que significa que declara cuántas veces se invoca un método. La firma del método times() es:

 public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } 

Método Mockito nunca()

Se utiliza para verificar que la interacción no ocurrió. La firma del método never() es:

 public static VerificationMode never() { return times(0); } 

Método Mockito atLeastOnce()

Se utiliza para verificar la invocación al menos una vez, lo que significa que el método debe invocarse al menos una vez.

La firma del método atLeastOnce() es:

 public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } 

Método Mockito al menos ()

Se utiliza para verificar la invocación al menos x número de veces. Por ejemplo, dado al menos (3) significa que el método invocará un mínimo de tres veces.

La firma del método atLeast() es:

 public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } 

Método Mockito atMost()

Se utiliza para verificar la invocación como máximo x número de veces. Por ejemplo, dado atMost(3) significa que el método invocará un máximo de tres veces.

La firma del método atMost() es:

 public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } 

Método Mockito llama()

Permite una verificación no codiciosa en orden. Sólo se puede utilizar con el método de verificación inOrder(). Por ejemplo, inOrder.verify(mock, call(3)).xyzMethod('...');

La firma del método call() es:

 public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } 

Método solo Mockito()

Comprueba que el método dado fue el único método invocado. La firma del método only() es:

ventana.abrir javascript

 public static VerificationMode only() { return VerificationModeFactory.only(); } 

Método de tiempo de espera de Mockito ()

Le permite a Mockito realizar la verificación con un tiempo de espera. Le indica a una verificación que espere un período de tiempo específico para una interacción particular en lugar de fallar inmediatamente. Puede resultar útil para realizar pruebas en situaciones existentes.

El método timeout() difiere del método after() en que el método after() espera el período completo a menos que se declare el resultado final, mientras que el método timeout() se detendrá tan pronto como pase la verificación. Rara vez se utiliza en pruebas.

La firma del método timeout() es:

 public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } 

Método Mockito después()

Le permite a Mockito verificar durante un período de tiempo determinado. Ya hemos comentado que el método after() difiere del método timeout().

La firma del método after() es:

 public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } 

Método Mockito validarMockitoUsage()

Se utiliza para validar explícitamente el estado del marco para detectar el uso no válido del marco Mockito. Es una característica opcional de Mockito porque valida el uso todo el tiempo. Tanto el ejecutor integrado (MockitoJUnitRunner) como la regla (MockitoRule) llaman al método validarMockitoUsage() después de cada método de prueba.

La firma del método validarMockitoUsage() es:

 public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } 

Método Mockito conSettings()

Se utiliza para crear simulacros con configuraciones simuladas adicionales. Debe usarse ocasionalmente en las pruebas. En lugar de utilizar el método withSettings(), cree pruebas sencillas utilizando simulacros sencillos. Las principales razones para utilizar MockSettings son

• Al usar MockSetting, podemos agregar fácilmente otras configuraciones simuladas cuando sea necesario.
• Combina diferentes configuraciones simuladas sin estropear el código.

La firma del método withSettings() es:

 public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }