Степень серьезности ошибки

• Серьезность
• Приоритет
• Глобальный приоритет
• Высокий приоритет и низкая серьезность
• Высокая серьезность и низкий приоритет

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

Поэтому баги, внесенные в системы отслеживания (bug-tracking системы), дифференцируются.

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

Серьезность (Severity) бага

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

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

Пример классификации серьезности багов:

• Blocker. Блокирующая ошибка. Она делает невозможной всю последующую работу с программой. Для возобновления работы нужно исправить Blocker.
• Critical. Критическая ошибка. Нарушает работу основного функционала. Баг проявляется постоянно и делает невозможным использование основных функций программы.
• Major. Существенный баг. Затрудняет работу основного функционала или делает невозможным использование дополнительных функций.
• Minor. Незначительный баг. На функционал системы влияет относительно мало, затрудняет использование  дополнительных функций. Для обхода этого бага могут быть очевидные пути.
• Trivial. Тривиальный баг. Не влияет на функционал проекта, но ухудшает общее впечатление от работы с продуктом.

Приоритет (Priority) бага

Приоритет — атрибут, определяющий скорость устранения бага.

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

Виды приоритетов:

• Top. Наивысший приоритет. Назначается экстренным ситуациям, которые очень отрицательно влияют на продукт или даже бизнес компании. Такие баги нужно устранять немедленно.
• High. Высокий приоритет. Назначается багам, которые должны быть устранены в первую очередь.
• Normal. Обычный приоритет, назначается по умолчанию. Эти баги устраняются во вторую очередь, в штатном порядке.
• Low. Низкий приоритет. Назначается багам, не влияющим на функционал. Исправление таких багов происходит в последнюю очередь, если есть время и ресурсы.

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

Частота (Frequency) — это показатель количества пользователей, которые сталкиваются с ошибкой. Определяется при анализе алгоритмов.

Частота бывает:

• High. Высокая: с багом сталкиваются больше 80% пользователей.
• Medium. Средняя: баг обнаружат от 30% до 80% пользователей.
• Low. Низкая: баг проявляется у 10-30% пользователей.
• Very low. Незначительная: такой баг встретится меньше чем 10% пользователей.

Глобальный приоритет бага (Global Severity)

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

Таким образом, для определения глобального приоритета бага нужно:

1. Определить серьезность бага.
2. Отдельно от серьезности определить приоритет.
3. Определить частоту (независимо от серьезности и приоритета).
4. Рассчитать влияние частоты на изначально определенный приоритет.

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

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

Низкая или незначительная частота вообще не меняет приоритет бага.

Для определения глобального приоритета можно пользоваться следующей таблицей:

Если глобальный приоритет — Critical, значит, баг нужно непременно исправить. Баги с приоритетом Minor тоже желательно исправить до релиза, хотя некоторое количество таких дефектов может остаться в проекте. Баги с приоритетом Trivial могут вообще не исправляться.

Высокий приоритет и низкая серьезность

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

Вот пара примеров:

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

Высокая серьезность и низкий приоритет

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

Примеры:

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

Итоги

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

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

релизы

— обычно отслеживаются и управляются с помощью баг-трекинговых систем. Добавленные элементы могут называться дефектами, заявками, проблемами или, в соответствии с парадигмой гибкой разработки, эпиками и сторями (stories and epics). Категории могут быть объективными, субъективными или комбинированными, такими как номер версии, область программного обеспечения, серьезность и приоритет, а также тип проблемы, такой как фича-реквест или баг.

Серьезность ошибки

Серьезность ошибки или серьезность дефекта при тестировании — это степень влияния ошибки или дефекта на тестируемое приложение. Более сильное влияние ошибки / дефекта на функциональность системы приведет к более высокому уровню серьезности. Инженер по обеспечению качества обычно определяет уровень серьезности ошибки / дефекта.

Что такое приоритет?

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

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

КЛЮЧЕВАЯ РАЗНИЦА

• Приоритет — это порядок, в котором разработчик должен устранить дефект, тогда как серьезность — это степень влияния дефекта на работу продукта.
• Приоритет делится на три типа: низкий, средний и высокий, тогда как уровень серьезности делится на пять типов: критический. основные, средние, второстепенные и косметические.
• Приоритет связан с планированием, а серьезность — с функциональностью или стандартами.
• Priority указывает, как скоро ошибка должна быть исправлена, тогда как Severity указывает серьезность дефекта в функциональности продукта.
• Приоритет дефектов определяется после консультации с менеджером / клиентом, а уровни серьезности дефектов определяет инженер по обеспечению качества.
• Приоритет определяется бизнес-ценностью, а серьезность определяется функциональностью.
• Значение приоритета является субъективным и может меняться с течением времени в зависимости от изменения ситуации в проекте, тогда как значение серьезности является объективным и вряд ли изменится.
• Статус «Высокий приоритет» и «Низкий приоритет» указывает на то, что дефект должен быть исправлен немедленно, но не влияет на приложение, в то время как статус высокого и низкого приоритета указывает на то, что дефект должен быть исправлен, но не на немедленной основе.
• Статус приоритета основан на требованиях клиента, тогда как статус важности основан на техническом аспекте продукта.

Типы серьезности

В тестировании программного обеспечения типы серьезности ошибки / дефекта можно разделить на четыре части:

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

Типы приоритета

Типы приоритета ошибки / дефекта можно разделить на три части:

• Низкий: дефект вызывает раздражение, но его можно исправить после устранения более серьезного дефекта.
• Средний: В ходе нормальной работы по разработке дефект должен быть устранен. Может подождать, пока не будет создана новая версия
• Высокий: дефект необходимо устранить как можно скорее, поскольку он серьезно влияет на систему и не может использоваться, пока не будет исправлен.

Советы по определению серьезности дефекта

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

Приоритет против серьезности: ключевое различие

Пример серьезности и приоритета дефекта

Давайте посмотрим на пример с низкой серьезностью и высоким приоритетом и наоборот

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

Сортировка дефектов

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

Как определить сортировку дефектов:

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

Процесс сортировки включает следующие шаги

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

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

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

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

Вывод:

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

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

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

Серьезность

Серьезность (Severity) — это атрибут, характеризующий влияние дефекта на работоспособность приложения. Проставляется специалистом по тестированию.

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

• S1 – Блокирующая (Blocker). Блокирующая ошибка, приводящая приложение в нерабочее состояние, в результате которого дальнейшая работа с тестируемой системой или ее функциями становится невозможна.
• S2 – Критическая (Critical). Критическая ошибка, неправильно работающая бизнес-логика, проблема, приводящая в нерабочее состояние некоторую часть системы, но есть возможность для работы с тестируемой функцией, используя другие входные точки.
• S3 – Значительная (Major). Значительная ошибка, часть бизнес-логики работает некорректно. Ошибка не критична или есть возможность для работы с тестируемой функцией, используя другие входные точки.
• S4 – Незначительная (Minor). Незначительная ошибка, не нарушающая бизнес-логику тестируемой части приложения, очевидная проблема пользовательского интерфейса.
• S5 – Тривиальная (Trivial). Тривиальная ошибка, не касающаяся бизнес-логики приложения, плохо воспроизводимая проблема, малозаметная по средствам пользовательского интерфейса, проблема сторонних библиотек или сервисов, проблема, не оказывающая никакого влияния на общее качество продукта.

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

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

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

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

У нас остается только три варианта: Значительная, Критическая и Блокирующая серьезности.

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

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

2. Невозможно указать адрес назначения с помощью “Указать на карте”.
Снова начинаем рассуждать. Тривиальная и Незначительная не подходят, потому что ошибка в какой-то мере нарушают бизнес логику работы приложения. Блокирующую можно не брать, т.к. функционал в целом работает и его можно использовать через другую точку входа, а именно ввести адрес вручную. Остается только два варианта: Критическая и Значительная. Мы уже сказали, что проблема не приводит к полной неработоспособности части функционала. Тем не менее это значительная ошибка, т.к. функционал частично не работает, следовательно остается только вариант Значительная. Его мы и укажем.

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

Приоритет

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

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

• P1 – Высокий (High) – требуется исправить в первую очередь.
• P2 – Средний (Medium) – требуется исправить во вторую очередь, когда нет дефектов с высоким приоритетом.
• P3 – Низкий (Low) – исправляется в последнюю очередь, когда все дефекты с более высоким приоритетом уже исправлены.

С помощью приоритета менеджер проекта говорит, когда стоит исправить найденную проблему.

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

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

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

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

________________________________
Если остались вопросы по определению параметров Серьезность и Приоритет, то задавайте их в комментариях к статье.
________________________________

Предыдущие статьи по оформлению баг-репорта:
Назначение отчета https://sedtest-school.ru/testovaya-dokumentacziya/otchety-o-defektah-naznachenie/
Шаблон отчета об ошибке https://sedtest-school.ru/testovaya-dokumentacziya/otchety-o-defektah-shablon-otcheta-ob-oshibke/

Автор: Андрей Петров

Оригинальная публикация

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

На сегодняшний день, приоритет принято разделять на три уровня, а серьезность – на пять:

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

• P1 – Высокий (High) – требуется исправить в первую очередь;
• P2 – Средний (Medium) – требуется исправить во вторую очередь, когда нет дефектов с высоким приоритетом;
• P3 – Низкий (Low) – исправляется в последнюю очередь, когда все дефекты с более высоким приоритетом уже исправлены.

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

• S1 – Блокирующий (Blocker) – дефект полностью блокирует выполнение функционала, нет никакого способа его обойти. Если провести аналогию с закрытым помещением и дверью – то дверь закрыта, у вас нет никакой возможности её открыть и покинуть помещение. Окон нет, ключ к двери не подходит.
• S2 – Критический (Critical) – дефект блокирует часть функциональности, но есть альтернативный путь для его обхода. По аналогии с помещением и дверью: вы можете покинуть помещение через окно, хотя дверь по-прежнему закрыта и ключ к ней не подходит.
• S3 – Значительный (Major) – дефект, указывающий на некорректную работу части функциональности. Зачастую связан не с тем, что функция не работает, а с тем, что она работает неправильно. В любом случае, существует более одной точки входа для инициации нужной функциональности. Так, вы можете покинуть помещение без использования ключа (дыра в безопасности), через вентиляцию (другая точка входа) или дверь открывается не в ту сторону (как следствие, упирается в угол и открывается только частично – некорректная реализация). Наиболее часто встречаются дефекты, которые можно отнести именно к этому уровню серьезности.
• S4 – Незначительный (Minor) – дефект, не относящийся к функциональности системы. Обычно серьезность Minor проставляется для тех дефектов, которые относятся к удобству использования или интерфейсу. По аналогии с помещением и дверью – на двери написано «От себя», хотя она открывается на себя, неудобное расположение замочной скважины и т.д.
• S5 – Тривиальный (Trivial) – дефект, не затрагивающий функциональность системы, а также оказывающий минимальное влияние на общее качество системы. Часто неотличим от уровня «minor». Обычно это грамматические дефекты в сопроводительной документации к системе. Иногда дефект относится к «невидимым» проблемам с точки зрения пользователя или пользовательского интерфейса и рассматривает сторонние библиотеки или сервисы, не относящиеся к самой разработанной системе. По аналогии с помещением и дверью – замок и ключ не одного производителя, в помещении слышится шум сверху (не относится к самому помещению) и т.д.

Но зачем нужно это деление, разве нельзя обойтись только одним атрибутом, например, серьезностью? Предположим, в некой системе не работает модуль отчетности. Это –дефект с уровнем серьезности «Блокирующий». Однако этот модуль потребуется только в конце отчетного периода (перед Новым Годом). Если сейчас лето, то данная функциональность не будет использоваться еще несколько месяцев. Как следствие, руководитель проекта или лицо, принимающее решение, может проставить низкий приоритет исправления.

Обратная ситуация: на лицевой странице сайта (или интерфейса приложения) неправильно отображается какая-то важная надпись/логотип (например, название Компании). Данный дефект способен сильно ударить по доверию пользователей к продукции, которую им предлагают: потенциальные клиенты могут подумать, что качество услуг весьма сомнительно, раз даже в названии компании присутствует дефект – и отказаться от использования продукта. С точки зрения подхода к качеству, даже нефункциональные дефекты с уровнем серьезности «Тривиальный» способны отрицательно повлиять на репутацию Компании. Поэтому такому дефекту может быть проставлен высокий приоритет исправления.

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

Обсудить в форуме