✻ Урок 6.3 · Тема 6: Тестирование и автотесты API
Тесты в CI: GitHub Actions на каждый push
Содержание урока
Как работать с кодом и когда идти дальше
Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:
- Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
- Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
- Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.
Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.
Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.
Зачем это нужно
Типичный случай: тесты прогнали у себя, увидели зелёное и отправили код коллеге. Через десять минут он пишет: «У меня всё падает». На ноутбуке автора в фоне давно работал стенд «Магазин», а у коллеги его никто не запускал. Тесты проверяли не код, а настроенный ноутбук. Вот как это выглядит, когда две машины запускают одну и ту же команду:
ноутбук автора: ноутбук коллеги:
$ pytest -q $ pytest -q
29 passed, 1 xfailed in 7.1s E requests.exceptions.ConnectionError: ... Connection refused
(localhost:8000)
У автора все 30 тестов зелёные (один из них xfail, ожидаемое падение), у коллеги красные, а код один и тот же. Разница в окружении: у одного стенд поднят, у другого нет.
Проверкам, которые человек запускает у себя на машине, верить нельзя. Он забывает и торопится, а машина обрастает мусором. Твоя ситуация похожа: до распродажи нужно убедиться, что корзина и заказ работают, прежде чем их нагружать. Автотесты из урока 6.2 у тебя уже есть, но пользы от них столько, сколько раз их запускают.
Решение называется CI (continuous integration, «непрерывная интеграция»). Это автоматика: при каждом изменении кода она сама берёт свежую копию, собирает чистое окружение, запускает проверки и показывает зелёную галочку или красный крест. У GitHub она зовётся GitHub Actions, и дальше мы разберём её по частям.
Для нагрузочного тестировщика у CI две задачи. Первая: стеречь собственные тесты, и через три минуты после правки видишь, остался ли набор зелёным. Вторая: краснеть при замедлении сервиса, короткий нагрузочный тест в CI ты добавишь в теме 12. Сегодня строим основу для обеих.
Шаг проекта: в perf-lab появится файл .github/workflows/api-tests.yml. При каждом git push в main и в каждом pull request GitHub поднимет на временной машине стенд «Магазин», прогонит тесты из 06-api-tests/, сохранит отчёт junit.xml и покажет результат. В README.md появится бейдж («значок» со статусом passing или failing), а в конце ты намеренно сломаешь тест и научишься читать красный запуск.
Что нужно знать
- Автотесты из урока 6.2: папка
~/perf-lab/06-api-tests/сconftest.py,pytest.iniи файламиtest_*.py. Они запускаются командойpytestи берут адрес стенда из переменнойBASE_URL. git commitиgit push, репозиторийperf-labна GitHub: тема 3 (уроки 3.1 и 3.2).- Формат YAML (отступы,
ключ: значение, списки с-) иdocker compose up -d --build --wait: урок 5.3. requirements.txtи виртуальное окружение: урок 4.5.
Картина целиком
Представь издательство. Ты сдаёшь рукопись, и она попадает в чистую комнату, где нет твоих заметок и привычного кресла. Строгий проверяющий читает её по списку и отвечает: «принято» или «вот что не так». Потом комнату убирают, чтобы следующая рукопись не наткнулась на мусор. CI делает то же с кодом: комната это виртуальная машина, список это твой файл с инструкцией, вердикт это зелёный или красный цвет. Аналогия ломается в одном: издательский проверяющий читает после сдачи, а CI стартует сам и мгновенно, при каждом push.
sequenceDiagram
participant Dev as Ты
participant GH as GitHub
participant Run as Чистая машина
participant Shop as Стенд «Магазин»
Dev->>GH: git push
GH->>Run: выдать машину, запустить инструкцию
Run->>Run: забрать код тестов и стенда
Run->>Shop: docker compose up --wait
Run->>Shop: pytest: запросы к localhost:8000
Shop-->>Run: ответы
Run-->>GH: результат и junit.xml
GH-->>Dev: зелёная галочка или красный крест
Главное: стенд поднимается на той же машине, где работают тесты, поэтому они обращаются к localhost:8000, как на твоём ноутбуке.
Выбери, где сломать, и посмотри, что случится со шагами.
Десять шагов идут сверху вниз, время каждого справа. Самый долгий шаг это сборка стенда, тесты рядом с ним мелочь. Когда что-то падает, следующие шаги пропускаются, кроме помеченных особыми условиями: о них ниже.
Теория
Что происходит после git push
Ты нажал git push и пошёл за чаем. Что происходит за эти минуты на стороне GitHub?
Слов здесь сразу несколько, поэтому сначала вложенность, а потом по порядку:
| Что | Что это | Пример |
|---|---|---|
| workflow («рабочий процесс») | один YAML-файл с инструкцией | api-tests.yml |
| job («задача») | блок в файле: всё, что идёт на одной машине | api-tests |
| шаг (step) | одна строка списка внутри job: команда или готовое действие | «Поднять стенд» |
| runner («бегун») | машина, на которой идёт job | ubuntu-latest |
| запуск (run) | один прогон от события до результата | запись в списке на вкладке Actions |
Выходит: workflow (файл) > запуск (один прогон) > job (машина) > шаги (команды). Событие здесь как датчик движения, который включает камеру: что-то произошло, и пошла запись.
Сначала GitHub заглядывает в папку .github/workflows/. Каждый YAML-файл в ней это workflow: инструкция, что делать и когда. В файле стоит блок on: с событием push, и такое «когда» называют событием (event).
Нашёл подходящий файл, и GitHub выдаёт runner («бегун»): временную виртуальную машину (компьютер внутри чужого сервера, который исчезает после работы) с Ubuntu, где уже стоят Git, Docker и Python. Машина одноразовая и после запуска исчезает. Поэтому она чистая, без твоих файлов и настроек, и в этом весь смысл CI.
На этой машине идёт job, то есть шаги по порядку. У нас job будет одна. Если шаг вернул ненулевой код выхода (0 значит успех, урок 6.2), job останавливается и краснеет. Один такой прогон от события до результата называют запуском (run), его видно на вкладке Actions.
Осторожно: workflow и job путают. Workflow это файл целиком, job это блок внутри него. И ещё одно: runner чистый, твой код туда сам не попадает, его скачивает отдельный шаг (о нём в следующем разделе).
Прикинь сам: ты запушил коммит, а на вкладке Actions пусто. Назови две вероятные причины.
Первая: файл лежит не там (.github/workflow/ без «s») или у него не .yml/.yaml. Вторая: событие в on: не совпало с действием, например там только pull_request, а ты пушишь в ветку без pull request, или push ограничен веткой main, а ты пушишь в другую. Если файл не разбирается как YAML, ни один шаг не выполнится: в списке запусков появится запись «Invalid workflow file» с номером строки.
Главное: событие запускает workflow, GitHub выдаёт чистый runner, и тот выполняет шаги job по порядку.
Теперь посмотрим, как эта инструкция выглядит внутри.
Как устроен файл workflow
Файл пишется для чужой машины, которая ничего о тебе не знает. Поэтому в нём всё сказано явно: когда запускать, где, что выполнить. Шаг бывает двух видов: команда оболочки (run) или готовое действие (action, uses), которое кто-то уже написал. Например, actions/checkout скачивает код репозитория. Вот минимальный каркас:
name: API-тесты Магазина # название в интерфейсе
on: # когда запускать
push:
branches: [main] # push только в основную ветку
pull_request: # и любой pull request
workflow_dispatch: # ещё и кнопка «Run workflow» вручную
concurrency: # не гонять одно и то же дважды
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
permissions:
contents: read # токен запуска может только читать код
jobs:
api-tests: # имя job
runs-on: ubuntu-latest # на какой машине
timeout-minutes: 20 # убить, если зависло
steps:
- name: Забрать код
uses: actions/checkout@v7.0.1
- name: Показать версию
run: python3 --version
Здесь push: с branches: [main] значит «push в основную ветку», pull_request: значит «любой pull request», а workflow_dispatch: добавляет кнопку ручного запуска. Почему не просто push: и pull_request: без уточнений? Ты работаешь в ветке и открываешь pull request: один и тот же коммит запустит workflow дважды, по push и по pull_request, и стенд поднимется два раза зря. Поэтому push оставляем только для main, а ветки проверяет pull_request. Блок concurrency добавляет вторую защиту: у запусков одной ветки общая группа (group), и новый запуск отменяет старый, ещё не законченный (cancel-in-progress: true). Ты запушил исправление, а прошлый прогон уже не нужен. Блок permissions: contents: read ограничивает права «пропуска» (токена), который GitHub выдаёт запуску: тестам незачем писать в репозиторий, поэтому даём только чтение.
runs-on выбирает образ машины. timeout-minutes: 20 нужен, потому что зависший шаг без него держал бы машину шесть часов. Каждый шаг в steps: начинается с -, а name: подписывает его. Запись actions/checkout@v7.0.1 читается так: действие checkout из организации actions, версия 7.0.1. Версию пишут всегда: автор действия выпускает новые версии, и без номера твой запуск однажды изменится без тебя. Точный тег (v7.0.1) закрепляет выпуск, плавающий @v7 следует за последней версией 7.x. Но и тег автор может переписать, неизменно закрепляет только SHA коммита (длинный хеш), о нём ниже.
Главная ловушка YAML: отступы это синтаксис. Один лишний пробел, и шаг окажется внутри чужого блока. Теперь шаг с несколькими командами: многострочный блок начинается с run: | (черта значит «дальше текст в несколько строк»).
- name: Поднять стенд
working-directory: stand/load-tester/project/shop
run: |
cp .env.example .env
docker compose up -d --build --wait --wait-timeout 300
working-directory задаёт папку для одного шага, как cd перед командой. Строки блока идут по очереди, и первая с ненулевым кодом останавливает шаг. Флаг --wait-timeout 300 (секунды) не даёт ожиданию тянуться бесконечно.
Осторожно: каждый шаг run: стартует в новой оболочке. Переменная из export в следующем шаге пропадёт, а папка после cd вернётся к исходной.
Как закрепляют действия по SHA, показывает пример (хеш здесь условный):
- uses: actions/checkout@0123456789abcdef0123456789abcdef01234567 # v7.0.1
В учебном workflow оставляем читаемый тег. Для чужих действий вне твоей организации в серьёзных проектах закрепляют SHA с комментарием версии, а обновляет такие строки Dependabot (бот GitHub, который сам присылает pull request с новыми версиями). Причина: в 2025 году у популярного стороннего действия подменили теги, и тысячи пайплайнов выполнили чужой код. Блок permissions: contents: read в нашем файле поставлен по той же причине: даже если действие скомпрометируют, токену запуска нечего писать.
Главное: workflow это явная инструкция для чистой машины, где каждый шаг живёт в своей оболочке, а отступы и версии действий решают всё.
В примере мелькнула папка stand/load-tester/project/shop. Откуда там стенд, если тесты лежат в другом репозитории?
Два репозитория: тесты и стенд
Тесты лежат в твоём perf-lab, а стенд «Магазин» живёт в distinguished-sre/learning. Чтобы проверить стенд, машине нужны оба.
Шаг actions/checkout без параметров клонирует текущий репозиторий. С параметрами он клонирует любой доступный:
- name: Код тестов (perf-lab)
uses: actions/checkout@v7.0.1
with:
persist-credentials: false
- name: Код стенда (learning)
uses: actions/checkout@v7.0.1
with:
repository: distinguished-sre/learning
path: stand
persist-credentials: false
with: передаёт параметры действию. repository говорит, какой репозиторий взять, а path: stand кладёт его в подпапку stand/, чтобы он не смешался с первым. persist-credentials: false не оставляет на диске токен доступа после клонирования: он дальше не нужен, а лишний токен это лишний риск. На машине получается такое дерево:
/home/runner/work/perf-lab/perf-lab/ <- рабочая папка (код твоего perf-lab)
├── 06-api-tests/ <- тесты
├── requirements.txt
└── stand/ <- клон learning
└── load-tester/project/shop/ <- стенд: compose.yaml, .env.example
Осторожно: какую версию стенда ты тестируешь? По умолчанию checkout берёт основную ветку (main), то есть всегда свежий стенд. Твои тесты могут упасть оттого, что стенд изменили, хотя ты ничего не пушил. Чтобы стенд не менялся, укажи ref: <тег или коммит> (ref это «метка», на какую версию кода встать).
Прикинь сам: что будет, если убрать
path: stand?
Оба репозитория лягут в одну папку: второй checkout либо упадёт, либо перемешает файлы. path разводит их.
Главное: два репозитория берут двумя шагами
checkout, второй кладут в отдельную папку черезpath.
Код на машине есть. Остаётся поднять сам стенд.
Стенд на чистой машине
Тесты API без работающего сервиса бесполезны, а на чистой машине стенда нет, значит, его поднимают в самом workflow.
На ubuntu-latest уже стоят Docker и Docker Compose, поэтому команды те же, что у тебя (урок 5.3):
cp .env.example .env
docker compose up -d --build --wait --wait-timeout 300
Сборка с нуля занимает пару минут: ни готовых слоёв образов, ни скачанных пакетов (урок 5.2) на новой машине нет. Флаг --wait держит команду, пока у всех сервисов с проверкой здоровья не появится статус «здоров». После этого readyz отвечает, а в базе уже лежат 10 000 товаров. Контейнеры публикуют порты на самой машине (8000:8000), и тест видит стенд по адресу http://localhost:8000, так что BASE_URL задавать не нужно: значение по умолчанию в тестах (http://localhost:8000) подходит. Переменная пригодилась бы, если бы стенд стоял на другом адресе.
Осторожно: профиль monitoring здесь не включай. Ресурсы у машины не безграничны, а каждый лишний контейнер удлиняет каждый запуск.
Проверь понимание: на ноутбуке тесты зелёные, а в CI первый тест падает с
ConnectionError. Куда смотреть?Ответ
На шаг «Поднять стенд» и логи контейнеров (их печатает шаг с
if: failure()): либо нет--waitи контейнеры не готовы, либо стенд упал. Если стенд в порядке, проверьBASE_URL.
Главное: на чистой машине стенд поднимают теми же командами, что дома, и обязательно с
--wait, иначе тесты опередят готовность сервиса.
Но что делать, когда тесты упали? Шаги после упавшего пропускаются, а именно тогда нужны отчёт и логи.
Условия шагов и артефакты
Просто так после упавшего шага остальные не запускаются. Но отчёт нужен при любом исходе, а логи стенда только после падения. Для этого у шага есть условие if:.
Без условия шаг выполнится только после успешных предыдущих. if: always() запустит его всегда: после успеха, после падения и даже после ручной отмены запуска. Для отчёта чаще пишут if: ${{ !cancelled() }}: после успеха и падения, но не после отмены. В нашем учебном файле оставлен always(), он короче. if: failure() запустит только тогда, когда какой-то предыдущий шаг упал.
Отчёт мы сохраним как артефакт (artifact): файл, который запуск оставляет на странице, чтобы его можно было скачать архивом. Для этого есть действие actions/upload-artifact. Три шага вместе:
- name: Прогнать тесты
working-directory: 06-api-tests
run: python -m pytest -v --junitxml=junit.xml
- name: Сохранить отчёт pytest
if: always()
uses: actions/upload-artifact@v7.0.2
with:
name: junit-report
path: 06-api-tests/junit.xml
- name: Логи стенда при падении
if: failure()
working-directory: stand/load-tester/project/shop
run: docker compose logs --no-color --tail=200
Допустим, pytest упал с кодом 1. Сработают оба условных шага: отчёт уйдёт в артефакт, а в лог попадут последние 200 строк каждого контейнера (--tail=200, а --no-color убирает цветовые коды). Параметр name это имя артефакта, path путь к файлу на машине.
Прикинь сам: шаг «Логи стенда» стоит без
if:. Тесты упали. Что будет с шагом логов?
Он будет пропущен: логи не появятся именно тогда, когда нужны. Лечится одной строкой if: failure().
Главное:
always()для того, что нужно при любом исходе (отчёт, уборка),failure()для того, что нужно только после падения (логи).
Теперь у нас есть всё для диагностики. Осталось научиться её вести.
Как читать красный запуск
Красный крест сам ничего не объясняет. Причину за пять минут находит тот, кто смотрит, где остановились шаги, а не тот, кто час «перезапускает и надеется».
Красный запуск почти всегда попадает в одну из четырёх категорий: YAML, окружение, стенд, тест. Различаются они по тому, что случилось с шагами:
flowchart TD
A["Запуск красный"] --> B{"Шаги вообще<br>начались?"}
B -->|нет| C["Ошибка YAML<br>Invalid workflow file"]
B -->|да| D{"Какой шаг<br>первым покраснел?"}
D -->|установка| E["Проблема окружения:<br>pip, сеть, версии"]
D -->|стенд| F["Стенд не поднялся:<br>логи compose"]
D -->|pytest| G{"Что в отчёте?"}
G -->|assert| H["Тест нашёл расхождение:<br>баг продукта или теста"]
G -->|ConnectionError| F
Сначала смотрим, начались ли шаги, потом какой покраснел первым, и только затем читаем отчёт pytest. Из четырёх исходов схемы отчёт pytest нужен только в одном: assert.
На деле открой вкладку Actions и красный запуск. Найди первый красный шаг: остальные красные и серые после него это следствие. Пролистай его лог до первой ошибки, а не до конца, ведь в конце часто лежит лишь «Process completed with exit code 1». Для pytest читай строку с > и строки с E, как в 4.7 и 6.2, а для стенда шаг «Логи стенда при падении». В скачанном junit-report ищи <failure>.
Лог в CI это тот же вывод pytest, что ты видел в терминале. Переключи сценарий и найди первую строку с E:
Упал один тест из четырнадцати, и по строке E ясно, почему: в ответе появилось quantity, а ждали stock. В CI ты увидишь ровно этот текст в логе шага «Прогнать тесты».
Теперь другой запуск: первые шаги зелёные, «Поднять стенд» красный, остальные серые, «Логи стенда» выполнен. Значит, тесты даже не начинались. Открываем лог стенда:
shop-1 | ...
Error response from daemon: ... dependency failed to start: container shop-postgres-1 is unhealthy
Контейнер PostgreSQL не стал здоровым, поэтому shop, который ждёт его в depends_on, даже не запустился: проблема стенда или машины, не тестов. Нажми Re-run jobs, а при повторе ищи причину в логе PostgreSQL выше.
Осторожно: перезапуск вслепую. Если красный запуск позеленел сам, это нестабильный тест (урок 6.2): запиши, что упало, и разберись.
Главное: сначала найди первый красный шаг и определи категорию (YAML, окружение, стенд, тест), и только потом читай детали.
Осталось два вопроса: как сделать CI быстрым и безопасным, а потом как показать результат другим.
Быстрый и безопасный CI
Медленный CI злит, а небезопасный опасен: workflow запускает чужой код на машине с твоими правами. Начнём со скорости. Три приёма, от простого к сложному.
Кэш (cache) хранит между запусками то, что долго скачивать: пакеты pip, слои образов. actions/setup-python умеет это сам, достаточно строки cache: pip. Первый запуск медленный, следующие быстрее. Матрица (matrix) запускает одну job с разными значениями, например на Python 3.12 и 3.13, параллельно на разных машинах. Параллельные job: если у workflow несколько независимых job (скажем, быстрые проверки и тяжёлые тесты со стендом), они идут одновременно, а не по очереди; порядок задают через needs:. Прежде чем ускорять, посмотри в логе, какой шаг самый долгий: у нас это «Поднять стенд», и кэш pip его не спасёт.
Теперь безопасность. Первое: форки (fork, чужая копия репозитория). Событие pull_request из форка идёт с урезанными правами и без секретов, и это правильно. Событие pull_request_target запускается в контексте твоего репозитория, с секретами и правом записи. Если оно ещё и забирает код из pull request и выполняет его, то посторонний человек получит твои секреты. Поэтому pull_request_target не совмещают с запуском чужого кода.
Второе: долгоживущие ключи. Чтобы workflow мог зайти в облако, раньше клали ключ доступа в Secrets, и он жил годами, пока его не украдут. Сейчас лучше OIDC (OpenID Connect): запуск получает от GitHub короткоживущее удостоверение, облако его проверяет и выдаёт временный доступ. В файле для этого нужно разрешение:
permissions:
id-token: write # разрешить запросить удостоверение у GitHub
contents: read
Третье: self-hosted runner, твоя собственная машина вместо облачной. Он нужен, когда требуется особое железо или доступ во внутреннюю сеть. Но машина долгоживущая, остатки прошлых запусков остаются на ней, а чужой код из pull request работает рядом с твоей сетью. Поэтому в публичные репозитории self-hosted runner не подключают.
Главное: ускоряй кэшем, матрицей и параллельными job, а безопасность держи на трёх правилах: не выполнять чужой код с секретами, не хранить долгие ключи, не пускать публичные pull request на свою машину.
Теперь вернёмся к результату для людей.
Бейдж и секреты
Результат нужен не только тебе. Бейдж (badge, значок статуса) в README.md показывает любому, кто открыл репозиторий, что тесты проходят: это часть портфолио (урок 13.3). Но CI, который идёт двадцать минут и падает без причины, быстро учит всех игнорировать красный цвет.
GitHub рисует бейдж по адресу, который ты вставляешь в Markdown как картинку-ссылку:
[](https://github.com/<логин>/perf-lab/actions/workflows/api-tests.yml)
 вставляет картинку, обёртка [...](адрес) делает её ссылкой на страницу запусков. Состояний три: passing (последний запуск на основной ветке зелёный), failing (красный) и no status (запусков ещё не было). Бейдж отражает последний запуск именно этого workflow на основной ветке.
Прикинь сам: бейдж зелёный, но сегодня ты запушил красный коммит в другую ветку. Почему бейдж не покраснел?
Он показывает состояние основной ветки (main), а запуск на другой ветке туда не попадает, пока ветка не влита. Красный крест ты увидишь на вкладке Actions или в pull request.
Есть ещё приём, который пригодится позже. Представь: вчера кто-то поменял стенд, а твой репозиторий не менялся, и push не случился. Тесты молчат, хотя могли бы уже краснеть. Поэтому тесты запускают ещё и по расписанию:
on:
schedule:
- cron: '0 3 * * *' # каждую ночь в 03:00 UTC
Запись cron (формат расписания из пяти полей) читается как «каждый день в 03:00». Поля идут по порядку: минута, час, день месяца, месяц, день недели. В 0 3 * * * минута 0 и час 3, а звёздочка значит «любое»: каждый день, каждый месяц, любой день недели. Чтобы запускать каждый час, напиши 0 * * * *. Время по UTC, то есть по Гринвичу, а не по твоим часам. Запуск может опоздать на несколько минут, особенно в начале часа, когда у GitHub пик нагрузки. Расписание GitHub запускает только на основной ветке, а в публичном репозитории отключает после 60 дней без активности. Если два месяца ничего не менять, включи его заново на вкладке Actions.
Осторожно, секреты. В нашем workflow их нет: пароль пользователей учебного стенда открытый (password), а стенд живёт минуту на одноразовой машине. Но привычка нужна: пароль, ключ, токен никогда не пишут в YAML и не коммитят. Для них у GitHub есть раздел Secrets («Settings → Secrets and variables → Actions»). Значение берётся выражением secrets.ИМЯ, а в логах GitHub заменяет его звёздочками. И граница: нагрузку в CI мы запускаем только против стенда на самой машине. Чужие сайты и серверы нагружать нельзя ни из CI, ни откуда-то ещё.
Главное: бейдж показывает состояние основной ветки, расписание ловит поломки со стороны стенда, а секреты живут в Secrets, а не в коде.
Вернёмся к распродаже. На вопрос менеджера «Корзина и заказ точно работают?» ты покажешь зелёный бейдж, а не «я вроде проверял».
Практика
Условия: репозиторий perf-lab на GitHub публичный (урок 3.2), локально в ~/perf-lab лежат 06-api-tests/ и requirements.txt в корне, тесты проходят командой pytest из папки 06-api-tests. Если requirements.txt в корне нет или в нём нет pytest, поправь (шаг 1).
1. Проверь, что готово локально
cd ~/perf-lab
source .venv/bin/activate
cat requirements.txt
(cd 06-api-tests && pytest -q)
git status --short
Что делает: показывает список зависимостей, один раз прогоняет тесты (скобки ( ... ) выполняют cd во временной оболочке, и текущая папка не меняется) и показывает несохранённые изменения.
Ожидаемый вывод (время в последней строке у тебя будет другим):
pytest==9.1.1
requests==2.34.2
............................x. [100%]
=========================== short test summary info ============================
XFAIL test_products.py::test_search_underscore_is_literal - BUG-001: _ и % в поиске работают как шаблон
29 passed, 1 xfailed in 7.1s
Как читать вывод: в requirements.txt должны быть и pytest, и requests с точными версиями: CI поставит ровно их. Тесты должны быть зелёными ещё до CI (с slow-тестом: набор целиком, без -m): иначе ты не отличишь поломку CI от красных тестов. git status лучше без изменений в 06-api-tests/.
Типичные ошибки:
- В
requirements.txtнетpytest: добавьpytest==9.1.1, проверьpip install -r requirements.txtи закоммить. pip freezeдобавил в файл десяток зависимостей зависимостей: это нормально, оставь.
2. Создай workflow
mkdir -p .github/workflows
Создай файл .github/workflows/api-tests.yml:
Перенеси workflow как готовый шаблон. В нём разберись с порядком действий: получить код, поднять стенд, дождаться готовности, запустить pytest и сохранить отчёт. Уметь написать весь YAML по памяти не требуется; в шагах ниже ты проверишь, что успешные тесты дают зелёный запуск, а намеренная поломка даёт красный и видна в отчёте.
name: API-тесты Магазина
on:
push:
branches: [main]
pull_request:
workflow_dispatch:
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
permissions:
contents: read
jobs:
api-tests:
runs-on: ubuntu-latest
timeout-minutes: 20
steps:
- name: Код тестов (perf-lab)
uses: actions/checkout@v7.0.1
with:
persist-credentials: false
- name: Код стенда (learning)
uses: actions/checkout@v7.0.1
with:
repository: distinguished-sre/learning
path: stand
persist-credentials: false
- name: Python
uses: actions/setup-python@v7.1.0
with:
python-version: '3.12'
cache: pip
- name: Зависимости
run: python -m pip install -r requirements.txt
- name: Поднять стенд
working-directory: stand/load-tester/project/shop
run: |
cp .env.example .env
docker compose up -d --build --wait --wait-timeout 300
curl --fail --silent http://localhost:8000/readyz
- name: Прогнать тесты
working-directory: 06-api-tests
run: python -m pytest -v --junitxml=junit.xml
- name: Сохранить отчёт pytest
if: always()
uses: actions/upload-artifact@v7.0.2
with:
name: junit-report
path: 06-api-tests/junit.xml
- name: Логи стенда при падении
if: failure()
working-directory: stand/load-tester/project/shop
run: docker compose logs --no-color --tail=200
- name: Погасить стенд
if: always()
working-directory: stand/load-tester/project/shop
run: docker compose down -v
Про маркеры и conftest.py: шаг запуска выполняется с working-directory: 06-api-tests, а там лежат и pytest.ini (с --strict-markers и списком маркеров smoke, negative, slow), и conftest.py. Поэтому pytest в CI находит настройки и фикстуры так же, как у тебя в терминале, а опечатка в маркере обрушит шаг, как и локально. Тесты запускаются все, включая slow: CI не торопится. Если когда-нибудь понадобится быстрый предварительный шаг, добавь к команде -m smoke, остальное не меняется.
Разбор незнакомого. on: с push только для main и pull_request для остальных веток нужен, чтобы коммит в ветке с открытым pull request не запускал workflow дважды (по push и по pull_request). concurrency с cancel-in-progress: true отменяет устаревший запуск той же ветки, когда ты пушишь новый коммит. Шаг «Погасить стенд» на облачной машине GitHub необязателен, она и так исчезнет; он оставлен по привычке для self-hosted runner, где машина живёт долго и контейнеры накапливались бы. cache: pip включает кэш скачанных пакетов, ключом служит содержимое requirements.txt. python -m pip вызывает pip именно той версии Python, которую поставил предыдущий шаг. curl --fail --silent .../readyz после запуска стенда это контрольный выстрел: --fail делает ненулевой код выхода, если сервер ответил ошибкой, --silent убирает индикатор прогресса. python -m pytest запускает pytest как модуль, что гарантирует тот же Python с теми же пакетами.
Проверь отступы глазами: все шаги начинаются с - на одном уровне, а name, uses, with внутри шага на два пробела глубже.
Типичные ошибки:
Invalid workflow file ... You have an error in your yaml syntax on line 18: лишний или недостающий пробел. Число в сообщении это номер строки: открой её и сравни отступ с соседней.- Файл лежит в
.github/workflow/(без «s»): GitHub его не увидит, запусков не будет.
3. Запушь и дождись запуска
Сначала проверь, что основная ветка называется main (в старых репозиториях бывает master), и что ты вошёл в GitHub (gh auth login или токен из урока 3.2):
git branch --show-current
Если там master, переименуй: git branch -M main, затем git push -u origin main. Дальше коммит:
git add .github requirements.txt
git commit -m "6.3: GitHub Actions: API-тесты Магазина на каждый push"
git push
Открой в браузере https://github.com/<логин>/perf-lab/actions (подставь свой логин). Вверху появится запуск с названием коммита и жёлтым кружком (идёт), через несколько минут зелёная галочка. Нажми на запуск, потом на job api-tests слева.
Ожидаемо в списке шагов (время у тебя будет другим):
✓ Set up job 2s
✓ Код тестов (perf-lab) 1s
✓ Код стенда (learning) 2s
✓ Python 3s
✓ Зависимости 5s
✓ Поднять стенд 2m 31s
✓ Прогнать тесты 8s
✓ Сохранить отчёт pytest 1s
- Логи стенда при падении 0s
✓ Погасить стенд 6s
✓ Post Python 0s
✓ Post Код стенда (learning) 0s
✓ Post Код тестов (perf-lab) 0s
✓ Complete job 0s
Как читать вывод: зелёная галочка это шаг успешен. Строка с прочерком (скипнут) у шага логов нормальна: условие failure() не сработало. Самый долгий шаг это стенд (сборка образов с нуля), тесты занимают секунды. Строки Post ... это уборка за действиями (checkout, кэш pip), GitHub добавляет их сам, в твоём YAML их нет. Раскрой «Прогнать тесты» и убедись, что в логе тот же вывод pytest -v, что и локально.
Типичные ошибки:
- Шаг «Поднять стенд» красный:
dependency failed to start: раскрой лог выше и найди, какой контейнер нездоров. Сначала просто перезапусти запуск (Re-run all jobs): бывает сбой скачивания образа. - Шаг тестов красный,
ConnectionError: стенд не готов, проверь, что--waitстоит иcurl .../readyzотработал. Error: Unable to resolve action 'actions/checkout@v7.0.1': опечатка в имени или версии действия.refusing to allow a Personal Access Token to create or update workflow ... without workflow scope: у токена, с которым вошёлgit, нет права менять файлы в.github/workflows. Выполниgh auth refresh -s workflowили создай токен заново с правом (scope)workflowи повториgit push.
Workflow красный, а строка с ошибкой в логе непонятна? Вставь нейросети свой
api-tests.ymlи текст упавшего шага, спроси, что значит ошибка. Проверь правку в ветке, а не вmain: нейросети часто предлагают версии действий, которых нет, поэтому сверьuses:с репозиторием действия на GitHub.
4. Скачай отчёт
Внизу страницы запуска, в разделе Artifacts, лежит junit-report. Скачай его и распакуй:
cd ~/Downloads
unzip -o junit-report.zip -d junit-report
head -c 500 junit-report/junit.xml
Ожидаемо:
<?xml version="1.0" encoding="utf-8"?><testsuites name="pytest tests"><testsuite name="pytest" errors="0" failures="0" skipped="1" tests="30" time="8.214" ...
Как читать вывод: tests="30", failures="0". skipped="1" это xfail-тест про BUG-001 из 6.2. Если unzip не установлен: sudo apt install unzip.
5. Добавь бейдж
В начало ~/perf-lab/README.md (после заголовка, если он есть) добавь строку, подставив свой логин:
[](https://github.com/<логин>/perf-lab/actions/workflows/api-tests.yml)
cd ~/perf-lab
git add README.md
git commit -m "README: бейдж API-тестов"
git push
Открой страницу репозитория на GitHub: под заголовком должен появиться зелёный значок passing. Если пишет no status, подожди минуту и обнови: бейдж появляется после первого завершённого запуска на основной ветке.
6. Сломай тест намеренно и прочитай красный запуск
Это упражнение, а не часть проекта: сделаем отдельную ветку, чтобы не пачкать основную.
cd ~/perf-lab
git switch -c experiment/red-ci
В 06-api-tests/test_products.py в тесте test_size_in_range замени [1, 100] на [1, 101] (ожидаем, что 101 теперь допустимо). Закоммить и запушь:
git commit -am "эксперимент: size=101 допустим (ломаем намеренно)"
git push -u origin experiment/red-ci
gh pr create --fill --base main
Запуск по push сработает только на main, поэтому для ветки нужен pull request: gh pr create --fill открывает его с заголовком из коммита (то же можно сделать кнопкой на странице репозитория). Открой Actions. Запуск станет красным. Пройди по алгоритму: первый красный шаг (должен быть «Прогнать тесты»), в его логе строка FAILED test_products.py::test_size_in_range[101], в отчёте строка E с KeyError: 'size': сервер на size=101 вернул 422 с телом {"detail": ...}, и поля size в нём нет, а тест прочитал его без проверки кода. Хороший повод вспомнить из 6.2: тест, который сразу читает тело, падает странной ошибкой вместо понятного «ожидали 200». Проверь, что в разделе Artifacts появился junit-report, а шаг «Логи стенда при падении» выполнился (теперь он без прочерка).
Верни как было и закрой эксперимент:
git switch main
git branch -D experiment/red-ci
git push origin --delete experiment/red-ci
Pull request закроется сам, когда ветка удалена. Бейдж на main всё это время оставался зелёным: он показывает состояние основной ветки.
Сломай и почини
Ветку из шага 6 ты удалил, поэтому заведи её заново и держись её, пока ломаешь:
cd ~/perf-lab && git switch -c experiment/red-ci
Каждую правку коммить и пушь в эту ветку (git push -u origin experiment/red-ci), а pull request открой один раз: gh pr create --fill --base main. Новые пуши в тот же pull request запускают workflow заново.
Поломка 1: опечатка в YAML. В api-tests.yml сдвинь строку uses: actions/checkout@v7.0.1 одного из шагов на один пробел вправо, закоммить и запушь в ветку эксперимента. Ни один шаг не выполнится: в списке появится запись «Invalid workflow file» (или красная плашка в самом файле) с номером строки. Сравни: шагов нет вообще, а значит, причина в самом файле. Верни отступ.
Поломка 2: забытый always(). Убери if: always() у шага «Сохранить отчёт pytest» и повтори сценарий из шага 6. Запуск красный, но раздел Artifacts пуст: отчёт не сохранён именно тогда, когда нужен. Верни условие.
Поломка 3: стенд не успевает. Замени --wait --wait-timeout 300 на просто -d (убрав --wait) и удали строку с curl --fail ... /readyz: она сама дождалась бы готовности или покраснела. Запуск (при невезении, а иногда и всегда) упадёт на первом же тесте с ConnectionError: контейнеры созданы, но «Магазин» ещё не готов. Диагностика по категории: стенд-шаг зелёный, тесты красные с ошибкой подключения, значит, виновата синхронизация. Верни --wait.
Не оставляй сломанное в main: все три упражнения делай в ветке experiment/red-ci и удаляй её (команды из шага 6).
ИИ в помощь
Нейросеть хорошо читает логи Actions и объясняет YAML построчно, но версии действий и синтаксис шагов она нередко помнит устаревшими. Общие правила: ИИ-помощник.
Задача: разобрать упавший запуск.
GitHub Actions, workflow api-tests.yml на ubuntu-latest. Вот файл: <вставь api-tests.yml>.
Упал шаг «<имя шага>», вот его лог: <вставь последние 40 строк лога>.
Объясни, что означает ошибка, назови две вероятные причины и как отличить одну
от другой. Не переписывай весь файл, предложи минимальную правку.
Проверь ответ: внеси правку в отдельной ветке и запусти workflow. Типичные ошибки: несуществующая версия действия (actions/checkout@v9), отступы YAML, которые ломают структуру, и ключи не из того уровня (например, run: рядом с uses:). Проверь uses: на странице действия и отступы по образцу из урока.
Задача: понять незнакомый ключ workflow.
Объясни простыми словами, что делает в GitHub Actions ключ <вставь ключ, например if: always()>
в моём шаге: <вставь шаг>. Когда он сработает, а когда нет? Пример, где он полезен для отчёта pytest.
Проверь ответ: найди ключ в документации GitHub Actions и проверь на деле: сломай тест и посмотри, загрузился ли отчёт.
В репозиторий и в чат не клади значения секретов: в workflow они живут в Secrets, а в запросе пиши <секрет>.
Словарик урока
| Термин | Простыми словами |
|---|---|
| CI (continuous integration) | Автоматика, которая при каждом изменении сама проверяет код |
| GitHub Actions | Встроенный в GitHub сервис CI |
| Событие (event) | То, что запускает workflow: push, pull_request, расписание, ручной запуск |
| Workflow | YAML-файл в .github/workflows/ с описанием, когда и что запускать |
| Job | Группа шагов, выполняемая на одной машине |
| Runner | Виртуальная машина, на которой идёт job (ubuntu-latest) |
| Шаг (step) | Одна команда (run) или готовое действие (uses) |
| Действие (action) | Готовый переиспользуемый шаг, например actions/checkout |
| Артефакт (artifact) | Файл, сохранённый запуском: отчёт, лог |
if: always() |
Условие шага: выполнить при любом исходе |
if: failure() |
Условие шага: выполнить, если что-то упало |
| Бейдж (badge) | Картинка-значок со статусом последнего запуска (passing, failing) |
| Секрет (secret) | Пароль или ключ, который хранят в настройках GitHub, а не в коде |
Расписание (cron) |
Запуск workflow в заданное время, по UTC |
Вопросы с собеседований
Раздел для повторения: ответь вслух, потом открой ответ. Короткие вопросы тренируй на скорость: ответ за 30 секунд.
1. [junior] [часто] Что такое CI и зачем он нужен?
Ответ
CI (непрерывная интеграция) это автоматический запуск проверок при каждом изменении кода на чистой машине. Он нужен, чтобы ловить поломки сразу, не зависеть от настроек чьего-то ноутбука («у меня работает») и не полагаться на то, что человек не забудет запустить тесты.
Что хотят услышать: автоматичность, чистое окружение, быстрая обратная связь.
Красный флаг: «CI это когда тесты запускаются на сервере» (без причин и последствий).
2. [junior] [часто] Из чего состоит workflow в GitHub Actions?
Ответ
Файл YAML в .github/workflows/. В нём события (on), задачи (jobs), у каждой машина (runs-on) и список шагов (steps). Шаг это либо команда (run), либо готовое действие (uses).
Что хотят услышать: event, job, runner, step, action.
Красный флаг: путают workflow и job.
3. [junior] [часто] Тесты в CI упали, на ноутбуке проходят. С чего начнёшь?
Ответ
Найду первый красный шаг и прочитаю его лог до первой ошибки. Сравню окружение: версии Python и библиотек, переменные (BASE_URL), состояние стенда, порядок тестов, данные. Помню, что runner чистый: в CI нет того, что накопилось у меня. Если стенд не поднялся, смотрю логи контейнеров, а не тестов.
Что хотят услышать: «первый красный шаг», сравнение окружения, чистая машина.
Красный флаг: «перезапущу, может, пройдёт».
4. [middle] Зачем нужен if: always()?
Ответ
По умолчанию после упавшего шага остальные не выполняются. always() заставляет шаг выполниться при любом исходе: нужно, чтобы сохранить отчёт и убрать за собой после любого исхода, в том числе падения. failure() выполнит шаг только после падения (печать логов).
Что хотят услышать: пример шагов (отчёт, очистка, логи), разница always и failure.
Красный флаг: «чтобы шаг запускался быстрее».
5. [middle] Что такое артефакт и зачем сохранять junit.xml?
Ответ
Артефакт это файл, который запуск сохраняет, чтобы его можно было скачать. junit.xml содержит результаты по каждому тесту; его читают инструменты отчётов, а человек может открыть, чтобы увидеть, что упало, даже если лог шага уже огромен. Сохраняют при любом исходе (always()).
Что хотят услышать: формат JUnit, смысл «при любом исходе».
Красный флаг: «артефакт это итоговая программа» (только сборка).
6. [middle] Как в CI протестировать сервис, живущий в другом репозитории?
Ответ
Вторым шагом actions/checkout с параметрами repository и path клонировать репозиторий сервиса в подпапку, поднять его (например, docker compose up --wait) и запустить тесты против localhost. Версию сервиса фиксируют параметром ref, если нужна воспроизводимость.
Что хотят услышать: два checkout, path, ожидание готовности.
Красный флаг: «просто закопирую файлы руками в репозиторий».
7. [middle] Почему --wait важен при поднятии стенда?
Ответ
Без него docker compose up -d возвращается, когда контейнеры созданы, а приложение ещё не готово (миграции, подключение к базе). Тесты стартуют на неготовый сервис и падают нестабильно. --wait дожидается проверок здоровья, а --wait-timeout не даёт ждать бесконечно.
Что хотят услышать: гонка «создан против готов», healthcheck.
Красный флаг: «поставлю sleep 30».
8. [middle] Как не хранить пароли и ключи в репозитории при работе с CI?
Ответ
Секреты кладут в настройки репозитория (Secrets) и берут в workflow через secrets.ИМЯ; GitHub маскирует их значения в логах. В коде и YAML секретов нет. Ограничивают права токена запуска (permissions). В учебном стенде пароли открытые и одноразовые, но привычка остаётся.
Что хотят услышать: Secrets, маскирование, наименьшие права.
Красный флаг: «зашифрую пароль в YAML base64».
9. [junior] Что показывает бейдж и чем он ограничен?
Ответ
Статус последнего запуска конкретного workflow на основной ветке: passing, failing или no status. Он не показывает состояние других веток и не говорит, какие именно тесты покрыты: зелёный бейдж значит «то, что мы проверяем, проходит».
Что хотят услышать: основная ветка, три состояния, оговорка про покрытие.
Красный флаг: «зелёный бейдж значит, что багов нет».
10. [middle] Зачем тесты запускать ещё и по расписанию, а не только на push?
Ответ
push срабатывает на изменения моего репозитория. Если меняется то, что я тестирую (чужой стенд, зависимость, образ), у меня ничего не запустится. Ночной запуск по cron ловит такие внешние изменения и «плавающие» поломки окружения.
Что хотят услышать: внешние зависимости, регресс со стороны сервиса.
Красный флаг: «расписание нужно, чтобы нагрузить CI».
11. [на скорость] Где хранятся файлы workflow?
Ответ
В .github/workflows/ в корне репозитория, расширение .yml или .yaml.
Что хотят услышать: каталог .github/workflows/ в корне репозитория, расширение .yml.
Красный флаг: кладёт файл в произвольную папку и удивляется, что workflow не запускается.
12. [на скорость] Как понять, какой шаг сломал запуск?
Ответ
Найти первый красный шаг на странице job: остальные красные и серые следуют из него.
Что хотят услышать: искать первый красный шаг в job, остальное следствие.
Красный флаг: читает лог с конца и чинит последствия, а не первую причину.
Проверено на версиях
GitHub Actions: actions/checkout@v7.0.1, actions/setup-python@v7.1.0, actions/upload-artifact@v7.0.2, runner ubuntu-latest (Ubuntu 24.04, Docker Compose v2). Python 3.12, pytest 9.1.1, requests 2.34.2. Октябрь 2026. Версии действий проверь на странице действия в GitHub Marketplace, они обновляются.
Итог урока: ты умеешь
- Объяснить, что такое CI, и назвать части GitHub Actions: событие, workflow, job, runner, шаг.
- Написать workflow, который клонирует два репозитория, ставит зависимости и поднимает стенд.
- Прогнать pytest в CI и сохранить
junit.xmlпри любом исходе (if: always()). - Прочитать красный запуск: найти первый красный шаг, различить ошибку YAML, окружения, стенда и теста.
- Добавить бейдж статуса в README.
- Объяснить, зачем нужны
--wait,timeout-minutes, ограничение прав и запуск по расписанию.
Дальше: тема 7. Метрики, логи, трейсы и алерты. Нагрузочный регресс в CI ты соберёшь в уроке 12.2.
Проверь себя
Короткий тест по уроку: 5 вопросов из банка в 35. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.
Тест работает с включённым JavaScript.