Criando testes unitários com Kotest

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.

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 é uma biblioteca em Kotlin para criação de testes unitários. Pode ser usada com diferentes estilos de teste, o que dá uma grande flexibilidade.

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

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.

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

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")
}

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

tasks.withType<Test> {
    useJUnitPlatform()
}

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()
}

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

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.

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
  }
}

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

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

val calculadora = Calculadora()

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

class TestarCalculadora: StringSpec({

})

• 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" {

  }
})

• 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)
  }
})

• 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)
  }
})

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

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

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

Neste artigo você aplicou testes unitários com Kotest a uma calculadora. Busque aprender mais formas de criar testes e diferentes estilos para tornar esse conhecimento mais flexível , tem muito mais coisa pra explorar.