Область видимости фикстур: scope и autouse

Из пятого урока мы вынесли правило: каждому тесту — свежий экземпляр фикстуры. Это безопасно, но не всегда дёшево: соединение с базой, запуск тестового сервера, чтение большого файла — каждое из них дорого, и создавать их по разу на тест расточительно. У pytest есть ручка и для этого: аргумент scope у декоратора фикстуры. Плюс вторая ручка — autouse — для фикстур, которые должны применяться ко всем тестам без просьб. Разберём обе с доказательствами, а не на словах.

По умолчанию: свежий экземпляр на каждый тест

Как доказать, что фикстура создаётся заново для каждого теста? Счётчиком. Положим в тестовый файл словарь-счётчик и будем увеличивать его в фикстуре — а тесты проверят его значение в момент выполнения.

from pathlib import Path

Path("test_scope.py").write_text("""import pytest

calls = {"cart": 0}

@pytest.fixture
def cart():
    calls["cart"] += 1
    return ["хлеб"]

def test_first(cart):
    assert cart == ["хлеб"]
    assert calls["cart"] == 1

def test_second(cart):
    assert cart == ["хлеб"]
    assert calls["cart"] == 2
""", encoding="utf-8")

import pytest

rc = pytest.main(["test_scope.py", "-q", "--no-header", "-p", "no:cacheprovider"])
print("exit:", int(rc))

..                                                                       [100%]
2 passed in 0.01s
exit: 0

Оба теста зелёные, и по assert'ам видна механика: в первом тесте счётчик равен единице — фикстура отработала один раз. Во втором — двойке: pytest снова вызвал фикстуру, свежую корзину получил второй тест, а счётчик честно это задокументировал. Это и есть значение scope по умолчанию — "function": один вызов на одну тест-функцию.

scope="module": один вызов на файл

Теперь та же схема, но фикстуре задан scope="module" — «один экземпляр на модуль», то есть на весь тестовый файл. Счётчик снова в деле — ожидания у тестов другие:

from pathlib import Path

Path("test_scope.py").write_text("""import pytest

calls = {"orders": 0}

@pytest.fixture(scope="module")
def orders():
    calls["orders"] += 1
    return 3

def test_orders_count(orders):
    assert orders == 3
    assert calls["orders"] == 1

def test_orders_positive(orders):
    assert orders > 0
    assert calls["orders"] == 1
""", encoding="utf-8")

import pytest

rc = pytest.main(["test_scope.py", "-q", "--no-header", "-p", "no:cacheprovider"])
print("exit:", int(rc))

..                                                                       [100%]
2 passed in 0.01s
exit: 0

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

autouse: фикстура без аргумента

Обе фикстуры выше тесты принимали аргументом. А если подготовка нужна всем тестам файла, и перечислять её в каждом — шум? Флаг autouse=True включает фикстуру автоматически: тесты её не объявляют, а она всё равно выполняется перед каждым из них. Классика жанра — лог: записать, какой тест запустился.

from pathlib import Path

Path("test_log.py").write_text("""import pytest

LOG = []

@pytest.fixture(autouse=True)
def note(request):
    LOG.append(request.node.name)

def test_sum():
    assert sum([1, 2, 3]) == 6
    assert LOG == ["test_sum"]

def test_len():
    assert len("pytest") == 6
    assert LOG[-1] == "test_len"
""", encoding="utf-8")

import pytest

rc = pytest.main(["test_log.py", "-q", "--no-header", "-p", "no:cacheprovider"])
print("exit:", int(rc))

..                                                                       [100%]
2 passed in 0.01s
exit: 0

Две точки, 2 passed, и ни один тест не упомянул note в аргументах. Разбор трюка: autouse=True включает фикстуру в прогон каждого теста файла, а аргумент request — встроенный объект pytest, через который фикстура узнаёт контекст: request.node.name вернул имя запускаемого теста. Лог зафиксировал оба имени в порядке выполнения — снова сверху вниз, как в четвёртом уроке.

Когда общее состояние опасно

Теперь цена вопроса. Фикстура со scope="module" создаётся один раз — значит, все тесты файла получают один и тот же объект. Пока объект только читают, всё хорошо. Стоит его изменить — изменения доживут до следующих тестов. Проведём опыт: module-корзина, первый тест кладёт в неё товар, второй проверяет, что в ней оказалось.

from pathlib import Path

Path("test_leak.py").write_text("""import pytest

@pytest.fixture(scope="module")
def cart():
    return ["хлеб"]

def test_add_item(cart):
    cart.append("молоко")
    assert cart == ["хлеб", "молоко"]

def test_sees_leftovers(cart):
    assert cart == ["хлеб", "молоко"]
""", encoding="utf-8")

import pytest

rc = pytest.main(["test_leak.py", "-q", "--no-header", "-p", "no:cacheprovider"])
print("exit:", int(rc))

..                                                                       [100%]
2 passed in 0.01s
exit: 0

Оба теста зелёные — и это плохая новость, замаскированная под хорошую. Второй тест увидел молоко, которое добавил первый: изменяемое состояние протекло между тестами. Набор стал зависимым от порядка: поменяй тесты местами — второй упадёт, потому что молока ещё нет. С фикстурой по умолчанию этот опыт невозможен: каждому тесту досталась бы своя корзина только с хлебом.

Сводим обе темы: scope и yield умеют работать в паре. Module-фикстура с уборкой выполняет код после yield один раз — после всех тестов файла. Это доказуемо тем же способом, каким мы проверяли уборку в шестом уроке: фикстура пишет файл на teardown, а скрипт проверяет его после прогона.

from pathlib import Path

Path("test_scope.py").write_text("""from pathlib import Path

import pytest

@pytest.fixture(scope="module")
def orders():
    yield 3
    Path("module_end.txt").write_text("фикстура закрылась после всех тестов файла", encoding="utf-8")

def test_orders_count(orders):
    assert orders == 3

def test_orders_positive(orders):
    assert orders > 0
""", encoding="utf-8")

import pytest

rc = pytest.main(["test_scope.py", "-q", "--no-header", "-p", "no:cacheprovider"])
print(Path("module_end.txt").read_text(encoding="utf-8"))
print("exit:", int(rc))

..                                                                       [100%]
2 passed in 0.01s
фикстура закрылась после всех тестов файла
exit: 0

Файл появился — значит, teardown module-фикстуры сработал, и сработал ровно один раз: после обоих тестов. Так строят долгоживущие ресурсы: соединение открывается на файл, а закрывается после последнего теста, даже если часть тестов упала — механизм уборки из шестого урока действует и на широком scope.

@pytest.fixture(scope="session")
def engine():
    return "соединение с базой"

@pytest.fixture(scope="session")
def api():
    return "запущенный тестовый сервер"

Широкий scope и autouse тоже сочетаются: @pytest.fixture(autouse=True, scope="module") — сквозная логика, выполняемая один раз на файл. Например, засечь время прогона файла целиком и записать в лог:

import time
import pytest

TIMES = []

@pytest.fixture(autouse=True, scope="module")
def stopwatch():
    started = time.monotonic()
    yield
    TIMES.append(round(time.monotonic() - started, 2))

И последнее в сегодняшней программе: фикстуры не обязаны жить в самом тестовом файле. Вынеси их в conftest.py рядом с тестами — pytest подхватит файл сам, без импортов, а флаги scope и autouse работают там же. Это разыменовывает руки: общая подготовка папки описывается один раз, а не копируется по файлам.

# conftest.py - лежит в папке с тестами
import pytest

@pytest.fixture(scope="module")
def config():
    return {"env": "test"}

@pytest.fixture(autouse=True)
def guard():
    yield
    # уборка после каждого теста папки

Что дальше

Ты умеешь управлять временем жизни фикстур: function — по умолчанию, module — на файл, session — на прогон; autouse — для сквозной логики без аргументов; и знаешь цену широкого scope — общее изменяемое состояние. Фикстуры освоены. Дальше параметризация: один тест и список случаев вместо десятка копий — второй мегаштабирующий приём pytest. А в одиннадцатом уроке встретимся со встроенными фикстурами capsys и tmp_path, которые pytest даёт бесплатно.

Scope — это обмен: платишь общим состоянием, получаешь экономию на подготовке. Покупай только то, что не мутирует.