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) == 0

Integraçã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 200
  • dividir_conta nunca 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.5

Depois: 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.

  1. 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 =====================
  2. 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 ==================
  3. A função dividir_conta foi corrigida em app/regras.py para 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 ==================
  4. Rode a suíte inteira de novo, agora com -v para 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ê.

  1. Separe pelo menos uma regra de negócio numa função pura e escreva testes de unidade para os casos de borda
  2. Escreva um teste de integração do repositório contra um banco de teste, com dados criados e desfeitos em cada teste
  3. Teste as rotas principais: um sucesso, uma entrada inválida, um recurso inexistente e um acesso negado
  4. Quebre uma regra de propósito e confira que algum teste fica vermelho
  5. Rode a suíte inteira duas vezes, em ordens diferentes, e confirme que o resultado não muda

Referências

Cursos relacionados