Testes de backend e design simples
Escrever testes que pegam bugs de verdade, combinar unidade, integração e contrato, e separar a regra de negócio do HTTP.
Cerca de 15 min · Revisado em
Ao final, você vai conseguir
- Escrever testes no formato organizar, agir, verificar que detectam um bug
- Classificar testes em unidade, integração, contrato e ponta a ponta
- Usar fakes e espiões para isolar dependências externas
- Separar a regra de negócio da rota HTTP para torná-la testável
- Rodar uma suíte com pytest e interpretar uma falha
Imagine mudar uma linha no cálculo de reembolso numa sexta-feira e, na segunda, descobrir que metade das pessoas recebeu valor em dobro. No backend, um erro não quebra só uma tela: ele grava dados errados, cobra a mais e se espalha para todo sistema que usa a API. Testes automatizados são a rede de segurança que deixa você mudar o código sem medo, e saber escrevê-los é uma das primeiras coisas que se espera de quem entra num time.
Uma rede de segurança para as regras
Um teste é um pedaço de código que chama o seu código com uma entrada conhecida e compara o resultado com o esperado. Se bater, passa; se não bater, falha e mostra a diferença. Você escreve uma vez e ele roda milhares de vezes, sem cansar.
O valor maior aparece depois. Quando alguém muda o código e quebra algo que funcionava, acontece uma regressão. A suíte de testes avisa em segundos, antes de o problema chegar a quem usa.
Qual é o principal ganho de ter testes automatizados no backend?
- Provar que o sistema não tem nenhum bug
- Avisar rapidamente quando uma mudança quebra algo que funcionava
- Dispensar a revisão de código por outras pessoas
Organizar, agir, verificar
Quase todo teste tem três partes, nesta ordem. Organizar: preparar os dados de entrada. Agir: chamar a função testada, uma vez. Verificar: conferir o resultado. Em inglês, arrange, act, assert.
Um teste com pytest, o framework de testes mais usado em Python
def test_transporte_tem_teto_de_200_reais():
valor, categoria, dias = 350, "transporte", 3
reembolso = calcular_reembolso(valor, categoria, dias)
assert reembolso == 200- Nome que conta a regra: O pytest roda toda função que começa com
test_. Um bom nome descreve a regra: quando falhar, você já sabe o que quebrou sem abrir o arquivo. - Organizar: Os dados do cenário. Valores concretos e pequenos, escolhidos para exercitar a regra: 350 está acima do teto de 200.
- Agir: Uma única chamada ao que está sendo testado.
- Verificar:
asserté uma palavra do próprio Python: se a condição for falsa, ele lança um erro e o teste falha. O pytest mostra os dois valores lado a lado.
Os melhores casos de teste ficam nas bordas: zero, um, o limite exato, valores que não dividem certinho. É onde moram os bugs. Um teste que só usa números redondos passa até em código errado, como você vai ver agora.
Escreva um teste que pegue o bug
Existem duas versões de dividir_conta, que racha uma conta entre pessoas (valores em centavos). Uma está certa; a outra perde centavos. O teste atual usa 4 pessoas e R$ 100,00, que divide certinho, então as duas passam. Acrescente em testar o caso de 3 pessoas: verifique que a soma das partes é igual ao total e que nenhuma parte difere da outra em mais de 1 centavo.
def dividir_conta(total_centavos, pessoas):
"""Divide uma conta em partes que somam exatamente o total."""
base, resto = divmod(total_centavos, pessoas)
return [base + 1 if i < resto else base for i in range(pessoas)]
def dividir_conta_com_bug(total_centavos, pessoas):
return [total_centavos // pessoas] * pessoas
def testar(dividir):
# Organizar
total = 10000 # R$ 100,00 em centavos
# Agir
partes = dividir(total, 4)
# Verificar
assert partes == [2500, 2500, 2500, 2500]
# Escreva aqui o caso de 3 pessoas
# ---- Não altere daqui para baixo: roda o seu teste nas duas versões ----
def passa(funcao):
try:
testar(funcao)
return True
except AssertionError:
return False
passa_na_versao_certa = passa(dividir_conta)
pega_o_bug = not passa(dividir_conta_com_bug)
print('A versão certa passa no teste:', passa_na_versao_certa)
print('O teste pega a versão com bug:', pega_o_bug)- O teste passa na versão certa
- O teste falha na versão com bug
Unidade, integração e contrato
Nem todo teste olha o mesmo tamanho de pedaço. Um backend saudável combina vários tipos, em quantidades diferentes, desenhando uma pirâmide.
A pirâmide de testes de um backend
- Ponta a ponta: Poucos. Uma jornada completa, do navegador ao banco. Mostram que tudo se encaixa, mas são lentos e difíceis de depurar.
- Integração e contrato: Alguns. Rotas HTTP com banco de teste real, migrações, e se as respostas seguem o contrato documentado.
- Unidade: Muitos. Funções de regra de negócio isoladas, sem rede nem banco. Rodam aos milhares em segundos.
- Teste de unidade
- Testa uma função ou classe sozinha, como
calcular_reembolso. Não acessa banco, rede nem arquivos. - Teste de integração
- Testa peças reais trabalhando juntas: a rota recebendo HTTP, o repositório gravando num banco de teste.
- Teste de contrato
- Confere se as respostas seguem o formato combinado, como o OpenAPI: campos, tipos e status. Protege quem consome a API.
Os mesmos tipos de teste, num projeto com FastAPI e pytest
Unidade
def test_mercado_nao_tem_reembolso():
assert calcular_reembolso(80, "mercado", dias_desde_a_compra=2) == 0Integração com banco
@pytest.fixture
def repo():
conexao = conectar(os.environ["DATABASE_URL_TESTE"])
conexao.execute("BEGIN")
yield RepositorioDespesas(conexao)
conexao.execute("ROLLBACK") # cada teste começa com o banco limpo
def test_lista_so_despesas_da_pessoa(repo):
repo.salvar(usuario_id=1, descricao="Feira", valor=52.3)
repo.salvar(usuario_id=2, descricao="Aluguel", valor=1500)
despesas = repo.listar_do_usuario(1)
assert [d.descricao for d in despesas] == ["Feira"]Rota HTTP
def test_post_com_valor_negativo_devolve_400(cliente):
resposta = cliente.post("/despesas", json={"descricao": "Feira", "valor": -5})
assert resposta.status_code == 400
assert resposta.json()["detalhes"][0]["campo"] == "valor"Repare na fixture repo: ela abre uma transação antes do teste e desfaz no fim, como você viu na aula de banco. Assim os testes têm dados isolados: um não depende do que o outro gravou, e podem rodar em qualquer ordem. Em JavaScript, o mesmo papel é feito por Vitest ou Jest com Supertest; em Java, por JUnit com Spring Boot Test.
Que tipo de teste é cada um?
Unidade · Integração · Contrato · Ponta a ponta
calcular_reembolso(350, "transporte", 3)devolve 200dividir_contanunca perde centavos- O repositório grava e lê despesas num PostgreSQL de teste
- A migração mais recente aplica e desfaz num banco vazio
- Toda resposta de
GET /despesas/{id}tem os campos e tipos do OpenAPI - A versão nova da API continua aceita pelo app que já está publicado
- Uma pessoa entra pelo navegador, cadastra uma despesa e a vê na lista
Dublês: quando o teste não pode chamar o mundo real
- Stub
- Devolve uma resposta pronta. Por exemplo, uma função de cotação do dólar que sempre responde
5.40. - Fake
- Uma versão simples que funciona de verdade, como um repositório que guarda as despesas numa lista em memória em vez do banco.
- Mock ou espião
- Anota como foi chamado, para o teste conferir depois: "o aviso foi enviado uma vez, com esta mensagem?".
Para trocar uma peça por um dublê, o código precisa receber a peça em vez de criá-la por dentro. Veja a função abaixo: ela recebe o repositório e a função de aviso como parâmetros. Em produção, você passa os reais; no teste, os dublês.
Construa um fake e um espião
Complete os dublês. RepositorioFalso.salvar deve guardar a despesa em self.itens e devolver o id, que é a posição dela começando em 1. avisar_falso deve, em vez de mandar um e-mail, anotar a mensagem na lista avisos. O teste no fim do código já usa os dois.
# Código de produção (não altere)
LIMITE_ALERTA = 500
def registrar_despesa(dados, repositorio, avisar):
despesa = {'descricao': dados['descricao'], 'valor': dados['valor']}
novo_id = repositorio.salvar(despesa)
if dados['valor'] > LIMITE_ALERTA:
avisar(f"Despesa alta: {dados['descricao']} de R$ {dados['valor']}")
return {'id': novo_id, **despesa}
# Dublês para o teste: complete os dois
class RepositorioFalso:
def __init__(self):
self.itens = []
def salvar(self, despesa):
pass
avisos = []
def avisar_falso(mensagem):
pass
# O teste (não altere)
repo = RepositorioFalso()
primeira = registrar_despesa({'descricao': 'Feira', 'valor': 52.3}, repo, avisar_falso)
segunda = registrar_despesa({'descricao': 'Notebook', 'valor': 3200}, repo, avisar_falso)
print('Salvas:', repo.itens)
print('Avisos:', avisos)
print('Ids:', primeira['id'], segunda['id'])- O repositório falso guardou as duas despesas
- Os ids devolvidos são 1 e 2
- Só a despesa acima do limite gerou aviso
Um time trocou o banco por dublês em todos os testes, inclusive nos de rota. A suíte passa, mas uma consulta com erro de SQL chegou à produção. Por quê?
- Porque dublês nunca deveriam ser usados em testes
- Porque nenhum teste executou o SQL de verdade contra um banco
- Porque a suíte deveria ter rodado mais vezes
Design simples: a regra longe do HTTP
Código difícil de testar costuma ser código que faz coisas demais no mesmo lugar. Quando a rota lê a requisição, consulta o banco, calcula a regra e monta a resposta numa função só, testar a regra exige subir servidor e banco.
A mesma rota de reembolso antes e depois de separar as responsabilidades
Antes: tudo junto
@app.post("/despesas/{id}/reembolso")
def pedir_reembolso(id: int):
linha = banco.execute(
"SELECT valor, categoria, data FROM despesas WHERE id = %s", (id,)
).fetchone()
if linha is None:
raise HTTPException(status_code=404)
valor, categoria, data = linha
if (date.today() - data).days > 30 or categoria == "mercado":
reembolso = 0
elif categoria == "transporte":
reembolso = min(valor, 200)
else:
reembolso = valor * 0.5
banco.execute("INSERT INTO reembolsos VALUES (%s, %s)", (id, reembolso))
return {"reembolso": reembolso}Depois: regras.py
def calcular_reembolso(valor, categoria, dias_desde_a_compra):
if dias_desde_a_compra > 30 or categoria == "mercado":
return 0
if categoria == "transporte":
return min(valor, 200)
return valor * 0.5Depois: rotas.py
@app.post("/despesas/{id}/reembolso")
def pedir_reembolso(id: int):
despesa = repositorio.buscar(id)
if despesa is None:
raise HTTPException(status_code=404)
dias = (date.today() - despesa.data).days
reembolso = calcular_reembolso(despesa.valor, despesa.categoria, dias)
repositorio.registrar_reembolso(id, reembolso)
return {"reembolso": reembolso}Depois da separação, calcular_reembolso é uma função pura: recebe valores, devolve um valor, não mexe em banco nem em data do relógio. Ela é testada com uma linha. A rota ficou fina, só costurando as peças, e o repositório concentra o SQL.
A regra nova diz que compras com mais de 30 dias não têm reembolso. Onde vale mais a pena testar os casos de 29, 30 e 31 dias?
- Em testes de unidade de
calcular_reembolso - Num teste de ponta a ponta no navegador
- Testando direto no banco de produção
Rodando a suíte com pytest
No dia a dia, você roda os testes pelo terminal várias vezes por hora, e a CI roda de novo a cada envio. Saber ler a saída é metade do trabalho: ela diz qual teste falhou, em que linha e com quais valores.
Encontrando e corrigindo uma falha
O projeto da API de despesas tem testes em tests/. Rode a suíte, leia a falha, rode só o teste que falhou e confirme a correção.
Rode todos os testes do projeto.
pytest========================= test session starts ========================= collected 14 items tests/test_regras.py ......F. [ 57%] tests/test_rotas.py ...... [100%] ============================== FAILURES =============================== ___________________ test_divide_sem_perder_centavo ____________________ def test_divide_sem_perder_centavo(): partes = dividir_conta(10000, 3) > assert sum(partes) == 10000 E assert 9999 == 10000 E + where 9999 = sum([3333, 3333, 3333]) tests/test_regras.py:31: AssertionError ======================= short test summary info ======================= FAILED tests/test_regras.py::test_divide_sem_perder_centavo - assert 9999 == 10000 ==================== 1 failed, 13 passed in 0.42s =====================Rode só os testes cujo nome contém
centavo, usando a opção-k.pytest -k centavo========================= test session starts ========================= collected 14 items / 13 deselected / 1 selected tests/test_regras.py F [100%] ============================== FAILURES =============================== E assert 9999 == 10000 tests/test_regras.py:31: AssertionError =================== 1 failed, 13 deselected in 0.08s ==================A função
dividir_contafoi corrigida emapp/regras.pypara distribuir o resto. Rode de novo o mesmo teste.pytest -k centavo========================= test session starts ========================= collected 14 items / 13 deselected / 1 selected tests/test_regras.py . [100%] =================== 1 passed, 13 deselected in 0.07s ==================Rode a suíte inteira de novo, agora com
-vpara ver o nome de cada teste.pytest -v========================= test session starts ========================= collected 14 items tests/test_regras.py::test_mercado_nao_tem_reembolso PASSED [ 7%] tests/test_regras.py::test_transporte_tem_teto_de_200 PASSED [ 14%] tests/test_regras.py::test_outras_categorias_reembolsam_metade PASSED [ 21%] tests/test_regras.py::test_compra_com_30_dias_ainda_reembolsa PASSED [ 28%] tests/test_regras.py::test_compra_com_31_dias_nao_reembolsa PASSED [ 35%] tests/test_regras.py::test_divide_em_partes_iguais PASSED [ 42%] tests/test_regras.py::test_divide_sem_perder_centavo PASSED [ 50%] tests/test_regras.py::test_divide_para_uma_pessoa PASSED [ 57%] tests/test_rotas.py::test_post_valido_devolve_201 PASSED [ 64%] tests/test_rotas.py::test_post_com_valor_negativo_devolve_400 PASSED [ 71%] tests/test_rotas.py::test_get_inexistente_devolve_404 PASSED [ 78%] tests/test_rotas.py::test_sem_login_devolve_401 PASSED [ 85%] tests/test_rotas.py::test_despesa_de_outra_pessoa_devolve_403 PASSED [ 92%] tests/test_rotas.py::test_lista_e_paginada PASSED [100%] ========================= 14 passed in 0.39s ==========================
Na lista final aparecem testes de 401 e 403. De qual aula vieram essas regras, e por que vale tanto tê-las como testes?
Da aula de autenticação e autorização. Regras de acesso são fáceis de esquecer numa rota nova e caras quando falham, porque vazam dados. Um teste que tenta ler a despesa de outra pessoa transforma esse esquecimento numa falha vermelha antes do deploy.
Você vai mudar uma regra de negócio. Coloque em ordem um fluxo de trabalho seguro.
- Rodar a suíte e confirmar que tudo passa antes de mexer
- Escrever um teste para a regra nova e vê-lo falhar
- Alterar o código até o teste novo passar
- Rodar a suíte inteira para pegar regressões
- Enviar a mudança e deixar a CI rodar os testes de novo
Fechamento
- Um teste chama o código com uma entrada conhecida e compara com o esperado; a suíte avisa rápido sobre regressões.
- Bons testes seguem organizar, agir, verificar e exploram as bordas, onde moram os bugs. Veja cada teste falhar ao menos uma vez.
- A pirâmide tem muitos testes de unidade, alguns de integração e contrato, e poucos de ponta a ponta, sempre com dados isolados.
- Dublês (stub, fake, mock) substituem peças lentas ou perigosas, mas não substituem testes com um banco de teste real.
- Separar a regra de negócio do HTTP e do banco deixa o código mais simples de ler e de testar; módulos bem divididos vêm antes de microsserviços.
Monte a rede de segurança da API de despesas
No projeto da sua stack (pytest, Vitest ou Jest com Supertest, JUnit), escreva testes que cubram regras, banco e rotas. Ao final, explique por escrito como os módulos foram divididos e por quê.
- Separe pelo menos uma regra de negócio numa função pura e escreva testes de unidade para os casos de borda
- Escreva um teste de integração do repositório contra um banco de teste, com dados criados e desfeitos em cada teste
- Teste as rotas principais: um sucesso, uma entrada inválida, um recurso inexistente e um acesso negado
- Quebre uma regra de propósito e confira que algum teste fica vermelho
- Rode a suíte inteira duas vezes, em ordens diferentes, e confirme que o resultado não muda