Padrões de Teste em Python

Guia completo para implementar estratégias de teste robustas em Python usando pytest, fixtures, mocking, parametrização e práticas de desenvolvimento orientado a testes.

Quando Usar Esta Habilidade

• Escrever testes unitários para código Python
• Configurar suítes de teste e infraestrutura de teste
• Implementar desenvolvimento orientado a testes (TDD)
• Criar testes de integração para APIs e serviços
• Simular dependências e serviços externos (mocking)
• Testar código assíncrono e operações concorrentes
• Configurar testes contínuos em CI/CD
• Implementar testes baseados em propriedades (property-based testing)
• Testar operações de banco de dados
• Depurar testes que falham

Conceitos Principais

1. Tipos de Teste

• Testes Unitários: Testam funções/classes individuais isoladamente
• Testes de Integração: Testam a interação entre componentes
• Testes Funcionais: Testam funcionalidades completas de ponta a ponta
• Testes de Performance: Medem a velocidade e o uso de recursos

2. Estrutura de Teste (Padrão AAA)

• Arrange (Organizar): Configurar dados de teste e pré-condições
• Act (Agir): Executar o código sob teste
• Assert (Verificar): Validar os resultados

3. Cobertura de Teste

• Medir qual código é executado pelos testes
• Identificar caminhos de código não testados
• Buscar cobertura significativa, não apenas porcentagens altas

4. Isolamento de Teste

• Testes devem ser independentes
• Sem estado compartilhado entre testes
• Cada teste deve se limpar após sua execução

Início Rápido

# test_example.py
def add(a, b):
    return a + b

def test_add():
    """Basic test example."""
    result = add(2, 3)
    assert result == 5

def test_add_negative():
    """Test with negative numbers."""
    assert add(-1, 1) == 0

# Run with: pytest test_example.py

Padrões detalhados e exemplos práticos

A documentação detalhada dos padrões está em references/details.md. Leia este arquivo quando a navegação acima for insuficiente.

Melhores Práticas de Teste

Organização de Testes

# tests/
#   __init__.py
#   conftest.py           # Shared fixtures
#   test_unit/            # Unit tests
#     test_models.py
#     test_utils.py
#   test_integration/     # Integration tests
#     test_api.py
#     test_database.py
#   test_e2e/            # End-to-end tests
#     test_workflows.py

Convenção de Nomenclatura de Testes

Um padrão comum: test_<unit>_<scenario>_<expected_outcome>. Adapte às preferências da sua equipe.

# Pattern: test_<unit>_<scenario>_<expected>
def test_create_user_with_valid_data_returns_user():
    ...

def test_create_user_with_duplicate_email_raises_conflict():
    ...

def test_get_user_with_unknown_id_returns_none():
    ...

# Good test names - clear and descriptive
def test_user_creation_with_valid_data():
    """Clear name describes what is being tested."""
    pass

def test_login_fails_with_invalid_password():
    """Name describes expected behavior."""
    pass

def test_api_returns_404_for_missing_resource():
    """Specific about inputs and expected outcomes."""
    pass

# Bad test names - avoid these
def test_1():  # Not descriptive
    pass

def test_user():  # Too vague
    pass

def test_function():  # Doesn't explain what's tested
    pass

Testando Comportamento de Retentativas (Retry)

Verifique se a lógica de retentativas funciona corretamente usando efeitos colaterais simulados (mock side effects).

from unittest.mock import Mock

def test_retries_on_transient_error():
    """Test that service retries on transient failures."""
    client = Mock()
    # Fail twice, then succeed
    client.request.side_effect = [
        ConnectionError("Failed"),
        ConnectionError("Failed"),
        {"status": "ok"},
    ]

    service = ServiceWithRetry(client, max_retries=3)
    result = service.fetch()

    assert result == {"status": "ok"}
    assert client.request.call_count == 3

def test_gives_up_after_max_retries():
    """Test that service stops retrying after max attempts."""
    client = Mock()
    client.request.side_effect = ConnectionError("Failed")

    service = ServiceWithRetry(client, max_retries=3)

    with pytest.raises(ConnectionError):
        service.fetch()

    assert client.request.call_count == 3

def test_does_not_retry_on_permanent_error():
    """Test that permanent errors are not retried."""
    client = Mock()
    client.request.side_effect = ValueError("Invalid input")

    service = ServiceWithRetry(client, max_retries=3)

    with pytest.raises(ValueError):
        service.fetch()

    # Only called once - no retry for ValueError
    assert client.request.call_count == 1

Simulação de Tempo com Freezegun

…