Testes unitários: como parar de testar código e começar a testar comportamento
Aprenda a pensar em testes unitários além da sintaxe. Neste artigo, uso Go para explicar casos de sucesso e erro, Table Driven Tests, TDD e como testar regras de negócio com uma visão voltada para Engenheiro de Software
Hoje, com inteligência artificial gerando código cada vez mais rápido, saber testar deixou de ser apenas uma boa prática e passou a ser uma habilidade muito importante para quem trabalha com desenvolvimento.
A IA consegue gerar uma função, criar uma API e até montar boa parte de uma feature em poucos segundos. Mas existe uma diferença enorme entre um código que compila e um código que realmente faz o que deveria fazer.
E é justamente aí que entram os testes.
Nesse artigo vou utilizar Go nos exemplos, mas quero deixar uma coisa clara desde o início: os conceitos que vamos ver aqui não pertencem ao Go. Você pode trabalhar com Java, Python, C#, JavaScript ou qualquer outra linguagem. A sintaxe muda, mas a forma de pensar continua praticamente a mesma.
A ideia não é decorar
testing.T .A ideia é aprender a responder uma pergunta:
Qual comportamento do meu sistema eu preciso garantir?
Antes de testar, entenda o que você está tentando proteger
Quando comecei a estudar testes, uma das coisas que mais confundia era pensar que teste unitário servia simplesmente para testar uma função.
Por exemplo:
func Soma(a, b int) int { return a + b} Por exemplo, para uma função de soma, um teste simples seria:
func TestSoma(t *testing.T) { resultado := Soma(2, 3)
if resultado != 5 { t.Errorf("esperava 5, recebeu %d", resultado) }}E isso está certo. A gente passou uma entrada, executou a função e verificou se o resultado recebido era o mesmo que esperávamos. Mas quando levamos esse pensamento como um engenheiro de software, fica muito mais interessante.
No nosso dia a dia, normalmente não queremos proteger apenas contas matemáticas.
Queremos proteger regras do sistema.
Pensando como um Engenheiro de Software
Vamos imaginar que estamos desenvolvendo um sistema de tarefas.
Temos uma
struct representando nossa tarefa e uma função para criar novas tasks e a regra para essa função é o título não ser vazio:type Task struct { Title string}
func NewTask(title string) (*Task, error) { if title == "" { return nil, errors.New("o título não pode ser vazio") } return &Task{Title: title}, nil}Antes de escrever qualquer teste, eu gosto de pensar em pelo menos dois cenários.
Caso de sucesso: Entrada
title = "Aprender Go" . Resultado esperado: uma Task válida e erro nil .Caso de erro: Entrada
title = "" . Resultado esperado: Task nula e um erro informando que o título é obrigatório.Percebe que antes mesmo de escrever o teste, já estamos pensando sobre o comportamento da aplicação?
Essa é uma parte muito importante.
Teste não deveria começar no código.
Teste deveria começar na regra.
Testando o caso de sucesso
Podemos escrever:
func TestNewTask(t *testing.T) { task, err := NewTask("Estudar Go")
if err != nil { t.Fatalf("não esperava erro: %v", err) }
if task == nil { t.Fatal("esperava uma task válida") }
if task.Title != "Estudar Go" { t.Errorf("título incorreto") }}Aqui estamos testando o chamado happy path.
Ou seja, o caminho onde tudo acontece como esperado.
Mas em backend, o happy path é apenas uma parte do problema.
Também precisamos pensar:
- E se o usuário mandar um dado vazio?
- E se aquele usuário não existir?
- E se o email já estiver cadastrado?
- E se o saldo for insuficiente?
- E se o usuário não tiver permissão?
- E se uma dependência falhar?
Um backend precisa saber lidar com aquilo que funciona e principalmente com aquilo que pode dar errado.
Testando um caso de erro
Nossa regra diz que uma task não pode existir sem título.
Então precisamos garantir isso.
func TestNewTaskSemTitulo(t *testing.T) { task, err := NewTask("")
if err == nil { t.Fatal("esperava um erro") }
if task != nil { t.Fatal("esperava task nil") }}Esse teste está dizendo algo muito importante sobre o nosso sistema:
Se existe título, posso criar uma task.
Se não existe título, a task não deve ser criada.E aqui aparece uma das coisas que mais gosto em testes.
Um bom teste também serve como documentação.
Uma pessoa que entrar no projeto depois pode olhar para esse teste e entender parte das regras do sistema sem precisar descobrir tudo lendo a implementação.
O que realmente estamos testando
Uma forma simples de pensar em um teste é:
Tenho uma regra
Defino uma entrada
Executo o comportamento
Recebo um resultado
Comparo com o resultado esperadoIsso funciona em praticamente qualquer linguagem.
Em Java você vai ter uma sintaxe.
Em Python outra.
Em Go estamos usando o pacote
testing .Mas o raciocínio continua sendo o mesmo.
Quando aparecem muitos cenários
Agora imagina que nossa
Task tenha várias regras.Título obrigatórioTítulo com tamanho máximoPrioridade válidaStatus válidoDescrição com tamanho máximoPoderíamos criar uma função de teste para cada caso, mas em Go existe um padrão muito utilizado chamado Table Driven Tests.
O nome parece mais complicado do que realmente é.
Basicamente criamos uma tabela com vários cenários e executamos todos utilizando a mesma estrutura de teste.
func TestNewTask(t *testing.T) { tests := []struct { name string title string wantErr bool }{ { name: "cria task válida", title: "Estudar Go", wantErr: false, }, { name: "título vazio retorna erro", title: "", wantErr: true, }, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { task, err := NewTask(tt.title)
if tt.wantErr { if err == nil { t.Fatal("esperava erro") }
if task != nil { t.Fatal("esperava task nil") }
return }
if err != nil { t.Fatalf("não esperava erro: %v", err) }
if task == nil { t.Fatal("esperava task válida") } }) }}O que fizemos aqui foi criar uma lista de cenários.
Cada item possui:
nametitlewantErrOu seja:
Qual é o nome do teste?
Qual entrada vou enviar?
Eu espero um erro?Depois percorremos os cenários com:
for _, tt := range testsE usamos:
t.Run()para executar cada um como um subteste.
A grande vantagem é que se surgir uma nova regra, conseguimos adicionar outro caso sem repetir toda a estrutura.
Testar não significa testar tudo
Esse também é um ponto importante. Um teste unitário não precisa subir sua aplicação inteira.
Se queremos testar a regra:
Task não pode existir sem títuloeu não deveria precisar subir:
PostgreSQLDockerServidor HTTPGinRedisA regra existe independente dessas tecnologias.
Pensa em uma API mais ou menos assim:
Request HTTPHandlerUse CaseDomainRepositoryBancoSe a regra pertence ao domínio ou ao caso de uso, eu quero conseguir testar aquela regra isoladamente. Isso deixa os testes mais rápidos e também deixa nosso código menos dependente de framework.
Hoje sua aplicação pode usar Gin.
Amanhã pode usar
net/http .Mas a regra continua sendo:
Uma task precisa ter título.Framework muda.
Regra de negócio não deveria mudar por causa disso.
E onde entra o TDD?
Talvez você já tenha ouvido falar em TDD.
TDD significa Test Driven Development.
A ideia é escrever o teste antes da implementação.
O ciclo normalmente é dividido em três etapas:

RED
Primeiro escrevemos um teste para um comportamento que queremos criar.
Como aquele comportamento ainda não existe, o teste falha.
GREEN
Depois implementamos o mínimo necessário para fazer aquele teste passar.
REFACTOR
Quando o teste está passando, podemos melhorar o código com mais segurança. Podemos reorganizar, melhorar nomes ou remover duplicações.
Depois rodamos os testes novamente. Se continuam passando, temos uma evidência clara de que a refatoração não quebrou nada e o comportamento anterior continua garantido.
TDD não precisa virar religião
Também acho importante falar isso. Você não precisa utilizar TDD em absolutamente tudo, TDD é uma ferramenta.
Existem situações onde faz bastante sentido definir primeiro o comportamento esperado.
Por exemplo:
Email vazio deve retornar erro.
Usuário duplicado não pode ser criado.
Saldo insuficiente deve impedir uma transferência.
Usuário sem permissão não pode acessar determinado recurso.Nesses casos, conseguimos escrever o contrato antes da implementação.
Mas mais importante do que falar que usa TDD é entender por que aquele teste existe.
Testes como contratos do sistema
Essa é provavelmente a forma que mais gosto de pensar sobre testes. Um teste representa um contrato.
Imagine uma funcionalidade de criação de usuário.
Temos as regras:
Nome é obrigatório.
Email é obrigatório.
Email precisa ser válido.
Não pode existir outro usuário com o mesmo email.Naturalmente começamos a enxergar alguns cenários:
Usuário válido
Nome vazio
Email vazio
Email inválido
Email duplicadoIsso é muito mais interessante do que simplesmente pensar:
Preciso testar a função CreateUser.A pergunta passa a ser:
Quais comportamentos o CreateUser precisa garantir?
Essa pequena mudança de pensamento faz muita diferença.
E com IA isso fica ainda mais importante
Hoje uma IA consegue gerar uma função assim em segundos:
func NewTask(title string) *Task { return &Task{ Title: title, }}O código compila e a função funciona. Mas existe um problema: ela permite criar uma
Task com o título totalmente vazio ( title = "" ), sem retornar nenhum erro ou validação.Se a nossa regra diz que uma task sem título não pode existir, esse código está incorreto. Mesmo compilando. Mesmo parecendo perfeito à primeira vista.
Por isso gosto de separar duas coisas: sintaxe válida e comportamento correto.
Saber escrever o código correto é apenas metade do trabalho. A IA pode acelerar drasticamente a nossa velocidade de desenvolvimento na hora de gerar sintaxe, mas a responsabilidade de definir regras, mapear cenários de falha e garantir o comportamento do sistema continua sendo do engenheiro de software.
E os testes são a principal ferramenta para garantir esse contrato.
O que eu quero que você leve desse artigo
Se você está começando a estudar testes, não tente decorar todas as funções do pacote
testing primeiro.Comece pensando:
Qual é a regra?
Qual é o caso de sucesso?
O que pode dar errado?
Qual entrada representa esse cenário?
Qual resultado eu espero?
Como eu consigo garantir isso automaticamente?Depois você aprende a ferramenta da linguagem.
Em Go, por exemplo, vai encontrar coisas como:
testing.Tt.Run()t.Error()t.Fatal()Vai encontrar Table Driven Tests.
Vai conhecer mocks, stubs, testes de integração e outras estratégias.
Mas tudo isso vem depois.
O mais importante é entender que testar não é simplesmente escrever um arquivo
_test.go .Testar é aprender a transformar regras e comportamentos do sistema em algo que conseguimos verificar automaticamente.
Os exemplos aqui foram feitos em Go porque é a linguagem que mais estou utilizando no momento.
Mas esse pensamento você pode levar para qualquer stack.
No final, linguagem muda, framework muda e banco muda.
A capacidade de entender o comportamento do sistema e garantir que ele continue funcionando é o que realmente importa para quem quer evoluir em Engenheiro de Software.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article