O objetivo de @pytest.mark.parametrize é evitar que a gente crie vários testes parecidos. Em vez de escrever um teste para remover um livro, outro para remover uma caneta, e assim por diante, nós criamos uma única estrutura que recebe os dados como parâmetros.
Para usar o parametrize precisamos:
Itens iniciais do carrinho (o que já estava lá dentro).
O item a ser removido (o nome do produto que queremos apagar).
O tamanho final esperado da lista após a remoção.
Quando precisamos testar a mesma funcionalidade com vários cenários diferentes (como diferentes listas de produtos no carrinho), escrever vários testes separados gera código duplicado. O pytest resolve isso com a ferramenta de parametrização (@pytest.mark.parametrize). 🧪
Com ela, definimos uma lista de tuplas contendo os dados de entrada e o resultado esperado, e o pytest roda o teste para cada caso de forma isolada.
➕Calculando múltiplos totais
Veja como podemos aplicar isso para testar múltiplos cálculos de totais, a estrutura do teste com o decorador ficaria assim::
Nessa estrutura, cada linha dentro da lista representa um cenário de teste independente que o pytest executa automaticamente.
Como você adaptaria essa mesma lógica de parametrização para testar a remoção de diferentes itens de um carrinho que já começa preenchido? 🤔
🗑️Testando remoção
Vamos detalhar como a parametrização funciona aplicada à remoção de itens. 🧪
O objetivo de @pytest.mark.parametrize é evitar que a gente crie vários testes parecidos. Em vez de escrever um teste para remover um livro, outro para remover uma caneta, e assim por diante, nós criamos uma única estrutura que recebe os dados como parâmetros.
Para testar a remoção de forma eficiente, cada cenário precisa de três informações:
Itens iniciais do carrinho (o que já estava lá dentro).
O item a ser removido (o nome do produto que queremos apagar).
O tamanho final esperado da lista após a remoção.
A estrutura do teste com o decorador ficaria assim:
@pytest.mark.parametrize( "itens_iniciais, item_remover, tamanho_esperado", [ ([("Livro", 45.0), ("Caneta", 5.0)], "Livro", 1), ([("Caderno", 15.0)], "Caderno", 0), ])def test_remover_varios_itens(itens_iniciais, item_remover, tamanho_esperado): # Como você preencheria o corpo deste teste?
Com base nessa estrutura, como você preencheria o corpo da função test_remover_varios_itens para adicionar os itens iniciais no carrinho, chamar o método de remoção e fazer a asserção (assert)? 🤔
Para implementar o teste parametrizado de remoção, preenchemos o corpo criando a instância, populando o carrinho com os itens_iniciais, chamando o método de remoção e validando o tamanho_esperado. 🧪
Cada tupla na lista de parâmetros executa esse bloco de código de forma isolada, permitindo testar múltiplos cenários de uma só vez.
Como você acha que podemos combinar o @pytest.mark.parametrize com o pytest.raises para testar vários cenários de erro ao tentar remover itens inexistentes? 🤔
🛠️ Testando atualização
Vamos aplicar o TDD para a função de editar um item. 🛠️
Para começarmos pela fase 🔴 Red, precisamos escrever um teste que verifique essa alteração. Se quisermos atualizar o preço de um item que já está no carrinho (por exemplo, mudar o preço do “Livro” de 45.0 para 50.0), como você estruturaria essa função de teste (test_deve_atualizar_preco_item)? 🧪
O primeiro passo (fase 🔴 Red) é escrever um teste que altere o preço de um produto que já está no carrinho e verifique se o valor foi atualizado corretamente.
No arquivo test_carrinho.py, podemos estruturar o teste assim:
def test_deve_atualizar_preco_do_item(): carrinho = CarrinhoDeCompras() carrinho.adicionar_item("Livro", 45.0) # Chamamos o método que vamos criar para atualizar o preço carrinho.atualizar_preco("Livro", 50.0) # O que devemos verificar aqui para garantir que o preço mudou para 50.0?
Como você completaria a asserção ( assert) para verificar se o preço do item foi atualizado com sucesso na lista do carrinho? 🤔
Para verificar se o preço foi atualizado, precisamos acessar o item específico dentro da lista carrinho.itens e checar se a chave "preco" mudou para o novo valor esperado. 🔍
Como a nossa lista armazena dicionários no formato {"nome": "Livro", "preco": 50.0}, como você escreveria a linha de assert para verificar se o preço do primeiro item da lista agora é 50.0?
assert carrinho.itens[0]["preco"] == 50.0
Esta linha de código verifica se o preço do primeiro item armazenado no carrinho foi alterado corretamente. Vamos dividir cada parte para entender como ela funciona:
assert: 🧪 É o comando de teste do Python. Se a condição à frente for verdadeira, o teste passa silenciosamente. Se for falsa, o teste falha e interrompe a execução.
carrinho.itens: 🛒 Acessa o atributo que guarda a lista de produtos dentro do nosso objeto carrinho.
[0]: 📍 Seleciona o primeiro elemento da lista (em Python, a contagem de índices começa em 0). Como o “Livro” foi o primeiro item adicionado, estamos apontando diretamente para ele.
["preco"]: 🔑 Como cada item na nossa lista é um dicionário (ex: {"nome": "Livro", "preco": 50.0}), isso extrai o valor guardado na chave "preco".
== 50.0: ⚖️ Compara se o preço encontrado é exatamente igual a 50.0.
Agora que entendemos como inspecionar o item alterado, como você estruturaria o método vamos agora implementar o método atualizar_preco(self, nome, novo_preco) na classe CarrinhoDeCompras para passarmos da fase 🔴 Red para a fase 🟢 Green.
Para atualizar o preço, precisamos percorrer a lista self.itens, encontrar o dicionário que possui o nome correspondente e alterar o valor da chave "preco".
Podemos usar um loop for básico para localizar o item correto dentro do loop. 🔍
Para finalizar o método atualizar_preco, você precisa comparar o nome do item atual da iteração com o nome que foi passado como argumento. Se forem iguais, você atualiza a chave "preco" com o novo_preco.
O código completo do método ficaria assim:
def atualizar_preco(self, nome, novo_preco): for item in self.itens: if item["nome"] == nome: item["preco"] = novo_preco return
Agora, para garantir que nosso código continue robusto, o que você acha que deveria acontecer se tentarmos atualizar o preço de um item que não existe no carrinho? 🛡️
🛡️Prevenindo erros
🛡️ Lançar um erro quando tentamos atualizar um item que não está no carrinho deixa o nosso código muito mais seguro e consistente.
Para fazermos isso, precisamos verificar se o produto existe na lista antes de tentar alterar o seu preço, seguindo a mesma lógica que usamos na remoção.
Como você escreveria essa verificação (por exemplo, usando any()) dentro do método atualizar_preco para disparar o ValueError caso o item não seja encontrado? 🤔
Para garantir que o programa lance um erro quando tentamos atualizar um produto que não está no carrinho, podemos usar a mesma verificação com any() que aplicamos na remoção 🛡️.
🧪 A função any()
A função any() do Python verifica se pelo menos um elemento de uma lista (ou outro iterável) é verdadeiro. Ela retorna True assim que encontra o primeiro item verdadeiro, ou False se todos os itens forem falsos ou se a lista estiver vazia.
Como funciona na prática:
Com valores booleanos: Se você passar [False, False, True], o any() retorna True. Se todos forem False, ele retorna False.
Com outros tipos de dados: No Python, números diferentes de zero, textos não vazios e listas com itens são considerados verdadeiros (truthy). Já o 0, texto vazio "" e None são considerados falsos (falsy).
Parada rápida (short-circuit): Assim que o any() encontra um único valor verdadeiro, ele para de olhar o restante da lista na hora. Isso deixa o código mais rápido.
Exemplo na na classe de carrinho:
Você pode usar o any() para checar se um produto já está no carrinho antes de adicioná-lo ou removê-lo:
def item_existe(self, nome): return any(item["nome"] == nome for item in self.itens)
Como seria sem usar compreensão, veja como escrever a exata mesma lógica do any() usando apenas um laço for tradicional:
def item_existe(self, nome): for item in self.itens: if item["nome"] == nome: return True return False
Retorno imediato: Assim que o if encontra o nome procurado, o return True encerra a função na hora.
Fim da busca: Se o laço passar por todos os itens e não encontrar nada, ele chega ao return False no final.
Assim como any(), o all() verifica se todos os itens atendem a uma condição e são verdadeiros. Ela retorna True apenas se nenhum for False.
def precos_validos(self): return all(item["preco"] > 0 for item in self.itens)
✨ atualizar_preco completo
O método atualizar_preco completo no arquivo carrinho.py fica assim:
def atualizar_preco(self, nome, novo_preco): if not any(item["nome"] == nome for item in self.itens): raise ValueError(f"Item '{nome}' não encontrado no carrinho.") for item in self.itens: if item["nome"] == nome: item["preco"] = novo_preco return
Nessa implementação:
any(...) percorre a lista para verificar se o item existe 🔍.
Se não encontrar (not), o programa interrompe a execução e lança um ValueError ⚠️.
Se o item existir, o loop prossegue para encontrar o produto e atualizar o seu preço 💰.
Como você escreveria o teste no arquivo test_carrinho.py usando pytest.raises(ValueError) para garantir que essa exceção seja disparada corretamente ao tentar atualizar um preço inexistente? 🧪
🧪 A função raises
raise x raises
raise 🚀 é uma palavra-chave nativa do Python utilizada para lançar ou disparar uma exceção de forma proposital no seu código (por exemplo, quando uma regra de negócio é violada).
pytest.raises 🧪 é uma função utilitária do pytest utilizada exclusivamente nos testes para capturar e verificar se um trecho de código realmente lançou a exceção que você esperava. Em resumo, o raise cria o erro na aplicação, e o pytest.raises confere se o erro aconteceu como planejado no teste.
Para verificar se a mensagem de erro gerada pelo raise está correta, podemos capturar a exceção com o pytest.raises usando a palavra-chave as exc_info 🧪.
Veja como fica essa estrutura no teste:
def test_deve_retornar_mensagem_ao_remover_inexistente(): carrinho = CarrinhoDeCompras() with pytest.raises(ValueError) as exc_info: carrinho.remover_item("Item Inexistente") assert "não encontrado" in str(exc_info.value)
O objeto exc_info.value armazena a exceção capturada, permitindo que a gente valide o texto exato da mensagem que o programa emitiu 🛡️.
Como você aplicaria essa mesma verificação de mensagem para o método atualizar_preco quando tentamos alterar o preço de um item que não existe? 💻
Para aplicar essa mesma validação ao método atualizar_preco, estruturamos o teste da seguinte forma 🧪:
def test_deve_retornar_mensagem_ao_atualizar_preco_inexistente(): carrinho = CarrinhoDeCompras() with pytest.raises(ValueError) as exc_info: carrinho.atualizar_preco("Item Inexistente", 50.0) assert "não encontrado" in str(exc_info.value)
Dessa forma, garantimos tanto que o erro correto (ValueError) foi lançado quanto que a mensagem informativa retornada está certa 🛡️.
Agora que construímos e testamos as principais operações do nosso carrinho (adicionar 📦, remover 🗑️, calcular total 💰 e atualizar preço ✍️).
🛠️ Usando fixtures
Vamos explorar a criação de uma fixture básica 🛠️.
No pytest, uma fixture é uma função decorada com @pytest.fixture que prepara o estado ou os dados necessários para os testes (como instanciar o nosso CarrinhoDeCompras). Em vez de repetir a criação do objeto em cada teste, nós passamos o nome da fixture como argumento para a função de teste.
Quando o pytest executa test_carrinho_vazio_deve_retornar_total_zero, ele percebe que o argumento carrinho_vazio corresponde ao nome da fixture, executa a função da fixture e injeta o objeto retornado diretamente no teste.
As fixtures 🛠️ ajudam a eliminar a repetição de código nos nossos testes (princípio DRY - Don’t Repeat Yourself). Em vez de instanciar e preencher o carrinho manualmente em vários testes, podemos criar fixtures que já entregam o objeto pronto para uso.
Podemos criar, por exemplo, uma fixture chamada carrinho_com_itens que já vem com produtos pré-adicionados:
Dessa forma, qualquer teste que precise de um carrinho populado 📦 só precisa declarar carrinho_com_itens como parâmetro, mantendo os testes limpos e fáceis de ler.
Como você reescreveria o teste de remoção de item ( test_deve_remover_item_do_carrinho) aproveitando essa fixture carrinho_com_itens? 🧪
Quando usamos a fixture carrinho_com_itens, o teste fica mais limpo porque o carrinho já vem populado com os produtos 🛒.
Como a fixture já adiciona o "Livro" (R45,00)ea‘"Caneta"‘(R 5,00), remover o "Livro" deixa exatamente 1 item no carrinho 📉.
Como você estruturaria um teste para o método calcular_total utilizando essa mesma fixture carrinho_com_itens? 💡
Para testar o método calcular_total usando a fixture carrinho_com_itens, o código fica bem direto, já que a fixture cuida de adicionar os produtos para a gente 🛒:
def test_calcular_total_com_itens(carrinho_com_itens): # A fixture já inicializou o carrinho com "Livro" (45.0) e "Caneta" (5.0) total = carrinho_com_itens.calcular_total() assert total == 50.0
Como a fixture já deixa o carrinho populado com um total de R$ 50,00, precisamos apenas chamar o método e conferir o resultado com o assert 💰.
Agora que vimos como usar fixtures para popular dados automaticamente, como você acha que podemos estruturar um teste usando uma fixture para garantir que o cálculo do total funcione corretamente mesmo quando o carrinho está vazio 🧪?
Para testar um carrinho vazio usando a nossa fixture 🛒, podemos verificar diretamente se o cálculo do total retorna 0.0 sem precisar adicionar nenhum produto manualmente:
Como a fixture carrinho_vazio já entrega o objeto recém-criado para o teste 🧪, evitamos repetição de código e mantemos a suíte de testes limpa e focada no comportamento esperado.
Com base nessa estrutura, como você adaptaria esse raciocínio para verificar se, ao adicionar um único item a um carrinho que começou vazio, o tamanho da lista ( len) passa a ser 1? 💡
Para escrever esse teste usando a fixture carrinho_vazio, chamamos o método adicionar_item no objeto fornecido pela fixture e depois verificamos o tamanho da lista 🛒.
Aqui, o pytest injeta o carrinho limpo, adicionamos o item e conferimos se o tamanho passou de 0 para 1.
Com base nessa estrutura de testes com fixtures, como você verificaria se o nome do item armazenado dentro de carrinho_vazio.itens[0] é exatamente "Livro"? 🔍
Aqui está como podemos estruturar esse teste para verificar o nome do item 🛒:
Nesse exemplo 🧪, usamos a fixture carrinho_vazio, adicionamos o item e verificamos diretamente na estrutura de dados se o dicionário na primeira posição ([0]) tem a chave "nome" igual a "Livro".
Agora que cobrimos como isolar o estado inicial com fixtures básicas, você gostaria de ver como usar parametrização no pytest para testar vários cenários de adição de uma só vez, ou prefere explorar como lidar com a limpeza de dados usando fixtures avançadas? 🚀