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.
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:
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.
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
}
}
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
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
StringSpecpoderemos 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çãoshouldBe, que recebe um argumento, e obriga o resultado de uma função ser esse argumento recebido. - Por exemplo, passamos á função
somaos valores10e20. Que irão resultar em30. Após isso, usamos a funçãoshouldBepara 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 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.
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.
Muito obrigada por ler ❤️🏳️⚧️ e me segue nas redes, é tudo @lissatransborda 👀
Top comments (0)