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:

  1. Itens iniciais do carrinho (o que já estava lá dentro).
  2. O item a ser removido (o nome do produto que queremos apagar).
  3. 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::

import pytest
from carrinho import CarrinhoDeCompras
 
@pytest.mark.parametrize(
    "itens, total_esperado",
    [
        ([("Livro", 45.0), ("Caneta", 5.0)], 50.0),
        ([("Caderno", 15.0)], 15.0),
        ([], 0.0),
    ]
)
def test_calcular_total_com_diferentes_itens(itens, total_esperado):
    carrinho = CarrinhoDeCompras()
    for nome, preco in itens:
        carrinho.adicionar_item(nome, preco)
    assert carrinho.calcular_total() == total_esperado
 

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:

  1. Itens iniciais do carrinho (o que já estava lá dentro).
  2. O item a ser removido (o nome do produto que queremos apagar).
  3. 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. 🧪

@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):
    carrinho = CarrinhoDeCompras()
    for nome, preco in itens_iniciais:
        carrinho.adicionar_item(nome, preco)
    
    carrinho.remover_item(item_remover)
    
    assert len(carrinho.itens) == 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:

  1. any(...) percorre a lista para verificar se o item existe 🔍.
  2. Se não encontrar (not), o programa interrompe a execução e lança um ValueError ⚠️.
  3. 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.

Veja como transformamos isso em código:

import pytest
from carrinho import CarrinhoDeCompras
 
@pytest.fixture
def carrinho_vazio():
    return CarrinhoDeCompras()
 
def test_carrinho_vazio_deve_retornar_total_zero(carrinho_vazio):
    assert carrinho_vazio.calcular_total() == 0.0
 

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:

@pytest.fixture
def carrinho_com_itens():
    carrinho = CarrinhoDeCompras()
    carrinho.adicionar_item("Livro", 45.0)
    carrinho.adicionar_item("Caneta", 5.0)
    return carrinho
 
def test_calcular_total_com_itens(carrinho_com_itens):
    assert carrinho_com_itens.calcular_total() == 50.0
 

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 🛒.

Veja como fica o teste de remoção:

def test_deve_remover_item_do_carrinho(carrinho_com_itens):
    carrinho_com_itens.remover_item("Livro")
    
    assert len(carrinho_com_itens.itens) == 1
 

Como a fixture já adiciona o "Livro" (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:

def test_carrinho_vazio_deve_retornar_total_zero(carrinho_vazio):
    assert carrinho_vazio.calcular_total() == 0.0
 

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 🛒.

def test_deve_adicionar_item_no_carrinho_vazio(carrinho_vazio):
    carrinho_vazio.adicionar_item("Livro", 45.0)
    assert len(carrinho_vazio.itens) == 1
 

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 🛒:

def test_deve_conferir_nome_do_item_adicionado(carrinho_vazio):
    carrinho_vazio.adicionar_item("Livro", 45.0)
    assert carrinho_vazio.itens[0]["nome"] == "Livro"
 

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? 🚀

⬅️ 1. Aplicando TDD com app carrinho de compras | ⬆️ uc3.04 - Aplicando TDD