Criando testes unitários com Kotest
Tags: kotlin, kotest, backend, braziliandevs
Published: 2021-11-08 03:58:54

## Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade [Kotlinautas](https://twitter.com/kotlinautas/), uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

![capa Kotlinautas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jreawpvk6whxigcpmctf.png)

## 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](https://kotest.io/) é 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](https://www.jetbrains.com/idea/) instalado na máquina e um conhecimento básico sobre a linguagem [Kotlin](https://kotlinlang.org/).

## 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](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tnv7k22iwi30d5odbycg.png)

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:

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

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

```kotlin
tasks.withType<Test> {
    useJUnitPlatform()
}
```

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

```kotlin
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.

![Elefante do Gradle no canto superior direito](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/805k86ksktoakp3rqr17.png)

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:

```kotlin
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:

```kotlin
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`:

```kotlin
val calculadora = Calculadora()
```

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

```kotlin
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:

```kotlin
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:

```kotlin
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:

```kotlin
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.

![Tarefa do Kotest](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3y5edqfdleobbtes35eo.png)

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

![Resultados do Kotest](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/29kczl9k8or5f7y6lg6n.png)

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](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7mvuvcr0o98ovkyxqux5.png)

## Finalização

Neste artigo você aplicou testes unitários com [Kotest](https://kotest.io/) á 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](https://twitter.com/lissatransborda) 👀