Овладяване на разширените фикстури в Pytest: параметризирано тестване и интеграция на mock обекти

Pytest е мощна и гъвкава рамка за тестване на Python. Нейната простота и разширяемост я правят предпочитана сред разработчиците по целия свят. Една от най-завладяващите характеристики на Pytest е нейната система от фикстури, която позволява елегантни и многократно използваеми настройки за тестове. Тази публикация в блога се задълбочава в разширените техники за фикстури, като се фокусира специално върху параметризираното тестване и интеграцията на mock обекти. Ще разгледаме как тези техники могат значително да подобрят вашия работен процес по тестване, водейки до по-надежден и лесен за поддръжка код.

Разбиране на Pytest фикстурите

Преди да се потопим в по-сложни теми, нека накратко припомним основите на Pytest фикстурите. Фикстурата е функция, която се изпълнява преди всяка тестова функция, към която е приложена. Тя се използва за осигуряване на фиксирана изходна база за тестовете, гарантирайки последователност и намалявайки повтарящия се код. Фикстурите могат да изпълняват задачи като:

• Създаване на връзка с база данни
• Създаване на временни файлове или директории
• Инициализиране на обекти със специфични конфигурации
• Удостоверяване с API

Фикстурите насърчават повторното използване на код и правят тестовете ви по-четими и лесни за поддръжка. Те могат да бъдат дефинирани с различен обхват (функция, модул, сесия), за да се контролира техният жизнен цикъл и потреблението на ресурси.

Пример за основна фикстура

Ето един прост пример за Pytest фикстура, която създава временна директория:

            
import pytest
import tempfile
import os

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

            

              
                Copy
              
            
          

За да използвате тази фикстура в тест, просто я включете като аргумент във вашата тестова функция:

            
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
              
            
          

Параметризирано тестване с Pytest

Параметризираното тестване ви позволява да изпълните една и съща тестова функция многократно с различни набори от входни данни. Това е особено полезно за тестване на функции с различни входни данни и очаквани резултати. Pytest предоставя декоратора @pytest.mark.parametrize за прилагане на параметризирани тестове.

Предимства на параметризираното тестване

• Намалява дублирането на код: Избягвайте писането на множество почти идентични тестови функции.
• Подобрява покритието на тестовете: Лесно тествайте по-широк набор от входни стойности.
• Подобрява четимостта на тестовете: Ясно дефинирайте входните стойности и очакваните резултати за всеки тестов случай.

Пример за основна параметризация

Да кажем, че имате функция, която събира две числа:

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

            

              
                Copy
              
            
          

Можете да използвате параметризирано тестване, за да тествате тази функция с различни входни стойности:

            
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
              
            
          

В този пример декораторът @pytest.mark.parametrize дефинира четири тестови случая, всеки с различни стойности за x, y и очаквания резултат. Pytest ще изпълни функцията test_add четири пъти, по веднъж за всеки набор от параметри.

Разширени техники за параметризация

Pytest предлага няколко разширени техники за параметризация, включително:

• Използване на фикстури с параметризация: Комбинирайте фикстури с параметризация, за да предоставите различни настройки за всеки тестов случай.
• Идентификатори (Ids) за тестови случаи: Присвоявайте персонализирани идентификатори на тестовите случаи за по-добро отчитане и отстраняване на грешки.
• Непряка параметризация: Параметризирайте аргументите, предавани на фикстурите, което позволява динамично създаване на фикстури.

Използване на фикстури с параметризация

Това ви позволява динамично да конфигурирате фикстури въз основа на параметрите, предадени на теста. Представете си, че тествате функция, която взаимодейства с база данни. Може да искате да използвате различни конфигурации на базата данни (напр. различни низове за връзка) за различни тестови случаи.

            
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):
    # Simulate establishing a database connection
    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):
    # Your test logic here, using the db_connection fixture
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

В този пример фикстурата db_config е параметризирана. Аргументът indirect=True казва на Pytest да предаде параметрите ("prod" и "test") на функцията на фикстурата db_config. След това фикстурата db_config връща различни конфигурации на базата данни в зависимост от стойността на параметъра. Фикстурата db_connection използва фикстурата db_config, за да установи връзка с базата данни. Накрая, функцията test_database_interaction използва фикстурата db_connection, за да взаимодейства с базата данни.

Идентификатори (Ids) за тестови случаи

Персонализираните идентификатори предоставят по-описателни имена за вашите тестови случаи в отчета за тестовете, което улеснява идентифицирането и отстраняването на грешки.

            
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
              
            
          

Без идентификатори Pytest би генерирал общи имена като test_uppercase[0], test_uppercase[1] и т.н. С идентификатори отчетът за тестовете ще показва по-смислени имена като test_uppercase[lowercase_hello].

Непряка параметризация

Непряката параметризация ви позволява да параметризирате входа на фикстура, вместо директно на тестовата функция. Това е полезно, когато искате да създадете различни инстанции на фикстури въз основа на стойността на параметъра.

            
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
              
            
          

В този пример фикстурата input_data е параметризирана със стойностите "valid" и "invalid". Аргументът indirect=True казва на Pytest да предаде тези стойности на функцията на фикстурата input_data. След това фикстурата input_data връща различни речници с данни в зависимост от стойността на параметъра. Функцията test_validate_data след това използва фикстурата input_data, за да тества функцията validate_data с различни входни данни.

Mocking с Pytest

Mocking (имитиране) е техника, използвана за замяна на реални зависимости с контролирани заместители (mocks) по време на тестване. Това ви позволява да изолирате тествания код и да избегнете разчитането на външни системи, като бази данни, API или файлови системи.

Предимства на Mocking

• Изолиране на код: Тествайте кода в изолация, без да разчитате на външни зависимости.
• Контрол на поведението: Дефинирайте поведението на зависимостите, като върнати стойности и изключения.
• Ускоряване на тестовете: Избягвайте бавни или ненадеждни външни системи.
• Тестване на крайни случаи: Симулирайте условия за грешки и крайни случаи, които са трудни за възпроизвеждане в реална среда.

Използване на библиотеката unittest.mock

Python предоставя библиотеката unittest.mock за създаване на mock обекти. Pytest се интегрира безпроблемно с unittest.mock, което улеснява имитирането на зависимости във вашите тестове.

Пример за основен Mocking

Да кажем, че имате функция, която извлича данни от външно API:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()

            

              
                Copy
              
            
          

За да тествате тази функция, без реално да правите заявка към API, можете да имитирате функцията requests.get:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configure the mock to return a specific response
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

В този пример декораторът @patch("requests.get") заменя функцията requests.get с mock обект. Аргументът mock_get е mock обектът. След това можем да конфигурираме mock обекта да връща конкретен отговор и да твърдим, че е бил извикан с правилния URL адрес.

Mocking с фикстури

Можете също да използвате фикстури за създаване и управление на mock обекти. Това може да бъде полезно за споделяне на mock обекти между няколко теста или за създаване на по-сложни mock настройки.

            
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):
    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Тук mock_api_get създава mock обект и го връща. След това patched_get използва monkeypatch, фикстура на pytest, за да замени реалния `requests.get` с mock обекта. Това позволява на други тестове да използват същата имитирана API крайна точка.

Разширени техники за Mocking

Pytest и unittest.mock предлагат няколко разширени техники за mocking, включително:

• Странични ефекти (Side Effects): Дефинирайте персонализирано поведение за mock обекти въз основа на входните аргументи.
• Mocking на свойства (Property Mocking): Имитирайте свойства на обекти.
• Контекстни мениджъри (Context Managers): Използвайте mock обекти в контекстни мениджъри за временни замени.

Странични ефекти

Страничните ефекти ви позволяват да дефинирате персонализирано поведение за вашите mock обекти въз основа на входните аргументи, които получават. Това е полезно за симулиране на различни сценарии или условия за грешки.

            
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
              
            
          

Този mock обект връща 1, 2 и 3 при последователни извиквания, след което предизвиква изключение `StopIteration`, когато списъкът се изчерпи.

Mocking на свойства

Mocking на свойства ви позволява да имитирате поведението на свойствата на обекти. Това е полезно за тестване на код, който разчита на свойства на обекти, а не на методи.

            
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
              
            
          

Този пример имитира свойството my_property на обекта MyClass, което ви позволява да контролирате неговата върната стойност по време на теста.

Контекстни мениджъри

Използването на mock обекти в контекстни мениджъри ви позволява временно да замените зависимости за определен блок от код. Това е полезно за тестване на код, който взаимодейства с външни системи или ресурси, които трябва да бъдат имитирани само за ограничено време.

            
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
    # The mock is automatically reverted after the 'with' block
    # Ensure the original function is restored, although we can't really assert
    # the real `os.path.exists` function's behavior without a real path.
    # The important thing is that the patch is gone after the context.
    print("Mock has been removed")

            

              
                Copy
              
            
          

Комбиниране на параметризация и Mocking

Тези две мощни техники могат да бъдат комбинирани за създаване на още по-сложни и ефективни тестове. Можете да използвате параметризация, за да тествате различни сценарии с различни 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
              
            
          

В този пример функцията test_get_user_data е параметризирана с различни стойности на user_id и expected_data. Декораторът @patch имитира функцията requests.get. Pytest ще изпълни тестовата функция два пъти, по веднъж за всеки набор от параметри, като mock обектът е конфигуриран да връща съответните expected_data.

Най-добри практики за използване на разширени фикстури

• Поддържайте фикстурите фокусирани: Всяка фикстура трябва да има ясна и конкретна цел.
• Използвайте подходящи обхвати: Изберете подходящия обхват на фикстурата (функция, модул, сесия), за да оптимизирате използването на ресурси.
• Документирайте фикстурите: Ясно документирайте целта и употребата на всяка фикстура.
• Избягвайте прекомерното имитиране (Over-Mocking): Имитирайте само зависимости, които са необходими за изолиране на тествания код.
• Пишете ясни твърдения (Assertions): Уверете се, че вашите твърдения са ясни и конкретни, като проверяват очакваното поведение на тествания код.
• Обмислете разработка, управлявана от тестове (TDD): Пишете вашите тестове преди да напишете кода, като използвате фикстури и mock обекти, за да ръководите процеса на разработка.

Заключение

Разширените техники за фикстури на Pytest, включително параметризирано тестване и интеграция на mock обекти, предоставят мощни инструменти за писане на надеждни, ефективни и лесни за поддръжка тестове. Като овладеете тези техники, можете значително да подобрите качеството на вашия Python код и да оптимизирате работния си процес по тестване. Не забравяйте да се съсредоточите върху създаването на ясни, фокусирани фикстури, използването на подходящи обхвати и писането на изчерпателни твърдения. С практика ще можете да използвате пълния потенциал на системата от фикстури на Pytest, за да създадете цялостна и ефективна стратегия за тестване.