Релиз в конце рабочего дня: почему тестировщик не всегда может проверить всё за час

Всем привет! Я работаю QA-тестировщиком в IT-компании. Это моя первая статья на площадке, поэтому решил начать с ситуации, которая, думаю, знакома многим разработчикам и тестировщикам. Бывает, что новую версию приложения передают на проверку почти перед окончанием рабочего дня, а выпустить её хотят уже сегодня. Расскажу, почему даже небольшое обновление иногда требует нескольких часов тестирования и как можно избежать постоянных авралов.

Когда новая сборка появляется слишком поздно

Представим обычный рабочий день небольшой команды разработчиков.

Утром проходит короткое обсуждение задач. Программисты заканчивают свои изменения, аналитик уточняет требования, а тестировщик проверяет то, что уже готово.

Вроде бы всё идёт по плану.

Но ближе к вечеру появляется новая задача. Разработчик сообщает, что закончил исправления, а руководитель проекта хочет выпустить обновление сегодня.

На часах 17:20. Рабочий день заканчивается в 18:00.

Нужно проверить новую сборку, несколько исправленных ошибок и убедиться, что основные функции приложения продолжают работать.

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

Но размер задачи разработчика далеко не всегда соответствует времени, необходимому на тестирование.

Например, программист исправил ошибку расчёта скидок в интернет-магазине.

Для этого ему потребовалось изменить всего несколько строк кода.

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

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

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

Иначе даже обычное обновление легко превращается в вечерний аврал.

Почему небольшое изменение может потребовать много проверок

Возьмём для примера интернет-магазин.

Раньше покупатели могли использовать промокод, который уменьшал стоимость заказа на 10%.

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

На первый взгляд изменение небольшое.

Но появляется несколько сценариев, которые нужно проверить.

  • Промокод работает без бонусных баллов.
  • Бонусные баллы применяются без промокода.
  • Скидка и бонусы используются одновременно.
  • Итоговая сумма не становится отрицательной.
  • После удаления промокода цена пересчитывается правильно.
  • После обновления страницы сохраняются нужные данные.
  • В платёжный сервис передаётся корректная сумма.

Дополнительно необходимо учитывать ограничения конкретных акций.

Например, некоторые промокоды могут действовать только на определённые категории товаров. А бонусами иногда разрешается оплатить не более установленной доли стоимости покупки.

Все эти условия должны соответствовать требованиям продукта.

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

Именно поэтому оценивать объём тестирования по количеству изменённых строк кода не совсем правильно.

Гораздо важнее понимать, какие функции затронуты и какие риски возникают после изменения.

Сколько времени действительно нужно на тестирование

Попробуем посчитать на примере задачи со скидками.

Допустим, необходимо проверить семь основных сценариев.

Подготовка тестового аккаунта, товаров и промокодов занимает примерно пятнадцать минут.

На каждый сценарий потребуется около пяти минут.

Получаем:

7 × 5 = 35 минут.

Дополнительно нужно проверить итоговые суммы и убедиться, что данные корректно сохраняются. На это заложим ещё двадцать минут.

И примерно десять минут потребуется на фиксацию результата.

Итого:

15 + 35 + 20 + 10 = 80 минут.

То есть даже при нормальной работе приложения тестирование займёт около часа двадцати минут.

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

Если в процессе обнаружится ошибка, потребуется дополнительное время.

Нужно воспроизвести проблему, собрать информацию, оформить задачу разработчику и после исправления провести повторную проверку.

Поэтому обещать закончить подобное тестирование за полчаса я бы не стал.

На мой взгляд, гораздо полезнее сразу показать команде примерный объём работы и объяснить, какие проверки обязательны перед выпуском.

Что делать, когда времени действительно мало

Не все ошибки одинаково опасны для приложения.

Например, если в личном кабинете немного съехала иконка, пользователь, скорее всего, сможет продолжить работу.

А если при оформлении заказа неправильно рассчитывается стоимость, последствия будут гораздо серьёзнее.

Поэтому при ограниченном времени приходится учитывать риски.

Представим, что разработчики изменили страницу оплаты и одновременно исправили незначительную визуальную ошибку в истории заказов.

Я бы начал с проверки оплаты.

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

Затем проверить связанные функции.

И уже после этого переходить к менее критичным изменениям.

Но здесь важно понимать, что приоритет тестирования определяется не только личным мнением QA-специалиста.

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

Если времени недостаточно для всех проверок, лучше открыто обозначить, что именно удалось протестировать, а какие сценарии остались непроверенными.

Это намного правильнее, чем просто сообщить, что приложение работает нормально.

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

Представим ситуацию.

В интернет-магазине обнаружили ошибку: если покупатель дважды нажимает кнопку оплаты, система иногда создаёт два заказа.

Разработчик исправляет проблему.

Теперь после первого нажатия кнопка блокируется до завершения операции.

Тестировщик открывает сайт, оформляет заказ и видит, что всё работает правильно.

Повторные заказы больше не создаются.

Кажется, задачу можно закрывать.

Но что произойдёт, если платёж не пройдёт?

Например, банк отклонил операцию или соединение с платёжным сервисом прервалось.

Пользователь получает сообщение об ошибке, исправляет данные карты и пытается повторить оплату.

А кнопка остаётся заблокированной.

В результате одну проблему исправили, но создали другую.

Чтобы обнаружить такой дефект, нужно проверить несколько сценариев:

  1. Успешную оплату.
  2. Ошибку платёжного сервиса.
  3. Повторную попытку после ошибки.
  4. Поведение после обновления страницы.
  5. Повторное нажатие кнопки во время обработки запроса.

Причём сама блокировка кнопки в браузере не гарантирует защиту от дублирования платежей.

Для финансовых операций необходима соответствующая серверная логика, например механизм идемпотентности, если он предусмотрен архитектурой системы.

Это хороший пример того, почему даже небольшое исправление может потребовать дополнительных технических проверок.

Почему не нужно каждый раз тестировать всё приложение

После изменений полезно проверить, не сломались ли функции, которые раньше работали правильно.

Для этого используется регрессионное тестирование.

Но объём регрессии может быть разным.

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

Полная проверка всех этих функций может занимать много часов.

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

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

Smoke-тестирование позволяет быстро оценить, работают ли основные функции приложения и можно ли продолжать тестирование сборки.

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

Регрессионное тестирование помогает обнаружить проблемы, которые могли появиться в ранее работавших функциях.

При этом регрессию можно ограничивать затронутыми компонентами с учётом рисков.

Например, после изменения логики промокодов стоит проверить корзину, расчёт стоимости и оформление заказа.

Но проверять все настройки профиля пользователя может быть необязательно, если эти функции не связаны с изменениями.

Конкретный набор тестов зависит от архитектуры приложения и принятой стратегии качества.

Как автоматизация помогает перед релизами

Допустим, команда выпускает обновления три раза в неделю.

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

На это уходит около сорока минут.

За неделю:

40 × 3 = 120 минут.

То есть два часа.

За четыре недели получается восемь часов.

Если часть повторяющихся сценариев автоматизировать, время ручных проверок может уменьшиться.

Например, автоматические тесты способны проверить основные API, корректность расчётов и успешное выполнение типовых операций.

Но я бы не рассматривал автоматизацию как универсальное решение.

Автотесты тоже требуют поддержки.

После изменения интерфейса часть проверок может перестать работать, хотя само приложение исправно.

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

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

Особенно полезно автоматизировать стабильные и часто повторяющиеся проверки, на выполнение которых команда регулярно тратит время.

Если сборку передали за двадцать минут до конца рабочего дня

Бывает ситуация, когда разработчик передаёт новую сборку практически перед окончанием рабочего дня.

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

Я бы в таком случае сначала уточнил, какие изменения вошли в сборку.

Затем посмотрел список затронутых функций.

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

Но если изменена логика оплаты, регистрации или сохранения данных, объём работы будет совершенно другим.

В такой ситуации полезно сразу обозначить, какие проверки успеваем выполнить.

Например, за оставшееся время можно протестировать основной успешный сценарий, но для проверки ошибок платёжного сервиса, повторных запросов и связанных функций понадобится дополнительное время.

После этого команда может принять решение.

Перенести релиз, сократить состав изменений, выделить дополнительное время или действовать по согласованной процедуре принятия риска.

Важно, чтобы решение принималось с пониманием того, что именно осталось непроверенным.

Я бы не стал подтверждать полную готовность приложения после одной короткой проверки.

Даже если очень хочется закончить работу вовремя.

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

Есть ещё одна проблема, которая встречается в небольших командах.

Представим проект, над которым работают пять разработчиков и один тестировщик.

В течение дня программисты заканчивают свои задачи.

Но новые версии передают на проверку ближе к вечеру.

В результате у одного QA-специалиста одновременно появляются несколько новых функций, исправленные ошибки и релизная сборка.

Допустим, пришло шесть задач.

На каждую требуется в среднем сорок минут.

Получается:

6 × 40 = 240 минут.

То есть четыре часа работы.

Если все задачи передали за час до окончания рабочего дня, выполнить их качественно физически невозможно.

И дело здесь не обязательно в скорости тестировщика.

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

Поэтому я считаю полезным заранее договариваться о времени передачи изменений на тестирование.

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

Конечно, это не универсальное правило.

В некоторых командах тестирование организовано посменно, а релизы проходят в любое время суток.

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

Что делать, если серьёзную ошибку нашли перед запуском

Представим, что до выпуска новой версии остаётся полчаса.

Во время тестирования обнаруживается проблема с оплатой.

Покупатель завершает платёж, деньги списываются, но приложение показывает сообщение об ошибке.

Человек не понимает, прошла операция или нет, и может попробовать оплатить заказ повторно.

В такой ситуации важно быстро собрать информацию.

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

Затем передать результаты разработчику и ответственному за релиз.

Если известны идентификаторы запросов или операций, они могут помочь найти события в логах.

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

Само решение о выпуске принимает команда в соответствии с внутренними процедурами.

Возможно, релиз придётся перенести.

Иногда можно отключить проблемную функцию или откатить изменение.

Но выпускать обновление, скрывая обнаруженный риск, я бы точно не советовал.

Почему удалённой команде особенно нужны понятные договорённости

Я работаю удалённо, поэтому хорошо понимаю, насколько важна нормальная коммуникация.

В офисе можно подойти к разработчику и быстро обсудить проблему.

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

Например, у одного специалиста рабочий день уже закончился, а у другого осталось ещё несколько часов.

Если заранее не договориться о порядке выпуска обновлений, срочные задачи будут постоянно появляться в неудобное время.

Поэтому полезно определить несколько вещей.

Кто отвечает за подготовку релизной сборки.

Когда она должна быть передана на проверку.

Какие тесты обязательны перед выпуском.

Кто принимает решение о релизе.

Что делать, если обнаружена блокирующая ошибка.

И где фиксируются результаты проверки.

Мне кажется, для небольшой команды не обязательно писать огромный документ на десятки страниц.

Иногда достаточно одной страницы с понятным порядком действий.

Главное, чтобы все участники процесса одинаково понимали свою ответственность.

Как я фиксирую результаты тестирования

После проверки важно не просто сообщить, что всё работает.

Я считаю полезным указывать конкретные сценарии, которые удалось проверить.

Например, результат может выглядеть так:

Проверена сборка 2.14.3 на тестовом окружении.

Успешно пройдены основные сценарии авторизации, добавления товаров в корзину и оформления заказа.

Исправление ошибки с промокодом подтверждено.

Дополнительно проверен расчёт скидки для нескольких товаров.

Полное регрессионное тестирование административной панели не проводилось, поскольку оно не входило в согласованный объём проверки.

Такое сообщение позволяет команде понять реальное состояние продукта.

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

Любая проверка имеет определённое покрытие и ограничения.

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

Особенно перед релизом.

Как избежать постоянных переработок

Иногда срочные задачи действительно неизбежны.

Например, обнаружена серьёзная проблема, которая мешает пользователям совершать покупки.

Но если каждый релиз заканчивается задержками, стоит разобраться в причинах.

Я бы начал с простого анализа рабочего процесса за несколько недель.

Посмотрел, в какое время разработчики обычно передают задачи на тестирование.

Сколько времени требуется на проверку.

Как часто обнаруженные ошибки приводят к переносу релиза.

И сколько задач регулярно поступает ближе к завершению рабочего дня.

Если собрать эти данные, станет проще обсуждать проблему с командой.

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

В таком случае имеет смысл пересмотреть порядок работы.

Возможно, стоит уменьшить объём одного релиза, раньше передавать готовые функции на проверку или автоматизировать часть повторяющихся тестов.

А иногда действительно требуется дополнительный QA-специалист, если объём задач постоянно превышает возможности одного человека.

Главное — оценивать ситуацию по фактической нагрузке, а не просто требовать от сотрудников работать быстрее.

Итог

Работа тестировщика гораздо шире, чем поиск ошибок.

Нужно понимать, как устроено приложение, оценивать последствия изменений, планировать проверки и объяснять команде возникающие риски.

Особенно хорошо это становится заметно перед выпуском новых версий.

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

На мой взгляд, эффективнее заранее договариваться о времени тестирования и объёме обязательных проверок.

А если сроки всё-таки изменились, честно фиксировать, что удалось проверить и какие риски остаются.

Я считаю, что постоянные переработки перед релизами чаще говорят о проблемах организации процесса, чем о недостаточной скорости одного сотрудника.

Конечно, ситуации бывают разные.

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

И это важно не только для тестировщика, но и для разработчиков, руководителя проекта и пользователей приложения.

А среди читателей есть QA-специалисты и разработчики? Интересно, как у вас организовано тестирование перед релизами и часто ли приходится задерживаться из-за изменений, которые поступают в последний момент?