O TDD (Test-Driven Development) é uma abordagem de desenvolvimento de software onde escrevemos os testes automáticos antes do código de produção, seguindo o ciclo Red-Green-Refactor.

Objetivos:

  1. 🔴 O ciclo Red-Green-Refactor: Entender a teoria básica, a lógica por trás de escrever um teste que falha e como o código evolui a partir disso.
  2. 🐍 O ecossistema em Python: Conhecer as ferramentas mais usadas, como o pytest, e ver como estruturar o ambiente de testes.
  3. 🛠️ Um exemplo prático do zero: Aplicar o TDD imediatamente construindo uma função simples (como uma calculadora ou validador de dados) passo a passo.

O comando assert

O comando assert é uma ferramenta do Python usada para verificar se uma condição é verdadeira durante o desenvolvimento ou em testes de código. Se a condição for falsa, o programa interrompe a execução imediatamente e lança um erro chamado AssertionError.

Sintaxe básica:

assert condicao, "Mensagem de erro opcional"
  • Condição verdadeira: Se o resultado da verificação for True, o Python não faz nada e segue para a próxima linha.
  • Condição falsa: Se o resultado for False, o código para na hora e exibe o AssertionError junto com a mensagem que você definiu.

Exemplo prático com a sua classe:

Imagine que você quer garantir que o cálculo do total do carrinho está funcionando corretamente antes de colocar o sistema no ar:

carrinho = Carrinho()
carrinho.adicionar_item("Teclado", 150)
carrinho.adicionar_item("Mouse", 50)
 
# Verifica se o total é realmente 200
assert carrinho.calcular_total() == 200, "Erro: o total deveria ser 200!"
 
print("Teste passou com sucesso!")

Se por algum motivo o método calcular_total() retornar 180, o Python vai parar na linha do assert e mostrar AssertionError: Erro: o total deveria ser 200!.

Quando usar assert e quando evitar

  • ✅Use para testes: É muito comum usar assert em arquivos de teste para validar se suas funções e métodos devolvem os resultados esperados.
  • ✅Use para depuração (debug): Ajuda a detectar bugs cedo, garantindo que certas regras internas do seu programa nunca sejam quebradas.
  • ❌Não use para validar dados do usuário: Nunca use assert para checar se o usuário digitou uma senha certa ou um preço positivo. Se o Python for executado em modo de otimização (usando a flag -O), todos os comandos assert são ignorados e desativados. Para validar entradas externas, use estruturas if e raise ValueError.

Iniciando a aplicação com os testes

Vamos unir o ciclo Red-Green-Refactor, a ferramenta pytest e construir um Carrinho de Compras passo a passo. 🛒

O Ciclo e a Ferramenta

  • 🔴 Red: Escrevemos um teste para uma funcionalidade que ainda não existe (o teste falha).
  • 🟢 Green: Escrevemos o código mínimo necessário para o teste passar.
  • ♻️ Refactor: Melhoramos o código (removemos duplicações, limpamos a estrutura) mantendo o teste verde.
  • 🐍 pytest: Nosso framework de testes. Ele identifica automaticamente arquivos chamados test_*.py e executa funções iniciadas com test_.

O Projeto: Carrinho de Compras

Vamos criar a classe CarrinhoDeCompras. O primeiro comportamento que queremos garantir é que, ao instanciar um novo carrinho, ele deve iniciar com a lista de itens vazia.

No arquivo test_carrinho.py, começamos estruturando o primeiro teste:

from carrinho import CarrinhoDeCompras
 
def test_carrinho_deve_iniciar_vazio():
    carrinho = CarrinhoDeCompras()
    # O que devemos verificar aqui?
 

Para dar o nosso primeiro passo no ciclo Red, como você completaria a asserção (assert) para verificar se a lista de itens do carrinho está vazia?

assert len(carrinho.itens) == 0

Perfeito! Essa asserção verifica exatamente se a lista de itens começa vazia. 🛒

Agora, se executarmos o pytest neste exato momento, o teste vai falhar (fase Red 🔴) porque a classe e o arquivo ainda não existem.

Para passarmos para a fase Green 🟢, precisamos criar o arquivo carrinho.py e escrever o código mínimo necessário. Como você estruturaria a classe CarrinhoDeCompras com o seu construtor (__init__) para que a lista de itens inicie vazia? 🐍

class CarrinhoDeCompras:
    def __init__(self):
        self.itens = []

Instalando o pytest

Para configurar o ambiente de testes do nosso carrinho de compras, vamos criar e ativar um ambiente virtual (venv) e instalar o pytest passo a passo. 🐍

  1. Criar o ambiente virtual: Terminal / Prompt de Comando.
    Abra a pasta do seu projeto no terminal e execute o comando para criar o venv:
python -m venv .venv
 

Verification: Uma pasta chamada .venv será gerada no diretório do projeto.

  1. Ativar o ambiente virtual: Sistema operacional.
    Ative o ambiente para que os pacotes sejam instalados isoladamente nele:
  • No Linux / macOS: source venv/bin/activate
  • No Windows (CMD): venv\Scripts\activate.bat
  • No Windows (PowerShell): venv\Scripts\Activate.ps1

Verification: O nome (venv) aparecerá no início da linha do seu terminal, indicando que está ativo.

  1. Instalar o pytest: Via pip.
    Com o ambiente ativado, instale o framework de testes com o pip:
pip install pytest
 

Verification: O terminal exibirá mensagens de sucesso confirmando a instalação do pytest e de suas dependências.

  1. Executar os testes: Validação.
    Execute o comando do pytest para rodar os testes da pasta:
pytest
 

Verification: O pytest escaneará os arquivos e mostrará o resultado da execução.

Quando executamos o pytest no terminal, o framework nos dá um feedback visual direto sobre o estado do código:

  • 🟢 Indicação de Sucesso: Se o teste passar, veremos a palavra PASSED em destaque verde, muitas vezes acompanhada por um ponto (.) para cada teste bem-sucedido.
  • 📊 Resumo Final: No final da execução, o pytest exibe um relatório (por exemplo, 1 passed), confirmando que todas as asserções foram verdadeiras.

Se houver uma falha (fase Red 🔴), ele exibe FAILED em vermelho e detalha exatamente qual linha falhou e o motivo da divergência.

Agora que o nosso carrinho já inicia vazio com sucesso, precisamos avançar para o próximo comportamento: adicionar um item. 🛒

Como você estruturaria a função de teste (por exemplo, test_deve_adicionar_item) para verificar se, após adicionar um produto com nome e preço, a lista de itens do carrinho deixa de estar vazia e passa a conter esse produto?

Adicionando funcionalidades

O TDD (Test-Driven Development) com Python e pytest nos guia passo a passo. No último passo, criamos a classe CarrinhoDeCompras que inicia com a lista de itens vazia. 🛒

Vamos dar o próximo passo no ciclo TDD para implementar a funcionalidade de adicionar um item ao carrinho.

1. 🔴 Fase Red: Escrevendo o teste que falha

Precisamos escrever um teste que verifique se, ao adicionar um produto (por exemplo, "Livro" por 45.0), a lista de itens do carrinho passa a conter esse elemento.

No seu arquivo test_carrinho.py, adicione a nova função de teste:

from carrinho import CarrinhoDeCompras
 
def test_carrinho_deve_iniciar_vazio():
    carrinho = CarrinhoDeCompras()
    assert len(carrinho.itens) == 0
 
def test_deve_adicionar_item_ao_carrinho():
    carrinho = CarrinhoDeCompras()
    carrinho.adicionar_item("Livro", 45.0)
    
    # Como você verificaria se o item foi adicionado corretamente à lista do carrinho?
 

Como você completaria a asserção ( assert) ou a verificação para garantir que o item "Livro" (ou os dados dele) foi armazenado corretamente no carrinho?

Verificar se o tamanho da lista mudou (ou passou a ter 1 item) é uma excelente estratégia para o teste. 🧪

Com isso, o nosso teste em test_carrinho.py fica estruturado assim:

def test_deve_adicionar_item_ao_carrinho():
    carrinho = CarrinhoDeCompras()
    carrinho.adicionar_item("Livro", 45.0)
    assert len(carrinho.itens) == 1
 

Se executarmos o pytest agora, o teste vai falhar (fase Red 🔴) porque a classe CarrinhoDeCompras ainda não possui o método adicionar_item.

2. 🟢Fase Green: Escrevemos o código mínimo necessário para o teste passar

Para passarmos para a fase Green 🟢, precisamos implementar esse comportamento. Como você escreveria o método adicionar_item(self, nome, preco) dentro da classe CarrinhoDeCompras no arquivo carrinho.py para armazenar o item na lista self.itens? 🐍

def adicionar_item(self, nome, preco):
        item = {"nome": nome, "preco": preco}
        self.itens.append(item)

Se executarmos o pytest agora, o teste passa com sucesso (fase Green 🟢).

Como a implementação está limpa, não precisamos refatorar nada por enquanto. Vamos avançar para o próximo comportamento do nosso carrinho: calcular o preço total dos itens adicionados. 💰

✨ Nova funcionalidade

Para seguir o TDD, qual seria o próximo teste que deveríamos escrever para garantir que o carrinho consegue somar corretamente o preço de múltiplos itens (por exemplo, um “Livro” por e uma “Caneta” por )? Como você estruturaria essa função de teste?

Para calcular o preço total, vamos escrever o próximo teste (fase 🔴 Red) no arquivo test_carrinho.py 🧪:

def test_deve_calcular_preco_total_do_carrinho():
    carrinho = CarrinhoDeCompras()
    carrinho.adicionar_item("Livro", 45.0)
    carrinho.adicionar_item("Caneta", 5.0)
    
    assert carrinho.calcular_total() == 50.0
 

Se executarmos o pytest agora, o teste falhará porque o método calcular_total ainda não existe na classe CarrinhoDeCompras.

Como você implementaria o método calcular_total(self) no arquivo carrinho.py para percorrer a lista self.itens e somar os preços de cada produto? 🐍

Para mantermos o ciclo TDD e vermos o teste falhar (fase 🔴 Red) por um motivo claro, podemos implementar o método retornando um valor fixo ou zero inicialmente. 🔢

No arquivo carrinho.py, adicione este método provisório:

def calcular_total(self):
    return 0.0  # Implementação incorreta propositalmente
 

Se você rodar o pytest agora, o framework indicará que o teste falhou porque esperava 50.0, mas recebeu 0.0.

Como você reescreveria o código desse método para percorrer a lista self.itens e somar corretamente o preço de cada produto? 🐍

3. ♻️ Refatorando o código

Para somar os preços de todos os itens do carrinho, podemos usar a função sum() do Python no arquivo carrinho.py:

def calcular_total(self):
    total = 0
    for item in self.itens:
        total += item["preco"]
    return total
 

Como funciona essa abordagem

  • Variável acumuladora: A linha total = 0 cria um contador inicial zerado antes de começar a percorrer a lista.
  • Laço de repetição: O for item in self.itens: passa por cada dicionário dentro da sua lista de itens, um por vez.
  • Soma incremental: O operador += pega o valor atual de total e soma o preço do item da vez (total = total + item[“preco”]).
  • Retorno final: Após o laço terminar de ler todos os itens, o return total devolve o valor final somado.

A função sum() combinada com uma compreensão de lista 📊 no arquivo carrinho.py, o método atualizado fica assim:

def calcular_total(self):
   return sum(item["preco"] for item in self.itens)
 

Isso percorre cada item na lista self.itens, extrai o valor da chave "preco" e soma tudo. Ao executar o pytest agora, o teste passa com sucesso, garantindo a fase Green 🟢!

Com a lógica básica funcionando, qual deve ser o resultado esperado do método calcular_total() caso o carrinho ainda esteja vazio (sem nenhum item)? 🤔

✅ Prevenindo erros

Para garantirmos que o carrinho vazio retorne 0.0, vamos escrever o teste (fase 🔴 Red) para esse comportamento específico 🧪:

def test_carrinho_vazio_deve_retornar_total_zero():
    carrinho = CarrinhoDeCompras()
    assert carrinho.calcular_total() == 0.0
 

Se executarmos o pytest agora, ele já passará com sucesso (fase 🟢 Green), pois a lógica com a função sum() retorna 0 quando a lista está vazia.

Agora que temos o carrinho adicionando itens e calculando o preço total corretamente, qual é o próximo comportamento ou funcionalidade que você gostaria de adicionar ao nosso carrinho de compras? 🛒

Agora que já sabemos adicionar itens 📦 e calcular o total 💰, o próximo passo no nosso ciclo TDD é implementar a funcionalidade de remover itens do carrinho. 🗑️

🗑️ Nova funcionalidade removendo item

Seguindo o processo, começamos pela fase Red 🔴 escrevendo um teste para esse novo comportamento. Para testar a remoção, precisamos primeiro adicionar um item e depois chamar um método de remoção que ainda vamos criar.

Como você estruturaria essa função de teste (por exemplo, test_deve_remover_item_do_carrinho) para garantir que, após adicionar um produto e removê-lo, a lista de itens do carrinho volte a ficar vazia? 🧪

Para escrever o teste de remoção de itens 🗑️, precisamos primeiro adicionar um produto ao carrinho, chamar o método de remoção e depois verificar se a lista voltou a ficar vazia.

No arquivo test_carrinho.py, adicionamos o seguinte teste:

def test_deve_remover_item_do_carrinho():
    carrinho = CarrinhoDeCompras()
    carrinho.adicionar_item("Livro", 45.0)
    
    carrinho.remover_item("Livro")
    
    assert len(carrinho.itens) == 0
 

Se você executar o pytest agora, ele falhará (fase 🔴 Red) porque o método remover_item ainda não existe na nossa classe.

✨ Implementando a função remover

Como você implementaria o método remover_item(self, nome) no arquivo carrinho.py para encontrar e retirar o item correspondente da lista self.itens? 🐍

Para escrever esse método, você deve criar uma nova lista vazia e usar um laço for com uma condição if, para guardar apenas os itens que devem continuar.

def remover_item(self, nome):
    novos_itens = []
    for item in self.itens:
        if item["nome"] != nome:
            novos_itens.append(item)
    self.itens = novos_itens
 
 

Como funciona essa abordagem:

• Nova lista temporária: A variável novos_itens = [] cria uma lista vazia para armazenar os itens que você deseja manter.
• Verificação de condição: O if item["nome"] != nome: checa se o nome do item atual é diferente do nome que você quer remover.
• Adição seletiva: O método .append(item) coloca na nova lista apenas os itens que passaram no filtro.
• Substituição: Por fim, self.itens = novos_itens atualiza a lista original da classe com a versão filtrada.

Nota: Evite usar .remove() diretamente dentro de um laço for na mesma lista que está sendo percorrida. Alterar o tamanho de uma lista enquanto o Python passa por ela faz com que alguns elementos sejam pulados.

♻️ Refatorando usando compreensão

Como uma outra maneira de implementar o método de remoção no arquivo carrinho.py, o método remover_item pode ser escrito utilizando uma compreensão de lista para manter apenas os itens cujos nomes não correspondem ao que queremos apagar:

def remover_item(self, nome):
    self.itens = [item for item in self.itens if item["nome"] != nome]
 

Se você executar o pytest agora, o teste de remoção passará com sucesso, garantindo a fase Green 🟢!


Agora que temos adicionar, calcular o total e remover itens, pense no seguinte cenário: o que acontece se tentarmos remover um item que não existe no carrinho?

Como você escreveria um teste para garantir que o sistema lida corretamente com essa situação (por exemplo, mantendo o carrinho inalterado ou sem lançar erros indesejados)? 🧪

❌ Esperando que ocorra um erro!

Para escrevermos um teste que espera um erro, usamos o pytest.raises. Veja como fica a estrutura no arquivo test_carrinho.py:

import pytest
from carrinho import CarrinhoDeCompras
 
def test_nao_deve_remover_item_inexistente():
    carrinho = CarrinhoDeCompras()
    with pytest.raises(ValueError):
        carrinho.remover_item("Item Inexistente")
 

O bloco with pytest.raises(ValueError): diz ao pytest: “este teste só deve passar se a linha de dentro lançar um erro do tipo ValueError”. Se nenhum erro for lançado, o teste falha (fase 🔴 Red).

Agora, para passarmos para a fase 🟢 Green, precisamos atualizar o método remover_item na classe CarrinhoDeCompras para verificar se o item realmente existe na lista antes de tentar apagá-lo.

Para tratar essa situação e lançar o erro corretamente, verificamos se o item está na lista antes de tentar filtrá-lo. 🛡️

No arquivo carrinho.py, o método remover_item atualizado fica assim:

def remover_item(self, nome):
    # Verifica se o item existe na lista
    if not any(item["nome"] == nome for item in self.itens):
        raise ValueError(f"Item '{nome}' não encontrado no carrinho.")
        
    self.itens = [item for item in self.itens if item["nome"] != nome]
 

Com essa validação, o pytest consegue capturar o ValueError esperado quando tentamos apagar algo que não existe, e todos os nossos testes passam com sucesso! 🟢

O que mais você gostaria de adicionar ou testar no nosso carrinho de compras para continuarmos explorando o TDD? 🛒

⬆️ uc3.04 - Aplicando TDD | ➡️2. Testes parametrizados no app carrinho