Освоение продвинутых фикстур Pytest: параметризованное тестирование и интеграция моков

Pytest — это мощный и гибкий фреймворк для тестирования на Python. Его простота и расширяемость делают его фаворитом среди разработчиков по всему миру. Одной из самых привлекательных особенностей Pytest является система фикстур, которая позволяет создавать элегантные и многократно используемые настройки для тестов. Этот пост в блоге посвящен продвинутым техникам работы с фикстурами, в частности, параметризованному тестированию и интеграции моков. Мы рассмотрим, как эти техники могут значительно улучшить ваш процесс тестирования, приводя к созданию более надежного и поддерживаемого кода.

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

Прежде чем углубляться в продвинутые темы, давайте кратко вспомним основы фикстур Pytest. Фикстура — это функция, которая выполняется перед каждой тестовой функцией, к которой она применяется. Она используется для обеспечения фиксированной базовой среды для тестов, гарантируя согласованность и уменьшая количество шаблонного кода. Фикстуры могут выполнять такие задачи, как:

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

Фикстуры способствуют повторному использованию кода и делают ваши тесты более читаемыми и поддерживаемыми. Их можно определять с разным временем жизни (scope) (function, module, session), чтобы контролировать их жизненный цикл и потребление ресурсов.

Пример базовой фикстуры

Вот простой пример фикстуры 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 предлагает несколько продвинутых техник для параметризации, включая:

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

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

Это позволяет динамически настраивать фикстуры на основе параметров, передаваемых в тест. Представьте, что вы тестируете функцию, которая взаимодействует с базой данных. Возможно, вы захотите использовать разные конфигурации базы данных (например, разные строки подключения) для разных тестовых случаев.

            
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 для взаимодействия с базой данных.

Идентификаторы для тестовых случаев

Пользовательские идентификаторы обеспечивают более описательные имена для ваших тестовых случаев в отчете о тестировании, что упрощает идентификацию и отладку сбоев.

            
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) — это техника, используемая для замены реальных зависимостей контролируемыми заменителями (моками) во время тестирования. Это позволяет изолировать тестируемый код и избежать зависимости от внешних систем, таких как базы данных, API или файловые системы.

Преимущества мокинга

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

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

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

Пример базового мокинга

Допустим, у вас есть функция, которая получает данные из внешнего 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, вы можете замокать (mock) функцию 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_get — это и есть мок-объект. Затем мы можем настроить мок-объект так, чтобы он возвращал определенный ответ, и проверить, что он был вызван с правильным URL.

Мокинг с помощью фикстур

Вы также можете использовать фикстуры для создания и управления моками. Это может быть полезно для совместного использования моков в нескольких тестах или для создания более сложных настроек моков.

            
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 создает мок и возвращает его. Затем patched_get использует monkeypatch, фикстуру pytest, чтобы заменить реальный `requests.get` на мок. Это позволяет другим тестам использовать ту же замоканную конечную точку API.

Продвинутые техники мокинга

Pytest и unittest.mock предлагают несколько продвинутых техник мокинга, включая:

• Побочные эффекты (Side Effects): Определяйте пользовательское поведение для моков на основе входных аргументов.
• Мокинг свойств: Мокайте свойства объектов.
• Контекстные менеджеры: Используйте моки в контекстных менеджерах для временной замены.

Побочные эффекты (Side Effects)

Побочные эффекты позволяют определять пользовательское поведение для ваших моков на основе входных аргументов, которые они получают. Это полезно для симуляции различных сценариев или условий ошибок.

            
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
              
            
          

Этот мок возвращает 1, 2 и 3 при последовательных вызовах, а затем вызывает исключение `StopIteration`, когда список исчерпан.

Мокинг свойств

Мокинг свойств позволяет мокать поведение свойств объектов. Это полезно для тестирования кода, который зависит от свойств объекта, а не от методов.

            
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, позволяя вам контролировать его возвращаемое значение во время теста.

Контекстные менеджеры

Использование моков в контекстных менеджерах позволяет временно заменять зависимости для определенного блока кода. Это полезно для тестирования кода, который взаимодействует с внешними системами или ресурсами, которые должны быть замоканы только на ограниченное время.

            
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
              
            
          

Совмещение параметризации и мокинга

Эти две мощные техники можно комбинировать для создания еще более сложных и эффективных тестов. Вы можете использовать параметризацию для тестирования различных сценариев с разными конфигурациями моков.

            
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 выполнит тестовую функцию дважды, по одному разу для каждого набора параметров, с моком, настроенным на возврат соответствующего expected_data.

Лучшие практики использования продвинутых фикстур

• Сохраняйте фикстуры сфокусированными: Каждая фикстура должна иметь четкое и конкретное назначение.
• Используйте подходящее время жизни (scope): Выбирайте подходящее время жизни фикстуры (function, module, session) для оптимизации использования ресурсов.
• Документируйте фикстуры: Четко документируйте назначение и использование каждой фикстуры.
• Избегайте избыточного мокинга: Мокайте только те зависимости, которые необходимы для изоляции тестируемого кода.
• Пишите четкие утверждения (assertions): Убедитесь, что ваши утверждения ясны и конкретны, проверяя ожидаемое поведение тестируемого кода.
• Рассмотрите разработку через тестирование (TDD): Пишите тесты перед написанием кода, используя фикстуры и моки для направления процесса разработки.

Заключение

Продвинутые техники фикстур Pytest, включая параметризованное тестирование и интеграцию моков, предоставляют мощные инструменты для написания надежных, эффективных и поддерживаемых тестов. Овладев этими техниками, вы сможете значительно улучшить качество вашего кода на Python и оптимизировать процесс тестирования. Не забывайте создавать четкие, сфокусированные фикстуры, использовать подходящее время жизни (scope) и писать исчерпывающие утверждения. С практикой вы сможете использовать весь потенциал системы фикстур Pytest для создания комплексной и эффективной стратегии тестирования.