Android Academy · Lección

Mocking con Mockito

Aísle dependencias con Mockito y MockK. Simule valores de retorno, verifique interacciones, capture argumentos y use spies para realizar mocking parcial.

Mocking con Mockito es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 4 lecciones en total.

¿Qué es la simulación?

Un mock es un objeto simulado que reemplaza una dependencia real en las pruebas. A diferencia de un Fake (una implementación funcional en memoria), un mock:

Lo genera automáticamente una biblioteca
Registra qué métodos se llamaron y con qué argumentos
Devuelve lo que se le indique (stubbing)
Permite verificar las interacciones después de la prueba

Configuración de Mockito

Añada Mockito y MockK (una alternativa centrada en Kotlin) a app/build.gradle:

// app/build.gradle:
testImplementation 'org.mockito:mockito-core:5.10.0'
testImplementation 'org.mockito.kotlin:mockito-kotlin:5.2.1'

// MockK (Kotlin-idiomatic alternative to Mockito):
testImplementation 'io.mockk:mockk:1.13.10'

Creación de mocks

Cree mocks con mock() o con la anotación @Mock:

import org.mockito.kotlin.*

interface UserApi {
    suspend fun fetchUsers(): List<User>
    suspend fun deleteUser(id: Int)
}

class RepositoryTest {

    // Option 1: create inline
    private val api: UserApi = mock()

    // Option 2: use annotation + MockitoJUnit4Runner
    @Mock lateinit var api2: UserApi

    @get:Rule
    val mockitoRule = MockitoJUnit.rule()
}

Stubbing: definición de valores de retorno

Use whenever(mock.method()).thenReturn(value) para establecer lo que devuelve un mock:

val api: UserApi = mock()

// Stub a return value:
whenever(api.fetchUsers()).thenReturn(
    listOf(User(1, "Alice"), User(2, "Bob"))
)

// Stub an exception:
whenever(api.fetchUsers()).thenThrow(RuntimeException("Network error"))

// Return different values on consecutive calls:
whenever(api.fetchUsers())
    .thenReturn(emptyList())           // first call
    .thenReturn(listOf(User(1, "Alice"))) // second call

verify(): comprobación de interacciones

Use verify() para comprobar que se llamó a un método y cuántas veces:

val api: UserApi = mock()
val repo = UserRepository(api)

repo.refreshUsers()

// Verify that fetchUsers() was called exactly once:
verify(api).fetchUsers()

// Verify called with specific argument:
repo.deleteUser(42)
verify(api).deleteUser(42)

// Verify called exactly 3 times:
verify(api, times(3)).fetchUsers()

// Verify never called:
verify(api, never()).deleteUser(any())

ArgumentCaptor

ArgumentCaptor captura el argumento que se pasa a un método de un mock para que pueda comprobar su valor:

val api: UserApi = mock()
val captor = argumentCaptor<User>()

val repo = UserRepository(api)
repo.saveUser(User(1, "Alice"))

verify(api).saveUser(captor.capture())

val captured = captor.firstValue
assertEquals(1, captured.id)
assertEquals("Alice", captured.name)

MockK: simulación centrada en Kotlin

MockK está diseñado para Kotlin y gestiona de forma nativa las funciones de extensión, las corrutinas y los objetos:

import io.mockk.*

val api = mockk<UserApi>()

// Stub:
every { api.fetchUsers() } returns listOf(User(1, "Alice"))

// Stub suspend function:
coEvery { api.fetchUsers() } returns listOf(User(1, "Alice"))

// Verify:
val repo = UserRepository(api)
runBlocking { repo.refresh() }
coVerify { api.fetchUsers() }

Simulación de corrutinas con MockK

Use coEvery y coVerify para funciones suspend:

val api = mockk<UserApi>()

// Stub suspend function:
coEvery { api.fetchUsers() } returns listOf(User(1, "Alice"))
coEvery { api.deleteUser(any()) } just Runs  // returns Unit

// Test:
runTest {
    val repo = UserRepository(api)
    repo.refresh()
    coVerify(exactly = 1) { api.fetchUsers() }
    coVerify(exactly = 0) { api.deleteUser(any()) }
}

Spy: simulación parcial

Un spy envuelve un objeto real. De forma predeterminada, se llaman los métodos reales, a menos que se sobrescriban:

// Mockito Spy:
val realList = mutableListOf("a", "b", "c")
val spyList = spy(realList)

// Real method called:
spyList.add("d")
assertEquals(4, spyList.size)   // real add() was called

// Override specific method:
doReturn(99).`when`(spyList).size
assertEquals(99, spyList.size)  // overridden

// MockK Spy:
val spyObj = spyk(RealService())
every { spyObj.expensiveCall() } returns "fake result"

Cuándo usar Mocks frente a Fakes

Directrices prácticas:

Use un Fake cuando necesite una implementación funcional en memoria (DAO, repositorio): es más fácil de leer y no requiere ninguna biblioteca
Use un Mock cuando necesite verificar que se llamó a un método específico con argumentos específicos (eventos de analítica, llamadas a API)
Evite simular en exceso: si simula todo, sus pruebas verifican los mocks, no su lógica

Errores habituales

Errores que debe evitar al usar mocks:

Simular objetos de valor — simule interfaces o abstracciones, no clases de datos
Simular demasiados niveles — si necesita 5 mocks en una prueba, el código está demasiado acoplado
No verificar cuando la interacción es importante: no se limite a configurar el comportamiento; verifíquelo también
Mockito y los valores predeterminados de Kotlin — los parámetros de Kotlin no aceptan valores nulos de forma predeterminada; use mockito-kotlin o MockK para evitar sorpresas con valores nulos

Simulación de objetos y objetos complementarios

MockK puede simular objetos de Kotlin y objetos complementarios, algo imposible con Mockito:

object DateProvider {
    fun today(): String = "2024-01-01"
}

// In test:
mockkObject(DateProvider)
every { DateProvider.today() } returns "2099-12-31"

val result = DateProvider.today()
assertEquals("2099-12-31", result)

// Restore after test:
unmockkObject(DateProvider)

Comprobación rápida

¿Cuál es la finalidad de verify() en una prueba de Mockito o MockK?

Repaso: simulación con Mockito y MockK

Los mocks permiten aislar y verificar el comportamiento:

mock() / mockk() — crea un mock a partir de una interfaz o clase
whenever(...).thenReturn(...) / every { } returns ... — configura valores de retorno
coEvery / coVerify — para funciones suspend de Kotlin (MockK)
verify(mock).method(args) — comprueba que se llamó al método
ArgumentCaptor — captura e inspecciona argumentos
spy() / spyk() — simulación parcial de un objeto real
Prefiera Fakes para los datos; use Mocks para verificar el comportamiento

A continuación: pruebas de interfaz de usuario con Espresso.

Preguntas frecuentes

¿La lección «Mocking con Mockito» es gratis?

Sí — el texto completo de «Mocking con Mockito» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Mocking con Mockito»?

Aísle dependencias con Mockito y MockK. Simule valores de retorno, verifique interacciones, capture argumentos y use spies para realizar mocking parcial. Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Mocking con Mockito»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy