Se você ainda não conhece, Testify é um conjunto de ferramentas para nos auxiliar na hora de escrever testes e mocks.

Por ser uma “casquinha” feita em cima dos próprios testes do Go, a utilização desse package não deve causar grandes problemas.

Na data em que escrevo esse post, o Testify é dividido em 4 packages:

• Assert (github.com/stretchr/testify/assert): Fornece funções para ajudar na escrita/validação dos testes.
• Require (github.com/stretchr/testify/require): Fornece as mesmas funções que o assert. A diferença é que ao invés de retornar um boolean, ao encontrar um erro, ele para os testes com um FailNow.
• Mock (github.com/stretchr/testify/mock): Fornece um mecanismo para facilitar a escrita de mocks.
• Suite (github.com/stretchr/testify/suite): Fornece funcionalidades para que você possa criar os testes utilizando uma abordagem de orientação a objetos, com métodos setup e teardown acoplados a sua struct.

Para começar, considerando o código abaixo, vamos ver como o package assert pode nos ajudar.

package soma

func Soma(valores ...int) (total int) {
	for _, valor := range valores {
		total += valor
	}

	return
}

Agora vamos escrever um pequeno teste para essa função.

package soma_test

import (
	"testing"

	"github.com/aprendagolang/soma"
	"github.com/stretchr/testify/assert"
)

func TestSoma(t *testing.T) {
	comNill := make([]int, 3)
	comNill[0] = 10
	comNill[1] = 10

	testes := []struct {
		Valores   []int
		Resultado int
	}{
		{Valores: []int{1, 2, 3}, Resultado: 6},
		{Valores: []int{1, 2, 3, 4}, Resultado: 10},
		{Valores: []int{3, 3, 3, 3}, Resultado: 12},
		{Valores: []int{1, 1, 1, 1}, Resultado: 4},
		{Valores: []int{12, 20, 35}, Resultado: 67},
		{Valores: []int{19, 21, 32}, Resultado: 72},
		{Valores: comNill, Resultado: 20},
	}

	for _, teste := range testes {
		total := soma.Soma(teste.Valores...)

		assert.Equal(t, total, teste.Resultado, "Valor esperado: %d - Valor retornado: %d", teste.Resultado, total)
	}
}

Para executar o teste, só precisamos executar o comando go test ./... como faríamos normalmente.

ok      github.com/aprendagolang/soma   0.230s

Ok, os testes passaram. Mas será que muda algo no output do teste quando eles não passam?

Para verificar isso, vamos modificar o “Resultado” 72 para 71 e executar o teste novamente.

--- FAIL: TestSoma (0.00s)
    soma_test.go:30: 
                Error Trace:    [OMITIDO]/soma_test.go:30
                Error:          Not equal: 
                                expected: 72
                                actual  : 71
                Test:           TestSoma
                Messages:       Valor esperado: 71 - Valor retornado: 72
FAIL
FAIL    github.com/aprendagolang/soma   0.625s
FAIL

Bacana as informações que ele traz, não?!

E se você está pensando… “Pô, vou adicionar uma dependência só para substituir um == por uma função?”

Com base nesse primeiro exemplo pode até parecer isso, mas garanto que não é só.

Quer ver?! Considere a seguinte função SUPER complexa escrita abaixo.

package soma

func JustPanic(b bool) {
	if b {
		panic("Fire!!! Fire!!! Fire!!!")
	}
}

Escrever testes para possíveis panic ou erros mais complexos podem tomar bastante tempo. No entanto, se você estiver utilizando o Testify, a complexidade é tão grande quanto…

package soma_test

import (
	"testing"

	"github.com/aprendagolang/soma"
	"github.com/stretchr/testify/assert"
)

func TestJustPanic(t *testing.T) {
	assert := assert.New(t)

	assert.Panics(func() { soma.JustPanic(true) })
	assert.NotPanics(func() { soma.JustPanic(false) })
}

Isso deixa os testes muito mais simples de serem escritos, assim como fáceis de entender.

Por ter uma API muitooooo extensa, te convido dar uma olhada na documentação para conhecer todas as validações em que o Testify pode ajudar.

Para esse post não ficar muito extenso, vou fazer mais dois outros posts para mostrar como utilizar o package mock e o suite.

Então se inscreva na nossa newsletter para receber a notificação assim que o post sair.

Até a próxima!

Se inscreva na nossa newsletter