Android Academy · Aula

Simulação com Mockito

Isole dependências com Mockito e MockK. Defina valores de retorno simulados, verifique interações, capture argumentos e use spies para simulação parcial.

Aula 2 de 414 etapas

Simulação com Mockito é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

O que é simulação?

Um mock é um objeto falso que substitui uma dependência real nos testes. Diferentemente de um Fake (uma implementação funcional em memória), um mock:

É gerado automaticamente por uma biblioteca
Registra quais métodos foram chamados e com quais argumentos
Retorna o que você determinar que ele retorne (configuração de comportamento)
Permite verificar as interações após o teste

Configuração do Mockito

Adicione Mockito e MockK (uma alternativa voltada para 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'

Criando Mocks

Crie mocks com mock() ou com a anotação @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()
}

Configuração de comportamento — definindo valores de retorno

Use whenever(mock.method()).thenReturn(value) para definir o que um mock retorna:

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() — verificando interações

Use verify() para confirmar que um método foi chamado — e quantas vezes:

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 o argumento passado a um método de um mock para que você possa verificar seu 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 — simulação voltada para Kotlin

MockK foi criado para Kotlin e lida nativamente com funções de extensão, corrotinas e 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() }

Simulando corrotinas com MockK

Use coEvery e coVerify para funções 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 — simulação parcial

Um spy encapsula um objeto real. Por padrão, os métodos reais são chamados, a menos que sejam substituídos:

// 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"

Quando usar Mocks ou Fakes

Orientações práticas:

Use um Fake quando precisar de uma implementação funcional em memória (DAO, repositório) — é mais fácil de ler e não exige uma biblioteca
Use um Mock quando precisar verificar se um método específico foi chamado com argumentos específicos (eventos de análise, chamadas de API)
Evite usar mocks em excesso — se você simular tudo, seus testes verificarão os mocks, não a sua lógica

Erros comuns

Armadilhas a evitar ao usar simulação:

Simular objetos de valor — simule interfaces e abstrações, não classes de dados
Simular em níveis muito profundos — se precisar de 5 mocks em um teste, o código está muito acoplado
Não verificar quando a interação for importante — não faça apenas a configuração de comportamento; também verifique
Padrões do Mockito + Kotlin — os parâmetros do Kotlin não aceitam nulos por padrão; use mockito-kotlin ou MockK para evitar surpresas com valores nulos

Simulando objetos e objetos complementares

MockK pode simular objetos Kotlin e objetos complementares — algo impossível com 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)

Verificação rápida

Qual é a finalidade de verify() em um teste com Mockito ou MockK?

Responda na aula interativa

Recapitulação: simulação com Mockito e MockK

Mocks permitem isolar e verificar comportamentos:

mock() / mockk() — cria um mock a partir de uma interface ou classe
whenever(...).thenReturn(...) / every { } returns ... — configura valores de retorno
coEvery / coVerify — para funções suspend do Kotlin (MockK)
verify(mock).method(args) — confirma que o método foi chamado
ArgumentCaptor — captura e inspeciona argumentos
spy() / spyk() — simulação parcial de um objeto real
Dê preferência a Fakes para dados; use Mocks para verificar comportamentos

A seguir: testes de interface com Espresso.

Grátis para começar

Aprenda Kotlin com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 36
Aulas: 152

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Simulação com Mockito” é grátis?

Sim — o texto completo de “Simulação com Mockito” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Simulação com Mockito”?

Isole dependências com Mockito e MockK. Defina valores de retorno simulados, verifique interações, capture argumentos e use spies para simulação parcial. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Simulação com Mockito”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy