Pruebas en Kotlin: Unit, Integration, E2E — guía completa

Introducción a las Pruebas en Kotlin: de Unitarias a Extremo a Extremo

Una base de código de alta calidad es imposible sin pruebas automatizadas. Kotlin, como lenguaje moderno para la JVM, proporciona a los desarrolladores un rico conjunto de herramientas para crear pruebas confiables. En este artículo, desglosaremos tres niveles de la pirámide de pruebas aplicados a Kotlin: unitarias, de integración y e2e. Aprenderás cómo escribir pruebas efectivas en Kotlin utilizando frameworks populares como JUnit 5, MockK, Ktor Client y Selenium.

1. Pruebas Unitarias en Kotlin: La Base de la Estabilidad

Las pruebas unitarias verifican el funcionamiento de funciones, clases o métodos individuales de forma aislada de las dependencias externas. En Kotlin, JUnit 5 se usa con mayor frecuencia para esto, en combinación con la librería de mocking MockK.

1.1. Configuración del Proyecto

Agrega las dependencias al archivo build.gradle.kts:

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

1.2. Ejemplo de Prueba Unitaria con MockK

Supongamos que tenemos un UserService que depende de un repositorio:

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

Prueba 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. Mejores Prácticas para Pruebas Unitarias

• Aísla las dependencias — usa mocks para todas las llamadas externas (base de datos, API).
• Prueba casos límite: null, cadenas vacías, números negativos.
• Usa nombres de prueba claros — deben describir el escenario y el resultado esperado.
• Sigue el principio AAA: Arrange, Act, Assert (Organizar, Actuar, Afirmar).

2. Pruebas de Integración en Kotlin: Verificando la Interacción

Las pruebas de integración verifican cómo varios componentes del sistema funcionan juntos. En Kotlin, esto podría ser probar una API REST usando Ktor Client o verificar operaciones de base de datos a través de Exposed.

2.1. Probando la API REST con Ktor

Crea un servidor Ktor simple y pruébalo:

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

// Testclass 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. Trabajando con una Base de Datos de Prueba

Para pruebas de integración con una base de datos, usa H2 (en memoria) o 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: