Разное

Методология тестирования по: Методологии тестирования ПО. Какую выбрать?

Содержание

Методологии тестирования ПО. Какую выбрать?

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

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

Каскадная модель (Линейная последовательная модель жизненного цикла ПО)

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

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

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

Узнайте больше о каскадной модели из предыдущей статьи.

V-Model (Модель верификации и валидации)

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

Схема данной модели показывает принцип разделения задач на две части. Те, которые относятся к дизайну и разработке, размещены слева. Задачи, относящиеся к тестированию ПО, размещены справа:

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

  • Этап определения требований. Приемочное тестирование относится к этому этапу. Его основная задача состоит в оценке готовности системы к финальному использованию
  • Этап, на котором происходит высокоуровневое проектирование, или High-Level Design (HDL). Этот этап относится к системному тестированию и включает оценку соблюдения требований к интегрированным системам
  • Фаза детального дизайна (Detailed Design) параллельна фазе интеграционного тестирования, во время которой происходит проверка взаимодействий между различными компонентами системы
  • После этапа написания кода начинается другой важный шаг — юнит-тестирование. Очень важно убедиться в том, что поведение отдельных частей и компонентов ПО корректно и соответствует требованиям

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

Инкрементная модель

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

  1. дизайн и разработка
  2. тестирование
  3. реализация.

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

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

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

Спиральная модель

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

  1. Планирование
  2. Анализ рисков
  3. Разработка
  4. Оценка

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

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

Читайте подробнее o спиральной модели в предыдущем блог посте.

Agile

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

Узнайте больше об Agile (прим. — статья на английском языке).

Экстремальное программирование (XP, Extreme Programming)

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

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

Scrum

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

  • Участие в Scrum планировании
  • Поддержка в юнит-тестировании
  • Тестирование пользовательских историй
  • Сотрудничество с заказчиком и владельцем продукта для определения критериев приемлемости
  • Предоставление автоматического тестировании

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

В то же время принципы Agile методологии в Scrum к появлению специфических особенностей:

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

Узнайте больше о методологии Scrum из предыдущей статьи.

Заключение

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

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

The following two tabs change content below.

QA cпециалист XB Softaware. Любимое изречение, которое она использует в каждодневной работе: «мы верим в Бога, а все остальное тестируем».

Способы тестирования программного обеспечения / Блог компании OTUS. Онлайн-образование / Хабр

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

В этой статье рассматриваются различные способы тестирования программного обеспечения, такие как модульное тестирование (unit testing), интеграционное тестирование (integration testing), функциональное тестирование (functional testing), приемочное тестирование (acceptance testing) и т.д.

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

Тестирование: ручное или автоматизированное?

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

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

Автоматизированные тесты – это ключевой компонент непрерывной интеграции (Continuous Integration) и непрерывной доставки (continuous delivery), а также хороший способ масштабировать ваш QA процесс во время добавления нового функционала для вашего приложения. Однако в ручном тестировании все равно есть своя ценность. Поэтому в статье мы обязательно поговорим об исследовательском тестировании (exploratory testing).

Различные типы тестов

Модульные тесты

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

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

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

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

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

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

Сквозные тесты (End-to-end tests)

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

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

Приемочное тестирование

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

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

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

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

Дымовое тестирование (Smoke testing)

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

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

Как автоматизировать тесты

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

Для автоматизации тестирования, вам для начала придется написать их на каком-то из языков программирования с использованием фреймворка для тестирования, который подойдет для вашего приложения. PHPUnit , Mocha, RSpec – это примеры фреймворков для тестирования, которые вы можете использовать для PHP, Javascript и Ruby, соответственно. В них есть множество возможностей для каждого языка, поэтому вам стоит немного позаниматься исследованием самостоятельно и проконсультироваться с сообществами разработчиков, чтобы понять, какой фреймворк подойдет вам лучше всего.

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

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

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

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

Вопрос заключается в том, надо ли вообще в таком случае проводить ручное тестирование? Короткий ответ – да, и оно должно быть сфокусировано на том, что называется «исследовательское тестирование» (exploratory testing), которое помогает выявить неочевидные ошибки.

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

Заметка о тестировании

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

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

По устоявшейся традиции ждем ваши комментарии и приглашаем всех на день открытых дверей, который уже 18 марта проведет наш преподаватель — ведущий автоматизатор в тестировании в Group-IB — Михаил Самойлов.

Тестирование. Фундаментальная теория / Хабр

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

Ниже основы основ для повторения перед собеседованием для Trainee and Junior: определение тестирования, качество, верификация / валидация, цели, этапы, тест план, пункты тест плана, тест дизайн, техники тест дизайна, traceability matrix, test case, чек-лист, дефект, error/deffect/failure, баг репорт, severity vs priority, уровни тестирования, виды / типы, подходы к интеграционному тестированию, принципы тестирования, статическое и динамическое тестирование, исследовательское / ad-hoc тестирование, требования, жизненный цикл бага, стадии разработки ПО, decision table, qa/qc/test engineer, диаграмма связей.

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

Тестирование программного обеспечения — проверка соответствия между реальным и ожидаемым поведением программы, осуществляемая на конечном наборе тестов, выбранном определенным образом. В более широком смысле, тестирование — это одна из техник контроля качества, включающая в себя активности по планированию работ (Test Management), проектированию тестов (Test Design), выполнению тестирования (Test Execution) и анализу полученных результатов (Test Analysis).

Качество программного обеспечения (Software Quality) — это совокупность характеристик программного обеспечения, относящихся к его способности удовлетворять установленные и предполагаемые потребности. [Quality management and quality assurance]

Верификация (verification) — это процесс оценки системы или её компонентов с целью определения удовлетворяют ли результаты текущего этапа разработки условиям, сформированным в начале этого этапа[IEEE]. Т.е. выполняются ли наши цели, сроки, задачи по разработке проекта, определенные в начале текущей фазы.
Валидация (validation) — это определение соответствия разрабатываемого ПО ожиданиям и потребностям пользователя, требованиям к системе [BS7925-1].

Также можно встретить иную интерпритацию:

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

Validation — ’is this the right specification?’.

Verification — ’is the system correct to specification?’.

Цели тестирования

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

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

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

Этапы тестирования:

1. Анализ продукта

2. Работа с требованиями

3. Разработка стратегии тестирования

и планирование процедур контроля качества

4. Создание тестовой документации

5. Тестирование прототипа

6. Основное тестирование

7. Стабилизация

8. Эксплуатация

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

Отвечает на вопросы:

Что надо тестировать?

Что будете тестировать?

Как будете тестировать?

Когда будете тестировать?

Критерии начала тестирования.

Критерии окончания тестирования.

Основные пункты тест плана

В стандарте IEEE 829 перечислены пункты, из которых должен (пусть — может) состоять тест-план:

a) Test plan identifier;

b) Introduction;

c) Test items;

d) Features to be tested;

e) Features not to be tested;

f) Approach;

g) Item pass/fail criteria;

h) Suspension criteria and resumption requirements;

i) Test deliverables;

j) Testing tasks;

k) Environmental needs;

l) Responsibilities;

m) Staffing and training needs;

n) Schedule;

o) Risks and contingencies;

p) Approvals.

Тест дизайн – это этап процесса тестирования ПО, на котором проектируются и создаются тестовые сценарии (тест кейсы), в соответствии с определёнными ранее критериями качества и целями тестирования.

Роли, ответственные за тест дизайн:

• Тест аналитик — определяет «ЧТО тестировать?»

• Тест дизайнер — определяет «КАК тестировать?»

Техники тест дизайна

• Эквивалентное Разделение (Equivalence Partitioning — EP). Как пример, у вас есть диапазон допустимых значений от 1 до 10, вы должны выбрать одно верное значение внутри интервала, скажем, 5, и одно неверное значение вне интервала — 0.

• Анализ Граничных Значений (Boundary Value Analysis — BVA). Если взять пример выше, в качестве значений для позитивного тестирования выберем минимальную и максимальную границы (1 и 10), и значения больше и меньше границ (0 и 11). Анализ Граничный значений может быть применен к полям, записям, файлам, или к любого рода сущностям имеющим ограничения.

• Причина / Следствие (Cause/Effect — CE). Это, как правило, ввод комбинаций условий (причин), для получения ответа от системы (Следствие). Например, вы проверяете возможность добавлять клиента, используя определенную экранную форму. Для этого вам необходимо будет ввести несколько полей, таких как «Имя», «Адрес», «Номер Телефона» а затем, нажать кнопку «Добавить» — это «Причина». После нажатия кнопки «Добавить», система добавляет клиента в базу данных и показывает его номер на экране — это «Следствие».

• Предугадывание ошибки (Error Guessing — EG). Это когда тестировщик использует свои знания системы и способность к интерпретации спецификации на предмет того, чтобы «предугадать» при каких входных условиях система может выдать ошибку. Например, спецификация говорит: «пользователь должен ввести код». Тестировщик будет думать: «Что, если я не введу код?», «Что, если я введу неправильный код? », и так далее. Это и есть предугадывание ошибки.

• Исчерпывающее тестирование (Exhaustive Testing — ET) — это крайний случай. В пределах этой техники вы должны проверить все возможные комбинации входных значений, и в принципе, это должно найти все проблемы. На практике применение этого метода не представляется возможным, из-за огромного количества входных значений.

• Попарное тестирование (Pairwise Testing) — это техника формирования наборов тестовых данных. Сформулировать суть можно, например, вот так: формирование таких наборов данных, в которых каждое тестируемое значение каждого из проверяемых параметров хотя бы единожды сочетается с каждым тестируемым значением всех остальных проверяемых параметров.

Допустим, какое-то значений (налог) для человека рассчитывается на основании его пола, возраста и наличия детей — получаем три входных параметра, для каждого из которых для тестов выбираем каким-то образом значения. Например: пол — мужской или женский; возраст — до 25, от 25 до 60, более 60; наличие детей — да или нет. Для проверки правильности расчётов можно, конечно, перебрать все комбинации значений всех параметров:

А можно решить, что нам не нужны сочетания значений всех параметров со всеми, а мы хотим только убедиться, что мы проверим все уникальные пары значений параметров. Т.е., например, с точки зрения параметров пола и возраста мы хотим убедиться, что мы точно проверим мужчину до 25, мужчину между 25 и 60, мужчину после 60, а также женщину до 25, женщину между 25 и 60, ну и женщину после 60. И точно так же для всех остальных пар параметров. И таким образом, мы можем получить гораздо меньше наборов значений (в них есть все пары значений, правда некоторые дважды):

Такой подход примерно и составляет суть техники pairwise testing — мы не проверяем все сочетания всех значений, но проверяем все пары значений.

Traceability matrix — Матрица соответствия требований — это двумерная таблица, содержащая соответствие функциональных требований (functional requirements) продукта и подготовленных тестовых сценариев (test cases). В заголовках колонок таблицы расположены требования, а в заголовках строк — тестовые сценарии. На пересечении — отметка, означающая, что требование текущей колонки покрыто тестовым сценарием текущей строки.

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

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

Пример:

Action Expected Result Test Result

(passed/failed/blocked)

Open page «login» Login page is opened Passed

Каждый тест кейс должен иметь 3 части:

PreConditions Список действий, которые приводят систему к состоянию пригодному для проведения основной проверки. Либо список условий, выполнение которых говорит о том, что система находится в пригодном для проведения основного теста состояния.

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

PostConditions Список действий, переводящих систему в первоначальное состояние (состояние до проведения теста — initial state)

Виды Тестовых Сценариев:

Тест кейсы разделяются по ожидаемому результату на позитивные и негативные:

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

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

Чек-лист (check list) — это документ, описывающий что должно быть протестировано. При этом чек-лист может быть абсолютно разного уровня детализации. На сколько детальным будет чек-лист зависит от требований к отчетности, уровня знания продукта сотрудниками и сложности продукта.

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

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

Error — ошибка пользователя, то есть он пытается использовать программу иным способом.

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

В качественной программе предусмотрены такие ситуации и выдаются сообщение об ошибке (error message), с красным крестиком которые.
Bug (defect) — ошибка программиста (или дизайнера или ещё кого, кто принимает участие в разработке), то есть когда в программе, что-то идёт не так как планировалось и программа выходит из-под контроля. Например, когда никак не контроллируется ввод пользователя, в результате неверные данные вызывают краши или иные «радости» в работе программы. Либо внутри программа построена так, что изначально не соответствует тому, что от неё ожидается.
Failure — сбой (причём не обязательно аппаратный) в работе компонента, всей программы или системы. То есть, существуют такие дефекты, которые приводят к сбоям (A defect caused the failure) и существуют такие, которые не приводят. UI-дефекты например. Но аппаратный сбой, никак не связанный с software, тоже является failure.

Баг Репорт (Bug Report) — это документ, описывающий ситуацию или последовательность действий приведшую к некорректной работе объекта тестирования, с указанием причин и ожидаемого результата.

Шапка

Короткое описание (Summary) Короткое описание проблемы, явно указывающее на причину и тип ошибочной ситуации.

Проект (Project) Название тестируемого проекта

Компонент приложения (Component) Название части или функции тестируемого продукта

Номер версии (Version) Версия на которой была найдена ошибка

Серьезность (Severity) Наиболее распространена пятиуровневая система градации серьезности дефекта:

• S1 Блокирующий (Blocker)

• S2 Критический (Critical)

• S3 Значительный (Major)

• S4 Незначительный (Minor)

• S5 Тривиальный (Trivial)

Приоритет (Priority) Приоритет дефекта:

• P1 Высокий (High)

• P2 Средний (Medium)

• P3 Низкий (Low)

Статус (Status) Статус бага. Зависит от используемой процедуры и жизненного цикла бага (bug workflow and life cycle)

Автор (Author) Создатель баг репорта

Назначен на (Assigned To) Имя сотрудника, назначенного на решение проблемы

Окружение

ОС / Сервис Пак и т.д. / Браузера + версия /… Информация об окружении, на котором был найден баг: операционная система, сервис пак, для WEB тестирования — имя и версия браузера и т.д.



Описание

Шаги воспроизведения (Steps to Reproduce) Шаги, по которым можно легко воспроизвести ситуацию, приведшую к ошибке.

Фактический Результат (Result) Результат, полученный после прохождения шагов к воспроизведению

Ожидаемый результат (Expected Result) Ожидаемый правильный результат

Дополнения

Прикрепленный файл (Attachment) Файл с логами, скриншот или любой другой документ, который может помочь прояснить причину ошибки или указать на способ решения проблемы

Severity vs Priority

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

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

Severity выставляется тестировщиком

Priority – менеджером, тимлидом или заказчиком

Градация Серьезности дефекта (Severity)

S1 Блокирующая (Blocker)

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

S2 Критическая (Critical)

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

S3 Значительная (Major)

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

S4 Незначительная (Minor)

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

S5 Тривиальная (Trivial)

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

Градация Приоритета дефекта (Priority)
P1 Высокий (High)

Ошибка должна быть исправлена как можно быстрее, т.к. ее наличие является критической для проекта.
P2 Средний (Medium)

Ошибка должна быть исправлена, ее наличие не является критичной, но требует обязательного решения.
P3 Низкий (Low)

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

Уровни Тестирования

1. Модульное тестирование (Unit Testing)

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

2. Интеграционное тестирование (Integration Testing)

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

3. Системное тестирование (System Testing)

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

4. Операционное тестирование (Release Testing).

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

5. Приемочное тестирование (Acceptance Testing)

Формальный процесс тестирования, который проверяет соответствие системы требованиям и проводится с целью:

• определения удовлетворяет ли система приемочным критериям;

• вынесения решения заказчиком или другим уполномоченным лицом принимается приложение или нет.

Виды / типы тестирования

Функциональные виды тестирования

• Функциональное тестирование (Functional testing)

• Тестирование пользовательского интерфейса (GUI Testing)

• Тестирование безопасности (Security and Access Control Testing)

• Тестирование взаимодействия (Interoperability Testing)

Нефункциональные виды тестирования

• Все виды тестирования производительности:

o нагрузочное тестирование (Performance and Load Testing)

o стрессовое тестирование (Stress Testing)

o тестирование стабильности или надежности (Stability / Reliability Testing)

o объемное тестирование (Volume Testing)

• Тестирование установки (Installation testing)

• Тестирование удобства пользования (Usability Testing)

• Тестирование на отказ и восстановление (Failover and Recovery Testing)

• Конфигурационное тестирование (Configuration Testing)

Связанные с изменениями виды тестирования

• Дымовое тестирование (Smoke Testing)
• Регрессионное тестирование (Regression Testing)
• Повторное тестирование (Re-testing)
• Тестирование сборки (Build Verification Test)
• Санитарное тестирование или проверка согласованности/исправности (Sanity Testing)

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

Тестирование пользовательского интерфейса (GUI Testing) — функциональная проверка интерфейса на соответствие требованиям — размер, шрифт, цвет, consistent behavior.

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

Тестирование взаимодействия (Interoperability Testing) – это функциональное тестирование, проверяющее способность приложения взаимодействовать с одним и более компонентами или системами и включающее в себя тестирование совместимости (compatibility testing) и интеграционное тестирование

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

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

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

Тестирование стабильности или надежности (Stability / Reliability Testing). Задачей тестирования стабильности (надежности) является проверка работоспособности приложения при длительном (многочасовом) тестировании со средним уровнем нагрузки.

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

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

User eXperience (UX) — ощущение, испытываемое пользователем во время использования цифрового продукта, в то время как User interface — это инструмент, позволяющий осуществлять интеракцию «пользователь — веб-ресурс».

Тестирование на отказ и восстановление (Failover and Recovery Testing) проверяет тестируемый продукт с точки зрения способности противостоять и успешно восстанавливаться после возможных сбоев, возникших в связи с ошибками программного обеспечения, отказами оборудования или проблемами связи (например, отказ сети). Целью данного вида тестирования является проверка систем восстановления (или дублирующих основной функционал систем), которые, в случае возникновения сбоев, обеспечат сохранность и целостность данных тестируемого продукта.

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

Дымовое (Smoke) тестирование рассматривается как короткий цикл тестов, выполняемый для подтверждения того, что после сборки кода (нового или исправленного) устанавливаемое приложение, стартует и выполняет основные функции.

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

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

В чем разница между regression testing и re-testing?

Re-testing — проверяется исправление багов

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

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

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

Подходы к интеграционному тестированию:
• Снизу вверх (Bottom Up Integration)

Все низкоуровневые модули, процедуры или функции собираются воедино и затем тестируются. После чего собирается следующий уровень модулей для проведения интеграционного тестирования. Данный подход считается полезным, если все или практически все модули, разрабатываемого уровня, готовы. Также данный подход помогает определить по результатам тестирования уровень готовности приложения.
• Сверху вниз (Top Down Integration)

Вначале тестируются все высокоуровневые модули, и постепенно один за другим добавляются низкоуровневые. Все модули более низкого уровня симулируются заглушками с аналогичной функциональностью, затем по мере готовности они заменяются реальными активными компонентами. Таким образом мы проводим тестирование сверху вниз.
• Большой взрыв («Big Bang» Integration)

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

Принципы тестирования

Принцип 1 – Тестирование демонстрирует наличие дефектов (Testing shows presence of defects)

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

Принцип 2 – Исчерпывающее тестирование недостижимо (Exhaustive testing is impossible)

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

Принцип 3 – Раннее тестирование (Early testing)

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

Принцип 4 – Скопление дефектов (Defects clustering)

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

Принцип 5 – Парадокс пестицида (Pesticide paradox)

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

или системы, и найти как можно больше дефектов.

Принцип 6 – Тестирование зависит от контекста (Testing is concept depending)

Тестирование выполняется по-разному в зависимости от контекста. Например, программное обеспечение, в котором критически важна безопасность, тестируется иначе, чем сайт электронной коммерции.
Принцип 7 – Заблуждение об отсутствии ошибок (Absence-of-errors fallacy)

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

Cтатическое и динамическое тестирование

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

Исследовательское / ad-hoc тестирование

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

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

Требования – это спецификация (описание) того, что должно быть реализовано.

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

Требования к требованиям:

• Корректность

• Недвусмысленность

• Полнота набора требований

• Непротиворечивость набора требований

• Проверяемость (тестопригодность)

• Трассируемость

• Понимаемость

Жизненный цикл бага

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

Программный продукт проходит следующие стадии:

• анализ требований к проекту;

• проектирование;

• реализация;

• тестирование продукта;

• внедрение и поддержка.

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

Жизненный цикл разработки ПО:

• Пре-альфа

• Альфа

• Бета

• Релиз-кандидат

• Релиз

• Пост-релиз

Таблица принятия решений (decision table) – великолепный инструмент для упорядочения сложных бизнес требований, которые должны быть реализованы в продукте. В таблицах решений представлен набор условий, одновременное выполнение которых должно привести к определенному действию.

QA/QC/Test Engineer


Таким образом, мы можем построить модель иерархии процессов обеспечения качества: Тестирование – часть QC. QC – часть QA.

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

Источники: www.protesting.ru, bugscatcher.net, qalight.com.ua, thinkingintests.wordpress.com, книга ISTQB, www.quizful.net, bugsclock.blogspot.com, www.zeelabs.com, devopswiki.net, hvorostovoz.blogspot.com.

Ресурсы рекомендованные в комментах Sofiya Novachenko: istqbexamcertification.com www.testingexcellence.com

Виды тестирования и подходы к их применению / Хабр

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

  • Блочное (Unit testing) — тестирование одного модуля в изоляции.
  • Интеграционное (Integration Testing) — тестирование группы взаимодействующих модулей.
  • Системное (System Testing) — тестирование системы в целом.

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

Блочное (модульное, unit testing) тестирование наиболее понятное для программиста. Фактически это тестирование методов какого-то класса программы в изоляции от остальной программы.

Не всякий класс легко покрыть unit тестами. При проектировании нужно учитывать возможность тестируемости и зависимости класса делать явными. Чтобы гарантировать тестируемость можно применять TDD методологию, которая предписывает сначала писать тест, а потом код реализации тестируемого метода. Тогда архитектура получается тестируемой. Распутывание зависимостей можно осуществить с помощью Dependency Injection. Тогда каждой зависимости явно сопоставляется интерфейс и явно определяется как инжектируется зависимость — в конструктор, в свойство или в метод.

Для осуществления unit тестирования существуют специальные фреймворки. Например, NUnit или тестовый фреймфорк из Visual Studio 2008. Для возможности тестирования классов в изоляции существуют специальные Mock фреймворки. Например, Rhino Mocks. Они позволяют по интерфейсам автоматически создавать заглушки для классов-зависимостей, задавая у них требуемое поведение.

По unit тестированию написано много статей. Мне очень нравится MSDN статья Write Maintainable Unit Tests That Will Save You Time And Tears, в которой хорошо и понятно рассказывается как создавать тесты, поддерживать которые со временем не становится обременительно.

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

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

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

Хорошая статья по интеграционному тестированию мне попалась лишь однажды — Scenario Driven Tests. Прочтя ее и книгу Ayende по DSL DSLs in Boo, Domain-Specific Languages in .NET у меня появилась идея как все-таки устроить интеграционное тестирование.

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


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

1) Допустим в присланных документах есть несколько разделов. Тогда в спецификации мы можем указать, что у разбираемого документа должны быть разделы с указанными именами:

$SectionNames = Введение, Текст статьи, Заключение, Литература

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

$IsCoverable = true

Понятно, что для проверки подобных спецификаций потребуется движок, который бы считывал спецификации и проверял их соответствие поведению программы. Я такой движок написал и остался доволен данным подходом. Скоро выложу движок в Open Source. (UPD: Выложил)

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

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

Первый подход — это использовать вариацию MVC паттерна — Passive View (вот еще хорошая статья по вариациям MVC паттерна) и формализовать взаимодействие пользователя с GUI в коде. Тогда системное тестирование сводится к тестированию Presenter классов, а также логики переходов между View. Но тут есть нюанс. Если тестировать Presenter классы в контексте системного тестирования, то необходимо как можно меньше зависимостей подменять mock объектами. И тут появляется проблема инициализации и приведения программы в нужное для начала тестирования состояние. В упомянутой выше статье Scenario Driven Tests об этом говорится подробнее.

Второй подход — использовать специальные инструменты для записи действий пользователя. То есть в итоге запускается сама программа, но щелканье по кнопкам осуществляется автоматически. Для .NET примером такого инструмента является White библиотека. Поддерживаются WinForms, WPF и еще несколько GUI платформ. Правило такое — на каждый use case пишется по скрипту, который описывает действия пользователя. Если все use case покрыты и тесты проходят, то можно сдавать систему заказчику. Акт сдачи-приемки должен подписать.

Методы тестирования программного обеспечения — Блог веб-программиста

Подробности




марта 31, 2016




Просмотров: 181130


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

Тестирование программного обеспечения является неотъемлемой частью цикла разработки программного обеспечения.

 

Что такое тестирование программного обеспечения?

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

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

 

Методика тестирования

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

 

1) Модульное тестирование

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

3) Системное тестирование

4) Приемочные испытания

 

Модульное тестирование

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

 

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

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

 

Системное тестирование

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

 

Приемочные испытания

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

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

 

Основные тесты

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

 

Тестирование методом черного ящика

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

 

Тестирование методом белого ящика

Тестирование методом «Белого ящика», в отличие от «черного ящика», учитывает внутреннее функционирование и логику работы кода. Для выполнения этого теста, тестер должен иметь знания кода, чтобы узнать точную часть кода, имеющую ошибки. Этот тест также известен как White-box, Open-Box или Glass box тестирование.

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

 

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

Тестирование методом серого ящика или Gray box тестирование, это что-то среднее между White Box и Black Box тестированием, где тестер обладает лишь общими знаниями данного продукта, необходимыми для выполнения теста. Эта проверка осуществляется посредством документации и схемы информационных потоков. Тестирование проводится конечным пользователем, или пользователям, которые представляются как конечные.

 

Нефункциональные тесты

Тестирование безопасности

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

 

Стресс-тестирование

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

 

Тестирование на совместимость

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

 

Тестирование эффективности

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

 

Юзабилити-тестирование

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

 

Тесты в процессе разработки программного обеспечения

 

Каскадная модель

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

Основными шагами, участвующими в данной методике тестирования программного обеспечения, являются:

  • Анализ потребностей
  • Тест дизайна
  • Тест реализации
  • Тестирование, отладка и проверка кода или продукта
  • Внедрение и обслуживание

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

 

Agile Model

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

 

Rapid Application Development (RAD). Методология быстрой разработки приложений

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

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

 

Спиральная модель

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

 

Rational Unified Process (RUP). Рациональный унифицированный процесс

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

 

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

Читайте также

 

 

 

 

Основные положения тестирования / Хабр

Области применения, цели и задачи тестирования ПО разнообразны, поэтому тестирование оценивается и объясняется по-разному. Иногда и самим тестировщикам бывает сложно объяснить, что такое тестирование ПО ‘as is’. Возникает путаница.

Для распутывания этой путаницы Алексей Баранцев (практик, тренер и консалтер в тестировании ПО; выходец из Института системного программирования Российской академии наук) предваряет свои тренинги по тестированию вводным видео про основные положения тестирования.

Мне кажется, что в этом докладе лектор смог наиболее адекватно и взвешенно объяснить «что такое тестирование» с точки зрения ученого и программиста. Странно, что этот текст еще не появлялся на хабре.

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

Основные положения тестирования

Уважаемые коллеги,

сначала попробуем понять, чем тестирование НЕ является.

Тестирование не разработка,

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

Тем не менее, тестирование — это не деятельность по разработке программного обеспечения.

Тестирование не анализ,

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

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

Тестирование не управление,

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

Тестирование не техписательство,

однако тестировщикам приходится документировать свои тесты и свою работу.

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

Деятельность значима только тогда, когда она востребована, то есть тестировщики должны что-то производить «на экспорт». Что они делают «на экспорт»?

Дефекты, описания дефектов, или отчеты о тестировании? Частично это правда.

Но это не вся правда.

Главная деятельность тестировщиков

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

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

Но эта вещь очень значимая, и, наверное, единственная наиболее значимая составляющая деятельности тестировщиков.

Существует наука — «теория систем». В ней определяется такое понятие как «обратная связь».

«Обратная связь» это некоторые данные, которые с выхода попадают обратно на вход, или какая-то часть данных, которые с выхода попадают обратно на вход. Эта обратная связь может быть положительной и отрицательной.

И та, и другая разновидности обратной связи равноценно важны.

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

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

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

К слову, отсюда и произрастает понимание того, что тестировщики не отвечают за качество. Они помогают тем, кто за него отвечает.

Синонимы термина «тестирование»

С точки зрения того, что тестирование — это предоставление отрицательной обратной связи, всемирно известная аббревиатура QA (англ. Quality Assurance — Обеспечение качества) синонимом термина «тестирование» уж совершенно точно НЕ является.

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

А вот «контроль качества» — Quality Control, можно считать в широком смысле синонимом для термина «тестирование», потому что контроль качества это и есть предоставление обратной связи в самых разных ее разновидностях, на самых разных этапах программного проекта.

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

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

Внешние определения

Определения, которые в разное время дали Майерс, Бейзер, Канер, описывают тестирование как раз с точки зрения его ВНЕШНЕЙ значимости. То есть, с их точки зрения, тестирование — это деятельность, которая предназначена ДЛЯ чего-то, а не состоит из чего-то. Все три этих определения можно обобщить как предоставление отрицательной обратной связи.

Внутренние определения

Это определения, которые приведены в стандарт терминологии, используемой в программной инженерии, например, в стандарт де-факто, который называется SWEBOK.

Такие определения конструктивно объясняют, ЧТО представляет из себя деятельность по тестированию, но не дают ни малейшего представления о том, ДЛЯ ЧЕГО нужно тестирование, для чего потом будут использоваться все полученные результаты проверки соответствия между реальным поведением программы и ее ожидаемым поведением.

Итак,

тестирование — это

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

Отсюда и далее будем считать это рабочим определением «тестирования».

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

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

Что такое тест

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

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

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

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

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

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

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

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

  • Пользовательский интерфейс (UI)
  • Программный интерфейс (API)
  • Сетевой протокол
  • Файловая система
  • Состояние окружения
  • События

Наиболее распространенные интерфейсы это

  • пользовательский,
  • графический,
  • текстовый,
  • консольный,
  • и речевой.

Используя все эти интерфейсы, тестировщик:

  • каким-то образом создает искусственные ситуации,
  • и проверяет в этих ситуациях как программа себя ведет.

Вот это и есть тестирование.

Другие классификации видов тестирования

Чаще всего используется разбиение на три уровня, это

  1. модульное тестирование,
  2. интеграционное тестирование,
  3. системное тестирование.

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

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

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

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

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

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

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

Комбинируем:

То есть, можно говорить о модульном тестировании функциональности.

Можно говорить о системном тестировании функциональности.

Можно говорить о модульном тестировании, например, эффективности.

Можно говорить о системном тестировании эффективности.

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

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

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

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

Классификацию по целям удобно выполнять с использованием «магического квадрата», который был изначально придуман Брайаном Мариком и потом улучшен Эри Тенненом.

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

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

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

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

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

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

Спасибо за внимание.

Дополнительно

  • Полная расшифровка текста со всеми картинками. Рассказывается о тестировании методом черного и белого ящика, о шести аспектах качества верхнего уровня (функциональность, надежность, практичность, эффективность, сопровождаемость, переносимость), о критериях полноты тестирования.
  • Видео-версия доклада: тут (ее можно и смотреть, и скачать как .wmv).
  • Если интересно: проводится распродажа записей вебинаров Баранцева.

В поисках самого лучшего способа тестирования системы

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

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

Почему существуют разные подходы к тестированию?

Я хотел бы начать с Линды Фишер. Вы ее не знаете, но более 19 лет назад я у нее проходил курсы по тестированию. Она говорила о том, что тестирование нужно делать вот так: сначала это, потом то (интерфейсы, проектирование и т.д.).

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

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

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

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

Основные подходы к тестированию

Существует два основных вида тестирования – сценарное (scripted) и исследовательское (exploratory).

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

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

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

Промежуточные подходы к тестированию

Однако эти два подхода к тестированию – не единственные. Кроме них существуют другие подходы, которые находятся где-то между ними.

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

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

Разберем эти направления в тестировании подробнее.

Подробное сценарное и общее сценарное тестирование (Detailed Scripting & Global scripting)

В чем отличия между подробным сценарным и общим сценарным тестированием? Объясню на примере.

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

  • Перейдите на стартовую страницу
  • Нажмите на кнопку «Новый»
  • В поле «Кому» напишите [email protected]
  • Нажмите на кнопку «Файл»
  • Выберите документ «Тест1»
  • В поле «Тема» напишите «Тестовое вложение <дата>»
  • Откройте почтовый ящик jcannegieter
  • Проверьте, доставлено ли сообщение и вложение.

Для этого же примера сценарий общего тестирования может выглядеть так:

  • Создайте и отправьте письмо с вложением одному получателю
  • Проверьте, доставлено ли сообщение и вложение

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

Сессионное тестирование и поиск багов (Session Based Testing & Bug Hunts)

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

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

Сессионное тестирование предусматривает наличие:

  1. Сессий тестирования.
  2. Миссии и точки тестирования / идей для тестирования.
  3. Заметок во время сессии.
  4. Отчета после сессии (что мы обнаружили, каково качество системы и пр.).

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

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

Исследовательское тестирование и туры (Exploratory Testing & Test Tours)

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

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

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

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

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

В книге «Исследовательское тестирование ПО» Джеймс Уиттакер пишет о самых разных исследовательских турах. Вот некоторые из них:

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

Основные различия методов тестирования и сравнение их эффективности

Итак, основные отличия исследовательского тестирования от сценарного представлены в таблице ниже:







Сценарное тестирование Исследовательское тестирование
Сфокусировано на подготовке Сфокусировано на действии
Сфокусировано на планировании Гибкое
Опирается на методы Прагматичное
Подчиняется процессу Ставит в центр внимания тестировщика
Сфокусировано на документации Сфокусировано на выполнении тестов

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

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

Как решить, какой метод тестирования подходит лучше

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

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

































Категория Ситуация Сценарное Исследовательское
Система Много вычислений +
Ориентирована на интерфейс +
Ориентирована на бэкенд +
Мобильное приложение +
Цели тестирования Проверка на соответствие требованиям +
Проверка ценности системы +
Юзабилити +
Тестирование бизнес-правил +
Производительность +
Проверка автоматизации +
Безопасность + +
Организация Ориентирована на планирование и подготовку +
Энергичный современный стартап +
Иерархическая, традиционная +
Приветствует самоуправление + +
Документация Много подробной документации + +
Немного документации +
Требования / документация постоянно меняются +
Разработка Каскадная модель + +
Agile +
Бюджет Большой + +
Небольшой
Время Включение в работу на ранних сроках + +
Включение в работу на поздних сроках +
Много времени + +
Мало времени +
Навыки тестировщиков Аналитические, скрупулезные +
Критическое мышление (сомневаются во всем) +
Гибкость +
Профессиональные тестировщики + +
Непрофессиональные тестировщики + +

Вместо заключения

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


Если ваша профессиональная деятельность связана с тестированием, наверняка вас заинтересуют вот эти доклады на нашей двухдневной декабрьской конференции Heisenbug 2017 Moscow:Методологии тестирования программного обеспечения

: ознакомьтесь с моделями QA

  • Home
  • Testing

      • Back
      • Agile Testing
      • BugZilla
      • Cucumber
      • Database Testing
      • J2 Назад
      • JUnit
      • LoadRunner
      • Ручное тестирование
      • Мобильное тестирование
      • Mantis
      • Почтальон
      • QTP
      • Назад
      • Центр качества (ALM)
      • SAP Testing
      • Управление тестированием
      • TestLink
  • SAP

      • Назад
      • A BAP
      • APO
      • Начинающий
      • Basis
      • BODS
      • BI
      • BPC
      • CO
      • Назад
      • CRM
      • Crystal Reports
      • Crystal Reports
      • Заработная плата
      • Назад
      • PI / PO
      • PP
      • SD
      • SAPUI5
      • Безопасность
      • Менеджер решений
      • Successfactors
      • SAP Tutorials

      4

    • Web
    • Apache
    • AngularJS
    • ASP.Net
    • C
    • C #
    • C ++
    • CodeIgniter
    • СУБД
    • JavaScript
    • Назад
    • Java
    • JSP
    • Kotlin
    • Linux
    • Linux
    • Kotlin
    • Linux
    • js

    • Perl
    • Назад
    • PHP
    • PL / SQL
    • PostgreSQL
    • Python
    • ReactJS
    • Ruby & Rails
    • Scala
    • SQL
    • 000

    • SQL
    • 000

      0003 SQL

      000

      0003 SQL

      000

    • UML
    • VB.Net
    • VBScript
    • Веб-службы
    • WPF
  • Обязательно учите!

      • Назад
      • Бухгалтерский учет
      • Алгоритмы
      • Android
      • Блокчейн
      • Business Analyst
      • Создание веб-сайта
      • CCNA
      • Облачные вычисления
      • 0003 COBOL
      • 000 Compiler
          9000 Встроенный

        • 000 9000 Compiler
        • Ethical Hacking
        • Учебники по Excel
        • Программирование на Go
        • IoT
        • ITIL
        • Jenkins
        • MIS
        • Сети
        • Операционная система
        • 0003
        • Назад
        • Управление проектами Обзоры
        • Salesforce
        • SEO
        • Разработка программного обеспечения
        • VB A
    • Big Data

        • Назад
        • AWS
        • BigData
        • Cassandra
        • Cognos
        • Хранилище данных
        • 0003

        • HBOps
        • 0003

        • HBOps
        • MicroStrategy
        • MongoDB

    .

    Методологии разработки и тестирования программного обеспечения (с плюсами и минусами)

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

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

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

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

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

    Значение методологий тестирования

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

    Методы тестирования

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

    # 1) Тестирование белого ящика:

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

    Методики тестирования «белого ящика» включают:

    • Покрытие операторов: Проверяет все операторы программирования.
    • Охват ветвей: Серия текущих тестов для проверки того, все ли ветки протестированы.
    • Покрытие пути: Проверяет все возможные пути для покрытия каждого оператора и ветви.
    # 2) Тестирование черного ящика:

    Метод тестирования черного ящика используется для проверки функциональности приложения на основе требований спецификации. В отличие от White Box Testing, он не фокусируется на внутренней структуре / коде приложения.

    Черный ящик Методы включают:

    • Анализ граничных значений
    • Разделение эквивалентности (разделение классов эквивалентности)
    • Таблицы решений
    • Тесты доменов
    • Модели состояния
    • Исследовательское тестирование (требует меньшей подготовки, а также помогает найти дефекты быстро).
    # 3) Тестирование серого ящика:

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

    Модели в SDLC

    Выбор подходящих методологий тестирования также связан с выбором подходящей модели в SDLC.

    Модели включают:

    • Модель Waterfall
    • Модель V
    • Agile модель
    • Спиральная модель
    • RAD

    Давайте подробнее рассмотрим каждую методологию разработки программного обеспечения с кратким объяснением.

    # 1) Модель водопада

    Модель водопада — это базовая модель жизненного цикла, разработанная Уинстоном Ройсом в 1970 году. Эта модель представляет несколько этапов или процессов в последовательной манере, которая постепенно течет вниз.

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

    Модель водопада определяется следующими этапами:

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

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

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

    Недостатки модели Waterfall:

    • Увеличение риска и неопределенности.
    • После входа в фазу тестирования ничего не может изменить на предыдущих этапах например, Дизайн и кодирование и т. Д.
    • Не подходит для сложных и крупных проектов.
    • Не подходит там, где требования постоянно меняются.
    # 2) Модель V

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

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

    В Модель подразделяется на 3 фазы.

    • Этап проверки
    • Этап кодирования
    • Этап проверки

    a) Этап проверки :

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

    б) Фаза кодирования:

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

    c) Этап проверки :

    • Модульное тестирование: Выполняется на отдельном модуле для устранения ошибок на ранней стадии.
    • Тестирование интеграции: Выполняется для проверки связи между различными модулями в системе.
    • Тестирование системы: Тестирование системы выполняется для системы в целом.
    • Приемочное тестирование: Это связано с бизнес-требованиями. Это выполняется в пользовательской среде с точки зрения пользователя.

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

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

    Недостатки модели V более или менее схожи с недостатками модели Waterfall.

    # 3) Agile Model

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

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

    Следующая диаграмма поможет вам более точно понять подход Agile Model:

    На следующем изображении показан цикл итераций в Agile модели:

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

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

    Недостатки Agile модели:

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

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

    Спиральная модель состоит из четырех этапов:

    • Этап планирования
    • Анализ рисков
    • Этап проектирования
    • Этап оценки

    1) Этап планирования: На этом этапе требования собираются и анализируются для завершения прецедент.

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

    3) Этап разработки: На этом этапе программное обеспечение разрабатывается и тестируется в конце.

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

    Графическое изображение спиральной модели:

    Когда использовать спиральную модель:

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

    Преимущества спиральной модели:

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

    Недостатки модели Spiral:

    • Комплексное управление.
    • Не подходит для небольших проектов.
    • Может касаться нет. спиралей (неопределенный).
    • Дорого.
    • Для успеха проекта требуется большой объем анализа рисков и экспертиза.
    # 5) Модель RAD

    Rapid Application Development (RAD) — это разновидность инкрементальной модели.При таком подходе компоненты разрабатываются параллельно.

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

    Этапы RAD следующие:

    • Бизнес-моделирование: Идентифицирует важную информацию и ее потоки между различными бизнес-каналами.
    • Моделирование данных: Информация, собранная на предыдущем этапе, используется для определения объектов данных, необходимых для бизнеса.
    • Моделирование процессов: Объекты данных преобразуются для получения бизнес-целей и потока информации.
    • Создание приложения: На этом этапе инструменты автоматизации используются для преобразования модели процесса в реальный код.
    • Testing and Turnover: Проверяет все компоненты системы, поэтому общее время тестирования сокращается.

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

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

    Недостатки RAD Модель:

    • Требуются высококвалифицированные ресурсы.
    • Оценка дороговизны.
    • Не применимо для более дешевых проектов.
    • Высокая зависимость от навыков моделирования.
    • С помощью RAD можно построить только модульную систему.

    Разница между методологиями тестирования и стратегиями тестирования

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

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

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

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

    Некоторые из них перечислены ниже:

    1) Модульное тестирование:

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

    2) Тестирование интеграции:

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

    3) Функциональное тестирование:

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

    4) Регрессионное тестирование:

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

    5) Тестирование системы:

    • Тестирование всех интегрированных модулей как коллективной системы.
    • Объединяет несколько функций в сквозные сценарии.

    6) Тестирование производительности:

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

    7) Приемочное тестирование :

    • Обычно финальный уровень тестирования, на котором программный продукт исследуется тестировщиками с точки зрения пользователей
    • Результат этого шага субъективен и требует немного времени, чтобы найти точную проблему

    Заключение:

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

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

    Сообщите нам свои мысли / предложения в разделе комментариев ниже.

    .

    Методологии тестирования программного обеспечения

    Написано Кирстен Эберсолд

    Функциональное и нефункциональное тестирование

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

    • Единичные испытания
    • Интеграционное тестирование
    • Системное тестирование
    • Приемочные испытания

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

    • Тестирование производительности
    • Тестирование безопасности
    • Юзабилити-тестирование
    • Тестирование совместимости

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

    Модульное тестирование

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

    Начать переключение влево и автоматизировать сейчас с TestLeft

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

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

    Тестирование системы

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

    Приемочные испытания

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

    Тестирование производительности

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

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

    Тестирование безопасности

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

    1. Целостность
    2. Конфиденциальность
    3. Аутентификация
    4. Авторизация
    5. Наличие
    6. Отсутствие отказа от авторства

    Юзабилити-тестирование

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

    Тест на совместимость

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

    Тестирование с помощью TestComplete

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

    .

    Методологий тестирования программного обеспечения — Изучите методы и инструменты

    Что такое методики тестирования?

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

    Что такое методологии тестирования программного обеспечения?

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

    Важность методологий тестирования

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

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

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

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

    Модульное тестирование

    Модульное тестирование — часть методологии тестирования — это тестирование отдельных программных модулей или компонентов, составляющих приложение или систему.Эти тесты обычно пишутся разработчиками модуля, и в методологии разработки, основанной на тестировании (такой как Agile, Scrum или XP), они фактически пишутся до того, как модуль будет создан как часть спецификации. Каждая функция модуля тестируется с помощью специального инструментария модульного тестирования, написанного на том же языке программирования, что и модуль.

    SpiraTest включает поддержку управления и выполнения автоматических модульных тестов. С его библиотекой плагинов и расширений для всех основных сред модульного тестирования (xUnit, JUnit, NUnit, PyUnit и т. Д.), SpiraTest позволяет менеджеру тестирования убедиться, что весь программный код полностью покрыт и все модульные тесты пройдены.

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

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

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

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

    Системное тестирование

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

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

    Приемочные испытания

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

    Пользовательские приемочные испытания (UAT)

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

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

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

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

    Нефункциональное тестирование

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

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

    Производительность, нагрузка, стресс-тестирование

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

    SpiraTest включает поддержку для хранения, управления и координации ваших действий, нагрузочного и стресс-тестирования. Благодаря своей библиотеке плагинов и расширений для различных инструментов автоматического тестирования производительности, включая LoadRunner, JMeter и NeoLoad, SpiraTest является идеальным решением для управления тестированием производительности.

    Безопасность, тестирование уязвимостей

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

    Юзабилити-тестирование

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

    Тест на совместимость

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

    Тестирование на основе данных

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

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

    Как насчет гибких методов тестирования?

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

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

    Исследовательское / сессионное тестирование

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

    Сессионное тестирование — это разновидность исследовательского тестирования, при котором у вас есть уставы тестирования и определенные «сеансы» с временными рамками для выполнения ваших действий.

    SpiraCapture — это бесплатный инструмент от Inflectra, который позволяет вам записывать ваши действия по веб-тестированию прямо в браузере Chrome.

    Непрерывное тестирование

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

    Зачем использовать SpiraTest для управления тестированием?

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

    • Интуитивно понятное веб-приложение, которое предоставляет полную картину состояния и работоспособности проекта, но требует только веб-браузера.

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

    Как мне начать?

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

    .

  • Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *

    2021 © Все права защищены. Карта сайта