Dominando Fixtures Avançadas do Pytest: Testes Parametrizados e Integração de Mocks

O Pytest é um framework de testes poderoso e flexível para Python. Sua simplicidade e extensibilidade o tornam um favorito entre desenvolvedores em todo o mundo. Uma das características mais notáveis do Pytest é seu sistema de fixtures, que permite configurações de teste elegantes e reutilizáveis. Este post de blog aprofunda-se em técnicas avançadas de fixtures, focando especificamente em testes parametrizados e integração de mocks. Exploraremos como essas técnicas podem aprimorar significativamente seu fluxo de trabalho de testes, levando a um código mais robusto e de fácil manutenção.

Entendendo as Fixtures do Pytest

Antes de mergulhar em tópicos avançados, vamos recapitular brevemente os conceitos básicos das fixtures do Pytest. Uma fixture é uma função que é executada antes de cada função de teste à qual é aplicada. Ela é usada para fornecer uma base fixa para os testes, garantindo consistência e reduzindo código repetitivo. Fixtures podem realizar tarefas como:

• Configurar uma conexão com o banco de dados
• Criar arquivos ou diretórios temporários
• Inicializar objetos com configurações específicas
• Autenticar com uma API

As fixtures promovem a reutilização de código e tornam seus testes mais legíveis e fáceis de manter. Elas podem ser definidas em diferentes escopos (função, módulo, sessão) para controlar seu ciclo de vida e consumo de recursos.

Exemplo Básico de Fixture

Aqui está um exemplo simples de uma fixture do Pytest que cria um diretório temporário:

            
import pytest
import tempfile
import os

@pytest.fixture
def temp_dir():
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir

            

              
                Copy
              
            
          

Para usar esta fixture em um teste, basta incluí-la como um argumento na sua função de teste:

            
def test_create_file(temp_dir):
    filepath = os.path.join(temp_dir, "test_file.txt")
    with open(filepath, "w") as f:
        f.write("Hello, world!")
    assert os.path.exists(filepath)

            

              
                Copy
              
            
          

Testes Parametrizados com Pytest

Testes parametrizados permitem que você execute a mesma função de teste várias vezes com diferentes conjuntos de dados de entrada. Isso é particularmente útil para testar funções com entradas e saídas esperadas variadas. O Pytest fornece o decorador @pytest.mark.parametrize para implementar testes parametrizados.

Benefícios dos Testes Parametrizados

• Reduz a Duplicação de Código: Evite escrever várias funções de teste quase idênticas.
• Melhora a Cobertura de Testes: Teste facilmente uma gama mais ampla de valores de entrada.
• Aumenta a Legibilidade dos Testes: Defina claramente os valores de entrada e as saídas esperadas para cada caso de teste.

Exemplo Básico de Parametrização

Digamos que você tenha uma função que soma dois números:

            
def add(x, y):
    return x + y

            

              
                Copy
              
            
          

Você pode usar testes parametrizados para testar esta função com diferentes valores de entrada:

            
import pytest

@pytest.mark.parametrize("x, y, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(x, y, expected):
    assert add(x, y) == expected

            

              
                Copy
              
            
          

Neste exemplo, o decorador @pytest.mark.parametrize define quatro casos de teste, cada um com valores diferentes para x, y e o resultado esperado. O Pytest executará a função test_add quatro vezes, uma para cada conjunto de parâmetros.

Técnicas Avançadas de Parametrização

O Pytest oferece várias técnicas avançadas para parametrização, incluindo:

• Usando Fixtures com Parametrização: Combine fixtures com parametrização para fornecer diferentes configurações para cada caso de teste.
• IDs para Casos de Teste: Atribua IDs personalizados aos casos de teste para melhores relatórios e depuração.
• Parametrização Indireta: Parametrize os argumentos passados para as fixtures, permitindo a criação dinâmica de fixtures.

Usando Fixtures com Parametrização

Isso permite que você configure dinamicamente as fixtures com base nos parâmetros passados para o teste. Imagine que você está testando uma função que interage com um banco de dados. Você pode querer usar diferentes configurações de banco de dados (por exemplo, diferentes strings de conexão) para diferentes casos de teste.

            
import pytest

@pytest.fixture
def db_config(request):
    if request.param == "prod":
        return {"host": "prod.example.com", "port": 5432}
    elif request.param == "test":
        return {"host": "test.example.com", "port": 5433}
    else:
        raise ValueError("Invalid database environment")


@pytest.fixture
def db_connection(db_config):
    # Simula o estabelecimento de uma conexão com o banco de dados
    print(f"Connecting to database at {db_config['host']}:{db_config['port']}")
    return f"Connection to {db_config['host']}"


@pytest.mark.parametrize("db_config", ["prod", "test"], indirect=True)
def test_database_interaction(db_connection):
    # Sua lógica de teste aqui, usando a fixture db_connection
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

Neste exemplo, a fixture db_config é parametrizada. O argumento indirect=True diz ao Pytest para passar os parâmetros ("prod" e "test") para a função da fixture db_config. A fixture db_config então retorna diferentes configurações de banco de dados com base no valor do parâmetro. A fixture db_connection usa a fixture db_config para estabelecer uma conexão com o banco de dados. Finalmente, a função test_database_interaction usa a fixture db_connection para interagir com o banco de dados.

IDs para Casos de Teste

IDs personalizados fornecem nomes mais descritivos para seus casos de teste no relatório, facilitando a identificação e depuração de falhas.

            
import pytest

@pytest.mark.parametrize(
    "input_string, expected_output",
    [
        ("hello", "HELLO"),
        ("world", "WORLD"),
        ("", ""),
    ],
    ids=["lowercase_hello", "lowercase_world", "empty_string"],
)
def test_uppercase(input_string, expected_output):
    assert input_string.upper() == expected_output

            

              
                Copy
              
            
          

Sem IDs, o Pytest geraria nomes genéricos como test_uppercase[0], test_uppercase[1], etc. Com IDs, o relatório de teste exibirá nomes mais significativos como test_uppercase[lowercase_hello].

Parametrização Indireta

A parametrização indireta permite parametrizar a entrada para uma fixture, em vez da função de teste diretamente. Isso é útil quando você deseja criar diferentes instâncias de fixture com base no valor do parâmetro.

            
import pytest

@pytest.fixture
def input_data(request):
    if request.param == "valid":
        return {"name": "John Doe", "email": "john.doe@example.com"}
    elif request.param == "invalid":
        return {"name": "", "email": "invalid-email"}
    else:
        raise ValueError("Invalid input data type")


def validate_data(data):
    if not data["name"]:
        return False, "Name cannot be empty"
    if "@" not in data["email"]:
        return False, "Invalid email address"
    return True, "Valid data"

@pytest.mark.parametrize("input_data", ["valid", "invalid"], indirect=True)
def test_validate_data(input_data):
    is_valid, message = validate_data(input_data)
    if input_data == {"name": "John Doe", "email": "john.doe@example.com"}:
        assert is_valid is True
        assert message == "Valid data"
    else:
        assert is_valid is False
        assert message in ["Name cannot be empty", "Invalid email address"]

            

              
                Copy
              
            
          

Neste exemplo, a fixture input_data é parametrizada com os valores "valid" e "invalid". O argumento indirect=True diz ao Pytest para passar esses valores para a função da fixture input_data. A fixture input_data então retorna diferentes dicionários de dados com base no valor do parâmetro. A função test_validate_data então usa a fixture input_data para testar a função validate_data com diferentes dados de entrada.

Usando Mocks com Pytest

Mocking é uma técnica usada para substituir dependências reais por substitutos controlados (mocks) durante os testes. Isso permite isolar o código que está sendo testado e evitar a dependência de sistemas externos, como bancos de dados, APIs ou sistemas de arquivos.

Benefícios do Mocking

• Isolar o Código: Teste o código de forma isolada, sem depender de dependências externas.
• Controlar o Comportamento: Defina o comportamento das dependências, como valores de retorno e exceções.
• Acelerar os Testes: Evite sistemas externos lentos ou não confiáveis.
• Testar Casos Extremos: Simule condições de erro e casos extremos que são difíceis de reproduzir em um ambiente real.

Usando a Biblioteca unittest.mock

O Python fornece a biblioteca unittest.mock para criar mocks. O Pytest se integra perfeitamente com unittest.mock, facilitando a simulação de dependências em seus testes.

Exemplo Básico de Mocking

Digamos que você tenha uma função que busca dados de uma API externa:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Lança uma exceção para códigos de status ruins
    return response.json()

            

              
                Copy
              
            
          

Para testar esta função sem realmente fazer uma requisição para a API, você pode simular (mock) a função requests.get:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configura o mock para retornar uma resposta específica
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Chama a função que está sendo testada
    data = get_data_from_api("https://example.com/api")

    # Afirma que o mock foi chamado com a URL correta
    mock_get.assert_called_once_with("https://example.com/api")

    # Afirma que a função retornou os dados esperados
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Neste exemplo, o decorador @patch("requests.get") substitui a função requests.get por um objeto mock. O argumento mock_get é o objeto mock. Podemos então configurar o objeto mock para retornar uma resposta específica e afirmar que ele foi chamado com a URL correta.

Mocking com Fixtures

Você também pode usar fixtures para criar e gerenciar mocks. Isso pode ser útil para compartilhar mocks entre vários testes ou para criar configurações de mock mais complexas.

            
import pytest
import requests
from unittest.mock import Mock

@pytest.fixture
def mock_api_get():
    mock = Mock()
    mock.return_value.json.return_value = {"data": "test data"}
    mock.return_value.status_code = 200
    return mock


@pytest.fixture
def patched_get(mock_api_get, monkeypatch):
    monkeypatch.setattr(requests, "get", mock_api_get)
    return mock_api_get


def test_get_data_from_api(patched_get):
    # Chama a função que está sendo testada
    data = get_data_from_api("https://example.com/api")

    # Afirma que o mock foi chamado com a URL correta
    patched_get.assert_called_once_with("https://example.com/api")

    # Afirma que a função retornou os dados esperados
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Aqui, mock_api_get cria um mock e o retorna. patched_get então usa monkeypatch, uma fixture do pytest, para substituir o `requests.get` real pelo mock. Isso permite que outros testes usem o mesmo endpoint de API simulado.

Técnicas Avançadas de Mocking

Pytest e unittest.mock oferecem várias técnicas avançadas de mocking, incluindo:

• Efeitos Colaterais (Side Effects): Defina um comportamento personalizado para mocks com base nos argumentos de entrada.
• Mocking de Propriedades: Simule propriedades de objetos.
• Gerenciadores de Contexto: Use mocks dentro de gerenciadores de contexto para substituições temporárias.

Efeitos Colaterais (Side Effects)

Os efeitos colaterais permitem que você defina um comportamento personalizado para seus mocks com base nos argumentos de entrada que eles recebem. Isso é útil para simular diferentes cenários ou condições de erro.

            
import pytest
from unittest.mock import Mock

def test_side_effect():
    mock = Mock()
    mock.side_effect = [1, 2, 3]

    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    with pytest.raises(StopIteration):
        mock()

            

              
                Copy
              
            
          

Este mock retorna 1, 2 e 3 em chamadas sucessivas e, em seguida, lança uma exceção `StopIteration` quando a lista se esgota.

Mocking de Propriedades

O mocking de propriedades permite que você simule o comportamento de propriedades em objetos. Isso é útil para testar código que depende de propriedades de objetos em vez de métodos.

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "original value"


def test_property_mocking():
    obj = MyClass()
    with patch.object(obj, "my_property", new_callable=pytest.PropertyMock) as mock_property:
        mock_property.return_value = "mocked value"
        assert obj.my_property == "mocked value"

            

              
                Copy
              
            
          

Este exemplo simula a propriedade my_property do objeto MyClass, permitindo que você controle seu valor de retorno durante o teste.

Gerenciadores de Contexto

Usar mocks dentro de gerenciadores de contexto permite que você substitua temporariamente dependências para um bloco de código específico. Isso é útil para testar código que interage com sistemas ou recursos externos que só devem ser simulados por um tempo limitado.

            
import pytest
from unittest.mock import patch


def test_context_manager_mocking():
    with patch("os.path.exists") as mock_exists:
        mock_exists.return_value = True
        assert os.path.exists("dummy_path") is True
    # O mock é revertido automaticamente após o bloco 'with'
    # Garante que a função original seja restaurada, embora não possamos realmente
    # afirmar o comportamento da função `os.path.exists` real sem um caminho real.
    # O importante é que o patch desaparece após o contexto.
    print("Mock has been removed")

            

              
                Copy
              
            
          

Combinando Parametrização e Mocking

Essas duas técnicas poderosas podem ser combinadas para criar testes ainda mais sofisticados e eficazes. Você pode usar a parametrização para testar diferentes cenários com diferentes configurações de mock.

            
import pytest
import requests
from unittest.mock import patch


def get_user_data(user_id):
    url = f"https://api.example.com/users/{user_id}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


@pytest.mark.parametrize(
    "user_id, expected_data",
    [
        (1, {"id": 1, "name": "John Doe"}),
        (2, {"id": 2, "name": "Jane Smith"}),
    ],
)
@patch("requests.get")
def test_get_user_data(mock_get, user_id, expected_data):
    mock_get.return_value.json.return_value = expected_data
    mock_get.return_value.status_code = 200

    data = get_user_data(user_id)

    assert data == expected_data
    mock_get.assert_called_once_with(f"https://api.example.com/users/{user_id}")

            

              
                Copy
              
            
          

Neste exemplo, a função test_get_user_data é parametrizada com diferentes valores de user_id e expected_data. O decorador @patch simula a função requests.get. O Pytest executará a função de teste duas vezes, uma para cada conjunto de parâmetros, com o mock configurado para retornar o expected_data correspondente.

Boas Práticas para Usar Fixtures Avançadas

• Mantenha as Fixtures Focadas: Cada fixture deve ter um propósito claro e específico.
• Use Escopos Apropriados: Escolha o escopo de fixture apropriado (função, módulo, sessão) para otimizar o uso de recursos.
• Documente as Fixtures: Documente claramente o propósito e o uso de cada fixture.
• Evite Excesso de Mocks: Simule apenas as dependências necessárias para isolar o código que está sendo testado.
• Escreva Asserções Claras: Garanta que suas asserções sejam claras e específicas, verificando o comportamento esperado do código em teste.
• Considere o Desenvolvimento Orientado a Testes (TDD): Escreva seus testes antes de escrever o código, usando fixtures e mocks para guiar o processo de desenvolvimento.

Conclusão

As técnicas avançadas de fixtures do Pytest, incluindo testes parametrizados e integração de mocks, fornecem ferramentas poderosas para escrever testes robustos, eficientes e de fácil manutenção. Ao dominar essas técnicas, você pode melhorar significativamente a qualidade do seu código Python e otimizar seu fluxo de trabalho de testes. Lembre-se de focar na criação de fixtures claras e focadas, usar escopos apropriados e escrever asserções abrangentes. Com a prática, você será capaz de aproveitar todo o potencial do sistema de fixtures do Pytest para criar uma estratégia de testes abrangente e eficaz.