Padrões de Teste em Kotlin

Padrões abrangentes de teste em Kotlin para escrever testes confiáveis e de fácil manutenção, seguindo a metodologia TDD com Kotest e MockK.

Quando Usar

• Escrevendo novas funções ou classes em Kotlin
• Adicionando cobertura de testes a código Kotlin existente
• Implementando testes baseados em propriedades
• Seguindo o fluxo de trabalho TDD em projetos Kotlin
• Configurando o Kover para cobertura de código

Como Funciona

1. Identifique o código alvo — Encontre a função, classe ou módulo a ser testado
2. Escreva uma especificação Kotest — Escolha um estilo de especificação (StringSpec, FunSpec, BehaviorSpec) que corresponda ao escopo do teste
3. Simule dependências — Use MockK para isolar a unidade sob teste
4. Execute os testes (RED) — Verifique se o teste falha com o erro esperado
5. Implemente o código (GREEN) — Escreva o código mínimo para que o teste passe
6. Refatore — Melhore a implementação mantendo os testes verdes
7. Verifique a cobertura — Execute ./gradlew koverHtmlReport e verifique 80%+ de cobertura

Exemplos

As seções a seguir contêm exemplos detalhados e executáveis para cada padrão de teste:

Referência Rápida

• Especificações Kotest — Exemplos de StringSpec, FunSpec, BehaviorSpec, DescribeSpec em Estilos de Especificação Kotest
• Mocking — Configuração do MockK, mocking de corrotinas, captura de argumentos em MockK
• Demonstração TDD — Ciclo completo RED/GREEN/REFACTOR com EmailValidator em Fluxo de Trabalho TDD para Kotlin
• Cobertura — Configuração e comandos do Kover em Cobertura Kover
• Testes Ktor — Configuração do testApplication em Testes Ktor testApplication

Fluxo de Trabalho TDD para Kotlin

O Ciclo RED-GREEN-REFACTOR

RED     -> Write a failing test first
GREEN   -> Write minimal code to pass the test
REFACTOR -> Improve code while keeping tests green
REPEAT  -> Continue with next requirement

TDD Passo a Passo em Kotlin

// Step 1: Define the interface/signature
// EmailValidator.kt
package com.example.validator

fun validateEmail(email: String): Result<String> {
    TODO("not implemented")
}

// Step 2: Write failing test (RED)
// EmailValidatorTest.kt
package com.example.validator

import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.result.shouldBeFailure
import io.kotest.matchers.result.shouldBeSuccess

class EmailValidatorTest : StringSpec({
    "valid email returns success" {
        validateEmail("user@example.com").shouldBeSuccess("user@example.com")
    }

    "empty email returns failure" {
        validateEmail("").shouldBeFailure()
    }

    "email without @ returns failure" {
        validateEmail("userexample.com").shouldBeFailure()
    }
})

// Step 3: Run tests - verify FAIL
// $ ./gradlew test
// EmailValidatorTest > valid email returns success FAILED
//   kotlin.NotImplementedError: An operation is not implemented

// Step 4: Implement minimal code (GREEN)
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)
}

// Step 5: Run tests - verify PASS
// $ ./gradlew test
// EmailValidatorTest > valid email returns success PASSED
// EmailValidatorTest > empty email returns failure PASSED
// EmailValidatorTest > email without @ returns failure PASSED

// Step 6: Refactor if needed, verify tests still pass

Estilos de Especificação Kotest

StringSpec (Mais Simples)

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 (Semelhante ao JUnit)

class UserServiceTest : FunSpec({
    val repository = mockk<UserRepository>()
    val service = UserService(repository)

    test("getUser retorna o usuário quando encontrado") {
        val expected = User(id = "1", name = "Alice")
        coEvery { repository.findById("1") } returns expected

        val result = service.getUser("1")

        result shouldBe expected
    }

    test("getUser lança exceção quando não encontrado") {
        coEvery { repository.findById("999") } returns null


…