AWS Builder Center

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 esperado
Isso 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ório
Título com tamanho máximo
Prioridade válida
Status válido
Descrição com tamanho máximo
Poderí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:
name
title
wantErr
Ou seja:
Qual é o nome do teste?

Qual entrada vou enviar?

Eu espero um erro?
Depois percorremos os cenários com:
for _, tt := range tests
E 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ítulo
eu não deveria precisar subir:
PostgreSQL
Docker
Servidor HTTP
Gin
Redis
A regra existe independente dessas tecnologias.
Pensa em uma API mais ou menos assim:
Request HTTP
Handler
Use Case
Domain
Repository
Banco
Se 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 duplicado
Isso é 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.T
t.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.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article