Pruebas en Kotlin: unit, integration, e2e de la A a la Z

Introducción a las pruebas en Kotlin: desde módulos hasta la experiencia del usuario

Kotlin es un lenguaje moderno que se utiliza activamente para desarrollar aplicaciones de servidor (Ktor, Spring Boot), aplicaciones Android y proyectos multiplataforma. Sin embargo, la calidad del código es imposible sin pruebas adecuadas. En este artículo, analizaremos tres niveles clave: unit (pruebas unitarias), integration (pruebas de integración) y e2e (pruebas de extremo a extremo). Aprenderá qué herramientas usar, cómo escribir pruebas en Kotlin y cómo construir una estrategia de verificación confiable para su aplicación.

1. Pruebas unitarias en Kotlin: la base de la estabilidad

Las pruebas unitarias verifican funciones, clases o métodos individuales de forma aislada de las dependencias externas. En Kotlin, para esto se usan principalmente JUnit 5 y MockK.

Herramientas y configuración

Agregue las dependencias en build.gradle.kts:

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

Ejemplo de prueba unitaria con MockK

Supongamos que tenemos un servicio que depende de un repositorio:

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

Prueba usando MockK:

import io.mockk.everyimport io.mockk.mockkimport org.junit.jupiter.api.Assertions.assertEqualsimport org.junit.jupiter.api.Test

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

Mejores prácticas para pruebas unitarias

• Una prueba — una verificación (use assert con criterio).
• Aísle las dependencias: use mocks (MockK) o stubs.
• Nombre las pruebas de forma clara: shouldReturnX_whenY.
• Pruebe casos límite: null, listas vacías, excepciones.

2. Pruebas de integración: verificación de la combinación de componentes

Las pruebas de integración verifican cómo funcionan juntos los componentes reales: base de datos, API, sistema de archivos. En Kotlin, para esto es conveniente usar Testcontainers y Ktor Client (si escribe un servidor).

Ejemplo: prueba de un repositorio con PostgreSQL

Conecte Testcontainers y exposed (biblioteca para trabajar con BD):

dependencies {    testImplementation("org.testcontainers:postgresql:1.19.3")    implementation("org.jetbrains.exposed:exposed:0.44.1")}

Prueba para UserRepository:

import org.junit.jupiter.api.*import org.testcontainers.containers.PostgreSQLContainerimport org.testcontainers.junit.jupiter.Containerimport org.testcontainers.junit.jupiter.Testcontainersimport org.jetbrains.exposed.sql.*

@Testcontainersclass UserRepositoryIntegrationTest {

    @Container    val postgres = PostgreSQLContainer<Nothing>("postgres:15").apply {        withDatabaseName("testdb")        withUsername("test")        withPassword("test")    }

    private lateinit var repo: UserRepository

    @BeforeEach    fun setUp() {        Database.connect(postgres.jdbcUrl, driver = "org.postgresql.Driver", user = postgres.username, password = postgres.password)        transaction { SchemaUtils.create(Users) }        repo = UserRepository()    }

    @Test    fun `save and find user by id`() {        val user = User(1, "Bob")        repo.save(user)        val found = repo.findById(1)        assertEquals("Bob", found?.name)    }

    @AfterEa