Testes em Kotlin: Unit, Integration, E2E — guia completo

Introdução ao teste em Kotlin: de unitários a end-to-end

Uma base de código de qualidade é impossível sem testes automatizados. Kotlin, como uma linguagem moderna para a JVM, fornece aos desenvolvedores um rico conjunto de ferramentas para criar testes confiáveis. Neste artigo, vamos analisar os três níveis da pirâmide de testes aplicados ao Kotlin: unit (unitários), integration (integração) e e2e (ponta a ponta). Você aprenderá como escrever testes eficazes em Kotlin usando frameworks populares como JUnit 5, MockK, Ktor Client e Selenium.

1. Teste unitário em Kotlin: a base da estabilidade

Testes unitários verificam o funcionamento de funções, classes ou métodos individuais isoladamente de dependências externas. Em Kotlin, para isso, usa-se mais frequentemente o JUnit 5 em combinação com a biblioteca de mocks MockK.

1.1. Configuração do projeto

Adicione as dependências no arquivo build.gradle.kts:

dependencies {    testImplementation("org.junit.jupiter:junit-jupiter:5.10.0")    testImplementation("io.mockk:mockk:1.13.8")}

1.2. Exemplo de teste unitário com MockK

Suponha que temos um serviço UserService que depende de um repositório:

class UserService(private val repository: UserRepository) {    fun getUserName(id: Long): String {        val user = repository.findById(id)        return user?.name ?: "Unknown"    }}

Teste usando MockK:

import io.mockk.everyimport io.mockk.mockkimport org.junit.jupiter.api.Testimport kotlin.test.assertEquals

class UserServiceTest {    @Test    fun `return userName when user exists`() {        val mockRepo = mockk<UserRepository>()        every { mockRepo.findById(1L) } returns User(1L, "Alice")        val service = UserService(mockRepo)

        val result = service.getUserName(1L)

        assertEquals("Alice", result)    }}

1.3. Melhores práticas de teste unitário

• Isole as dependências — use mocks para todas as chamadas externas (banco de dados, API).
• Teste casos limite: null, strings vazias, números negativos.
• Use nomes de teste claros — eles devem descrever o cenário e o resultado esperado.
• Siga o princípio AAA: Arrange (preparação), Act (ação), Assert (verificação).

2. Teste de integração em Kotlin: verificando a interação

Testes de integração verificam como vários componentes do sistema funcionam juntos. Em Kotlin, isso pode ser o teste de uma REST API usando Ktor Client ou a verificação do trabalho com o banco de dados através do Exposed.

2.1. Testando REST API com Ktor

Criamos um servidor simples em Ktor e o testamos:

// Servidorfun Application.module() {    routing {        get("/hello") {            call.respondText("Hello, Kotlin!")        }    }}

// Testeclass ApiTest {    @Test    fun `test hello endpoint`() = testApplication {        application { module() }        val response = client.get("/hello")        assertEquals(HttpStatusCode.OK, response.status)        assertEquals("Hello, Kotlin!", response.bodyAsText())    }}

2.2. Trabalhando com banco de dados de teste

Para testes de integração com BD, use H2 (em memória) ou Testcontainers para PostgreSQL:

@Testfun `test user creation`() {    withTestDatabase {        val user = User.new {            name = "Bob"            email = "bob@test.com"        }        assertEquals("Bob", user.name)        assertNotNull(user.id)    }}

private fun withTestDatabase(block: () -> Unit) {    Database.connect("jdbc:h2:mem: