Padroneggiare le Fixture Avanzate di Pytest: Test Parametrizzati e Integrazione di Mock

Pytest è un framework di testing per Python potente e flessibile. La sua semplicità ed estensibilità lo rendono uno dei preferiti dagli sviluppatori di tutto il mondo. Una delle caratteristiche più interessanti di Pytest è il suo sistema di fixture, che consente di creare setup di test eleganti e riutilizzabili. Questo articolo approfondisce le tecniche di fixture avanzate, concentrandosi in particolare su test parametrizzati e integrazione di mock. Esploreremo come queste tecniche possano migliorare significativamente il tuo flusso di lavoro di testing, portando a un codice più robusto e manutenibile.

Comprendere le Fixture di Pytest

Prima di addentrarci in argomenti avanzati, riepiloghiamo brevemente le basi delle fixture di Pytest. Una fixture è una funzione che viene eseguita prima di ogni funzione di test a cui viene applicata. Viene utilizzata per fornire una base di partenza fissa per i test, garantendo coerenza e riducendo il codice ripetitivo. Le fixture possono svolgere compiti come:

• Impostare una connessione a un database
• Creare file o directory temporanee
• Inizializzare oggetti con configurazioni specifiche
• Autenticarsi con un'API

Le fixture promuovono la riutilizzabilità del codice e rendono i test più leggibili e manutenibili. Possono essere definite con diversi scope (function, module, session) per controllarne il ciclo di vita e il consumo di risorse.

Esempio di Fixture di Base

Ecco un semplice esempio di una fixture Pytest che crea una directory temporanea:

            
import pytest
import tempfile
import os

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

            

              
                Copy
              
            
          

Per utilizzare questa fixture in un test, è sufficiente includerla come argomento della funzione di test:

            
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
              
            
          

Test Parametrizzati con Pytest

I test parametrizzati consentono di eseguire la stessa funzione di test più volte con diversi set di dati di input. Ciò è particolarmente utile per testare funzioni con input e output attesi variabili. Pytest fornisce il decoratore @pytest.mark.parametrize per implementare i test parametrizzati.

Vantaggi dei Test Parametrizzati

• Riduzione della Duplicazione del Codice: Evita di scrivere più funzioni di test quasi identiche.
• Miglioramento della Copertura dei Test: Testa facilmente una gamma più ampia di valori di input.
• Aumento della Leggibilità dei Test: Definisci chiaramente i valori di input e gli output attesi per ogni caso di test.

Esempio di Parametrizzazione di Base

Supponiamo di avere una funzione che somma due numeri:

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

            

              
                Copy
              
            
          

Puoi usare i test parametrizzati per testare questa funzione con diversi valori di input:

            
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
              
            
          

In questo esempio, il decoratore @pytest.mark.parametrize definisce quattro casi di test, ciascuno con valori diversi per x, y e il risultato atteso. Pytest eseguirà la funzione test_add quattro volte, una per ogni set di parametri.

Tecniche di Parametrizzazione Avanzate

Pytest offre diverse tecniche avanzate per la parametrizzazione, tra cui:

• Utilizzo di Fixture con Parametrizzazione: Combina le fixture con la parametrizzazione per fornire setup diversi per ogni caso di test.
• ID per i Casi di Test: Assegna ID personalizzati ai casi di test per migliorare la reportistica e il debugging.
• Parametrizzazione Indiretta: Parametrizza gli argomenti passati alle fixture, consentendo la creazione dinamica di fixture.

Utilizzo di Fixture con Parametrizzazione

Questo ti permette di configurare dinamicamente le fixture in base ai parametri passati al test. Immagina di testare una funzione che interagisce con un database. Potresti voler utilizzare diverse configurazioni del database (ad es. diverse stringhe di connessione) per diversi casi di test.

            
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 la creazione di una connessione al database
    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):
    # La tua logica di test qui, usando la fixture db_connection
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

In questo esempio, la fixture db_config è parametrizzata. L'argomento indirect=True indica a Pytest di passare i parametri ("prod" e "test") alla funzione della fixture db_config. La fixture db_config restituisce quindi diverse configurazioni del database in base al valore del parametro. La fixture db_connection utilizza la fixture db_config per stabilire una connessione al database. Infine, la funzione test_database_interaction utilizza la fixture db_connection per interagire con il database.

ID per i Casi di Test

Gli ID personalizzati forniscono nomi più descrittivi per i tuoi casi di test nel report, rendendo più facile identificare ed eseguire il debug degli errori.

            
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
              
            
          

Senza ID, Pytest genererebbe nomi generici come test_uppercase[0], test_uppercase[1], ecc. Con gli ID, il report dei test mostrerà nomi più significativi come test_uppercase[lowercase_hello].

Parametrizzazione Indiretta

La parametrizzazione indiretta ti consente di parametrizzare l'input di una fixture, invece della funzione di test direttamente. Ciò è utile quando si desidera creare diverse istanze di fixture in base al valore del parametro.

            
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, "Il nome non può essere vuoto"
    if "@" not in data["email"]:
        return False, "Indirizzo email non valido"
    return True, "Dati validi"

@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 == "Dati validi"
    else:
        assert is_valid is False
        assert message in ["Il nome non può essere vuoto", "Indirizzo email non valido"]

            

              
                Copy
              
            
          

In questo esempio, la fixture input_data è parametrizzata con i valori "valid" e "invalid". L'argomento indirect=True indica a Pytest di passare questi valori alla funzione della fixture input_data. La fixture input_data restituisce quindi dizionari di dati diversi in base al valore del parametro. La funzione test_validate_data utilizza quindi la fixture input_data per testare la funzione validate_data con dati di input diversi.

Il Mocking con Pytest

Il mocking è una tecnica utilizzata per sostituire le dipendenze reali con sostituti controllati (mock) durante i test. Ciò consente di isolare il codice in fase di test e di evitare di dipendere da sistemi esterni, come database, API o file system.

Vantaggi del Mocking

• Isolare il Codice: Testa il codice in isolamento, senza dipendere da sistemi esterni.
• Controllare il Comportamento: Definisci il comportamento delle dipendenze, come valori di ritorno ed eccezioni.
• Accelerare i Test: Evita sistemi esterni lenti o inaffidabili.
• Testare i Casi Limite: Simula condizioni di errore e casi limite difficili da riprodurre in un ambiente reale.

Utilizzo della Libreria unittest.mock

Python fornisce la libreria unittest.mock per la creazione di mock. Pytest si integra perfettamente con unittest.mock, rendendo semplice la creazione di mock per le dipendenze nei tuoi test.

Esempio di Mocking di Base

Supponiamo di avere una funzione che recupera dati da un'API esterna:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Solleva un'eccezione per codici di stato non validi
    return response.json()

            

              
                Copy
              
            
          

Per testare questa funzione senza effettuare realmente una richiesta all'API, puoi usare un mock per la funzione requests.get:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configura il mock per restituire una risposta specifica
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Chiama la funzione da testare
    data = get_data_from_api("https://example.com/api")

    # Verifica che il mock sia stato chiamato con l'URL corretto
    mock_get.assert_called_once_with("https://example.com/api")

    # Verifica che la funzione abbia restituito i dati attesi
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

In questo esempio, il decoratore @patch("requests.get") sostituisce la funzione requests.get con un oggetto mock. L'argomento mock_get è l'oggetto mock. Possiamo quindi configurare l'oggetto mock per restituire una risposta specifica e verificare che sia stato chiamato con l'URL corretto.

Mocking con le Fixture

Puoi anche utilizzare le fixture per creare e gestire i mock. Questo può essere utile per condividere i mock tra più test o per creare configurazioni di mock più complesse.

            
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):
    # Chiama la funzione da testare
    data = get_data_from_api("https://example.com/api")

    # Verifica che il mock sia stato chiamato con l'URL corretto
    patched_get.assert_called_once_with("https://example.com/api")

    # Verifica che la funzione abbia restituito i dati attesi
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Qui, mock_api_get crea un mock e lo restituisce. patched_get utilizza quindi monkeypatch, una fixture di pytest, per sostituire la funzione reale `requests.get` con il mock. Ciò consente ad altri test di utilizzare lo stesso endpoint API "mockato".

Tecniche di Mocking Avanzate

Pytest e unittest.mock offrono diverse tecniche di mocking avanzate, tra cui:

• Side Effects (Effetti Collaterali): Definisci un comportamento personalizzato per i mock in base agli argomenti di input.
• Mocking delle Proprietà: Crea mock per le proprietà degli oggetti.
• Context Manager: Utilizza i mock all'interno di context manager per sostituzioni temporanee.

Side Effects (Effetti Collaterali)

Gli effetti collaterali (side effects) ti consentono di definire un comportamento personalizzato per i tuoi mock in base agli argomenti di input che ricevono. Ciò è utile per simulare diversi scenari o condizioni di errore.

            
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
              
            
          

Questo mock restituisce 1, 2 e 3 a chiamate successive, poi solleva un'eccezione `StopIteration` quando la lista è esaurita.

Mocking delle Proprietà

Il mocking delle proprietà ti consente di creare un mock per il comportamento delle proprietà degli oggetti. Ciò è utile per testare codice che si basa sulle proprietà degli oggetti piuttosto che sui metodi.

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "valore originale"


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

            

              
                Copy
              
            
          

Questo esempio crea un mock per la proprietà my_property dell'oggetto MyClass, consentendoti di controllarne il valore di ritorno durante il test.

Context Manager

L'uso di mock all'interno di context manager consente di sostituire temporaneamente le dipendenze per un blocco di codice specifico. Ciò è utile per testare codice che interagisce con sistemi o risorse esterne che dovrebbero essere "mockati" solo per un tempo limitato.

            
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
    # Il mock viene annullato automaticamente dopo il blocco 'with'
    # Assicurati che la funzione originale sia ripristinata, anche se non possiamo realmente asserire
    # il comportamento della funzione reale `os.path.exists` senza un percorso reale.
    # L'importante è che la patch venga rimossa dopo il contesto.
    print("Il mock è stato rimosso")

            

              
                Copy
              
            
          

Combinare Parametrizzazione e Mocking

Queste due potenti tecniche possono essere combinate per creare test ancora più sofisticati ed efficaci. Puoi usare la parametrizzazione per testare diversi scenari con diverse configurazioni di 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
              
            
          

In questo esempio, la funzione test_get_user_data è parametrizzata con diversi valori di user_id e expected_data. Il decoratore @patch crea un mock della funzione requests.get. Pytest eseguirà la funzione di test due volte, una per ogni set di parametri, con il mock configurato per restituire il corrispondente expected_data.

Best Practice per l'Uso di Fixture Avanzate

• Mantieni le Fixture Mirate: Ogni fixture dovrebbe avere uno scopo chiaro e specifico.
• Usa Scope Appropriati: Scegli lo scope della fixture appropriato (function, module, session) per ottimizzare l'uso delle risorse.
• Documenta le Fixture: Documenta chiaramente lo scopo e l'utilizzo di ogni fixture.
• Evita l'Eccesso di Mocking: Crea mock solo per le dipendenze necessarie a isolare il codice in fase di test.
• Scrivi Asserzioni Chiare: Assicurati che le tue asserzioni siano chiare e specifiche, verificando il comportamento atteso del codice testato.
• Considera lo Sviluppo Guidato dai Test (TDD): Scrivi i tuoi test prima di scrivere il codice, usando fixture e mock per guidare il processo di sviluppo.

Conclusione

Le tecniche avanzate di fixture di Pytest, inclusi i test parametrizzati e l'integrazione di mock, forniscono strumenti potenti per scrivere test robusti, efficienti e manutenibili. Padroneggiando queste tecniche, puoi migliorare significativamente la qualità del tuo codice Python e ottimizzare il tuo flusso di lavoro di testing. Ricorda di concentrarti sulla creazione di fixture chiare e mirate, utilizzando scope appropriati e scrivendo asserzioni complete. Con la pratica, sarai in grado di sfruttare tutto il potenziale del sistema di fixture di Pytest per creare una strategia di testing completa ed efficace.