Kotlin Testing

作者 affaan-mef648e01899b无许可证275K 个星标收录于 2026年10月8日更新于 2026年10月8日仓库3天前更新

Patrones de pruebas Kotlin con Kotest, MockK, pruebas de coroutines, pruebas basadas en propiedades y cobertura con Kover. Sigue la metodología TDD con prácticas idiomáticas de Kotlin.

仅含说明Software Development
AI 生成的概览

Kotlin 测试模式：Kotest、MockK、协程与属性测试，以及 TDD 流程下的 Kover 覆盖率。

功能
提供编写 Kotlin 测试的参考模式与可运行示例：Kotest 的 spec 风格、匹配器、MockK 模拟与参数捕获、协程与 Flow 测试、属性测试、数据驱动测试以及测试生命周期夹具。还涵盖 Kover 覆盖率配置与 Gradle 测试命令，并以邮箱校验器为例演示 RED-GREEN-REFACTOR 的 TDD 循环。
适用场景
适用于编写新的 Kotlin 函数或类、为现有 Kotlin 代码补充测试覆盖、实现属性测试、在 Kotlin 项目中遵循 TDD 工作流，或配置 Kover 覆盖率时。
运行要求
需要带有 Kotest、MockK、kotlinx-coroutines-test 和 Kover 插件的 Kotlin/Gradle 项目；不附带脚本，只有说明和代码示例。

Patrones de Pruebas Kotlin

Patrones completos de pruebas Kotlin para escribir pruebas confiables y mantenibles siguiendo la metodología TDD con Kotest y MockK.

Cuándo Usar

  • Escribir nuevas funciones o clases Kotlin
  • Agregar cobertura de pruebas a código Kotlin existente
  • Implementar pruebas basadas en propiedades
  • Seguir el flujo de trabajo TDD en proyectos Kotlin
  • Configurar Kover para cobertura de código

Cómo Funciona

  1. Identificar el código objetivo — Encontrar la función, clase o módulo a probar
  2. Escribir un spec Kotest — Elegir un estilo de spec (StringSpec, FunSpec, BehaviorSpec) acorde al alcance de la prueba
  3. Mockear dependencias — Usar MockK para aislar la unidad bajo prueba
  4. Ejecutar pruebas (ROJO) — Verificar que la prueba falla con el error esperado
  5. Implementar código (VERDE) — Escribir el código mínimo para pasar la prueba
  6. Refactorizar — Mejorar la implementación manteniendo las pruebas en verde
  7. Verificar cobertura — Ejecutar ./gradlew koverHtmlReport y verificar 80%+ de cobertura

Ejemplos

Las siguientes secciones contienen ejemplos detallados y ejecutables para cada patrón de prueba:

Referencia Rápida

Flujo de Trabajo TDD para Kotlin

El Ciclo ROJO-VERDE-REFACTORIZAR
ROJO        -> Escribir primero una prueba fallidaVERDE       -> Escribir el código mínimo para pasar la pruebaREFACTORIZAR -> Mejorar el código manteniendo las pruebas en verdeREPETIR     -> Continuar con el siguiente requisito
TDD Paso a Paso en Kotlin
kotlin
// Paso 1: Definir la interfaz/firma// EmailValidator.ktpackage com.example.validator
fun validateEmail(email: String): Result<String> {    TODO("not implemented")}
// Paso 2: Escribir la prueba fallida (ROJO)// EmailValidatorTest.ktpackage com.example.validator
import io.kotest.core.spec.style.StringSpecimport io.kotest.matchers.result.shouldBeFailureimport io.kotest.matchers.result.shouldBeSuccess
class EmailValidatorTest : StringSpec({    "valid email returns success" {        validateEmail("[email protected]").shouldBeSuccess("[email protected]")    }
    "empty email returns failure" {        validateEmail("").shouldBeFailure()    }
    "email without @ returns failure" {        validateEmail("userexample.com").shouldBeFailure()    }})
// Paso 3: Ejecutar pruebas - verificar FALLO// $ ./gradlew test// EmailValidatorTest > valid email returns success FAILED//   kotlin.NotImplementedError: An operation is not implemented
// Paso 4: Implementar el código mínimo (VERDE)fun validateEmail(email: String): Result<String> {    if (email.isBlank()) return Result.failure(IllegalArgumentException("Email cannot be blank"))    if ('@' !in email) return Result.failure(IllegalArgumentException("Email must contain @"))    val regex = Regex("^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$")    if (!regex.matches(email)) return Result.failure(IllegalArgumentException("Invalid email format"))    return Result.success(email)}
// Paso 5: Ejecutar pruebas - verificar PASE// $ ./gradlew test// EmailValidatorTest > valid email returns success PASSED// EmailValidatorTest > empty email returns failure PASSED// EmailValidatorTest > email without @ returns failure PASSED
// Paso 6: Refactorizar si es necesario, verificar que las pruebas siguen pasando

Estilos de Spec Kotest

StringSpec (El Más Simple)
kotlin
class CalculatorTest : StringSpec({    "add two positive numbers" {        Calculator.add(2, 3) shouldBe 5    }
    "add negative numbers" {        Calculator.add(-1, -2) shouldBe -3    }
    "add zero" {        Calculator.add(0, 5) shouldBe 5    }})
FunSpec (Similar a JUnit)
kotlin
class UserServiceTest : FunSpec({    val repository = mockk<UserRepository>()    val service = UserService(repository)
    test("getUser returns user when found") {        val expected = User(id = "1", name = "Alice")        coEvery { repository.findById("1") } returns expected
        val result = service.getUser("1")
        result shouldBe expected    }
    test("getUser throws when not found") {        coEvery { repository.findById("999") } returns null
        shouldThrow<UserNotFoundException> {            service.getUser("999")        }    }})
BehaviorSpec (Estilo BDD)
kotlin
class OrderServiceTest : BehaviorSpec({    val repository = mockk<OrderRepository>()    val paymentService = mockk<PaymentService>()    val service = OrderService(repository, paymentService)
    Given("a valid order request") {        val request = CreateOrderRequest(            userId = "user-1",            items = listOf(OrderItem("product-1", quantity = 2)),        )
        When("the order is placed") {            coEvery { paymentService.charge(any()) } returns PaymentResult.Success            coEvery { repository.save(any()) } answers { firstArg() }
            val result = service.placeOrder(request)
            Then("it should return a confirmed order") {                result.status shouldBe OrderStatus.CONFIRMED            }
            Then("it should charge payment") {                coVerify(exactly = 1) { paymentService.charge(any()) }            }        }
        When("payment fails") {            coEvery { paymentService.charge(any()) } returns PaymentResult.Declined
            Then("it should throw PaymentException") {                shouldThrow<PaymentException> {                    service.placeOrder(request)                }            }        }    }})
DescribeSpec (Estilo RSpec)
kotlin
class UserValidatorTest : DescribeSpec({    describe("validateUser") {        val validator = UserValidator()
        context("with valid input") {            it("accepts a normal user") {                val user = CreateUserRequest("Alice", "[email protected]")                validator.validate(user).shouldBeValid()            }        }
        context("with invalid name") {            it("rejects blank name") {                val user = CreateUserRequest("", "[email protected]")                validator.validate(user).shouldBeInvalid()            }
            it("rejects name exceeding max length") {                val user = CreateUserRequest("A".repeat(256), "[email protected]")                validator.validate(user).shouldBeInvalid()            }        }    }})

Matchers de Kotest

Matchers Principales
kotlin
import io.kotest.matchers.shouldBeimport io.kotest.matchers.shouldNotBeimport io.kotest.matchers.string.*import io.kotest.matchers.collections.*import io.kotest.matchers.nulls.*
// Igualdadresult shouldBe expectedresult shouldNotBe unexpected
// Stringsname shouldStartWith "Al"name shouldEndWith "ice"name shouldContain "lic"name shouldMatch Regex("[A-Z][a-z]+")name.shouldBeBlank()
// Coleccioneslist shouldContain "item"list shouldHaveSize 3list.shouldBeSorted()list.shouldContainAll("a", "b", "c")list.shouldBeEmpty()
// Nullsresult.shouldNotBeNull()result.shouldBeNull()
// Tiposresult.shouldBeInstanceOf<User>()
// Númeroscount shouldBeGreaterThan 0price shouldBeInRange 1.0..100.0
// ExcepcionesshouldThrow<IllegalArgumentException> {    validateAge(-1)}.message shouldBe "Age must be positive"
shouldNotThrow<Exception> {    validateAge(25)}
Matchers Personalizados
kotlin
fun beActiveUser() = object : Matcher<User> {    override fun test(value: User) = MatcherResult(        value.isActive && value.lastLogin != null,        { "User ${value.id} should be active with a last login" },        { "User ${value.id} should not be active" },    )}
// Usouser should beActiveUser()

MockK

Mocking Básico
kotlin
class UserServiceTest : FunSpec({    val repository = mockk<UserRepository>()    val logger = mockk<Logger>(relaxed = true) // Relaxed: retorna valores por defecto    val service = UserService(repository, logger)
    beforeTest {        clearMocks(repository, logger)    }
    test("findUser delegates to repository") {        val expected = User(id = "1", name = "Alice")        every { repository.findById("1") } returns expected
        val result = service.findUser("1")
        result shouldBe expected        verify(exactly = 1) { repository.findById("1") }    }
    test("findUser returns null for unknown id") {        every { repository.findById(any()) } returns null
        val result = service.findUser("unknown")
        result.shouldBeNull()    }})
Mocking de Coroutines
kotlin
class AsyncUserServiceTest : FunSpec({    val repository = mockk<UserRepository>()    val service = UserService(repository)
    test("getUser suspending function") {        coEvery { repository.findById("1") } returns User(id = "1", name = "Alice")
        val result = service.getUser("1")
        result.name shouldBe "Alice"        coVerify { repository.findById("1") }    }
    test("getUser with delay") {        coEvery { repository.findById("1") } coAnswers {            delay(100) // Simular trabajo asíncrono            User(id = "1", name = "Alice")        }
        val result = service.getUser("1")        result.name shouldBe "Alice"    }})
Captura de Argumentos
kotlin
test("save captures the user argument") {    val slot = slot<User>()    coEvery { repository.save(capture(slot)) } returns Unit
    service.createUser(CreateUserRequest("Alice", "[email protected]"))
    slot.captured.name shouldBe "Alice"    slot.captured.email shouldBe "[email protected]"    slot.captured.id.shouldNotBeNull()}
Spy y Mocking Parcial
kotlin
test("spy on real object") {    val realService = UserService(repository)    val spy = spyk(realService)
    every { spy.generateId() } returns "fixed-id"
    spy.createUser(request)
    verify { spy.generateId() } // Sobreescrito    // Otros métodos usan la implementación real}

Pruebas de Coroutines

runTest para Funciones Suspend
kotlin
import kotlinx.coroutines.test.runTest
class CoroutineServiceTest : FunSpec({    test("concurrent fetches complete together") {        runTest {            val service = DataService(testScope = this)
            val result = service.fetchAllData()
            result.users.shouldNotBeEmpty()            result.products.shouldNotBeEmpty()        }    }
    test("timeout after delay") {        runTest {            val service = SlowService()
            shouldThrow<TimeoutCancellationException> {                withTimeout(100) {                    service.slowOperation() // Tarda > 100ms                }            }        }    }})
Pruebas de Flows
kotlin
import io.kotest.matchers.collections.shouldContainInOrderimport kotlinx.coroutines.flow.MutableSharedFlowimport kotlinx.coroutines.flow.toListimport kotlinx.coroutines.launchimport kotlinx.coroutines.test.advanceTimeByimport kotlinx.coroutines.test.runTest
class FlowServiceTest : FunSpec({    test("observeUsers emits updates") {        runTest {            val service = UserFlowService()
            val emissions = service.observeUsers()                .take(3)                .toList()
            emissions shouldHaveSize 3            emissions.last().shouldNotBeEmpty()        }    }
    test("searchUsers debounces input") {        runTest {            val service = SearchService()            val queries = MutableSharedFlow<String>()
            val results = mutableListOf<List<User>>()            val job = launch {                service.searchUsers(queries).collect { results.add(it) }            }
            queries.emit("a")            queries.emit("ab")            queries.emit("abc") // Solo este debería disparar la búsqueda            advanceTimeBy(500)
            results shouldHaveSize 1            job.cancel()        }    }})
TestDispatcher
kotlin
import kotlinx.coroutines.test.StandardTestDispatcherimport kotlinx.coroutines.test.advanceUntilIdle
class DispatcherTest : FunSpec({    test("uses test dispatcher for controlled execution") {        val dispatcher = StandardTestDispatcher()
        runTest(dispatcher) {            var completed = false
            launch {                delay(1000)                completed = true            }
            completed shouldBe false            advanceTimeBy(1000)            completed shouldBe true        }    }})

Pruebas Basadas en Propiedades

Pruebas de Propiedades con Kotest
kotlin
import io.kotest.core.spec.style.FunSpecimport io.kotest.property.Arbimport io.kotest.property.arbitrary.*import io.kotest.property.forAllimport io.kotest.property.checkAllimport kotlinx.serialization.json.Jsonimport kotlinx.serialization.encodeToStringimport kotlinx.serialization.decodeFromString
// Nota: La prueba de roundtrip de serialización requiere que la data class User// esté anotada con @Serializable (de kotlinx.serialization).
class PropertyTest : FunSpec({    test("string reverse is involutory") {        forAll<String> { s ->            s.reversed().reversed() == s        }    }
    test("list sort is idempotent") {        forAll(Arb.list(Arb.int())) { list ->            list.sorted() == list.sorted().sorted()        }    }
    test("serialization roundtrip preserves data") {        checkAll(Arb.bind(Arb.string(1..50), Arb.string(5..100)) { name, email ->            User(name = name, email = "[email protected]")        }) { user ->            val json = Json.encodeToString(user)            val decoded = Json.decodeFromString<User>(json)            decoded shouldBe user        }    }})
Generadores Personalizados
kotlin
val userArb: Arb<User> = Arb.bind(    Arb.string(minSize = 1, maxSize = 50),    Arb.email(),    Arb.enum<Role>(),) { name, email, role ->    User(        id = UserId(UUID.randomUUID().toString()),        name = name,        email = Email(email),        role = role,    )}
val moneyArb: Arb<Money> = Arb.bind(    Arb.long(1L..1_000_000L),    Arb.enum<Currency>(),) { amount, currency ->    Money(amount, currency)}

Pruebas Dirigidas por Datos

withData en Kotest
kotlin
class ParserTest : FunSpec({    context("parsing valid dates") {        withData(            "2026-01-15" to LocalDate(2026, 1, 15),            "2026-12-31" to LocalDate(2026, 12, 31),            "2000-01-01" to LocalDate(2000, 1, 1),        ) { (input, expected) ->            parseDate(input) shouldBe expected        }    }
    context("rejecting invalid dates") {        withData(            nameFn = { "rejects '$it'" },            "not-a-date",            "2026-13-01",            "2026-00-15",            "",        ) { input ->            shouldThrow<DateParseException> {                parseDate(input)            }        }    }})

Ciclo de Vida y Fixtures de Prueba

BeforeTest / AfterTest
kotlin
class DatabaseTest : FunSpec({    lateinit var db: Database
    beforeSpec {        db = Database.connect("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1")        transaction(db) {            SchemaUtils.create(UsersTable)        }    }
    afterSpec {        transaction(db) {            SchemaUtils.drop(UsersTable)        }    }
    beforeTest {        transaction(db) {            UsersTable.deleteAll()        }    }
    test("insert and retrieve user") {        transaction(db) {            UsersTable.insert {                it[name] = "Alice"                it[email] = "[email protected]"            }        }
        val users = transaction(db) {            UsersTable.selectAll().map { it[UsersTable.name] }        }
        users shouldContain "Alice"    }})
Extensiones de Kotest
kotlin
// Extensión de prueba reutilizableclass DatabaseExtension : BeforeSpecListener, AfterSpecListener {    lateinit var db: Database
    override suspend fun beforeSpec(spec: Spec) {        db = Database.connect("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1")    }
    override suspend fun afterSpec(spec: Spec) {        // limpieza    }}
class UserRepositoryTest : FunSpec({    val dbExt = DatabaseExtension()    register(dbExt)
    test("save and find user") {        val repo = UserRepository(dbExt.db)        // ...    }})

Cobertura con Kover

Configuración de Gradle
kotlin
// build.gradle.ktsplugins {    id("org.jetbrains.kotlinx.kover") version "0.9.7"}
kover {    reports {        total {            html { onCheck = true }            xml { onCheck = true }        }        filters {            excludes {                classes("*.generated.*", "*.config.*")            }        }        verify {            rule {                minBound(80) // Fallar el build por debajo del 80% de cobertura            }        }    }}
Comandos de Cobertura
bash
# Ejecutar pruebas con cobertura./gradlew koverHtmlReport
# Verificar umbrales de cobertura./gradlew koverVerify
# Reporte XML para CI./gradlew koverXmlReport
# Ver reporte HTML (usa el comando para tu SO)# macOS:   open build/reports/kover/html/index.html# Linux:   xdg-open build/reports/kover/html/index.html# Windows: start build/reports/kover/html/index.html
Objetivos de Cobertura
Tipo de CódigoObjetivo
Lógica de negocio crítica100%
APIs públicas90%+
Código general80%+
Código generado / configuraciónExcluir

Pruebas con Ktor testApplication

kotlin
class ApiRoutesTest : FunSpec({    test("GET /users returns list") {        testApplication {            application {                configureRouting()                configureSerialization()            }
            val response = client.get("/users")
            response.status shouldBe HttpStatusCode.OK            val users = response.body<List<UserResponse>>()            users.shouldNotBeEmpty()        }    }
    test("POST /users creates user") {        testApplication {            application {                configureRouting()                configureSerialization()            }
            val response = client.post("/users") {                contentType(ContentType.Application.Json)                setBody(CreateUserRequest("Alice", "[email protected]"))            }
            response.status shouldBe HttpStatusCode.Created        }    }})

Comandos de Prueba

bash
# Ejecutar todas las pruebas./gradlew test
# Ejecutar clase de prueba específica./gradlew test --tests "com.example.UserServiceTest"
# Ejecutar prueba específica./gradlew test --tests "com.example.UserServiceTest.getUser returns user when found"
# Ejecutar con salida detallada./gradlew test --info
# Ejecutar con cobertura./gradlew koverHtmlReport
# Ejecutar detekt (análisis estático)./gradlew detekt
# Ejecutar ktlint (verificación de formato)./gradlew ktlintCheck
# Pruebas continuas./gradlew test --continuous

Buenas Prácticas

HACER:

  • Escribir pruebas PRIMERO (TDD)
  • Usar los estilos de spec de Kotest de forma consistente en el proyecto
  • Usar coEvery/coVerify de MockK para funciones suspend
  • Usar runTest para pruebas de coroutines
  • Probar comportamiento, no implementación
  • Usar pruebas basadas en propiedades para funciones puras
  • Usar fixtures de data class para mayor claridad

NO HACER:

  • Mezclar frameworks de prueba (elegir Kotest y mantenerlo)
  • Mockear data classes (usar instancias reales)
  • Usar Thread.sleep() en pruebas de coroutines (usar advanceTimeBy)
  • Saltarse la fase ROJA en TDD
  • Probar funciones privadas directamente
  • Ignorar pruebas inestables (flaky tests)

Integración con CI/CD

yaml
# Ejemplo de GitHub Actionstest:  runs-on: ubuntu-latest  steps:    - uses: actions/checkout@v4    - uses: actions/setup-java@v4      with:        distribution: 'temurin'        java-version: '21'
    - name: Run tests with coverage      run: ./gradlew test koverXmlReport
    - name: Verify coverage      run: ./gradlew koverVerify
    - name: Upload coverage      uses: codecov/codecov-action@v5      with:        files: build/reports/kover/report.xml        token: ${{ secrets.CODECOV_TOKEN }}

Recuerda: Las pruebas son documentación. Muestran cómo debe usarse tu código Kotlin. Usa los matchers expresivos de Kotest para que las pruebas sean legibles y MockK para un mocking limpio de dependencias.

来源与署名

来源：affaan-m/ecc位于docs/es/skills/kotlin-testing提交ef648e0

许可证： 无许可证

内容归原作者所有。SourceWeft 从公开仓库中收录这些内容。

举报或申请下架

更多来自 affaan-m/ecc 的技能

Vue Patterns

affaan-m

Vue 3 Composition API、组件架构、Pinia 状态管理、Vue Router 与 Nuxt SSR 模式的参考指南。

Software Development275K3天前更新

Uncloud

affaan-m

使用 uc CLI 管理 Uncloud 集群的参考指南：部署服务、Caddy 入口、端口、扩缩容与日志。

DevOps & Cloud275K3天前更新

Team Agent Orchestration

affaan-m

以团队方式协调多个 AI 智能体，使用工作项、看板状态、分支隔离与合并门禁。

AI & Agents275K3天前更新

Tasteforge Video

affaan-m

Use for file-driven multimodal image, video, and 3D-asset discovery; taste interviews; distill or apply workflows; style-pack validation; editable EDL/FCPXML export; provenance audits; and offline planning that must fail closed before provider generation.

待分类275K3天前更新

Taste

affaan-m

为音乐视频和短视频剪辑定义 angelcore / cloud-trance / hyperpop 视觉方向，包含氛围、剪辑语法与按节拍映射的分镜方案。

Design & Creative275K3天前更新

Social Publisher

affaan-m

通过 SocialClaw 工作区 API 在 13 个平台上安排和发布社交媒体帖子。

Marketing & Sales275K3天前更新

更多Software Development技能

Playground

anthropics

精选

构建自包含的交互式 HTML 演练场，包含控件、实时预览和可复制的提示词输出。

Software Development37K今天更新

M5 Onboard

anthropics

精选

通过 USB 检测 M5Stack ESP32 开发板，刷写 UIFlow 2.0 固件并安装 MicroPython 应用包。

Software Development37K今天更新

Cardputer Buddy

anthropics

精选

指导迭代 Cardputer-Adv 的 MicroPython 应用包：添加应用、通过 USB 串口推送文件、查看日志并运行 REPL 命令。

Software Development37K今天更新

Testing Strategy

anthropics

精选

设计测试策略与测试计划，涵盖测试类型、覆盖率目标与示例测试用例。

Software Development27K今天更新

Tech Debt

anthropics

精选

识别、分类并排序技术债务，产出评分后的待办清单与分阶段整改计划。

Software Development27K今天更新

System Design

anthropics

精选

通过需求、高层设计、深入设计、扩展与权衡分析来指导系统与架构设计。

Software Development27K今天更新