Что такое регрессионное тестирование

Регрессионное тестирование на Scrum-проектах: руководство по проведению

Согласно отчету The State of Agile Report («О развитии методологии Agile»), 95% опрошенных компаний разрабатывают программное обеспечение по Agile.

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

При этом тесты регрессии остаются одними из наиболее частых проверок перед релизом новой функциональности. Как выполнять их эффективно, особенно если время на тестирование ограничено всего одним спринтом, зачастую составляющим 2 недели? Что делать, если нужно внести изменения в функциональность продукта на поздней стадии спринта?

В этой статье мы ответим на эти вопросы, а также расскажем о том, как проводить регрессионное тестирование на Scrum-проектах и уверенно преодолевать возникающие сложности.

Регрессионное тестирование в Scrum-среде

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

повышать общее качество и стабильность ПО благодаря снижению вероятности критических ошибок при его использовании и многократному уменьшению числа дефектов к моменту релиза;

ускорять доставку решения на рынок, уменьшая время прогона тестов за счет автоматизации;

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

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

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

Топ-5 распространенных проблем и способы их преоделения

При проведении регрессионного тестирования на Scrum-проектах важно сфокусироваться на двух аспектах.

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

Второй ― выбрать проверки, которые можно автоматизировать. Важно помнить, что использовать автоматизацию уместно не во всех случаях. Особенно это касается GUI-проверок, где малейшие правки в дизайне приложения приводит к пересмотру тест-кейса с нуля.

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

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

Возрастающий объем регрессии

На крупных проектах с каждым новым спринтом объем регрессионного тестирования может увеличиваться. Чтобы эффективно им управлять, важно пересматривать тест-кейсы и удалять устаревшие. Делать это стоит по возможности и в зависимости от частоты вмешательства в релизы. Кроме того, это первый звонок, что уже можно и нужно внедрять автоматизацию.

Недостаточная коммуникация между участниками проекта

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

Поддержка тестовых сценариев

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

Частые доработки функциональности

Смоделируем ситуацию: на проекте возникли непредвиденные и объемные изменения в требованиях к функциональности продукта. Еще и в конце спринта. Что делать? Да, сроки имеют значение, но важно позаботиться о качестве и оценить, сколько времени займет перезапуск тестов с учетом входной информации, чтобы расширить спринт и перенести дату релиза.

Ложноположительные результаты тестов

Причина может заключаться в некорректной разработке автоматизированного тест-кейса. Исключить подобную вероятность поможет валидация инженером по функциональному тестированию, который проходит тест-кейс по шагам и проверяет соответствие ожидаемому результату. Кроме того, в спринтах стоит закладывать время на интуитивное (ad hoc) и исследовательское (exploratory) тестирование, чтобы максимально расширить тестовое покрытие.

Тестируем регрессию на Scrum-проекте: о чем важно помнить

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

Что еще нужно учитывать? Предлагаем рассмотреть 5 шагов, от которых напрямую зависит результативность регрессионного тестирования.

1. Подготовить план тестирования

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

2. Создать доску регрессии

Все задачи, над которыми работают QA-инженеры Scrum-команды, располагаются на доске в порядке сверху вниз по приоритетности в зависимости от возможных рисков, важности для клиента и ряда других факторов. Переставляя элементы на доске, команда всегда будет понимать актуальность задач и сможет планировать свое время так, чтобы укладываться в сроки.

3. Анализировать отчеты о дефектах

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

4. Добавить исследовательское тестирование

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

5. Настроить модель коммуникации на проекте

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

Заключение

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

В ходе регрессионного тестирования на Scrum-проектах команды сталкиваются с рядом сложностей, которые можно решить благодаря:

обеспечению непрерывной коммуникации между участниками проекта;

поддержке документации в актуальном состоянии;

расширению спринта в случае внесения изменений в функциональность перед релизом;

валидации автоматизированных тест-кейсов.

Чтобы эффективно организовать процесс тестирования, важно:

создать план выполнения регрессии;

использовать доску регрессии;

тщательнее работать над ошибками;

не забывать о преимуществах исследовательского тестирования;

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

Подобный подход поможет гарантировать качество и стабильность ПО, несмотря на непрерывные доработки, и обеспечить слаженную работу Scrum-команд.

Источник

В чём разница Smoke, Sanity, Regression, Re-test и как их различать?

Оригинал. Перевод разбавлен размышлениями и дополнениями автора из своего опыта

О чём это всё

Будучи инженером по тестированию, вы, вероятно, слышали о таких видах тестирования как «дымовое» (smoke), «санитарное тестирование» (sanity), «ре-тест» и регрессионное тестирование. Вполне возможно, многие из этих видов используются вами на ежедневной основе.

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

Для новичков в тестировании (и даже опытных тестировщиков) разделение этих понятий может быть затруднительно. И в самом деле, как отличить где начинается санити-тестирование и заканчивается smoke? Насколько сильно нам надо ограничить проверку части функциональности системы или её компонентов, чтобы назвать это «дымовым» тестированием? Является ли ввод логина/пароля в пользовательскую форму входа на сайт дымовым тестом, или сам факт её появления на странице сайта уже является пройденным тестом?

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

Ликбез

Ниже приведены краткие определения видов тестирования, которые мы сегодня сравниваем:

Ну а по существу?

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

Пример: у нас есть веб-сервис с пользовательским интерфейсом и RESTful API. Будучи тестировщиками, мы знаем:

Подведём итог

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

UPD:
Часто «тестирование согласованности» или «тестированием на вменяемость», называют термином «санитарное тестирование». Думаю что это пошло из-за фонетических свойств английского слова sanity, схожего по звучанию с чем-то «санитарным». Гугл транслейт вносит ясность. В интернете встречаются оба варианта. Относительно данной статьи прошу считать «санитарное» тестирование как «тестирование на согласованность».

Источник

Регрессионное тестирование

Что такое регрессионное тестирование?

РЕГРЕССИОННОЕ ИСПЫТАНИЕ определяется как тип тестирования программного обеспечения для подтверждения того, что недавнее изменение программы или кода не оказало неблагоприятного воздействия на существующие функции.

Регрессионное тестирование — это не что иное, как полный или частичный отбор уже выполненных тестовых случаев, которые повторно выполняются для обеспечения нормальной работы существующих функций.

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

В этом уроке мы узнаем

Необходимость регрессионного тестирования

Регрессионное тестирование требуется, когда есть

Как сделать регрессионное тестирование

Обслуживание программного обеспечения — это действие, которое включает в себя улучшения, исправления ошибок, оптимизацию и удаление существующих функций. Эти модификации могут привести к некорректной работе системы. Таким образом, регрессионное тестирование становится необходимым. Регрессионное тестирование может проводиться с использованием следующих методов:

Перепроверить все

Выбор регрессионного теста

Приоритизация тестовых случаев

Выбор тестовых случаев для регрессионного тестирования

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

Инструменты регрессионного тестирования

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

В таких случаях ручное выполнение тестовых случаев увеличивает время выполнения теста, а также затраты.

Автоматизация регрессионных тестов является разумным выбором в таких случаях.

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

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

Ranorex Studio : универсальная автоматизированная система регрессионного тестирования для настольных, веб-и мобильных приложений со встроенным Selenium WebDriver. Включает в себя полный IDE плюс инструменты для автоматизации без кода.

Selenium : это инструмент с открытым исходным кодом, используемый для автоматизации веб-приложений. Selenium можно использовать для регрессионного тестирования на основе браузера.

Quick Test Professional (QTP) : HP Quick Test Professional — это автоматизированное программное обеспечение, разработанное для автоматизации функциональных и регрессионных тестов. Он использует язык VBScript для автоматизации. Это управляемый данными инструмент на основе ключевых слов.

Регрессионное тестирование и управление конфигурацией

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

Разница между повторным и регрессионным тестированием:

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

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

Проблемы в регрессионном тестировании:

Ниже приведены основные проблемы тестирования для проведения регрессионного тестирования:

Практическое применение примера регрессионного тестирования с видео

Нажмите здесь, если видео не доступно

Вывод:

Эффективная регрессионная стратегия, экономит организации время и деньги. Согласно одному из тематических исследований в банковской сфере, регрессия экономит до 60% времени в исправлениях ошибок (которые были бы обнаружены регрессионными тестами) и до 40% в деньгах.

Источник

Автоматизированный подход к регрессионному тестированию

Здравствуйте, дорогие читатели. Сегодняшний материал мы хотели бы приурочить к запуску курса «Python QA Engineer». Предвещая возможные вопросы, предупреждаем, что в статье нет ни слова о Python, но все же мы считаем этот материал полезным для тестировщиков, поэтому и решили поделиться им с вами.

Тестирование каждой мельчайшей детали кода – вещь неосуществимая, поэтому регрессионное тестирование должно осуществлять комплексную проверку и фокусироваться на определенной области во всем ее объеме. Основной целью при этом является уверенность в том, что ни одна регрессионная ошибка не повредит критически важному бизнес-процессу. Именно это усилие и позволяет извлекать выгоду из автоматизации. Автоматизированный подход к тестированию, ориентированный на уменьшение регрессионных ошибок, поможет пройти долгий путь к выстраиванию хороших отношений с клиентами и повышению ценности бренда.

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

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

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

Регрессионные ошибки вызваны изменениями, которые не были учтены project-менеджером или product owner’ом при приемочных тестах; архитектором, разработчиком во время code review на этапе проектирования или реализации; или же QA-аналитиком и тестировщиком в тестовых кейсах. Все сети безопасности пропустили ошибку и на нее наткнулся пользователь. Если ошибка в недавнем обновлении была выявлена на любом из вышеперечисленных этапов, т.е. командами, заинтересованными сторонами или любым другим звеном, которое присутствует в вашей организации, то ее рассмотрели до релиза или, как минимум, оценили на критичность.

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

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

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

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

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

Выявление и реализация регрессионных тестов

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

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

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

Когда тестировщик фокусируется на новой функции или каком-то изменении, тест получается ориентированным конкретно на него, т.е. проверяется уместность конкретного изменения. Регрессионное тестирование отличается тем, что оно должно проверять, что ничего больше не претерпело изменений. Такое различие отражается в сценариях автоматизации. Оно делает сценарии тестирования конкретных функций непригодными для поиска регрессионных ошибок, поэтому здесь необходим другой подход.

Например, если вы работаете с системой управления заказами, вам понадобится скрипт для размещения заказов с множеством входных данных, чтобы размещать заказы на две установленные тестирующие системы (желательно, работающие параллельно), затем вы получаете отчет о заказах за прошедший день и сравниваете в них каждое значение. Затем все заказы подтверждаются или одобряются (это действие), а отчеты, такие как ежедневные подтвержденные заказы, заказы по номенклатуре, отчеты со склада, заказы с каждого перевозчика, тип отгрузки, тип платежа и т.д. будут сравниваться в двух системах. Так продолжается в течение всего рабочего процесса. Вы можете объединять действия, такие как размещение и подтверждение заказов, а затем сравнивать отчеты на отдельных этапах.

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

Сравнение двух отчетов – это момент истины, и он должен быть безупречным, в том смысле, что ни у кого из заинтересованных сторон не должно быть сомнений в его правильности. Разница в отчетах – это настоящая разница.

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

Сравнение происходит по трем фронтам:

Такой способ будет работать для XML, XLS, CSV фиксированной ширины или любого другого формата. Нам нужно убедиться, что нет лишних записей, нет отсутствующих записей и все значения записей совпадают.

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

Успех такого подхода заключается в инструменте сравнения или утилите, которая обрабатывает кейсы, относящиеся к вашему приложению. Вы можете считать себя счастливчиком, если найдете что-то подходящее «из коробки», в противном случае, важно понимать, что инвестиции в такой инструмент стоят того, поскольку они принесут хорошие плоды.

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

Настройка программы

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

«Запутать» данные с продакшена, удалив e-mail идентификаторы или другую конфиденциальную информацию, или же заменить ее фиктивными данными;

Получить данные в надлежащем виде для запуска теста;

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

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

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

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

Вариации могут начинаться с технологий – JSON, XML или скейлеров (int/string/float), и расширяться до того момента, пока тестируемое приложение и продакшен будут реагировать различными структурами, но все еще соответствовать архитектуре. Например, продакшен-версия может использовать старый JAR файл, который оперирует определенным форматом, а в новой версии JAR файл был обновлен и теперь формат ответа изменился, поэтому их сравнение покажет несоответствия. Для того, чтобы их сравнить надлежащим образом понадобится временный плагин.

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

Существует несколько вариантов обработки таких сравнений:

Игнорировать некоторые поля, такие как идентификаторы и даты;

Игнорировать числовые различия менее 0,0001;

Игнорировать чувствительность к регистру;

Структурировать изменения в два ответа.

Улучшение регрессионного тестирования

Регрессионное тестирование должно быть целостным и фокусироваться на целой области. Этот баланс поможет извлечь выгоду из автоматизации. Автоматизированный подход к тестированию поможет уменьшить количество регрессионных ошибок и поможет на пути к хорошим отношениям с клиентами и повышению стоимости бренда.

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

Перевод подготовлен специально для студентов курса «Python QA Engineer».

Источник

Что нужно знать о регрессионном тестировании

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

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

Определение

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

Термин произошел от понятия «регресс» — движение назад, отход, откат, возврат. Такое тестирование характеризует собирательную проверку ПО, которая направлена на обнаружение ошибок в ранее «изученных» элементах кода.

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

Когда требуется

При регрессионном тестировании могут быть обнаружены баги, мешающие нормальной работе софта. Они носят называние регрессионных ошибок.

Рассматриваемое тестирование потребуется в следующих ситуациях:

Также регрессионная проверка нужна, когда нет выстроенного процесса разработки утилиты:

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

Преимущества метода

Regression Testing обладает определенными преимуществами:

Исправление ошибки или обнаруженной неполадки – важный процесс перед выпуском софта. Особенно это касается игровых приложений. Тестинг позволяет убедиться в том, что система функционирует «так, как задумано изначально».

Недостатки

Регрессионное тестирование – хороший способ проверки утилиты. Но оно имеет ряд недостатков:

А еще данный прием требует большого количества ручного труда. Кроме автоматизированного ПО работу тестеров никто не отменял.

О задачах

У регресс-тестирования ключевая задача – это проверка того, что исправление ошибки не отразилось негативно на всем остальном программном коде. Функциональные возможности контента должны быть сохранены.

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

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

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

Типы и виды

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

Функциональность

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

Первый вариант базируется на функциях, которые будет выполнять система. Он осуществляется на интеграционном, системном, приемочной, а также компонентном уровня. Основные требования (аспекты), по которым осуществляется тестинг – установленные принципы и бизнес-процессы.

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

Говоря о бизнес-процессах, упор осуществляется именно на них. Подготавливаются и прогоняются сценарии, необходимые для ежедневной работы.

Нефункциональные тесты – отвечают за проверку свойств, не относящихся к функциям приложения. Примеры:

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

Автоматизация

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

К ключевым задачам, работающим автоматически, можно отнести:

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

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

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

Старые ошибки

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

Как провести

Регрессионное тестирование отнимает немало времени и сил. Поэтому стоит обратить внимание на то, сколько ресурсов и как быстро необходимо реализовать test. В зависимости от соответствующего момента можно выполнить полную регрессию или частичную.

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

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

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

Алгоритм организации

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

Чтобы завершить регрессио, остается протестить систему, получить результаты и проанализировать их. Далее – вносить корректировки. После этого можно снова браться за регрессионное тестирование.

Как лучше разобраться в теме

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

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

С дистанционными курсами, которые удастся проходить в любом удобном месте, когда захочется (достаточно иметь доступ к интернету), понять регрессионное тестирование, а также другие виды проверок утилит и кодов не составит никакого труда.

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

Источник

Что такое регрессионное тестирование?

Регрессионное тестирование — задача, с которой сталкивается каждый тестировщик. Ведь любой предмет после изменений в одном месте может начать ломаться в месте, где раньше работал исправно. То же самое касается и ПО, которое мы тестируем. В этой статье мы чуть-чуть подробнее рассмотрим этот вид тестирования и разберём готовую стратегию, которая поможет сэкономить время, и поддержать качество на нужном уровне.

Что это такое?

Для начала разберём 2 понятия:

Перепроверка (Retest, Defect Validation) — Процесс перепроверки упавших (failed) тестов, связанных с исправленным багом.

Регрессионное тестирование (Regression testing) — Тестирование уже протестированной программы,
проводящееся после модификации для уверенности в том, что процесс модификации не внес
или не активизировал ошибки в областях, не подвергавшихся изменениям. Проводится после
изменений в коде программного продукта или его окружении.

В чём разница?

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

Regression testing проверят ранее пройденные успешно тесты со статусом Passed c целью удостовериться, что изменения не поломали ранее рабочий функционал.

А зачем это делать регрессионное тестирование?

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

Нашу систему можно представить как сказку о репке.

И вот мы захотели убрать из истории собачку Жучку, чтобы сэкономить количество текста в сказке.

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

И вот оказалось, что дальше наша история ломается:

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

Какие изменения могут повлечь за собой регрессию?

Изменения в коде:

Изменения в окружении:

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

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

Как проводить регрессионное тестирование?

Время — это одно из главных наших ограничений.

Поэтому в зависимости от времени мы делаем либо полную регрессию (Complete regression), либо частичную (Partial Regression).
С полной регрессией, думаю, вопросов быть не должно. Мы просто выполняем все тесты, которые у нас есть.
А вот с частичной регрессией всё куда интереснее.

Как выбрать достаточное количество тест-кейсов из общего числа? Не будем же мы брать наугад?

Это, наверное, один из самых важных вопросов в тестировании.
Попробуем на него ответить.

Для выбора тестов мы будем опираться на 2 фактора:

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

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

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

Если времени чуть больше, то берём ещё и часть нечасто используемого функционала и совмещаем с тестами из пункта 2 в Likelihood.

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

Подытожим:

Retest — перепроверяет упавшие тесты после исправления дефектов.

Regression testing — проверяет ранее положительно пройденные тесты после любых изменений в коде, либо окружении приложения.

Retest & Regression testing нужно делать как можно чаще. Желательно на каждой сборке либо в каждой итерации.

Источник

Антирегрессионное тестирование – минимизируйте затраты

Регрессионное тестирование играет важнейшую роль в разработке продукта и считается непростой задачей. С этим трудно не согласиться, когда вы тестируете то, что уже было протестировано, а потом тестируете это снова. Термин «регрессия» ассоциируется у членов команды с большими усилиями. Мы знаем, насколько головоломным и вместе с тем незаменимым может быть регрессионное тестирование для процесса релиза и спрашиваем «Приведет ли невыполненное регрессионное тестирование к неудовлетворительному результату?» и «Нужно ли проводить регрессионное тестирование, если программа без ошибок – это недостижимая цель?» Что ж, ответом будет «Да! Регрессионное тестирование нужно проводить регулярно».

Что подразумевается под регрессионным тестированием?

На этот вопрос можно ответить одной фразой: «Исправляя одну ошибку, вы привносите в приложение несколько новых ошибок». Регрессионное тестирование – это то, что позволяет обеспечить исправление ошибки без побочных эффектов.
Во время тестирования выявляются некоторые ошибки, при этом разработчики проекта проводят быструю отладку. Тестировщики и разработчики проводят регрессионное тестирование, чтобы исправление ошибок не привело к нарушению функционала приложения.

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

Антирегрессионное тестирование

Сам термин «регрессионное тестирование» в некотором роде неточен. Правильнее было бы назвать тестирование «антирегрессионным», так как мы выполняем тесты, чтобы проверить, что система не регрессировала (то есть в результате внесения изменений в ней не возникло еще больше ошибок). Точнее говоря, цель регрессионного тестирования состоит в том, чтобы убедиться, что изменение или улучшение кода программы или среды не нарушило функциональность и не создало побочных эффектов.

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

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

Почему с регрессионными дефектами трудно иметь дело?

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

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

Временные сложности: Время регрессионного тестирования приходит после завершения одного этапа разработки и тестирования. По мере приближения сроков выполнения проекта регрессионное тестирование становится серьезным испытанием для команды. У разработчиков остается очень мало времени на исправление ошибок, а у тестировщиков – на проведение повторных функциональных и регрессионных испытаний.

Замедление процесса управления проектом: Каждая компания использует некоторый процесс, обеспечивающий создание продукта в соответствии с требованиями. При обнаружении значительного дефекта в программном обеспечении этот процесс может быть нарушен. Это негативно скажется на сроках выполнения проекта и развертывания продукта.

Тонкости исправления регрессионных дефектов

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

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

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

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

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

Сравнение регрессионного тестирования и повторного тестирования

Очень тонкая линия разделяет регрессионное тестирование и повторное тестирование.

Цель регрессионного тестирования – убедиться, что изменения не повлияли на неизмененённую часть. Повторное тестирование проводится для того, чтобы проверить, что тестовые сценарии, не прошедшие во время последнего выполнения, работают после исправления дефектов. Регрессионное тестирование не проводится для исправления конкретных дефектов. Повторное тестирование выполняется на основе исправлений дефектов.

Автоматизация – ключевой фактор регрессионного тестирования, тогда как повторное тестирование невозможно автоматизировать по причине неопределенности. Проверка дефекта проводится только в рамках повторного тестирования.

Когда применяется регрессионное тестирование?

Регрессионное тестирование рекомендуется выполнять при возникновении следующих событий:

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

Источник

Регрессионное тестирование

Из опыта разработки ПО известно, что повторное появление одних и тех же ошибок — случай достаточно частый. Иногда это происходит из-за слабой техники управления версиями или по причине человеческой ошибки при работе с системой управления версиями. Но настолько же часто решение проблемы бывает «недолго живущим»: после следующего изменения в программе решение перестаёт работать. И наконец, при переписывании какой-либо части кода часто всплывают те же ошибки, что были в предыдущей реализации.

Поэтому считается хорошей практикой при исправлении ошибки создать тест на неё и регулярно прогонять его при последующих изменениях программы. Хотя регрессионное тестирование может быть выполнено и вручную, но чаще всего это делается с помощью специализированных программ, позволяющих выполнять все регрессионные тесты автоматически. В некоторых проектах даже используются инструменты для автоматического прогона регрессионных тестов через заданный интервал времени. Обычно это выполняется после каждой удачной компиляции (в небольших проектах) либо каждую ночь или каждую неделю.

Регрессионное тестирование является неотъемлемой частью экстремального программирования. В этой методологии проектная документация заменяется на расширяемое, повторяемое и автоматизированное тестирование всего программного пакета на каждой стадии процесса разработки программного обеспечения.

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

Источник

Регрессионное тестирование — это что, где и зачем оно используется?

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

Регрессионное тестирование

Когда проводят регрессионное тестирование

Преимущества и недостатки регрессионного тестирования

В качестве преимуществ можно отметить:

В качестве недостатков можно отметить:

Заключение

Регрессионное тестирование — это дополнительный гарант качества вашего программного продукта. Основная масса подобных тестов проходит «вручную», потому что, как ни странно, очень часто автоматизация регрессионного тестирования приводит к дополнительным финансовым затратам. В итоге получается, что проводить такие тесты дешевле руками молодых тестировщиков, чем автоматизированными решениями профессионалов тестирования.

Мы будем очень благодарны

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

Источник

История о бесконечном регрессионном тестировании

И снова привет, Хабр!

На протяжении 5 лет работы инженером-тестировщиком я всегда старалась найти ходы и выходы, чтобы упростить и оптимизировать процесс тестирования (рутина и монотонность – это не мое). Спойлер: у меня не получилось. В этой статье я хочу вам рассказать историю регрессионного тестирования на проекте, и о том, как у меня не получилось его оптимизировать ручным и авто-тестированием.

Маленькое отступление

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

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

Первые шаги

Изучив основную часть ПО, решила, что нужно составить mind map. Но ее сплетения пересекались между собой, что заставляло путаться и ничего не понимать. После всех попыток что-то сотворить решила, что стоит для каждого модуля составить свою «умную» карту.

Взяла один модуль, начала составлять. Связывала последовательности один за другим. Ну вот и готово, теперь можно и тесты составлять. Конечно, здесь есть НО – в том, что последовательности и результаты функционала одинаковые, а формы для заполнения данными, чтобы появились эти последовательности и результаты – разные. И здесь задалась вопросом: «А стоит ли вообще составлять mind map?». Эта карта отлично подошла бы для небольшого проекта, но для проекта с кучей форм, настроек, параметров, функционала и прочих атрибутов, которые пересекаются, это вряд ли хорошая идея.

В итоге вернулась к тому, что стала обновлять устаревшие тесты, оставленные после коллеги-тестировщика давным-давно.

Второе дыхание

С бóльшим погружением в проект стала глубже понимать процесс разработки ПО. Теперь уже от аналитиков получаю требования, на основе которых начала составлять тест-кейсы (потому что другие тесты не требовались).

Процесс пошел, и вроде бы все было отлично. А вот и нет. С каждой новой правкой от программиста аналитики просили провести регрессионное тестирование приложения только по основным операциям. «Хех, только…»: насчитывалось более 800 тест-кейсов, а времени было лишь 2 дня.

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

Казалось бы, нам нужно проверить, что дверь открывается, а действий, приводящих к этому тесту, много. Вот и здесь, в этом приложении, ситуация примерно такая же. Не трудно подумать, сколько на самом деле тест-кейсов нужно выполнить (*шепотом*: «Более 800»). А что по поводу времени? На один такой тест уходит 3-5 минут. Простая арифметика: 4*800 = 3200 минут (53,33 часов), 53, 33 / 8 = 6,6 дней. А протестировать программный продукт нужно за 2 дня…

Моим решением этой ситуации было то, что, раз уж нужно сделать кучу действий, чтобы выполнить один тест, то и эти действия тоже можно отныне называть тестами. И вот он ключ, приводящий, к оптимизации регресса – начать тестировать с далекого теста (достаем ключ из кармана) и далее, как по накатанной, прийти к конечному тесту. Решено! Нужно делать.

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

И все бы ничего, но столкнулась с такой проблемой, что эти действия в итоге оказались не нужны, так как система уже имеет свои неизменные настройки (которые настраивают аналитики и разработчики).

Но, если мы все равно будет стоять на своем, и действия используем в папке «Вспоминающих тестов», то при регрессионном тестировании образуется путаница. Так как наши тесты распределены по областям функций банковского ПО. И “кишмиш” будет не только в созданной папке с действиями, но и в голове самого тестировщика, ведь ему придется прыгать из папки в папку, чтобы поставить статус теста “Passed”.

Таким образом, «Второе дыхание» кануло в Лету.

А как же автоматизация?

«Проблему оптимизации регрессионного тестирования легко решит автоматизация», – подумала я… Но на самом деле – это не совсем так.

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

Авто-тесты в этом проекте пишутся исключительно вручную, рекордера тут нет. И пишутся такие тесты на языке Python в Pycharm с применением инструмента Inpector (отображающий ID объектов, их названия, координаты, типы и прочее) и Pywinauto (набор модулей, который автоматизирует взаимодействия MS Windows GUI). Так как язык Python мне пришлось изучать вот прямо сейчас на авто-тестах, я нашла авто-тестировщика в компании (большая благодарность ему), который подсказывал, какой код нужно написать в той или иной ситуации.

Первая проблема авто-тестирования

Вот и первая проблема подкатила. Тестируемый программный продукт “слеплен из заплаток”. Потому что он имеет разные не только фреймворки, но Pywinauto видеть не хочет некоторые объекты (кнопочки в тестируемом ПО), хоть и где-то фреймворк одинаковый. Это еще полбеды, проблема возникла и в одинаковых именах, ID, типов и прочих параметров в объектах. Здесь, конечно же, спасли бы координаты, но кто согласиться их применять? Их можно применить в самых безвыходных ситуациях, и то очень неохотно.

Вторая проблема авто-тестирования

Здесь можно задаться вопросом: а почему нельзя пригласить авто-тестировщика, который сможет оптимизировать ручное регрессионное тестирование?

Отвечу прямо: к сожалению, нельзя, потому что в команде подразумеваются лишь два тестировщика (не важно, ручной или авто), на которых и заложен бюджет. Пригласив третьего специалиста, финансовая составляющая команды будет выходить за рамки бюджета. И прибыль сократится пропорционально размеру заработной плате авто-тестировщика (на рынке IT зарплаты таких инженеров начинаются примерно с 250 000 рублей). И не стоит забывать, что с увеличением опыта и сложностей авто-тестирования в программном продукте, зарплата растет параллельно.

Подведение итогов

Я сдалась… да, вот такая неудача вышла на моем опыте.

И снова не забудем, что это дополнительная нагрузка на меня, как на ручного тестировщика, так как нужно успевать составлять тесты по требованиям, тестировать новые программные модули и проводить регрессионное тестирование (за 2 дня, Карл!) перед выкладкой билда, потому что, как ранее говорила, заказчик использует гибкую методологию проекта, где в каждом спринте разрабатывается функционал.

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

Спасибо, что прочитали эту статью до конца. Буду благодарна, если не будете кидать помидорами.

Источник

Регресс или регрессив в тестировании

О себе писать не буду (кто я и чем занимаюсь). Моя статья возможно ответит на эти вопросы.

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

Да, я — тестировщик. Хотя мои близкие меня постоянно спрашивают — «Ты точно тестировщик? Не похожа!» Очень смешно.

В общем статья сегодня вот о чем. Как правильно говорить — регрессионное или регрессивное тестирование? Как вы сами думаете? Лично я и мои «нормальные» коллеги заняты большую часть времени на работе, проводя регрессионное тестирование. Хм… А может они проводят всё-таки регрессивное тестирование? Пойду-ка спрошу у своих ребят. И вот я в поисках правды провела небольшой опрос среди 20 человек. Опрос легкий с одним вопросом — «привет! ты проводишь регрессивное или регрессионное тестирование?». Большая часть из них сказали «регрессионное», два человека сказали, что это для них одно и тоже, один сказал — «регрессивное». Опроса мне не хватило, и я пошла к знакомой (кандидат филологических наук), спросила про перевод слова «regression». Знакомая сказала, что переводится как регрессия, и скинула скрин вырезки этого перевода из multitran.ru. Оказывается как прилагательное это слово переводится и как «регрессионный», и как «регрессивный».

Недолго думая посмотрела перевод слова «regressive» в этом же сервисе:

После просмотренной информации пришла к выводу, что тому, чем мы занимаемся на работе, больше подходит слово «регрессионное». Поясню. Регрессивный — в моем понимании как в переводе это всё-таки «убывающий» или «уменьшающий» или «действующий в обратном направлении». А регрессионный — «возвращение в исходное или прежнее состояние» или «возврат к более ранней точке развития» (если цитировать предложенные переводы).

Если подойти к этой проблеме с другой более простой стороны и открыть Glossary ISTQB, то при поиске слова «регрессивный» мы ничего не найдем, а при поиске «регрессионный» — найдем определение и несколько совпадений этого слова в других определениях.

Но всё же остаётся проблема — почему некоторые тестировщики говорят «регрессивный»? В этом вопросе мне помогла еще одна моя знакомая, которая недавно читала книгу Романа Савина «Тестирование Dot Com или Пособие по жесткому обращению с багами в интернет-стартапах». Книга очень популярная среди начинающих тестировщиков. Я её тоже в своё время читала. Оказывается в этой книге Савин употребляет слово «регрессивный», как я понимаю вместо «регрессионный». Почему он так делает я не выясняла, но вернулась к своему опросу и вспомнила трех коллег, ответивших «регрессивный». Они — начинающие тестировщики с опытом работы год, меньше года или чуть больше года. Савин по моему мнению поделил тестировщиков не регрессивных и регрессионных!

Источник

Регрессионное тестирование

Регрессионное тестирование – это тесты, которые направлены на поиск дефектов в тех участках приложения, которые уже протестированы. Мы в Qualitica делаем это не для того, чтобы окончательно убедиться в отсутствии багов, а для поиска и исправления регрессионных ошибок.

Регрессионные ошибки – это те же дефекты с одной лишь разницей: они появляются не при написании программы, а при добавлении в существующий релиз нового участка программы или при исправлении других багов.

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

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

Регрессионное тестирование включает в себя несколько видов тестов:

Их проводят для проверки и исправления обнаруженного дефекта.

Этот тест содержит принципы smoke-тестирования и тестирования сборки: в рамках тестирования верификации версии мы проверяем работоспособность основного функционала программы в каждой новой сборке.

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

Их проводят, когда у вас на руках уже есть новый релиз, но нужно проверить, не “ожили” ли дефекты, которые исправляли еще в старом релизе.

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

Как проводят регрессионное тестирование

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

Факты – регрессионное тестирование:

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

Три ключевых направления в регрессионном тестировании

Регресс – это тестирование трех основных направлений: дефектов, старых проблем и побочных эффектов.

Это поиск проблем, которые официально были устранены, но есть основания считать, что они до сих пор существуют. В этом случае необходимо проверять все действия с определенным объектом в различных комбинациях. Главное здесь – узнать, действительно ли дефект был устранен, и протестировать механизм, с помощью которого он был выявлен.

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

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

Преимущества и недостатки регрессионного тестирования

К преимуществам регрессионного тестирования можно отнести:

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

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

Однако это почти всегда необходимые расходы: согласно отчёту World Quality Report 2018, в среднем 26% всего IT-бюджета компаний идет на тестирование. При этом 40–70% этих затрат приходится на регрессионное тестирование. Если перевести проценты в реальные деньги, можно понять, почему регрессионное тестирование стоит каждого рубля, заслуживает внимания и требует продуманной стратегии.

Чтобы эффективно обнаружить все проблемные места, устранить их и обеспечить высокое качество цифрового продукта, нужно выбрать правильный подход и собрать сильную команду тестировщиков.

И у меня для вас хорошие новости – в Qualitica уже сейчас работает команда из 50 профессиональных тестировщиков, которые готовы провести вам регрессионное тестирование по всем стандартам качества. Пишите на hello@qualitica.ru, расскажите о вашем продукте, подключайте нашу команду и выпускайте качественные релизы без дефектов.

Правила обработки персональных данных

1. Персональные данные Посетителя обрабатываются в соответствии с ФЗ «О персональных данных» № 152-ФЗ.

2. При отправке формы обратной связи Посетитель предоставляет следующую информацию: имя, контактный номер телефона, адрес электронной почты.

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

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

5. Владелец сайта вправе использовать технологию «cookies». «Cookies» не содержат конфиденциальную информацию. Посетитель настоящим дает согласие на сбор, анализ и использование cookies, в том числе третьими лицами для целей формирования статистики и оптимизации рекламных сообщений.

6.Владелец сайта получает информацию об ip-адресе Посетителя. Данная информация не используется для установления личности посетителя.

7.Владелец сайта вправе осуществлять записи телефонных разговоров с Покупателем. При этом Владелец сайта обязуется: предотвращать попытки несанкционированного доступа к информации, полученной в ходе телефонных переговоров, и/или передачу ее третьим лицам, не имеющим непосредственного отношения к взаимодействию между Владельцем сайта и Посетителем, в соответствии с п. 4 ст. 16 Федерального закона «Об информации, информационных технологиях и о защите информации».

Источник

QA без рутины: как мы автоматизировали регрессионное тестирование

Всем привет, меня зовут Александр Мастюгин, я работаю тестировщиком в студии Nord. В сфере IT бытует предубеждение, что работа тестировщиком — нудное и однообразное занятие. Но я с этим не согласен: на мой взгляд, это творческая, техническая и исследовательская деятельность. Чтобы выполнять эту работу хорошо, нужно погрузиться в задачу, понять все ее тонкости, сложности, разобраться, какие у нее есть подводные камни.

Но для справедливости нужно сказать, что скучный момент все же есть — это регрессия. Чтобы минимизировать ее роль в рабочем процессе и, соответственно, избавиться от рутины, мы в студии Nord решили автоматизировать регрессионное тестирование. В этом тексте я расскажу, что у нас получилось.

Автоматизация механики автобатлера

Мы занимаемся разработкой игры Hustle Castle. Это мобильный автобатлер с элементами экономической стратегии и RPG. В качестве движка используется Unity, а сервер написан на Java. Core-механика автобоя заключается в следующем: юниты игрока и врага противостоят друг другу, у всех персонажей есть особая экипировка, которая дает способности, а сам бой идет автоматически — пользователь может лишь кастовать заклинания и использовать таланты своего героя.

Еще в Hustle Castle есть замок с кучей комнат — там можно добывать ресурсы, крафтить предметы и так далее. Также в игре есть сетевые механики с кланами, развитием территорий, ареной и многим другим. И все это сосуществует друг с другом и подчинено общей логике.

С описанием Hustle Castle закончили, теперь можно переходить к более глубоким вещам. Геймплей в игре завязан на способностях юнитов. С технической точки зрения абилка — это некая сущность, у которой есть множество настроек: как и когда она будет активироваться, на кого она будет действовать, какой у нее эффект, какие другие способности она может активировать и так далее.

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

Все это учитывается алгоритмом автобоя. Если сильно упростить, то работает это так. На входе есть некоторые данные — это состояние наших бойцов: какие у них статы, какими абилками они обладают. Эти данные мы передаем в батл-калькулятор, который и занимается всеми вычислениями. На каждый свой шаг вычислений он сообщает, какое произошло событие, активировал ли он какую-то абилку, нанес ли урон. После полного цикла вычислений мы получаем результат боя.

Стоит отметить, что код батл-калькулятора есть как на клиенте, так и на сервере. Это нужно для валидации результатов боя — получается, что и клиент, и сервер, и батл-калькулятор смотрят на одни и те же данные.

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

Тесты на сервере и на клиенте

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

Суть пирамиды проста. Чем мы ближе к основанию, тем дешевле и быстрее тесты. И наоборот — чем выше, тем дольше и дороже.

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

Для серверной логики почти отсутствуют юнит-тесты, а те, что есть — это компонентные тесты, которые в основном покрывают матчмейкинг, базовую логику режимов и фичей.

Если брать отдельно сервер, то у нас следующая ситуация. Интеграционных тестов у нас на сервере нет. Тесты API теоретически можно написать, поскольку клиент и сервер у нас общаются по протоколу protobuf. А значит, описание протокола есть, можно взять клиент и слать запросы. Но пока что мы держим эту идею в запасе.

Что же на клиенте. Там дела обстоят несколько трагичнее. Юнит-тестов нет, компонентных тоже. Так мы оказываемся на вершине пирамиды — нам остается тестировать наше приложение через UI. Большая часть нашей игры выглядит вот так: много кнопок, диалогов, поп-апов, снова диалогов, снова кнопок. Почти все элементы интерфейса живут на Canvas.

Так выглядят разные экраны в Hustle Castle

В качестве базового инструмента мы взяли open-source решение AltUnityTester — это драйвер, который предоставляет:

Поиск объектов с помощью x-path;

Симуляцию input-методов (tap, scroll, drag-n-drop и так далее);

Вызов методов и получение свойств game-object’ов;

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

;

В итоге мы взяли Java, Allure, TestNG, решили применить паттерн Page-Object и начали писать тесты. Поначалу получалось очень здорово и классно. Мы написали примерно 10-15 базовых тестов, которые просто проходились по интерфейсу и что-то выполняли.

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

Проблема заключалась не только в том, что это выглядело массивно, но еще и в том, что во все наши классы попало API AltUnity. И если разработчики в новой версии что-то поменяют, нам будет мучительно больно обновляться.

Другая проблема заключалась в ответственности Page-Object’ов. Во-первых, внутри Page-Object’а мы напрямую дергали драйвер (привет, API!). Во-вторых, объекты могли выполнять накрученную логику. В-третьих, наши Page-Object’ы знали о других Page-Object’ах — то есть навигацией по объектам занимались они сами.

Наши Page-Object’ы выглядели примерно так

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

Так выглядят зависимости типичного теста

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

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

И последняя проблема, с которой мы столкнулись — это дублирование кода. Например, на картинке выше представлен метод «OpenShopAndBuyRoom», который является приватным для этого тестового класса, поэтому мы не можем применять его где-то еще. Но так как мы стремимся написать больше тестов, мы хотим как-то переиспользовать этот метод и он должен принадлежать какому-то классу.

Время остановится и подумать

Использование AltUnityTester и паттерна Page-Object сильно напоминает автоматизацию в разработке web-приложений. Там наши коллеги используют Selenium WebDriver. И если взять концепции из web и переложить на нашу предметную область, то мы получим:

UnityDriver — взаимодействие с игрой.

Unity-Object — структурный паттерн для описания диалогов, экранов и сцен. Мы используем их только для описания структуры, а всей логикой занимаются степы.

Unity-Element — кнопки, картинки, диалоги, текст и так далее. В общем, все то, что есть на сцене в Unity, у нас — UnityElement.

Мы подсмотрели в исходники WebDriver и фреймворка HTML Elements и смогли адаптировать код под наши нужды. Также мы воспользовались паттерном Steps, чтобы отделить логику тестов от UnityObject’ов. На выходе мы получили фреймворк, с помощью которого мы можем:

Выделить сущности в отдельные классы (Button, Label, AbstractDialog и так далее).

Задавать x-path элементов UI с помощью аннотаций @FindBy, а также вводить новые аннотации и расширения.

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

Создавать представления компонентов в Unity на стороне тестов (так как на объекте может быть несколько компонентов).

За счет степов писать тесты в терминах бизнес-логики игры («Отрыть магазин», «Купить товар» и так далее).

Код AltUnity находится глубоко в ядре, а драйвер спрятан за интерфейсом.

Немного про степы — они соединяют наши тесты с Unity Objects. Как раз Unity Objects дают возможность кликнуть на элемент или передать какие-то данные из игры, а вся логика находится в степах. Это дает нам возможность писать тесты в терминах бизнес-процесса. Например, «На локации — открой казарму», «В казарме — проапгрейдь казарму», «Возьми юнита — перенеси его в казарму». А уже под капотом находится drag-n-drop, клики и все остальное.

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

Итак, ниже находится Unity Object. Помните, как выглядели наши селекторы? Они были страшно некрасивыми. Теперь же мы используем просто аннотации, в которых прописываем, как искать нужный элемент и все.

Пример типизированного элемента

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

Инициализацией полей классов занимается Unity Element Loader — он получает определенный класс и драйвер. Согласно некоторой логике, мы создаем прокси-элементы для каждого поля в классе. И тем самым мы можем просто написать «Кнопка нажмись», хотя на самом деле система сначала найдет эту кнопку, информация об этом вернется обратно и только после этого будет отправлена команда «Нажать».

Ниже можно увидеть, что у нас есть степы для диалогового окна с квестами. И эти степы описываются уже в терминах самой игры.

Пример теста

Примерно так выглядят все тесты. Мы применяем лишь одну инъекцию самих степов. Отталкиваясь от нее, мы пишем в терминах бизнес-логики то, что хотим сделать. В итоге все выглядит достаточно аккуратно.

Планы на будущее

Наши основные планы — сделать еще больше тестов. Все эти усилия были направлены на удобное, простое и понятное расширение нашей кодовой базы. Но впереди у нас маячит проблема — многопоточность.

На данный момент тесты прогоняются в одном потоке для одного инстанса игры. Все работает хорошо, но это долго.

Чтобы справиться с этим, мы можем создавать несколько инстансов на нашем удаленном сервере. Или же можем собрать ферму из устройств и подключаться к ним. Но часть наших фич «Глобальны» и могут мешать прохождению тестов. Например, если открыт «Портал для фарма», то он открыт для всех. А при открытии или закрытии «Портала» есть нотификации, что могут появится в интерфейсе у параллельно идущего теста и тап произойдет случайно по нотификации, а не по нужному элементу.

Следующая вещь, которую мы хотели бы реализовать — это back-to-back тесты: это когда вы берете две версии приложения, запускаете один и тот же сценарий, и в определенный момент делаете скриншоты. А после сравниваете. Так вы можете проверить, не поехало ли что-то у вас, не появилась ли фича раньше времени и так далее.

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

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

Источник

Регрессионное тестирование: цели и задачи, условия применения, классификация тестов и методов отбора

Цели и задачи регрессионного тестирования

Другая цель регрессионного тестирования состоит в том, чтобы удостовериться, что программа функционирует в соответствии со своей спецификацией, и что изменения не привели к внесению новых ошибок в ранее протестированный код. Эта цель всегда может быть достигнута повторным выполнением всех тестов регрессионного набора, но более перспективно отсеивать тесты, на которых выходные данные модифицированной и старой программы не могут различаться. Результаты сравнения выборочных методов и метода повторного прогона всех тестов приведены в таблица 11.1.

Таблица 11.1. Выборочное регрессионное тестирование и повторный прогон всех тестов.

Повторный прогон всех тестов	Выборочное регрессионное тестирование
Прост в реализации	Требует дополнительных расходов при внедрении
Дорогостоящий и неэффективный	Способно уменьшать расходы за счет исключения лишних тестов
Обнаруживает все ошибки, которые были бы найдены при исходном тестировании	Может приводить к пропуску ошибок

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

Источник

Регрессионное тестирование: методики, не связанные с отбором тестов и методики порождения тестов

Интеграционное регрессионное тестирование

Регрессионное тестирование объектно-ориентированных программ

Уменьшение объема тестируемой программы

Еще один путь сокращения затрат на регрессионное тестирование состоит в том, чтобы вместо повторного тестирования (большой) измененной программы с использованием соответственно большого числа тестов доказать, что измененная программа адекватно тестируется с помощью выполнения некоторого (меньшего) числа тестов на остаточной программе. Остаточная программа создается путем использования графа зависимости системы вместо графа потока управления, что позволяет исключить ненужные зависимости между компонентами в пределах одного пути графа потока управления. Так, корректировка какого-либо оператора в идеале должна приводить к необходимости тестировать остаточную программу, состоящую из всех операторов исходной программы, способных повлиять на этот оператор или оказаться в сфере его влияния. Для получения остаточной программы необходимо знать место корректировки (в терминах операторов), а также информационные и управляющие связи в программе. Этот подход работает лучше всего для малых и средних изменений больших программ, где высокая стоимость регрессионного тестирования может заставить вообще отказаться от его проведения. Наличие дешевого метода остаточных программ, обеспечивающего такую же степень покрытия кода, делает регрессионное тестирование успешным даже в таких случаях.

Метод остаточных программ имеет ряд ограничений. В частности, он не работает при переносе программы на машину с другим процессором или объемом памяти. Более того, он может давать неверные результаты и на той же самой машине, если поведение программы зависит от адреса ее начальной загрузки, или если для остаточной программы требуется меньше памяти, чем для измененной, и, соответственно, на остаточной программе проходит тест, который для измененной программы вызвал бы ошибку нехватки памяти. Исследования метода на программах небольшого объема показали, что выполнение меньшего количества тестов на остаточной программе не оправдывает затрат на отбор тестов и уменьшение объема программы. Однако для программ с большими наборами тестов это не так.

Сведения о методике уменьшения объема тестируемой программы приведены в Табл. 13.2.

Источник

Как тестируем системы в OrbitSoft: функциональное, smoke-, регрессионное, приемочное тестирование

QA-инженеры в OrbitSoft проверяют каждый продукт в несколько этапов: smoke-тестирование → функциональное → регрессионное → приемочное тестирование. Благодаря тщательным проверкам заказчик получает те функции, которые ожидает. В статье подробно рассказываем о процессе работы.

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

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

Чек-лист — это список проверок для тестирования продукта.

Тест-кейс — это описание задачи из чек-листа с ожидаемым результатом и набором предварительных условий и входных значений.

Тестировщики пишут тест-план на основе технического задания, которое составили разработчики. Например, на основе технического задания для формы оплаты на сайте.

Это пример чек-листа одного из проектов: описание функций и статус — работает или нет

Это пример тест-кейса: описание шагов для проверки работоспособности каждой функции

Чтобы найти явные ошибки, мы проводим тестирование по модели черного ящика. Еще этот процесс называют smoke-тестированием. Основная цель — проверить стабильность системы в целом.

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

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

Скриншот программы Orbit Ad Server: на странице Manage Bank Payments у администратора должна быть возможность просмотреть все произведенные через систему банковские платежи

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

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

После того как тестировщики находят и описывают несоответствия, проводится регрессионное тестирование. Этот этап делится на две части: первая — проверка исправлений ошибок, обнаруженных на предыдущем этапе, вторая — перепроверка всех функций. Это нужно делать, так как после исправления багов нет гарантии того, что случайно не сломался компонент, который проверяли ранее.

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

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

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

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

Когда разработка завершена и все тесты пройдены успешно, по желанию заказчика QA-инженеры проводят тестирование на проде на оборудовании заказчика.

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

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

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

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

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

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

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

Тестировщики проверяют корректность исправлений и доработок всех недочетов, которые были обнаружены на предыдущем этапе. Пересматриваются все функции, чтобы новые исправления не повлияли на уже протестированные функции системы.

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

Приемочное тестирование. Финальное тестирование перед сдачей проекта заказчику. Задача: убедиться, что разработчики реализовали все так, как просил заказчик.

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

Источник

Тестирование вёрстки на визуальные регрессии с помощью PhantomCSS

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

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

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

С другой стороны, мы могли просто переименовать файлы и включить их в один прекомпилированный css (без какого-либо рефакторинга). Но для улучшения кода было бы хорошо порефакторить стили. Эта работа более затратная, но в будущем себя бы окупила. И, что самое важное — это позволило бы нам работать быстрее, с большей уверенностью что мы что-то не сломаем.

Раньше я рассматривал такие изменения как большие риски. В конце концов, C в CSS это каскадирование, где порядок абсолютно важен. Реструктуризация нескольких стилей означает изменение порядка, что, естественно, приводит к большому риску что-то сломать.

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

На этот раз было решено построить визуально регрессионный набор тестов.

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

Это может показаться немного нелогичным. Мы изменяем CSS, потому что мы сами хотим, чтобы наш интерфейс выглядел как-то иначе. Проще говоря, зачем нам строить какой-то процесс, который будет уведомлять нас каждый раз, что мы что-то сломали, когда мы что-то изменяем в наших стилях?

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

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

Человек против Машины

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

Существует даже игра на основе этого. Вы помните картинки из серии «найдите несколько отличий»?

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

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

Слепота к изменениям

Исследования в этой области начались еще в 1970 году. В 1996 году George McConkie и Christopher Currie в университете Урбана-Шампейн штата Иллинойс провели ряд исследований, которые вызвали значительный интерес к этой области.

Слепота к изменениям — это дефицит восприятия. Эксперименты показали, что серьёзные изменения в поле зрения часто остаются незамеченными вне зависимости от того, происходят ли они постепенно, резкими короткими вспышками или появляются неожиданно с разными временными интервалами. Это не связано с каким-то визуальным дефектом, это чистая психология.

В исследовании McConkie & Currie обнаружили, что в некоторых случаях пятая часть всех изменений может пройти незамеченными. Это видео представляет собой прекрасный пример того, насколько много изменений может быть пропущено, если вы не акцентируете на них внимание.

Инструменты

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

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

Во-первых, он имеет относительно большое и активное сообщество на GitHub. Когда дело доходит до open source, я всегда проверяю, что инструмент или библиотека активно развивается. Работа с замороженными open source проектами может довольно быстро стать обузой.

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

Ядро PhantomCSS — это комбинация трех ключевых компонентов:

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

Реализация

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

Настройка Grunt

Во-первых, для запуска тестов нам потребуется Grunt, поэтому убедитесь, что он установлен. Для этого, в командной строке введите
После чего откройте Gruntfile проекта, загрузите задачу PhantomCSS, и добавьте ее в grunt.initConfig():

Тестирование на различных устройствах

Мне нравится использовать Sass MQ для работы с различными устройствами. Этот подход имеет дополнительное преимущество: он возвращает список всех моих устройств, которые я могу легко использовать для своих тестов.

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

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

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

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

Настройка тестов

В определении Grunt можно увидеть, что мы запускаем процесс из файла tests/phantomcss/start.js. Этот файл запускает Casper (который затем запускает сценарии тестов и наш браузер), и выглядит он так:

Теперь вернемся к нашему Grunt. Вы наверно уже заметили, что мы запускаем все файлы в директории `tests/phantomcss/`, которые оканчиваются на `-test.js`. Grunt проходит циклом по каждому из этих файлов в алфавитном порядке.

Вы можете сами решить, как организовать тестовые файлы. Лично я создаю тестовый файл для каждого компонента в своем приложении.

Пишем первый тест

После того как вы реализовали ваш файл `start.js`, настало время написать свой первый тест. Мы назовем этот файл `header-test.js`.

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

Взаимодействия сценариев

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

Вы также можете тестировать состояния login/logout. В файле `start.js` мы можем написать функцию, которая заполнит форму логина в WordPress, как только мы запустим экземпляр Casper.

Вы можете заметить, что мы делаем это в casper.start() вместо того, чтобы делать это внутри каждого отдельного теста. Эта настройка сессии внутри casper.start() в файле `start.js` делает сессию доступной из других файлов с вашими тестами, так как casper.start() всегда запускается первым.

Для дополнительной информации я рекомендую взглянуть на документацию по Casper.

Запуск тестов

Теперь, когда мы реализовали набор тестов, пора их запускать. В командной строке запустите `$ grunt phantomcss`.

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

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

Проблемы

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

Динамический контент

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

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

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

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

Так как эти тесты не будут развернуты на рабочем сервере, вам не придется беспокоиться об XSS уязвимости. Таким образом, до создания скриншота, я использую `.html()` в моих тестах для замены динамического контакта на статический, который берется из объекта JSON, который я включил в мой репозиторий.

Второй подход заключается в использовании инструмента под названием Hologram или mdcss, который позволит вам использовать комментарии в CSS для создания автоматически генерируемых стилей. Этот подход вносит большие изменения в рабочий процесс, что требует больше времени и средств, но имеет дополнительное преимущество — создание превосходной документации для интерфейсных веб-компонентов.

Распределение тестов внутри команды

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

Чтобы решить эту проблему, мы зарегистрировали нашу `$ grunt test` задачу, принимающую параметр `—url`, который затем сохраняется в файл локально с помощью grunt.log.

Затем, в начале тестового файла прописываем:

При запуске, ваши тесты будут смотреть на файл `.local_url`, но если файл не существует, то он будет использовать значение по умолчанию `http://local.wordpress.dev`.

В заключение

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

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

Альтернативы

PhantomCSS — это не единственный инструмент. Я его выбрал просто потому что посчитал для целей нашей команды он подойдет наилучшим образом. Если вас заинтересовало визуальное регрессионное тестирование, но PhantomCSS вам не понравился, я советую взглянуть на следующие инструменты:

Источник