Utilizando Mockito para simular dependencias en proyectos de Kotlin

Avatar
3 min lectura

Mockito es una librería de testing en Java que permite crear objetos “falsos” o “mock” para simular comportamientos y comprobar el correcto funcionamiento de nuestro código.

Esta librería ha sido adaptada también para Kotlin, permitiendo utilizarla en proyectos desarrollados en esta popular y moderna plataforma.

¿Qué es un Mock?

Un mock es un objeto “falso” que se utiliza en pruebas para simular un comportamiento o dependencia.

Los mocks se utilizan para realizar pruebas de manera aislada, sin depender de componentes o servicios externos que puedan afectar al resultado de las pruebas.

De esta manera, podemos asegurarnos de que nuestro código está funcionando correctamente y no hay errores en su implementación.

¿Cómo funciona Mockito?

Uno de los usos más comunes de Mockito es para simular dependencias en nuestro código.

Simular dependencias en Mockito

Por ejemplo, imaginemos que tenemos una clase que depende de un servicio externo para obtener datos.

En vez de conectarnos realmente a ese servicio, podemos utilizar Mockito para crear un objeto “falso” que simule el comportamiento del servicio y nos permita realizar pruebas sin depender de un servicio externo.

En Kotlin, podemos utilizar Mockito de la siguiente manera:

val mockService = mock<ExternalService>()

Con esto, hemos creado un objeto “falso” de la clase ExternalService.

Ahora, podemos especificar el comportamiento que queremos que tenga este objeto “falso” utilizando la función whenever de Mockito:

val myClass = MyClass(mockService)
assertEquals("fake data", myClass.getDataFromService())

En este caso, hemos creado una instancia de nuestra clase MyClass y le hemos pasado nuestro objeto “falso” como parámetro.

Luego, hemos llamado al método getDataFromService de nuestra clase y hemos comprobado que el valor devuelto es el que esperábamos (“fake data”).

Verificar llamadas a funciones con Mockito

Otro uso común de Mockito es para verificar que se están llamando a ciertos métodos en nuestro código.

Por ejemplo, podemos utilizar la función verify de Mockito para comprobar que se ha llamado al método saveData de nuestro objeto “falso” una determinada cantidad de veces:

verify(mockService, times(3)).saveData(any())

En este caso, estamos comprobando que el método saveData de nuestro objeto “falso” se ha llamado exactamente tres veces. De esta manera, podemos asegurarnos de que nuestro código está utilizando correctamente el servicio externo y no hay errores en su implementación.

Capturar argumentos en las llamadas a funciones con Mockito

Otro uso común de Mockito es el llamado “argument captor”. Esta característica nos permite capturar el valor de un parámetro que se le pasa a un método cuando éste es llamado. Esto nos permite realizar comprobaciones adicionales en nuestras pruebas sobre el valor que se le está pasando al método.

En Kotlin, podemos utilizar un argument captor de la siguiente manera:

val argumentCaptor = argumentCaptor<String>()

En este caso, hemos creado un argument captor que capturará un valor de tipo String. Luego, podemos utilizar este argument captor para verificar el valor que se le pasa al método saveData de nuestro objeto “falso”:

verify(mockService).saveData(argumentCaptor.capture())
assertEquals("expected value", argumentCaptor.value)

En este caso, estamos comprobando que el método saveData se ha llamado y, además, estamos verificando que el valor que se le ha pasado es el que esperábamos (“expected value”).

Esto nos permite realizar pruebas más precisas y asegurarnos de que nuestro código está funcionando correctamente.

¿En qué lenguajes puedo usar Mockito?

Mockito es una librería de testing en Java, por lo que se puede utilizar en cualquier proyecto desarrollado en Java. Además, Mockito ha sido adaptado también para otros lenguajes de programación como Kotlin, Scala o Groovy, por lo que también se puede utilizar en proyectos de estos lenguajes.

Conclusión

En resumen, Mockito es una herramienta muy útil para realizar pruebas en nuestro código de Kotlin.

Nos permite simular comportamientos y verificar el correcto funcionamiento de nuestro código sin depender de servicios externos o componentes reales.

Esto nos permite acelerar el proceso de pruebas y mejorar la calidad de nuestro código.