DEV Community

Cover image for Criando testes unitários com Kotest
Lissa Ferreira for Kotlinautas

Posted on

Criando testes unitários com Kotest

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

capa Kotlinautas

Teste Unitário

Teste unitário é um tipo de teste onde cada componente do software pode ser testado separadamente. Com isso, cada parte do sistema será isolada, dando a garantia que está funcionando como o esperado.

Kotest

Kotest é uma biblioteca em Kotlin para a criação de testes unitários. Kotest pode ser usado com diferentes estilos de teste, permitindo uma grandle flexibilidade.

Materiais

Será necessário ter o IntelliJ instalado na máquina e um conhecimento básico sobre a linguagem Kotlin.

O quê vamos criar?

Vamos criar uma classe Calculadora, que terá quatro funções, sendo Soma, Subtração, Multiplicação e Divisão. Cada uma dessas funções representa uma operação matemática.

Iremos criar um teste unitário para essa classe, testando cada operação separadamente usando a Kotest.

Criando o projeto

Abra seu IntelliJ no menu inicial e clique em New Project:

botão New Project no menu inicial do IntelliJ

Depois, selecione a opção Kotlin DSL build script, selecione também a opção Kotlin/JVM, e opicionalmente remova a primeira opção Java. Essa opção não vai mudar em nada, pois ela dá suporte do Gradle á linguagem Java, mas apenas iremos usar Kotlin.

Após isso, clique em Next e escreva o nome do projeto e a localização na sua máquina. Essas duas opção são completamente pessoais, caso não tenha nenhuma ideia, coloque algo como kotest apenas como identificação.

Agora, com o projeto aberto, vá ao aquivo build.gradle.kts e adicione a dependência testImplementation("io.kotlintest:kotlintest-runner-junit5:3.1.7"), com a seção dependencies ficando assim:

dependencies {
    implementation(kotlin("stdlib"))
    testImplementation("io.kotlintest:kotlintest-runner-junit5:3.1.7")
}
Enter fullscreen mode Exit fullscreen mode

Também adicione uma modificação ás Tasks do Gradle:

tasks.withType<Test> {
    useJUnitPlatform()
}
Enter fullscreen mode Exit fullscreen mode

Ao final, nosso arquivo build.gradle.kts ficará assim:

plugins {
    java
    kotlin("jvm") version "1.5.30"
}

group = "org.example"
version = "1.0-SNAPSHOT"

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    testImplementation("io.kotlintest:kotlintest-runner-junit5:3.1.7")
}

tasks.withType<Test> {
    useJUnitPlatform()
}
Enter fullscreen mode Exit fullscreen mode

Agora, clique no elefante no canto superior direito para carregar as alterações no Gradle.

Elefante do Gradle no canto superior direito

Após isso, poderemos começar a programar. Você pode criar um arquivo em src/main/kotlin/ chamado main.kt para ser o arquivo principal da aplicação.

Criando a classe Calculadora

Vamos criar um arquivo em src/main/kotlin/Calculadora.kt que irá armazenar uma classe Calculadora com alguns métodos que representam operações matemáticas:

class Calculadora {
    fun soma(x: Int, y: Int): Int {
        return x + y
    }

    fun subtração(x: Int, y: Int): Int {
        return x - y
    }

    fun multiplicação(x: Int, y: Int): Int {
        return x * y
    }

    fun divisão(x: Int, y: Int): Int {
        return x / y
    }
}
Enter fullscreen mode Exit fullscreen mode

Criando testes

Agora vamos criar uma pasta chamado src/main/tests/ e um arquivo calculadora.kt dentro dessa pasta.

Essa pasta irá guardar todos os testes unitários do nosso projeto, e será usada pela Kotest para ver quais são os testes disponíveis.

Primeiro, vamos importar a kotest ao nosso arquivo:

import io.kotlintest.shouldBe
import io.kotlintest.specs.StringSpec
Enter fullscreen mode Exit fullscreen mode

Após isso, vamos criar uma variável chamada calculadora que irá armazenar uma instância da nossa classe Calculadora:

val calculadora = Calculadora()
Enter fullscreen mode Exit fullscreen mode

Vamos criar uma classe chamada TestarCalculadora, que irá armazenar os testes unitários da classe Calculadora:

class TestarCalculadora: StringSpec({

})
Enter fullscreen mode Exit fullscreen mode
  • Nesse estilo StringSpec poderemos inserir um teste usando um texto que irá definir esse teste, aumentando a semântica.

Vamos adicionar o primeiro teste que será sobre a função soma, primeiro, vamos colocar o texto do teste:

class TestarCalculadora: StringSpec({
    "Testar soma da calculadora" {

    }
})
Enter fullscreen mode Exit fullscreen mode
  • Podemos abrir um bloco para esse teste usando o texto que define o teste, seguido por {}

Após isso, podemos inserir os testes dessa maneira:

class TestarCalculadora: StringSpec({
    "Testar soma da calculadora" {
        calculadora.soma(10, 20).shouldBe(30)
        calculadora.soma(20, 20).shouldBe(40)
        calculadora.soma(50, 40).shouldBe(90)
    }
})
Enter fullscreen mode Exit fullscreen mode
  • Usamos a função soma, passando os números, e após isso podemos usar a função shouldBe, que recebe um argumento, e obriga o resultado de uma função ser esse argumento recebido.
  • Por exemplo, passamos á função soma os valores 10 e 20. Que irão resultar em 30. Após isso, usamos a função shouldBe para garantir que esse valor será 30.

Após isso, podemos repetir o mesmo processo para as outras operações, sempre criando um novo teste:

class TestarCalculadora: StringSpec({
    "Testar soma da calculadora" {
        calculadora.soma(10, 20).shouldBe(30)
        calculadora.soma(20, 20).shouldBe(40)
        calculadora.soma(50, 40).shouldBe(90)
    }

    "Testar substração da calculadora" {
        calculadora.subtração(10, 20).shouldBe(-10)
        calculadora.subtração(20, 20).shouldBe(0)
        calculadora.subtração(30, 10).shouldBe(20)
    }

    "Testar multiplicação da calculadora" {
        calculadora.multiplicação(2, 5).shouldBe(10)
        calculadora.multiplicação(5, 5).shouldBe(25)
        calculadora.multiplicação(10, 7).shouldBe(70)
    }

    "Testar divisão da calculadora" {
        calculadora.divisão(10, 2).shouldBe(5)
        calculadora.divisão(30, 3).shouldBe(10)
        calculadora.divisão(60, 5).shouldBe(12)
    }
})
Enter fullscreen mode Exit fullscreen mode

Agora você pode clicar no menu do Gradle ao lado da tela, clique em Run Configurations e em kotest [test] para rodar os testes.

Tarefa do Kotest

Com isso todos os testes irão passar e a classe Calculadora estará testada.

Resultados do Kotest

Agora tente modificar algum teste intencionalmente para modificar o resultado e rode os teste novamente. Com isso, os testes resultarão em um erro, mostrando que a classe Calculadora está sendo implementada de maneira incorreta segundo essa nova versão dos testes.

Resultados do Kotest com erro

Finalização

Neste artigo você aplicou testes unitários com Kotest á uma calculadora. Busque aprender mais maneira de criar testes e diferentes estilos de testes para tornar esse conhecimento mais flexível.

Obrigado por ler 💙

Discussion (0)