Блог

Git для тестировщика: ветки, PR и работа с командой

Git для тестировщика: ветки, PR и работа с командой

Git нужен QA для трёх вещей: забрать код продукта на ревью, положить свои автотесты в общий репозиторий, не сломать ветку команды. Хватит 12 команд: clone, status, add, commit, push, pull, branch, checkout, merge, log, diff, stash. Остальное гуглится по мере появления.
Если ты тестируешь руками — Git тебе всё равно нужен. Команда выкладывает фичу в feature-ветку, ты её забираешь и проверяешь до того, как код уехал в master. Без этого ты узнаёшь о фиче из релиз-нот вместе с пользователями.
Если ты пишешь автотесты — без Git вообще никак. Тесты лежат в репозитории рядом с кодом, прогоняются в CI после каждого пуша, ревьюятся коллегами. Локальный test_login.py на твоём ноуте никому не нужен.
Я Яна, Senior AQA в Магните. За 5+ лет видела десятки джунов, которые ломались именно на Git: либо боялись пушить, либо пушили в master напрямую и собирали недовольство тимлида. Эта статья — то, что я даю своим ученикам в первые две недели обучения.

Зачем QA Git, если код пишут разработчики

Короткий ответ: чтобы ты участвовал в разработке, а не наблюдал со стороны.
Длинный ответ — четыре сценария.
Проверить фичу до релиза. Разработчик завёл ветку `feature/checkout-redesign`. Ты делаешь `git checkout feature/checkout-redesign`, поднимаешь приложение локально, проверяешь по чек-листу. Нашёл баг — пишешь в комментарии к Pull Request с цитатой строки кода. Разработчик правит в той же ветке, ты перепроверяешь. До master доходит уже зелёная фича.
Положить свои автотесты в общий репо. Написал `test_login.py` — закоммитил, запушил, открыл PR. Тимлид посмотрел, попросил переименовать переменную, ты поправил. Теперь твой тест прогоняется в CI после каждого изменения кода. Если разработчик случайно сломает логин — твой тест упадёт первым.
Откатиться назад. Сломал что-то у себя локально. `git checkout -- .` — и файл вернулся в состояние последнего коммита. `git reset --hard HEAD~1` — откатил последний коммит целиком. Безопасная песочница: можно экспериментировать, не боясь потерять работу.
История изменений. В понедельник кто-то сломал автотесты, и они падают. `git log --oneline test_checkout.py` показывает все коммиты, которые трогали этот файл. `git blame` — кто и когда написал каждую строку. Ты находишь проблемный коммит за минуту, не идёшь к разработчику с вопросом «а что вы тут вчера сделали».

Минимальный набор: 12 команд, которых хватит на первые полгода

Не учи всё сразу. Начни с этих и добавляй остальные, когда упрёшься.
Setup и просмотр:
  • `git clone <url>` — забрать репозиторий с сервера на свой ноут
  • `git status` — что у меня изменено, готово к коммиту, не отслеживается
  • `git diff` — что именно я изменил в файлах
  • `git log --oneline -10` — последние 10 коммитов в одну строку
Локальная работа:
  • `git add <file>` или `git add .` — пометить изменения для коммита
  • `git commit -m "fix: stable locator for login button"` — зафиксировать
  • `git stash` — отложить изменения, не коммитя (когда нужно срочно переключиться на другую ветку)
Синхронизация с командой:
  • `git pull` — забрать изменения с сервера в свою ветку
  • `git push` — отправить свои коммиты на сервер
Ветки:
  • `git branch` — список локальных веток, текущая помечена звёздочкой
  • `git checkout -b feature/test-checkout-flow` — создать новую ветку и переключиться
  • `git merge master` — влить master в свою ветку (разрешить конфликты, если есть)
Всё. С этим набором ты решишь 90% задач. Сложные сценарии вроде rebase, cherry-pick, bisect — добавишь, когда конкретный кейс прижмёт.

Как устроены ветки и почему это удобно

Ветка в Git — это не папка с копией кода. Это указатель на конкретный коммит. Когда ты делаешь `git checkout -b feature/api-tests`, Git создаёт указатель на текущий коммит и переключается на него. Файлы на диске остаются те же.
Дальше ты пишешь автотесты, коммитишь — указатель ветки сдвигается на новый коммит. А master остаётся там, где был. Когда ты переключаешься на master через `git checkout master` — Git меняет файлы на диске обратно, как было в master.
В реальном проекте ветки выглядят так:
  • `master` или `main` — стабильный код, который катится в продакшн
  • `develop` — сборка перед релизом (есть не везде)
  • `feature/<имя>` — отдельные фичи, по одной ветке на задачу
  • `bugfix/<имя>` — фиксы багов
  • `release/<версия>` — подготовка к релизу
Тестировщик обычно работает в feature-ветках разработчиков (проверяет фичи) и в собственных feature-ветках для автотестов: `feature/autotest-checkout-positive`, `feature/autotest-search-filter`.
Правило одно: не коммить в master напрямую. Всегда через PR. Это защита от ошибок и обязательное условие в любой команде больше двух человек.

Pull Request: как сдать работу команде

Pull Request (или Merge Request в GitLab) — это запрос «влейте мою ветку в master». Команда смотрит изменения, обсуждает, просит поправки. Когда всё ок — вливают (merge).
Что проверяет ревьюер в твоём PR с автотестами:
  • Тесты проходят локально (запустил `pytest test_checkout.py` — зелёный)
  • Локаторы стабильные (не `xpath=//div[3]/span[2]`, а `data-testid='checkout-button'`)
  • Названия тестов читаемые (`test_checkout_with_promo_code_applies_discount`, не `test_1`)
  • Нет мусора: закомментированного кода, отладочных print, лишних импортов
  • Ассерты содержательные (`assert response.status_code == 200, f"Expected 200, got {response.status_code}"`)
Хорошее описание PR экономит ревьюеру 10 минут:
```

Что

Добавил автотест на оформление заказа с промокодом

Зачем

Покрытие checkout flow — 0% автотестов, баг с промокодом ловили вручную 3 раза за месяц

Как проверить

  1. Скачать ветку: git checkout feature/autotest-checkout-promo
  2. Запустить: pytest tests/test_checkout.py::test_promo_code -v
  3. Проверить, что тест зелёный

Что не сделал

  • Не покрыл негативные кейсы (просроченный промокод) — отдельным PR
```
Без описания ревьюер открывает diff на 200 строк и думает «зачем мне это вообще». С описанием — за 5 минут разбирается и одобряет.

Конфликты при merge: что делать, когда страшно

Конфликт — это когда ты и кто-то ещё изменили одни и те же строки в файле. Git не знает, чью версию выбрать, и просит решить вручную.
Выглядит так:
```python
def test_login():
<<<<<<< HEAD
driver.find_element(By.ID, "login-btn").click()
=======
driver.find_element(By.CSS_SELECTOR, "[data-testid='login']").click()
>>>>>>> master
```
Между `<<<<<<<` и `=======` — твоя версия. Между `=======` и `>>>>>>>` — версия из master. Тебе нужно выбрать одну, обе или написать новую, удалить маркеры, сохранить.
Алгоритм при конфликте:
  1. `git status` — какие файлы конфликтуют
  2. Открыть файл, найти `<<<<<<<`, разобрать каждый блок
  3. Решить, что оставить: твоё, чужое или комбинацию
  4. Удалить маркеры `<<<<<<<`, `=======`, `>>>>>>>`
  5. `git add <файл>` — пометить конфликт как решённый
  6. `git commit` — завершить merge (Git подставит сообщение автоматически)
Если конфликт сложный и непонятно, что выбрать — не угадывай. Спроси автора другого изменения. Я знаю джунов, которые в страхе делали `git reset --hard` и теряли два дня работы. Лучше написать в чат «у меня конфликт в test_payment.py, помогите разобрать».

Code review: как воспринимать комментарии

Самое сложное в Git для джуна — не команды. Это первые комментарии в PR от тимлида.
Тебе пришло «локатор по xpath нестабильный, перепиши через data-testid». Ты воспринимаешь как «я плохо написал». На самом деле тимлид экономит твоё будущее время: через месяц вёрстка изменится, xpath отвалится, и ты будешь переписывать 30 тестов вместо одного.
Правила выживания на code review:
  • Не оправдывайся. «Спасибо, поправлю» — короткий и правильный ответ. Не «но я думал, что так быстрее».
  • Спрашивай, если непонятно. «Не понял про fixture scope, можешь скинуть пример?» лучше, чем поправить наугад.
  • Не воспринимай лично. Ревьюер критикует код, не тебя. Через полгода ты будешь так же критиковать чужой код.
  • Учись из комментариев. Я веду заметку «что мне говорили на ревью» — через год это база знаний, которая у меня в голове как рефлекс.

Что часто ломают джуны и как не попасть

Список грабель, на которые я наступила сама и видела у учеников.
Коммит в master напрямую. В большинстве команд master защищён, и push в него запрещён. Но если защиты нет — запушил в master, сломал прод, выгребаешь. Правило: всегда работай в feature-ветке.
Пуш гигантского PR на 50 файлов. Никто такое ревьюить не будет, или будут неделю. Дроби: один PR — одна логическая задача. Лучше 5 PR по 10 файлов, чем один на 50.
Коммит секретов. Случайно закоммитил .env с паролем от тестового контура — теперь он в истории навсегда. Удалить из текущего коммита мало, надо чистить историю через `git filter-branch` (страшно). Профилактика: `.gitignore` с `*.env`, `*.key`, `secrets/`.
`git push --force` в общую ветку. Перезаписал чужие коммиты, которые они уже забрали к себе. У всех расходится история, виноват ты. Правило: `--force` только в свою feature-ветку и только если уверен.
`git pull` без `git status`. Pull сначала, потом понял, что у тебя были несохранённые изменения, и они пропали. Всегда `git status` → `git stash` → `git pull` → `git stash pop`.

FAQ

Можно ли работать с Git только через GUI (SourceTree, GitKraken)?
Можно, и многие так делают. Но базовые команды в терминале знать всё равно нужно: половина инструкций в интернете и документации написана для CLI, а в CI/CD пайплайнах GUI нет вообще. Я советую первый месяц работать в терминале, чтобы понять, что происходит «под капотом» у GUI. Потом — что удобно.
Чем git rebase отличается от git merge и что выбрать?
Merge склеивает две ветки и создаёт новый «merge-коммит». История выглядит как дерево с ветвлениями. Rebase переносит твои коммиты поверх свежего master, как будто ты с него и начинал. История получается линейная и красивая, но переписанная. Для джуна правило: всегда merge. Rebase — продвинутая тема, легко выстрелить в ногу при работе с общими ветками.
Что делать, если я случайно закоммитил не в ту ветку?
Не паникуй, в Git почти ничего нельзя сломать необратимо. Если ты ещё не запушил — `git reset HEAD~1` отменяет последний коммит, файлы остаются изменёнными. Переключаешься на нужную ветку, делаешь коммит там. Если запушил — пиши в чат команде, что произошло, дальше разбираемся в каждом случае отдельно.
Сколько времени нужно, чтобы научиться Git?
Базовый набор из 12 команд осваивается за 1-2 недели практики на реальных задачах. Свободное владение, включая разрешение сложных конфликтов и работу с историей — 3-4 месяца ежедневной работы в команде. Чтение учебников без практики не работает: пока сам не словишь конфликт и не разберёшь — в голове не уложится.

Что делать дальше

Поставь Git локально, склонируй любой публичный репозиторий с GitHub (например, мой шаблон автотестов), сделай свою ветку, поменяй README, открой PR в свой же форк. Это весь процесс в миниатюре: clone → branch → commit → push → PR.
Когда базовые команды войдут в руки — начнётся настоящее обучение: ты упрёшься в ситуации, которые гайды не покрывают. Конфликт в бинарном файле. Случайный force-push. Ветка, которую кто-то удалил, пока ты в ней работал. Это нормально и неизбежно. Главное — не угадывать, а спрашивать.
В моих группах AQA Python мы первые две недели разбираем именно работу с Git и репозиторием — без этого нет смысла идти дальше в pytest и Selenium. Если хочешь сэкономить полгода набивания шишек самостоятельно — приходи на бесплатную консультацию, разберём твой кейс и план обучения. Записаться t.me/yakorqa