load-tester Все курсы

✻ Урок 4.7 · Тема 4: Python для тестировщика

pytest: первые тесты

⏱ 3.5 ч

Как работать с кодом и когда идти дальше

Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:

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

Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.

Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.

Зачем это нужно

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

Автоматический тест это маленькая программа, которая сама делает проверку и отвечает «прошёл» или «упал». Тесты запускает pytest: библиотека, то есть набор готового кода, как requests в уроке 4.5. Саму проверку в нём пишут словом assert («утверждаю»).

Типичный случай: кто-то «слегка поправил» функцию, которая считает перцентиль p95: число, не больше которого 95 замеров из 100 (урок 4.2). Неделю команде уходят отчёты с неверными цифрами, и ошибку замечают случайно. С автоматическим тестом о ней узнают через секунду. Вот как он сообщил бы:

...F......
FAILED test_shoptools.py::test_percentile_of_sample[95-48] - assert 31 == 48
1 failed, 9 passed

Девять точек и одна буква F: девять проверок прошли, одна упала, потому что правка сломала расчёт p95 (вместо ожидаемых 48 получилось 31). Глазами такую ошибку в отчёте легко пропустить.

Тестировщику нагрузки тесты нужны для двух дел. Первое: проверять свои инструменты, как в этом случае. Второе: перед нагрузкой убедиться, что «Магазин» отвечает как надо: вход работает, корзина без токена даёт 401, несуществующий товар даёт 404. Нагрузка на сломанный сервис бессмысленна: ты измеришь, как быстро он отвечает ошибками.

Шаг проекта: ты ставишь pytest в окружение ~/perf-lab/.venv, пишешь модуль shoptools.py (перцентиль и доля ошибок), тесты к нему и первые тесты API «Магазина», коммитишь всё в perf-lab. Эти файлы работают в связке с measure.py из урока 8.1, а полноценные автотесты API ты разовьёшь в уроке 6.2.

Что нужно знать

  • Функции, return, исключения и try/except: урок 4.3.
  • Списки и словари, JSON-ответы API: урок 4.1, урок 4.4.
  • requests, Session, коды ответов, токен: урок 4.5. Тесты API из этого урока используют те же приёмы.
  • Окружение ~/perf-lab/.venv включено, стенд «Магазин» запущен (урок 2.1).
  • Перцентили (p50, p95, p99): урок 8.1. Если ты ещё не там, достаточно знать формулу из этого урока: перцентиль это значение, не больше которого p% измерений.
  • Из урока 4.6 нужен только синтаксис @имя и @имя(аргумент) (например, @pytest.fixture, @pytest.mark.parametrize). Классы здесь не требуются: пока считай @ пометкой над функцией.

Картина целиком

Возьми контролёра на фабрике. У него есть список проверок: «размер такой-то», «цвет такой-то». Он идёт по списку, ставит галочки и в конце докладывает: «из 18 проверок 17 прошли, одна провалена, вот какая и почему». Одна проверка из списка это тест, контролёр это pytest, доклад это отчёт. Для проверки изделие в Python часто нужно сначала подготовить. Такая подготовка (и уборка после неё) называется фикстурой: например, «новый покупатель, который уже вошёл в магазин».

flowchart TD
    A["pytest<br/>ищет файлы test_*.py"] --> B["Собирает функции<br/>test_*"]
    B --> C["Готовит фикстуры<br/>(сессия, покупатель)"]
    C --> D["Запускает тест:<br/>assert за assert"]
    D --> E["Отчёт:<br/>passed, failed"]

Что здесь видно: тесты не надо перечислять, pytest находит их по именам. Тебе остаётся написать сами проверки.

Теория

assert: проверка одной строкой

Как сказать программе «вот что должно быть верно» и заставить её закричать, если это не так? Для этого в Python есть слово assert. Если выражение после него истинно, программа идёт дальше. Если ложно, возникает исключение AssertionError (про исключения урок 4.3), и pytest отмечает тест как упавший.

Это галочка в чек-листе: условие либо выполнено, либо нет. На первой невыполненной галочке тест останавливается: остальные assert в нём уже не сработают.

Записывается просто: assert выражение. Особенность pytest в том, что при падении он показывает значения всех частей выражения, и писать сообщения вроде «ожидали 200, получили 201» не нужно.

def test_status_is_ok():
    status = 201
    assert status == 200
>       assert status == 200
E       assert 201 == 200

Стрелка > указывает на проверку, которая не сошлась. Строка с E (от «Error») показывает значения: слева то, что получили (201), справа то, что ждали (200). Для вызова функции в левой части pytest добавит строку where: откуда взялось значение.

Осторожно: assert (False, "ошибка") в скобках всегда проходит, потому что непустой кортеж считается истинным. Своё сообщение пишут без скобок: assert x == 5, "ожидали 5".

Главное: assert говорит «это должно быть верно», а pytest при падении сам показывает, что получили и что ждали.

Один assert мы написали. А как pytest узнаёт, какие функции вообще надо запускать?

Как pytest находит и запускает тесты

Перечислять тесты вручную скучно, поэтому pytest ищет их по именам. Ты запускаешь pytest в каталоге, и он обходит все вложенные папки и берёт файлы test_*.py (подойдёт и *_test.py). В них он ищет функции с именем test_... (и методы классов Test...) и выполняет каждую отдельно. Падение одного теста остальные не останавливает.

Тест проходит, если функция закончилась без исключения, и падает, если возникло исключение (чаще всего AssertionError). return и print для результата не нужны.

Вот самый маленький тест. В файле shoptools.py лежит функция percentile(values, p), полный код будет в практике:

from shoptools import percentile


def test_percentile_median_of_odd_list():
    assert percentile([30, 10, 20], 50) == 20

Строка from shoptools import percentile подключает функцию из соседнего файла, как import в уроке 4.3. Список [30, 10, 20] нарочно перемешан. После сортировки получится [10, 20, 30], середина это 20. Функция без сортировки вернула бы 10, и тест упал бы. Хороший тест проверяет не «функция запускается», а конкретный результат, который ты знаешь заранее.

Прикинь сам: ты написал функцию check_error_rate() в файле test_tools.py, внутри assert. Запустил pytest. Что будет?

Файл pytest найдёт, а функцию пропустит: её имя не начинается с test_. Итог: no tests ran («ни один тест не запущен»). Переименуй в test_error_rate, и всё заработает.

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

Главное: pytest сам находит файлы test_*.py и функции test_*, а тест проходит, если внутри не возникло исключение.

Запускать умеем. Что именно проверять в функциях, чтобы ловить настоящие ошибки?

Тестируем функции: обычные, крайние и ошибочные случаи

Вернёмся к случаю из начала. Ошибка в percentile сдвинула p95 на одну позицию, и все отчёты поплыли. Мелкие функции это сердце отчётов, а тесты на них пишутся быстрее всего. Проверяют три вида случаев.

Первый, обычный: данные, ответ на которых ты знаешь заранее (например, выборка из урока 8.1). Второй, крайний: пустой список, один элемент, p0 или p100. Ошибки живут именно на краях, а не посередине. Третий, ошибочный: данные, на которых функция обязана сломаться.

Для третьего нужен pytest.raises. Блок with (урок 4.4) значит «внутри обязана случиться ошибка ValueError» (про неё урок 4.3).

import pytest

from shoptools import percentile


def test_percentile_of_empty_list_fails():
    with pytest.raises(ValueError):
        percentile([], 95)

Если ошибки не случилось, тест упадёт с сообщением DID NOT RAISE. Текст ошибки тоже можно проверить: pytest.raises(ValueError, match="хотя бы одно"). Зачем так строго? Пустая выборка в нагрузочном скрипте означает «ни один запрос не прошёл», а не «задержка нулевая». Тихий ноль выглядел бы как отличный результат. Функция должна сказать о проблеме громко.

Ещё одна проверка: функция не должна портить свои аргументы. Наш перцентиль сортирует копию (sorted(values)). Сортировка самого списка (values.sort()) незаметно поменяла бы порядок замеров у вызывающего. Тест страхует от этого:

def test_percentile_does_not_change_input():
    data = [3, 1, 2]
    percentile(data, 50)
    assert data == [3, 1, 2]

Прикинь сам: функция error_rate(codes) считает долю кодов 400 и выше, а 0 считается обрывом соединения. Какие тесты ты бы написал?

Обычный: [200, 200, 200, 500] даёт 0.25, одна ошибка из четырёх. С обрывом: [200, 404, 0, 201] даёт 0.5, потому что и 404, и 0 считаются ошибками. Крайний: [200, 201, 204] даёт 0. Ошибочный: пустой список [] должен вызывать ValueError, а не деление на ноль.

Главное: для каждой функции проверяй обычный, крайний и ошибочный случаи, а ошибку проверяй через pytest.raises.

Для перцентиля нас интересуют сразу четыре значения: p50, p90, p95 и p99. Неужели писать четыре почти одинаковых теста?

Параметризация: один тест, много данных

Нет, четыре копии писать не надо. Как у контролёра: действия те же, различаются изделия. Ты описываешь таблицу «входные данные и ожидаемый результат» и один тест, который пробегает по ней. Это называется параметризацией.

Над тестом ставят декоратор @pytest.mark.parametrize (из урока 4.6 нужна только пометка @; здесь она «размножает» тест). Первый аргумент это строка с именами параметров через запятую. Второй это список наборов значений. pytest запускает тест отдельно для каждого набора, и в отчёте это отдельные строки.

import pytest

from shoptools import percentile

# Те же 20 измерений, что в уроке 8.1 (мс).
SAMPLE = [12, 13, 13, 14, 14, 15, 15, 15, 16, 16, 17, 17, 18, 19, 20, 22, 25, 31, 48, 410]


@pytest.mark.parametrize("p, expected", [(50, 16), (90, 31), (95, 48), (99, 410)])
def test_percentile_of_sample(p, expected):
    assert percentile(SAMPLE, p) == expected

Имена в "p, expected" совпадают с аргументами теста, наборов четыре. Проверим ожидания вручную. Для p95 умножаем долю на число замеров: 0,95 × 20 = 19. Берём девятнадцатое по счёту значение в отсортированном списке: это 48. Для p99: 0,99 × 20 = 19,8, округляем вверх до 20 (в коде это целочисленная формула с + 99 из урока 4.3), двадцатое значение это 410. Это метод ближайшего ранга, как в уроке 8.1.

flowchart TD
    A["Один тест<br/>test_percentile_of_sample"] --> B["p=50, expected=16"]
    A --> C["p=90, expected=31"]
    A --> D["p=95, expected=48"]
    A --> E["p=99, expected=410"]

Что здесь видно: из одной функции получилось четыре независимых теста. В отчёте с ключом -v («verbose», подробно) у каждого своя строка с набором в скобках: test_percentile_of_sample[95-48] PASSED. Если что-то упадёт, сразу видно, на каких данных.

Прикинь сам: сколько тестов запустит pytest для @pytest.mark.parametrize("product_id", [1, 42, 10000])?

Три, по одному на значение. В отчёте они будут называться test_product_exists[1], test_product_exists[42] и test_product_exists[10000].

Осторожно: цикл for внутри одного теста останавливается на первом падении, и непонятно, на каком наборе оно случилось. А ожидание, посчитанное той же функцией, всегда зелёное и бесполезное: считай его вручную, как мы сделали выше.

Главное: параметризация превращает таблицу данных в отдельные тесты, и по отчёту видно, какой набор упал.

С чистыми функциями разобрались. А для тестов API нужен залогиненный покупатель. Откуда его брать?

Фикстуры: подготовка и уборка

Тесту API нужно то, что не относится к проверке: адрес стенда, открытая сессия, залогиненный покупатель с токеном. Вход, написанный в каждом тесте, повторится десять раз. А общий покупатель на всех заставит тесты мешать друг другу: один положит товар в корзину, другой увидит чужую корзину.

Помогает фикстура (fixture, «приспособление»): функция, которая готовит нужное тесту и, если надо, убирает за ним.

Фикстура это обычная функция с декоратором @pytest.fixture. Чтобы тест её получил, достаточно назвать её среди аргументов теста: pytest сам подставит результат. Если в фикстуре есть yield («отдай»), код до него это подготовка, значение уходит тесту, а код после него - уборка. Она выполнится, даже если тест упал.

Ещё фикстура решает, как часто готовиться, и за это отвечает scope. По умолчанию подготовка идёт для каждого теста, а scope="session" значит один раз на весь запуск: так делают для адреса стенда и общей Session.

Нажми «Шаг ▶» и проследи за подготовкой и уборкой:

Что здесь видно: подготовка идёт до теста, yield передаёт сессию тесту, уборка выполняется после. Второй тест получает нового покупателя и пустую корзину.

Общие фикстуры живут в файле conftest.py рядом с тестами. pytest читает его сам, импортировать не нужно. Вот он для «Магазина»:

import os
import uuid
from urllib.parse import urlparse

import pytest
import requests


def pytest_addoption(parser):
    parser.addoption("--allow-remote", action="store_true", help="разрешить тесты не на локальном стенде")


@pytest.fixture(scope="session")
def base_url(request):
    """Адрес стенда; можно переопределить BASE_URL. Не локальный адрес только с --allow-remote."""
    url = os.getenv("BASE_URL", "http://localhost:8000")
    if urlparse(url).hostname not in ("localhost", "127.0.0.1") and not request.config.getoption("--allow-remote"):
        pytest.exit(f"{url} не локальный стенд; добавь --allow-remote, если уверен", returncode=2)
    return url


@pytest.fixture(scope="session")
def shop():
    """Одна Session на весь запуск: соединение переиспользуется."""
    with requests.Session() as session:
        yield session


@pytest.fixture
def buyer(shop, base_url):
    """Свежий покупатель: регистрируется, входит и отдаёт Session с токеном."""
    credentials = {"email": f"pytest-{uuid.uuid4().hex[:12]}@shop.lab", "password": "password"}
    assert shop.post(f"{base_url}/api/register", json=credentials, timeout=30).status_code == 201
    response = shop.post(f"{base_url}/api/login", json=credentials, timeout=30)
    assert response.status_code == 200
    with requests.Session() as session:
        session.headers["Authorization"] = "Bearer " + response.json()["token"]
        yield session

base_url читает переменную окружения (урок 1.1) и без неё берёт адрес по умолчанию. Защита: если адрес не локальный, тесты не стартуют без флага --allow-remote. Тесты создают пользователей и заказы, поэтому на боевой сервис их не запускай никогда.

shop это общая Session на весь запуск, yield внутри with закроет её в конце. buyer для каждого теста заводит нового пользователя. uuid.uuid4().hex[:12] это случайная строка из 12 символов, поэтому почта каждый раз новая, например pytest-3f9a1c2b7d10@shop.lab. Фикстура получает shop и base_url, назвав их в параметрах. Токен кладётся в заголовки отдельной сессии, как в уроке 4.5.

Честно про мусор: пользователи pytest-<uuid> остаются в базе учебного стенда после каждого запуска, их никто не удаляет. Для учебного стенда это нормально, сбросить всё можно командой docker compose down -v.

Метки тестов (smoke, slow) и уборку на реальном API разберёт урок 6.2: сейчас они не нужны.

Прикинь сам: зачем buyer регистрирует нового пользователя на каждый тест, а не берёт user0001?

У user0001 корзина общая для всех тестов и всех запусков: товар, добавленный одним тестом, останется для следующего. Новый пользователь даёт пустую корзину и независимые тесты.

Осторожно: фикстуру не вызывают как функцию (buyer()), pytest подставляет её сам. А scope="session" даёт один общий объект, поэтому всё, что тест меняет (корзину, пользователя), готовь с областью по умолчанию. Если упадёт assert внутри фикстуры, pytest сообщит об ошибке подготовки, а не о падении теста: чем они различаются, объясню дальше.

Главное: фикстура готовит и убирает, тест получает её по имени аргумента, а область scope решает, как часто её готовить.

Тесты написаны, один упал. Как прочитать отчёт и не утонуть в красном тексте?

Как читать отчёт о падении

Упавший тест это не «плохо», а сообщение, ради которого тесты и пишут. Новичок читает отчёт с первой строки и тонет в вызовах чужих библиотек. Читай его по трём местам.

Внизу итоговая строка, например 1 failed, 17 passed in 1.1s. Над ней блок short test summary info, по строке на каждый упавший тест. Выше блок FAILURES: у каждого упавшего теста там заголовок с именем, код со строкой-стрелкой >, строки E (что ждали и что получили) и файл с номером строки.

Основных статусов три. Тест может пройти (passed) или упасть (failed): не сошёлся assert либо возникло исключение в теле. Если упала фикстура до начала теста, это error. Главное различие: failed говорит «тест упал», error говорит «до теста не добрались».

Для любопытных: skipped и xfailed

Ещё бывают skipped (тест пропущен нарочно, например на чужой системе) и xfailed (упал, как и ожидалось: известный дефект). В этом уроке они не встретятся.

Переключай сценарии и наводи курсор на подсвеченные строки:

Что здесь видно: в первых двух сценариях отчёт короткий, и все ответы лежат в строках со стрелкой и E. В третьем отчёт длинный: исключение случилось внутри библиотеки requests, и pytest показал весь путь вызова. Ответ всё равно внизу: тип исключения и текст.

Отчёт помогают сократить три ключа. --tb=short сокращает каждый кадр трассировки до файла, строки и одной строки кода, -x останавливается на первом упавшем тесте, -q убирает лишнее.

Прикинь сам: тест test_product_missing показал E assert 200 == 404. Сервис ответил 404 или 200?

Слева то, что получили, справа то, что ждали. Сервис вернул 200: товар с таким номером существует. Тест ждал 404, значит, надо проверить, какой id в нём записан. Допустимы номера 1–10000, нужен заведомо несуществующий, например 99999999.

Осторожно: упавший тест не значит «тест плохой». Сломаться мог сервис, ожидание, данные или сам тест, и надо решить, кто прав. Не подгоняй тест под результат, пока не проверил, правилен ли он. Тест ждал 410 для p95, а получил 48: по расчёту выше прав результат, ошибся тест.

Главное: читай отчёт по трём местам (строка >, строки E, итог), а перед правкой реши, кто неправ: сервис, ожидание или тест.

Перцентиль из 4.3 теперь страхуют четыре строки с ожидаемыми числами. Пора повторить это руками.

Стоп-точка: теория закончилась. Если устал, закрой урок здесь и вернись к практике завтра; ничего повторять не придётся.

Практика

1. Поставь pytest и зафиксируй версию

cd ~/perf-lab
source .venv/bin/activate
pip install pytest
pip freeze > requirements.txt
printf '.pytest_cache/\n' >> .gitignore
pytest --version
pytest 9.1.1

Как читать вывод: версия 9.x подойдёт; у тебя может быть новее. pip freeze > requirements.txt перезаписал список зависимостей: теперь в нём pytest и всё, что ему нужно (iniconfig, packaging, pluggy, pygments), плюс requests из прошлого урока. Строка в .gitignore исключает папку .pytest_cache, куда pytest складывает служебные файлы. Если окружение не включено, будет ошибка externally-managed-environment, как в уроке 4.5.

2. Модуль с функциями

Создай ~/perf-lab/04-python/shoptools.py. Это отдельный модуль со своими функциями: не подставляй сюда perflib.py из урока 4.3. Там error_rate возвращает проценты, а здесь долю (0,25 вместо 25). На пустом списке обе версии бросают ValueError. Тесты ниже написаны под эту версию, поэтому бери её целиком:

"""Мелкие функции для обработки результатов нагрузки."""


def percentile(values, p):
    """Перцентиль методом ближайшего ранга: значение, не больше которого p% выборки."""
    if not values:
        raise ValueError("нужно хотя бы одно измерение")
    ordered = sorted(values)
    rank = (p * len(ordered) + 99) // 100
    return ordered[max(rank, 1) - 1]


def error_rate(codes):
    """Доля неудачных ответов: код 400 и выше, а 0 означает обрыв соединения."""
    if not codes:
        raise ValueError("нужен хотя бы один код ответа")
    bad = sum(1 for code in codes if code == 0 or code >= 400)
    return bad / len(codes)

Разбор: sorted(values) возвращает новый отсортированный список и не трогает исходный. Выражение (p * n + 99) // 100 целиком в целых числах округляет p * n / 100 вверх (разбор в уроке 4.3): для 20 измерений и p95 получим (95 * 20 + 99) // 100 = 19. max(rank, 1) - 1 превращает номер по счёту (с единицы) в индекс (с нуля) и защищает от нулевого ранга при p=0. sum(1 for code in codes if ...) считает, сколько кодов подходят под условие (это генераторное выражение: как списковое включение, только без создания списка). Логика та же, что в уроке 8.1: ошибка это код 0 (обрыв) или 400 и выше. Здесь в ошибки попадает и 404; в отчёте о надёжности обычно считают только 5xx, и для этого у error_rate из perflib.py (4.3) есть параметр threshold.

3. Первые тесты на функции

Создай ~/perf-lab/04-python/test_shoptools.py:

import pytest

from shoptools import error_rate, percentile

# Те же 20 измерений, что в уроке 8.1.
SAMPLE = [12, 13, 13, 14, 14, 15, 15, 15, 16, 16, 17, 17, 18, 19, 20, 22, 25, 31, 48, 410]


def test_percentile_median_of_odd_list():
    assert percentile([30, 10, 20], 50) == 20


@pytest.mark.parametrize("p, expected", [(50, 16), (90, 31), (95, 48), (99, 410)])
def test_percentile_of_sample(p, expected):
    assert percentile(SAMPLE, p) == expected


def test_percentile_rank_is_exact():
    # 7% от 100 измерений это ровно седьмое значение; дробная формула дала бы восьмое
    assert percentile(list(range(1, 101)), 7) == 7


def test_percentile_does_not_change_input():
    data = [3, 1, 2]
    percentile(data, 50)
    assert data == [3, 1, 2]


def test_percentile_of_empty_list_fails():
    with pytest.raises(ValueError):
        percentile([], 95)


def test_error_rate():
    assert error_rate([200, 200, 200, 500]) == 0.25
    assert error_rate([200, 404, 0, 201]) == 0.5


def test_error_rate_without_errors():
    assert error_rate([200, 201, 204]) == 0
cd ~/perf-lab/04-python
pytest -v test_shoptools.py
============================= test session starts ==============================
platform linux -- Python 3.12.3, pytest-9.1.1, pluggy-1.6.0 -- /home/student/perf-lab/.venv/bin/python
cachedir: .pytest_cache
rootdir: /home/student/perf-lab/04-python
collecting ... collected 10 items

test_shoptools.py::test_percentile_median_of_odd_list PASSED             [ 10%]
test_shoptools.py::test_percentile_of_sample[50-16] PASSED               [ 20%]
test_shoptools.py::test_percentile_of_sample[90-31] PASSED               [ 30%]
test_shoptools.py::test_percentile_of_sample[95-48] PASSED               [ 40%]
test_shoptools.py::test_percentile_of_sample[99-410] PASSED              [ 50%]
test_shoptools.py::test_percentile_rank_is_exact PASSED                  [ 60%]
test_shoptools.py::test_percentile_does_not_change_input PASSED          [ 70%]
test_shoptools.py::test_percentile_of_empty_list_fails PASSED            [ 80%]
test_shoptools.py::test_error_rate PASSED                                [ 90%]
test_shoptools.py::test_error_rate_without_errors PASSED                 [100%]

============================== 10 passed in 0.01s ==============================

Как читать вывод: collected 10 items значит «нашёл десять тестов» (параметризованный тест дал четыре). Каждая строка это один тест, PASSED значит «прошёл», а в скобках процент выполнения. В квадратных скобках после имени ([95-48]) идентификатор набора: значения параметров по порядку. Последняя строка это итог: 10 passed. Строка platform покажет твою версию Python: 3.12.x на Ubuntu 24.04, 3.14.x на 26.04; версии pytest и pluggy тоже могут быть новее. Если у тебя иное число, проверь, что файл сохранён и имена функций начинаются с test_.

Код возврата pytest можно проверить сразу после запуска:

echo $?
0

0 значит «все тесты прошли», 1 «есть упавшие», 5 «ни одного теста не нашлось». Этим числом пользуются скрипты и CI (автоматический запуск проверок): они смотрят не на текст, а на код.

Типичные ошибки:

  • ModuleNotFoundError: No module named 'shoptools': ты запустил pytest не из каталога ~/perf-lab/04-python, или файл называется иначе.
  • no tests ran: имя файла или функции не начинается с test_.
  • ModuleNotFoundError: No module named 'pytest': окружение не включено (which pytest должен показывать путь внутри .venv).

4. Тесты API «Магазина»

Сначала используй готовые фикстуры и тесты. Разбери в одном тесте подготовку, запрос и assert: какое поведение он проверяет и при каком ответе должен упасть. Писать всё с пустого файла сейчас не требуется; в шаге 5 ты намеренно сломаешь функцию расчёта и проверишь, что тесты обнаружили ошибку.

Создай рядом conftest.py (код из теории выше) и test_shop_api.py:

import pytest


def test_readyz(shop, base_url):
    response = shop.get(f"{base_url}/readyz", timeout=10)
    assert response.status_code == 200
    assert response.json() == {"status": "ready"}


def test_catalog_page_size(shop, base_url):
    response = shop.get(f"{base_url}/api/products", params={"page": 2, "size": 5}, timeout=10)
    assert response.status_code == 200
    body = response.json()
    assert body["page"] == 2
    assert len(body["items"]) == 5
    assert body["total"] == 10000


@pytest.mark.parametrize("product_id", [1, 42, 10000])
def test_product_exists(shop, base_url, product_id):
    response = shop.get(f"{base_url}/api/products/{product_id}", timeout=10)
    assert response.status_code == 200
    assert response.json()["id"] == product_id


def test_product_missing(shop, base_url):
    response = shop.get(f"{base_url}/api/products/99999999", timeout=10)
    assert response.status_code == 404
    assert response.json() == {"detail": "product not found"}


def test_login_wrong_password(shop, base_url):
    body = {"email": "user0001@shop.lab", "password": "wrong"}
    assert shop.post(f"{base_url}/api/login", json=body, timeout=30).status_code == 401


def test_cart_needs_token(shop, base_url):
    assert shop.get(f"{base_url}/api/cart", timeout=10).status_code == 401


def test_add_to_cart(buyer, base_url):
    response = buyer.post(f"{base_url}/api/cart/items", json={"product_id": 1, "qty": 2}, timeout=10)
    assert response.status_code == 201
    item = response.json()["items"][0]
    assert item["product_id"] == 1
    assert item["qty"] == 2

Что проверяет каждый тест: test_readyz сервис готов; test_catalog_page_size номер и размер страницы и общее число товаров; test_product_exists три товара из разных частей каталога; test_product_missing несуществующий товар даёт 404 и сообщение; test_login_wrong_password и test_cart_needs_token защита (401); test_add_to_cart корзина покупателя. Это набор «дымовых» проверок: не детальных, а ровно столько, чтобы убедиться, что нагружать есть что.

Запусти все тесты каталога:

pytest -v
============================= test session starts ==============================
platform linux -- Python 3.12.3, pytest-9.1.1, pluggy-1.6.0 -- /home/student/perf-lab/.venv/bin/python
cachedir: .pytest_cache
rootdir: /home/student/perf-lab/04-python
collecting ... collected 19 items

test_shop_api.py::test_readyz PASSED                                     [  5%]
test_shop_api.py::test_catalog_page_size PASSED                          [ 10%]
test_shop_api.py::test_product_exists[1] PASSED                          [ 15%]
test_shop_api.py::test_product_exists[42] PASSED                         [ 21%]
test_shop_api.py::test_product_exists[10000] PASSED                      [ 26%]
test_shop_api.py::test_product_missing PASSED                            [ 31%]
test_shop_api.py::test_login_wrong_password PASSED                       [ 36%]
test_shop_api.py::test_cart_needs_token PASSED                           [ 42%]
test_shop_api.py::test_add_to_cart PASSED                                [ 47%]
test_shoptools.py::test_percentile_median_of_odd_list PASSED             [ 52%]
test_shoptools.py::test_percentile_of_sample[50-16] PASSED               [ 57%]
test_shoptools.py::test_percentile_of_sample[90-31] PASSED               [ 63%]
test_shoptools.py::test_percentile_of_sample[95-48] PASSED               [ 68%]
test_shoptools.py::test_percentile_of_sample[99-410] PASSED              [ 73%]
test_shoptools.py::test_percentile_rank_is_exact PASSED                  [ 78%]
test_shoptools.py::test_percentile_does_not_change_input PASSED          [ 84%]
test_shoptools.py::test_percentile_of_empty_list_fails PASSED            [ 89%]
test_shoptools.py::test_error_rate PASSED                                [ 94%]
test_shoptools.py::test_error_rate_without_errors PASSED                 [100%]

============================== 19 passed in 1.1s ==============================

Как читать вывод: 19 тестов, файлы идут по алфавиту. Два теста заметно медленнее остальных: test_login_wrong_password делает одну проверку bcrypt, test_add_to_cart две (регистрация нового покупателя в фикстуре и вход), каждая около четверти секунды. Время итога у тебя будет иным (обычно 1–2 секунды). Если упал test_product_missing, проверь, что стенд не перезапускали с другим набором данных.

Теперь потренируйся управлять запуском:

pytest -q
pytest -k percentile -v
pytest test_shop_api.py::test_readyz -v
pytest -x --tb=short

Разбор ключей: -q короткий вывод (точки вместо строк: каждая точка это прошедший тест). -k percentile запускает только тесты, в имени которых есть слово «percentile» (-k от «keyword», ключевое слово). Путь с :: запускает один конкретный тест: это ровно то, что pytest печатает в строке сводки FAILED ..., поэтому её можно копировать. -x --tb=short останавливается на первом падении и печатает короткий отчёт.

Типичные ошибки:

  • ConnectionError ... Connection refused во всех API-тестах: стенд не запущен. Тесты функций при этом проходят: они не ходят в сеть.
  • fixture 'buyer' not found: файл называется не conftest.py или лежит не рядом с тестами.
  • assert 422 == 201 в фикстуре buyer: сервис отверг регистрацию. Причина в теле ответа; например, пароль короче 8 символов (в фикстуре сейчас password, ровно восемь). Чтобы увидеть ошибку своими глазами, сократи пароль в фикстуре до passwd и запусти pytest -x. Верни обратно.
  • ERROR at teardown of test_add_to_cart: упала уборка в фикстуре после yield. Сам тест мог пройти, но отчёт честно покажет ошибку.
  • SyntaxWarning: assertion is always true, perhaps remove parentheses?: написано assert (условие, "сообщение"). Кортеж из двух элементов всегда истинен, и проверка не работает. Пиши assert условие, "сообщение".

5. Сломай тест намеренно

Убедись, что тест действительно ловит ошибку. Измени в shoptools.py строку rank = (p * len(ordered) + 99) // 100 на rank = p * len(ordered) // 100 (без + 99 округление идёт вниз вместо вверх) и запусти:

pytest test_shoptools.py -q
F...F.....                                                               [100%]
=================================== FAILURES ===================================
____________________ test_percentile_median_of_odd_list ____________________
...
E       assert 10 == 20
...
___________________ test_percentile_of_sample[99-410] ___________________
...
E       assert 48 == 410
=========================== short test summary info ============================
FAILED test_shoptools.py::test_percentile_median_of_odd_list - assert 10 == 20
FAILED test_shoptools.py::test_percentile_of_sample[99-410] - assert 48 == 410
2 failed, 8 passed in 0.03s

Как читать вывод: упали два теста из десяти, остальные восемь зелёные. Первая F это тест с тремя числами: 50 × 3 // 100 даёт 1 вместо 2, индекс сдвигается на единицу, и вместо 20 функция возвращает 10. Вторая F это p99: 99 × 20 // 100 = 19 вместо 20, и вернулось 48, а не 410. Тесты p50, p90 и p95 остались зелёными: там 50 × 20, 90 × 20 и 95 × 20 делятся на 100 без остатка (10, 18 и 19), и округление вверх или вниз ничего не меняет. Тест не обязан ловить всё сразу: он ловит то, что ты в него заложил.

Верни + 99, запусти ещё раз: все зелёные. Привычка: убедись, что тест хоть раз был красным по нужной причине, иначе неизвестно, проверяет ли он что-либо.

6. Закоммить результат

cd ~/perf-lab
git add .gitignore requirements.txt 04-python/shoptools.py 04-python/test_shoptools.py 04-python/conftest.py 04-python/test_shop_api.py
git commit -m "4.7: pytest, тесты функций и первые тесты API Магазина"
git push

Как читать вывод: git сообщит число изменённых файлов. Проверь git status: рабочее дерево чистое, и папки .pytest_cache в списке нет.

Тест упал, и ты не понимаешь почему? Прочитай строки assert и E в отчёте сам, потом покажи нейросети весь отчёт. Её версию проверь повторным запуском одного теста.

Стоп-точка: практика сделана. «Сломай и почини» можно оставить на другой вечер.

Сломай и почини

Поломка 1: тест падает из-за неверного ожидания. В test_shop_api.py замени в test_add_to_cart проверку assert response.status_code == 201 на == 200 и запусти pytest -x --tb=short:

test_shop_api.py:43: in test_add_to_cart
    assert response.status_code == 200
E   assert 201 == 200
E    +  where 201 = <Response [201]>.status_code
FAILED test_shop_api.py::test_add_to_cart - assert 201 == 200

Задача. Определи, что сломано: сервис или тест. Что сделать?

Разбор

Левая часть (201) это ответ сервиса, правая (200) то, что ждал тест. Но создание ресурса в REST-API по уроку 2.2 это 201, значит, сервис прав, а ожидание ошибочно. Верни == 201. Общий приём: перед тем как «чинить» падение, определи, кто прав: сервис, спецификация или тест.

Поломка 2: падает «чужой» тест. Верни 201, останови стенд (cd ~/learning/load-tester/project/shop && docker compose stop shop) и запусти pytest -x --tb=short. Потом верни стенд (docker compose start shop, подожди, пока ответит readyz).

E   requests.exceptions.ConnectionError: HTTPConnectionPool(host='localhost', port=8000): Max retries exceeded with url: /readyz (Caused by NewConnectionError(... Connection refused))
FAILED test_shop_api.py::test_readyz - requests.exceptions.ConnectionError: ...

Задача. Почему тест не показал сообщение вида «assert … == …»? Куда смотреть в таком отчёте?

Разбор

До assert дело не дошло: исключение случилось в самом вызове shop.get(...), и pytest показал его так, как есть. Строка E называет тип (ConnectionError), адрес и порт (localhost:8000) и причину (Connection refused: на порту никто не слушает). Это не ошибка теста, а недоступность стенда. Проверь curl -s localhost:8000/readyz и подними стенд. На Ubuntu в тексте будет [Errno 111], на macOS [Errno 61]: это один и тот же отказ в соединении.

Поломка 3: ошибка в ожидании параметризованного теста. Измени в test_shoptools.py ожидание (95, 48) на (95, 410) и запусти pytest -q. Упадёт один набор: test_percentile_of_sample[95-410], assert 48 == 410. Выбери решение: поправить функцию или тест.

Разбор

Для 20 измерений p95 по методу ближайшего ранга это значение с рангом (95 × 20 + 99) // 100 = 19, то есть 48 (двадцатое значение 410 это p99). Значит, функция верна, а ожидание ошибочно: верни (95, 48). А вот если бы ты изменил формулу в функции и тест остался зелёным, это был бы сигнал, что тестов недостаточно: надо добавить случай, который эту разницу ловит.

ИИ в помощь

Нейросеть быстро набрасывает тесты, но смысл проверки должен понимать ты: тест, который ничего не проверяет, хуже его отсутствия. Общие правила на странице ИИ-помощник.

Задача: набросать тесты для функции.

pytest 9, Python 3.12. Функция:
<вставь функцию percentile>
Напиши тесты: обычный случай, граничные значения (пустой список, один элемент, p=0 и p=100) и проверку исключения через pytest.raises. Используй parametrize. Объясни, что проверяет каждый тест.

Проверь ответ: запусти pytest -v и намеренно сломай функцию: тесты обязаны упасть. Типичная ошибка: тест повторяет ту же формулу, что и функция, и всегда проходит, а ожидаемые числа не посчитаны вручную.

Задача: прочитать отчёт о падении теста.

pytest показал:
<вставь вывод падения целиком>
Объясни каждую часть отчёта (какая строка, что ожидалось и что получено). Это failed или error? Что исправлять: тест или код?

Проверь ответ: воспроизведи падение одним тестом: pytest test_x.py::test_имя -v. Типичная ошибка: «исправить» тест под неверный результат вместо того, чтобы исправить код.

Словарик урока

Термин Простыми словами
Тест (test) Функция test_..., которая проверяет одно утверждение и либо проходит, либо падает
pytest Библиотека, которая находит тесты по именам, запускает их и печатает отчёт
assert Утверждение: если ложно, возникает AssertionError, тест падает
AssertionError Исключение, которое вызывает ложный assert
pytest.raises Проверка, что код внутри блока вызывает указанное исключение
Фикстура (fixture) Функция, которая готовит (и убирает) то, что нужно тесту; подставляется по имени аргумента
yield в фикстуре Отдаёт значение тесту; код после него это уборка
scope Как часто готовить фикстуру: для каждого теста или один раз на запуск (session)
conftest.py Файл с общими фикстурами; pytest находит его сам
Параметризация Один тест, запущенный на нескольких наборах данных
passed, failed, error Прошёл; не сошлась проверка; упала подготовка до теста
Строка > и строки E В отчёте: проверка, которая не сошлась; ожидали и получили
-x, -q, -k, --tb=short Остановиться на первом падении; короткий вывод; фильтр по имени; сокращённый путь ошибки
Дымовой тест (smoke) Короткая проверка «живо ли и работает ли главное»

Вопросы с собеседований

Раздел для повторения: ответь вслух, потом открой ответ. Вопросы с пометкой [на скорость] тренируй на время: ответ за 30 секунд.

1. [junior] [часто] Как pytest находит тесты?

Ответ

По соглашению об именах: файлы test_*.py или *_test.py и в них функции test_* (и методы Test* классов). Запуск pytest без аргументов обходит текущий каталог рекурсивно. Файл conftest.py pytest подхватывает сам для общих фикстур.

Что хотят услышать: имена файлов и функций, рекурсивный обход, conftest.py.

Красный флаг: считает, что тесты надо перечислять вручную.

2. [junior] [часто] Чем тест, который упал (failed), отличается от теста с ошибкой (error)?

Ответ

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

Что хотят услышать: разница по месту падения, пример с фикстурой.

Красный флаг: считает их одним и тем же.

3. [junior] [часто] Что такое фикстура и зачем она нужна?

Ответ

Функция с @pytest.fixture, которая готовит данные или объекты для теста (сессию, залогиненного пользователя, адрес стенда) и по желанию убирает за ним (код после yield). Тест получает её результат, просто назвав фикстуру аргументом. Это убирает повторяющийся код и делает тесты независимыми: каждому свой чистый покупатель.

Что хотят услышать: подготовка и уборка, подстановка по имени, область scope.

Красный флаг: вызывает фикстуру руками как обычную функцию.

4. [middle] Как проверить, что функция правильно бросает исключение?

Ответ

Через with pytest.raises(ValueError): и вызов внутри блока. Тест проходит, если исключение указанного типа возникло. Если не возникло, будет DID NOT RAISE. Можно дополнительно проверить текст: pytest.raises(ValueError, match="хотя бы одно").

Что хотят услышать: pytest.raises и проверка типа (и при желании текста).

Красный флаг: оборачивает в try/except и пишет pass.

5. [middle] Что такое параметризация и когда она лучше цикла for внутри теста?

Ответ

@pytest.mark.parametrize запускает один тест на нескольких наборах данных, и каждый набор это отдельный тест в отчёте. Цикл for внутри теста останавливается на первом падении: остальные наборы не проверяются, а какой набор упал, видно не всегда. Параметризация даёт независимые случаи, понятные идентификаторы и повторный запуск одного набора.

Что хотят услышать: отдельные тесты, понятный отчёт, пример.

Красный флаг: копирует тест четыре раза с разными числами.

6. [junior] Как прочитать отчёт о падении теста?

Ответ

Сначала итоговая строка (сколько упало), затем блок упавшего теста: строка со стрелкой > это проверка, которая не сошлась; строки E показывают, что получили и что ожидали, where откуда взялось значение; последняя строка блока это файл и номер строки. Для длинных отчётов смотреть на последнюю строку и на E, внутренние файлы библиотек пропускать. Помогают --tb=short и -x.

Что хотят услышать: стрелка, E, итог, ключи для сокращения.

Красный флаг: читает все сто строк и теряется.

7. [middle] Тест упал. Что вы сделаете в первую очередь?

Ответ

Прочитаю отчёт и определю, кто неправ: сервис, ожидание в тесте, данные или окружение (стенд не запущен). Воспроизведу отдельным запуском (pytest путь::имя -x). Поправлю то, что действительно сломано, а не «подгоню» ожидание под фактический результат без проверки.

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

Красный флаг: «просто поменяю ожидаемое значение на то, что пришло».

8. [middle] Почему тесты должны быть независимы друг от друга?

Ответ

Порядок запуска может меняться, тесты запускают по одному (-k), часть может быть пропущена или запущена параллельно. Если тест зависит от результатов предыдущего (например, от товара в корзине), он падает «случайно», и причину ищут не там. Независимость достигается фикстурами: каждому тесту своё чистое окружение.

Что хотят услышать: фикстура на каждый тест, нет общего состояния.

Красный флаг: тесты, которые работают только в определённом порядке.

9. [middle] Зачем в тесте функции перцентиля проверять, что исходный список не изменился?

Ответ

Функция, которая сортирует переданный список на месте, незаметно ломает данные вызывающего: порядок измерений по времени теряется, и следующая функция, считающая что-то по порядку, даёт неверные числа. Тест на неизменность аргумента ловит такую «побочную» ошибку, которую по результату самой функции не заметить.

Что хотят услышать: побочные эффекты, пример с sorted и sort.

Красный флаг: считает, что достаточно проверить возвращаемое значение.

10. [на скорость] Как запустить один конкретный тест?

Ответ

pytest файл.py::имя_теста, например pytest test_shop_api.py::test_readyz -v. Либо фильтр по имени: pytest -k readyz.

Что хотят услышать: путь с :: или -k.

Красный флаг: запускает всё и ищет глазами.

12. [на скорость] Что значит строка E assert 201 == 200?

Ответ

Проверка assert получили == ожидали не сошлась: слева получено 201, справа ожидалось 200.

Что хотят услышать: слева факт, справа ожидание.

Красный флаг: читает наоборот: слева ожидание, справа факт.

13. [на скорость] Что означают коды завершения pytest 0, 1 и 5?

Ответ

0 значит «все тесты прошли», 1 значит «есть упавшие тесты», 5 значит «ни одного теста не собрано». CI останавливает сборку по ненулевому коду.

Что хотят услышать: три значения.

Красный флаг: считает, что код всегда 0, если pytest запустился.

Проверено на версиях

Ubuntu 24.04 (Python 3.12.3) и 26.04 (Python 3.14), pytest 9.1, requests 2.34.2, стенд «Магазин» из project/shop. Октябрь 2026. Номера версий в твоём requirements.txt могут быть новее.

Итог урока: ты умеешь

  • Поставить pytest в окружение и зафиксировать версию в requirements.txt.
  • Написать тест-функцию с assert и понимать, по каким правилам pytest её находит.
  • Проверять функции на типичных, граничных и ошибочных данных, в том числе через pytest.raises.
  • Использовать @pytest.mark.parametrize для нескольких наборов данных.
  • Написать фикстуру с подготовкой и уборкой и вынести общие в conftest.py.
  • Написать первые тесты API «Магазина» через requests.
  • Прочитать отчёт о падении: строка со стрелкой, строки E, итог; отличить failed от error.
  • Запускать нужные тесты ключами -k, -x, -q, --tb=short и путём с ::.
  • Попросить нейросеть набросать тесты и проверить их: сломанный код должен их ронять.

Дальше: тема 5. Docker и контейнеры. Тесты API разовьются в уроке 6.2, а shoptools.py пригодится для обработки результатов нагрузки.

Проверь себя

Короткий тест по уроку: 5 вопросов из банка в 30. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.

Тест работает с включённым JavaScript.

тема 4 урок 4.7 3.5 ч курс 0/0 ← → уроки

Помоги улучшить курс

Что нужно изменить?