Русский
Обсудить проект
Общее◷ 6 мин чтения

Почему тестирование сайта начинается не перед релизом

Тестирование сайта начинается не тогда, когда разработчик написал последнюю строку кода. И не тогда, когда задача уже стоит в статусе «готово к QA». Оно начинается значительно раньше — в момент, когда команда формулир…

Почему тестирование сайта начинается не перед релизом

Тестирование сайта начинается не тогда, когда разработчик написал последнюю строку кода. И не тогда, когда задача уже стоит в статусе «готово к QA». Оно начинается значительно раньше — в момент, когда команда формулирует требование и определяет, как поймёт, что функция действительно работает правильно. Хороший цикл выглядит так: Requirement ↓ Acceptance Criteria ↓ Development ↓ Tests ↓ Deployment На практике тестирование проходит через весь этот процесс, а не существует отдельным этапом в самом конце. Это важное отличие зрелой разработки от подхода:

«Сначала сделаем, потом проверим». Потому что чем позже найдена ошибка, тем дороже её исправлять. Что происходит, если QA появляется только в конце Представим простую задачу. Бизнес говорит: Нужно добавить форму заявки. Разработчик несколько дней делает:

  • интерфейс;
  • backend;
  • отправку данных;
  • интеграцию с CRM.

После этого задача приходит QA. И только в этот момент выясняется:

  • поле бюджета должно было быть обязательным;
  • заявка должна создавать статус «Новая»;
  • пользователь должен получать подтверждение;
  • менеджеру должно приходить уведомление;
  • после ошибки форма не должна очищаться.

Формально функция есть. Но реализована она не так, как ожидал бизнес. Проблема появилась не на этапе тестирования. Она появилась раньше — когда команда не договорилась о критериях результата. QA просто обнаружил её последним. Цена позднего дефекта Чем позже находится проблема, тем больше компонентов уже зависят от решения. Если несоответствие заметили на этапе требования, достаточно изменить несколько строк описания. Если после разработки — нужно менять код. Если после интеграции — код и связанные сервисы. Если после production — дополнительно могут потребоваться:

  • hotfix;
  • rollback;
  • коммуникация с клиентами;
  • исправление данных;
  • повторный deployment.

Поэтому современный QA стремится обнаруживать проблемы как можно раньше. Этот подход часто называют shift-left testing . Проверка смещается ближе к началу жизненного цикла разработки. QA начинается с Requirement Первый объект тестирования — не код. Первый объект тестирования — требование. Например: Добавить возможность удалить статью. На первый взгляд всё понятно. Но QA может сразу задать вопросы:

  • Кто имеет право удалять статью?
  • Автор или только администратор?
  • Удаление необратимое?
  • Нужен confirmation dialog?
  • Что произойдёт с URL статьи?
  • Что увидит пользователь после удаления?
  • Что произойдёт с изображениями?
  • Записывается ли удаление в историю?

Это не придирки. Это будущие сценарии системы. Чем раньше команда отвечает на них, тем меньше вероятность, что разработчик и заказчик представляют функцию по-разному. Acceptance Criteria превращают идею в проверяемый результат Хорошее требование можно проверить. Вместо: Сделать удобную форму. лучше:

  • форма содержит имя, контакт и комментарий;
  • имя обязательно;
  • контакт обязательно;
  • при некорректном значении отображается ошибка;
  • после успешной отправки пользователь видит confirmation;
  • заявка создаётся в CRM в статусе «Новая».

Теперь команда понимает, что значит «готово». Acceptance Criteria полезны одновременно:

  • разработчику;
  • QA;
  • дизайнеру;
  • product owner;
  • заказчику.

Они превращают субъективное ожидание в конкретный контракт. Development и testing не должны идти последовательно Старая модель выглядит так: Development → QA Современная модель ближе к: Development ↔ Testing Пока разработчик реализует функцию, уже могут появляться:

  • unit tests;
  • integration tests;
  • API tests;
  • test data;
  • test scenarios.

Разработчик проверяет отдельные компоненты. QA проверяет риски и пользовательские сценарии. Автоматизация начинает собираться вместе с функциональностью. В результате тесты не догоняют продукт через несколько недель. Они развиваются вместе с ним. Какие тесты нужны сайту Не существует одного универсального типа тестирования. Разные проверки отвечают на разные вопросы. 1. Unit tests Unit-тесты проверяют маленькие части логики изолированно. Например, есть функция расчёта скидки. Правила:

  • обычный клиент получает 0%;
  • постоянный — 10%;
  • партнёр — 15%.

Unit tests могут быстро проверить каждое правило. Их задача: Правильно ли работает отдельный компонент? Плюсы unit-тестов:

  • быстро выполняются;
  • легко запускаются;
  • помогают локализовать ошибку;
  • хорошо подходят для бизнес-логики.

Если сломался unit test функции расчёта, разработчику не нужно исследовать весь пользовательский интерфейс. Проблема уже локализована. 2. Integration tests Integration tests проверяют взаимодействие нескольких компонентов. Например: форма вызывает backend, backend записывает данные в database, после этого создаётся lead. По отдельности каждый компонент может работать правильно. Но связь между ними — нет. Integration test отвечает на вопрос: Правильно ли эти части работают вместе? Типичный пример: API успешно принимает заявку, но из-за неправильной схемы она не сохраняется в базе.

Unit tests отдельных функций могут быть зелёными. Integration test обнаружит проблему. 3. API tests Для современных сайтов API часто становится одним из главных уровней тестирования. Можно проверять:

  • status codes;
  • validation;
  • permissions;
  • response schema;
  • business rules;
  • errors;
  • filtering;
  • pagination.

Например: POST /api/leads Успешный запрос должен вернуть 201. Запрос без обязательного контакта — 422. Неавторизованный запрос к закрытому endpoint — 401 или 403 в зависимости от сценария. API-тесты особенно полезны потому, что работают быстрее UI и позволяют точно проверить серверную бизнес-логику. 4. UI tests UI testing проверяет интерфейс. Например:

  • кнопка видна;
  • меню открывается;
  • поле можно заполнить;
  • validation message отображается;
  • layout не ломается;
  • пользователь может нажать CTA.

Часть UI-проверок выполняется вручную. Часть можно автоматизировать. Но проверять весь продукт только через UI дорого и медленно. Поэтому хороший test strategy использует несколько уровней. 5. E2E tests E2E — End-to-End testing. Это проверка полного пользовательского сценария. Например: Пользователь открывает сайт ↓ переходит на страницу услуги ↓ заполняет форму ↓ отправляет заявку ↓ видит подтверждение ↓ заявка появляется в CRM Это уже не тест одной кнопки. Это проверка бизнес-процесса от начала до конца. E2E особенно важны для критических flows:

  • регистрация;
  • login;
  • заявка;
  • checkout;
  • payment;
  • публикация контента;
  • работа CRM.

Таких тестов обычно меньше, чем unit tests, но они защищают самые важные пользовательские сценарии. 6. Regression testing Представим, команда исправила форму заявки. Сама форма теперь работает. Но после изменения неожиданно перестала работать форма на другой странице. Или изменился общий компонент кнопки, и сломался checkout. Regression testing отвечает на вопрос: Не сломали ли новые изменения то, что работало раньше? Это особенно важно для активно развивающихся систем. Чем больше функциональности, тем сложнее человеку вручную помнить обо всех зависимых сценариях.

Автоматизированная regression suite помогает проверять их после изменений. 7. Smoke testing Smoke tests — небольшая группа быстрых проверок после deployment. Их задача не проверить всё. Их задача ответить: Система вообще жива после релиза? Например:

  • главная открывается;
  • API отвечает;
  • database доступна;
  • login работает;
  • форма заявки отправляется;
  • ключевой endpoint возвращает успешный ответ.

Если smoke падает сразу после deployment, нет смысла запускать длительную regression suite. Сначала нужно разобраться с базовой работоспособностью релиза. Пирамида тестирования Условно тесты можно представить слоями. Внизу много быстрых проверок: Unit Дальше: Integration API Выше: UI И небольшое количество самых дорогих сценариев: E2E Идея не в том, чтобы проверять всё каждым видом тестов. Например, правило расчёта скидки не нужно десятки раз прогонять через браузер. Дешевле и быстрее проверить его unit-тестами. А через E2E убедиться, что пользователь действительно может оформить заказ с правильным результатом.

Почему нельзя автоматизировать только UI Иногда автоматизация QA начинается так: Давайте напишем Playwright на весь сайт. Playwright — отличный инструмент для браузерных и E2E-сценариев. Но если вся тестовая стратегия состоит только из UI automation, suite постепенно становится:

  • медленной;
  • дорогой;
  • чувствительной к изменению интерфейса;
  • сложной в диагностике.

Если тест: «Пользователь не смог создать заказ» упал, причина может находиться в:

  • UI;
  • API;
  • database;
  • authentication;
  • сторонней интеграции.

Поэтому правильнее комбинировать уровни. Unit и API дают быстрый feedback. E2E проверяет критический путь пользователя. Тесты — это часть функциональности В VERB для продуктовых изменений полезно использовать простое правило: Пользовательский flow изменился → тесты должны измениться вместе с ним. Например, раньше заявка имела два статуса: Новая → Оплачена Теперь добавился: Новая → В работе → Оплачена Это не только изменение frontend или CRM. Нужно обновить проверки:

  • unit;
  • API;
  • integration;
  • E2E;
  • regression.

Иначе продукт уже работает по новым правилам, а test suite продолжает проверять старые. Такие тесты создают ложное чувство безопасности. Тест — такой же код Автоматический тест нельзя написать один раз и забыть. Он требует:

  • review;
  • поддержки;
  • рефакторинга;
  • удаления устаревших сценариев;
  • обновления test data.

Если бизнес-логика изменилась, тест должен отражать новую логику. Если функция удалена, старый тест тоже нужно удалить или изменить. Test suite — часть кодовой базы продукта. QA во время проектирования QA полезен ещё до начала development. Например, команда проектирует форму загрузки файла. QA может обратить внимание:

  • какой максимальный размер?
  • какие форматы?
  • что происходит при обрыве соединения?
  • можно ли загрузить пустой файл?
  • можно ли загрузить файл дважды?
  • что видит пользователь при ошибке?

Эти вопросы помогают не только написать будущие тесты. Они помогают спроектировать сам продукт. Поэтому сильный QA занимается не поиском дефектов как основной задачей. Он помогает предотвращать их появление. QA после deployment Релиз не означает окончание проверки. После production deployment нужно убедиться, что реальное окружение работает. Например:

  • migrations применились;
  • database доступна;
  • environment variables корректны;
  • сторонние API работают;
  • CDN отдаёт файлы;
  • application health checks зелёные.

Здесь особенно полезны smoke tests и мониторинг. Некоторые ошибки невозможно увидеть на локальной машине или staging. Production имеет собственную инфраструктуру и интеграции. Что даёт бизнесу раннее тестирование На первый взгляд тесты — технические расходы. На практике они влияют на бизнес напрямую.

Меньше переделок

Неправильно понятые требования обнаруживаются раньше.

Быстрее релизы

Автоматизация снижает объём ручной regression.

Меньше production-багов

Критические сценарии регулярно проверяются.

Безопаснее изменения

Команда меньше боится рефакторить систему.

Проще развивать продукт

После каждого нового релиза проверяется не только новая функция, но и существующие flows. Тестирование и скорость разработки не противоречат друг другу Иногда тесты воспринимают как то, что замедляет выпуск. На короткой дистанции написать тест действительно требует дополнительного времени. Но без него следующая задача может занимать больше. Разработчик начинает думать: Если я поменяю это, что ещё сломается? После изменений команда проводит большую ручную regression. Bug fixes на production отвлекают от roadmap. В результате первоначальная «экономия» времени возвращается в виде:

  • ручных проверок;
  • дефектов;
  • hotfix;
  • повторных релизов.

Тестирование не делает разработку мгновенной. Оно делает изменения предсказуемее. Пример полного цикла Допустим, VERB добавляет форму обратной связи.

Requirement

Пользователь должен иметь возможность отправить заявку.

Acceptance Criteria

  • имя обязательно;
  • контакт обязателен;
  • комментарий опционален;
  • после отправки показывается confirmation;
  • заявка создаётся в CRM со статусом «Новая».

Development

Реализуются frontend, API и CRM integration.

Tests

Unit Validation отдельных полей. API Создание заявки и ошибки запроса. Integration Сохранение + CRM. UI Работа формы. E2E Пользователь отправляет заявку, заявка появляется в CRM.

Deployment

Release проходит через CI/CD.

Smoke

После production проверяется, что форма реально работает. Теперь функция существует не только в коде. Она существует вместе с системой проверок. Современный QA участвует в четырёх точках Хорошую модель можно запомнить так. QA участвует: при формулировании требований Чтобы понять, что именно строим. при проектировании Чтобы заранее увидеть риски и edge cases. во время development Чтобы тесты создавались вместе с кодом. после deployment Чтобы убедиться, что пользовательский сценарий работает в реальной системе. Это значительно эффективнее модели:

Разработка закончилась → отдаём тестировщику. Подход VERB В VERB тестирование — часть разработки, а не финальный контроль качества. Для каждого критического пользовательского flow должны существовать подходящие проверки. Если меняется:

  • login;
  • форма;
  • CRM;
  • checkout;
  • CMS;
  • публикация;
  • API;

вместе с функциональностью меняется и test coverage. Принцип простой: Requirement ↓ Acceptance Criteria ↓ Development + Tests ↓ Deployment ↓ Smoke + Monitoring Так тесты становятся не препятствием перед релизом, а инструментом более безопасного развития продукта. Главный вывод QA не должен впервые видеть функцию, когда она уже закончена. Если функция реализована неправильно, но разработчик уже потратил несколько дней, тестирование нашло проблему слишком поздно. Сильный процесс пытается обнаружить несоответствие ещё тогда, когда оно существует только в тексте требования.

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

Хотите понять, насколько безопасно развивается ваш сайт?

VERB может провести аудит процесса разработки и test coverage:

  • требований;
  • acceptance criteria;
  • unit tests;
  • integration tests;
  • API tests;
  • UI automation;
  • E2E;
  • regression;
  • smoke;
  • CI/CD.

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

V
Команда VERBПроектируем и развиваем цифровые продукты для бизнеса.
Другие статьи

СОЗДАЁМ DIGITAL-ПРОДУКТЫ

Готовы запустить проект?

Оставьте заявку — обсудим задачу и предложим решение.
Оставить заявку