Mestring av Avanserte Pytest Fixtures: Parametrisert Testing og Mock-integrasjon

Pytest er et kraftig og fleksibelt testrammeverk for Python. Dets enkelhet og utvidbarhet gjør det til en favoritt blant utviklere over hele verden. En av Pytests mest overbevisende funksjoner er fixture-systemet, som muliggjør elegante og gjenbrukbare testoppsett. Dette blogginnlegget dykker ned i avanserte fixture-teknikker, med spesielt fokus på parametrisert testing og mock-integrasjon. Vi vil utforske hvordan disse teknikkene kan forbedre testarbeidsflyten din betydelig, noe som fører til mer robust og vedlikeholdbar kode.

Forståelse av Pytest Fixtures

Før vi dykker ned i avanserte emner, la oss kort oppsummere det grunnleggende om Pytest fixtures. En fixture er en funksjon som kjører før hver testfunksjon den blir brukt på. Den brukes til å gi et fast utgangspunkt for tester, noe som sikrer konsistens og reduserer overflødig kode. Fixtures kan utføre oppgaver som:

• Sette opp en databasetilkobling
• Opprette midlertidige filer eller mapper
• Initialisere objekter med spesifikke konfigurasjoner
• Autentisere med et API

Fixtures fremmer gjenbruk av kode og gjør testene dine mer lesbare og vedlikeholdbare. De kan defineres med forskjellige omfang (function, module, session) for å kontrollere levetiden og ressursbruken deres.

Grunnleggende Fixture-eksempel

Her er et enkelt eksempel på en Pytest fixture som oppretter en midlertidig mappe:

            
import pytest
import tempfile
import os

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

            

              
                Copy
              
            
          

For å bruke denne fixturen i en test, inkluderer du den bare som et argument til testfunksjonen din:

            
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
              
            
          

Parametrisert Testing med Pytest

Parametrisert testing lar deg kjøre den samme testfunksjonen flere ganger med forskjellige sett av inndata. Dette er spesielt nyttig for å teste funksjoner med varierende input og forventet output. Pytest tilbyr dekoratoren @pytest.mark.parametrize for å implementere parametriserte tester.

Fordeler med Parametrisert Testing

• Reduserer kodeduplisering: Unngå å skrive flere nesten identiske testfunksjoner.
• Forbedrer testdekning: Test enkelt et bredere spekter av inndataverdier.
• Forbedrer lesbarheten til tester: Definer tydelig inndataverdiene og forventet output for hvert testtilfelle.

Grunnleggende Parametriseringseksempel

La oss si du har en funksjon som legger sammen to tall:

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

            

              
                Copy
              
            
          

Du kan bruke parametrisert testing for å teste denne funksjonen med forskjellige inndataverdier:

            
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
              
            
          

I dette eksemplet definerer @pytest.mark.parametrize-dekoratoren fire testtilfeller, hver med forskjellige verdier for x, y, og det forventede resultatet. Pytest vil kjøre test_add-funksjonen fire ganger, én gang for hvert sett med parametere.

Avanserte Parametriseringsteknikker

Pytest tilbyr flere avanserte teknikker for parametrisering, inkludert:

• Bruke Fixtures med Parametrisering: Kombiner fixtures med parametrisering for å gi forskjellige oppsett for hvert testtilfelle.
• ID-er for Testtilfeller: Tildel egendefinerte ID-er til testtilfeller for bedre rapportering og feilsøking.
• Indirekte Parametrisering: Parametriser argumentene som sendes til fixtures, noe som tillater dynamisk opprettelse av fixtures.

Bruke Fixtures med Parametrisering

Dette lar deg dynamisk konfigurere fixtures basert på parameterne som sendes til testen. Tenk deg at du tester en funksjon som samhandler med en database. Du vil kanskje bruke forskjellige databasekonfigurasjoner (f.eks. forskjellige tilkoblingsstrenger) for forskjellige testtilfeller.

            
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):
    # Simulerer etablering av databasetilkobling
    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):
    # Din testlogikk her, ved bruk av db_connection fixture
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

I dette eksemplet er db_config-fixturen parametrisert. Argumentet indirect=True forteller Pytest at parameterne ("prod" og "test") skal sendes til db_config-fixturefunksjonen. db_config-fixturen returnerer deretter forskjellige databasekonfigurasjoner basert på parameterverdien. db_connection-fixturen bruker db_config-fixturen for å etablere en databasetilkobling. Til slutt bruker test_database_interaction-funksjonen db_connection-fixturen for å samhandle med databasen.

ID-er for Testtilfeller

Egendefinerte ID-er gir mer beskrivende navn for testtilfellene dine i testrapporten, noe som gjør det enklere å identifisere og feilsøke feil.

            
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
              
            
          

Uten ID-er ville Pytest generert generiske navn som test_uppercase[0], test_uppercase[1], osv. Med ID-er vil testrapporten vise mer meningsfulle navn som test_uppercase[lowercase_hello].

Indirekte Parametrisering

Indirekte parametrisering lar deg parametrisere input til en fixture, i stedet for direkte til testfunksjonen. Dette er nyttig når du vil opprette forskjellige fixture-instanser basert på parameterverdien.

            
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
              
            
          

I dette eksemplet er input_data-fixturen parametrisert med verdiene "valid" og "invalid". Argumentet indirect=True forteller Pytest at disse verdiene skal sendes til input_data-fixturefunksjonen. input_data-fixturen returnerer deretter forskjellige data-ordbøker basert på parameterverdien. test_validate_data-funksjonen bruker deretter input_data-fixturen for å teste validate_data-funksjonen med forskjellige inndata.

Mocking med Pytest

Mocking er en teknikk som brukes til å erstatte ekte avhengigheter med kontrollerte substitutter (mocks) under testing. Dette lar deg isolere koden som testes og unngå å være avhengig av eksterne systemer, som databaser, API-er eller filsystemer.

Fordeler med Mocking

• Isoler kode: Test kode isolert, uten å stole på eksterne avhengigheter.
• Kontroller oppførsel: Definer oppførselen til avhengigheter, som returverdier og unntak.
• Gjør tester raskere: Unngå trege eller upålitelige eksterne systemer.
• Test hjørnetilfeller: Simuler feiltilstander og hjørnetilfeller som er vanskelige å reprodusere i et ekte miljø.

Bruk av unittest.mock-biblioteket

Python tilbyr unittest.mock-biblioteket for å lage mocks. Pytest integreres sømløst med unittest.mock, noe som gjør det enkelt å mocke avhengigheter i testene dine.

Grunnleggende Mocking-eksempel

La oss si du har en funksjon som henter data fra et eksternt API:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Kast et unntak for dårlige statuskoder
    return response.json()

            

              
                Copy
              
            
          

For å teste denne funksjonen uten å faktisk gjøre en forespørsel til API-et, kan du mocke requests.get-funksjonen:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Konfigurer mock-objektet til å returnere en spesifikk respons
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Kall funksjonen som testes
    data = get_data_from_api("https://example.com/api")

    # Verifiser at mock-objektet ble kalt med riktig URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Verifiser at funksjonen returnerte de forventede dataene
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

I dette eksemplet erstatter @patch("requests.get")-dekoratoren requests.get-funksjonen med et mock-objekt. mock_get-argumentet er mock-objektet. Vi kan deretter konfigurere mock-objektet til å returnere en spesifikk respons og verifisere at det ble kalt med riktig URL.

Mocking med Fixtures

Du kan også bruke fixtures til å opprette og administrere mocks. Dette kan være nyttig for å dele mocks på tvers av flere tester eller for å lage mer komplekse mock-oppsett.

            
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):
    # Kall funksjonen som testes
    data = get_data_from_api("https://example.com/api")

    # Verifiser at mock-objektet ble kalt med riktig URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Verifiser at funksjonen returnerte de forventede dataene
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Her oppretter mock_api_get en mock og returnerer den. patched_get bruker deretter monkeypatch, en pytest-fixture, for å erstatte den ekte `requests.get` med mocken. Dette lar andre tester bruke det samme mockede API-endepunktet.

Avanserte Mocking-teknikker

Pytest og unittest.mock tilbyr flere avanserte mocking-teknikker, inkludert:

• Sideeffekter: Definer tilpasset oppførsel for mocks basert på inndata-argumentene.
• Mocking av Egenskaper: Mock egenskaper (properties) til objekter.
• Kontekstbehandlere: Bruk mocks innenfor kontekstbehandlere for midlertidige erstatninger.

Sideeffekter

Sideeffekter lar deg definere tilpasset oppførsel for dine mocks basert på inndata-argumentene de mottar. Dette er nyttig for å simulere forskjellige scenarier eller feiltilstander.

            
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
              
            
          

Denne mocken returnerer 1, 2 og 3 ved påfølgende kall, og kaster deretter et `StopIteration`-unntak når listen er tom.

Mocking av Egenskaper

Mocking av egenskaper lar deg mocke oppførselen til egenskaper (properties) på objekter. Dette er nyttig for å teste kode som er avhengig av objektegenskaper i stedet for metoder.

            
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
              
            
          

Dette eksemplet mocker my_property-egenskapen til MyClass-objektet, slik at du kan kontrollere returverdien under testen.

Kontekstbehandlere

Bruk av mocks innenfor kontekstbehandlere lar deg midlertidig erstatte avhengigheter for en spesifikk kodeblokk. Dette er nyttig for å teste kode som samhandler med eksterne systemer eller ressurser som bare skal mockes i en begrenset periode.

            
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
    # Mocken blir automatisk tilbakestilt etter 'with'-blokken
    # Sikre at den opprinnelige funksjonen er gjenopprettet, selv om vi egentlig ikke kan verifisere
    # den ekte `os.path.exists`-funksjonens oppførsel uten en ekte filsti.
    # Det viktige er at patchen er borte etter konteksten.
    print("Mock has been removed")

            

              
                Copy
              
            
          

Kombinere Parametrisering og Mocking

Disse to kraftige teknikkene kan kombineres for å lage enda mer sofistikerte og effektive tester. Du kan bruke parametrisering for å teste forskjellige scenarier med forskjellige mock-konfigurasjoner.

            
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
              
            
          

I dette eksemplet er test_get_user_data-funksjonen parametrisert med forskjellige user_id- og expected_data-verdier. @patch-dekoratoren mocker requests.get-funksjonen. Pytest vil kjøre testfunksjonen to ganger, én gang for hvert sett med parametere, med mocken konfigurert til å returnere den tilsvarende expected_data.

Beste Praksis for Bruk av Avanserte Fixtures

• Hold Fixtures Fokuserte: Hver fixture bør ha et klart og spesifikt formål.
• Bruk Passende Omfang (Scopes): Velg riktig fixture-omfang (function, module, session) for å optimalisere ressursbruken.
• Dokumenter Fixtures: Dokumenter formålet og bruken av hver fixture tydelig.
• Unngå Overdreven Mocking: Mock kun de avhengighetene som er nødvendige for å isolere koden som testes.
• Skriv Tydelige Assertions: Sørg for at dine assertions er klare og spesifikke, og verifiserer den forventede oppførselen til koden som testes.
• Vurder Testdrevet Utvikling (TDD): Skriv testene dine før du skriver koden, og bruk fixtures og mocks for å veilede utviklingsprosessen.

Konklusjon

Pytests avanserte fixture-teknikker, inkludert parametrisert testing og mock-integrasjon, gir kraftige verktøy for å skrive robuste, effektive og vedlikeholdbare tester. Ved å mestre disse teknikkene kan du betydelig forbedre kvaliteten på Python-koden din og effektivisere testarbeidsflyten. Husk å fokusere på å lage klare, fokuserte fixtures, bruke passende omfang og skrive omfattende assertions. Med øvelse vil du kunne utnytte det fulle potensialet i Pytests fixture-system for å skape en omfattende og effektiv teststrategi.