Kotlin Academy · Aula

Escrita de Testes com JUnit5

Estruture os testes

Escrita de Testes com JUnit5 é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

O que é o JUnit5?

JUnit5 (JUnit Jupiter) é a estrutura padrão de testes para a JVM e o Kotlin. Ela fornece anotações para marcar e estruturar o código de teste.

Os testes ficam em src/test/kotlin
Cada teste é uma função
O executor os executa e relata os resultados

Adicionando a dependência

Adicione o JUnit Jupiter à configuração de testes e habilite a plataforma JUnit.

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
}

tasks.test {
    useJUnitPlatform()
}

Seu primeiro teste

Anote uma função com @Test. Um teste verifica uma afirmação sobre o seu código.

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals

class MathTest {
    @Test
    fun addsTwoNumbers() {
        assertEquals(4, 2 + 2)
    }
}

Nomes de teste descritivos

Use @DisplayName para gerar relatórios de teste legíveis, sem nomes de função longos.

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.DisplayName

class OrderTest {
    @Test
    @DisplayName("total includes tax")
    fun totalWithTax() {
        // ...
    }
}

Configuração com @BeforeEach

@BeforeEach é executado antes de cada teste, sendo ideal para preparar dados novos. @AfterEach é executado depois de cada teste para fazer a limpeza.

import org.junit.jupiter.api.BeforeEach

class CartTest {
    private lateinit var cart: MutableList<String>
    @BeforeEach
    fun setUp() {
        cart = mutableListOf()
    }
}

Configuração no nível da classe

@BeforeAll e @AfterAll são executados uma vez para toda a classe. No Kotlin, eles precisam de um objeto companion com @JvmStatic (ou de um ciclo de vida por classe).

import org.junit.jupiter.api.BeforeAll

class DbTest {
    companion object {
        @BeforeAll
        @JvmStatic
        fun connect() {
            // open shared connection
        }
    }
}

Preparar-Executar-Verificar

Estruture cada teste em três fases claras:

Preparar — configure as entradas e o estado
Executar — invoque o código que está sendo testado
Verificar — confirme o resultado

Isso mantém os testes legíveis e focados.

Testes aninhados

@Nested agrupa testes relacionados, produzindo um relatório em formato de árvore que documenta o comportamento.

import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test

class StackTest {
    @Nested
    inner class WhenEmpty {
        @Test fun isEmpty() { /* ... */ }
    }
}

Testes parametrizados

Execute o mesmo teste com várias entradas usando @ParameterizedTest e uma fonte de valores.

import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.junit.jupiter.api.Assertions.assertTrue

class NumberTest {
    @ParameterizedTest
    @ValueSource(ints = [2, 4, 6])
    fun isEven(n: Int) {
        assertTrue(n % 2 == 0)
    }
}

Desativação e marcação

Pule temporariamente um teste com @Disabled e agrupe testes com @Tag, para incluí-los ou excluí-los nas execuções de CI.

import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

class FlakyTest {
    @Test
    @Disabled("fix later")
    @Tag("slow")
    fun pending() { }
}

Um exemplo autocontido

Veja uma função simples escrita exclusivamente em Kotlin e a ideia por trás de testá-la (o teste em si é executado pelo JUnit).

fun add(a: Int, b: Int): Int = a + b

fun main() {
    val result = add(2, 3)
    println(if (result == 5) "PASS" else "FAIL")
}

Verificação rápida

Você precisa de uma lista nova e vazia antes de cada método de teste. Qual anotação é adequada?

Recapitulação

Você pode estruturar testes do JUnit5:

@Test marca os testes e @DisplayName dá nome a eles
@BeforeEach / @BeforeAll cuidam da configuração inicial
Preparar-Executar-Verificar mantém os testes claros
@Nested e @ParameterizedTest organizam e ampliam os testes

A seguir: asserções.

Perguntas Frequentes

A aula “Escrita de Testes com JUnit5” é grátis?

Sim — o texto completo de “Escrita de Testes com JUnit5” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Escrita de Testes com JUnit5”?

Estruture os testes Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Escrita de Testes com JUnit5”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy