В разработке, подобной agile, кто должен писать тестовые примеры?[закрыто]

https://stackoverflow.com/questions/194790

10-07-2019
|

Вопрос

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

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

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

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

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

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

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

Предложения?

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

Решение

Команда.

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

Руководитель проекта (PM) должен понимать домен лучше, чем кто-либо в команде.Их знания в области жизненно важный к наличию тестовых примеров, которые имеют смысл применительно к домену.Им нужно будет предоставить примеры входных данных и ответить на вопросы об ожиданиях в отношении недопустимых входных данных.Они должны предоставить, по крайней мере, тестовый пример "счастливого пути".
Разработчик (ы) будет знать код.Вы предполагаете, что разработчик, возможно, лучше всего подходит для этой задачи, но вы ищете тестовые примеры из черного ящика.Любые тесты, которые предлагает разработчик, являются тестами белого ящика.В этом преимущество того, что разработчики создают тестовые примеры – они знают, где находятся швы в коде.

Хорошие разработчики также будут приходить в личку с вопросами "Что должно произойти, когда ...?" – каждый из них является тестовым примером.Если ответ сложный "Если a тогда x, но если b тогда y, за исключением четвергов" – существует несколько тестовых примеров.
Тестировщики (QA) знать, как тестировать программное обеспечение.Тестировщики, скорее всего, придумают тестовые случаи, о которых премьер-министр и разработчики не подумали бы – вот почему у вас есть тестировщики.

Другие советы

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

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

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

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

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

Мы экспериментировали с объединением разработчика и специалиста по контролю качества с довольно хорошими результатами.Как правило, они "держали друг друга в честности", и поскольку у разработчика были модульные тесты для обработки кода, он / она уже был достаточно хорошо знаком с изменениями.Специалист по контролю качества не был, но подошел к этому со стороны черного ящика.Оба были привлечены к ответственности за полноту.Часть текущего процесса проверки помогла выявить недостатки модульного тестирования, и поэтому мне было известно не так уж много инцидентов, когда кто-то намеренно избегал написания X-теста, потому что это, скорее всего, доказало бы наличие проблемы.

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

В любом случае, надеюсь, это как-то поможет вам.

Исходя из прошлого опыта, нам довольно удачно удалось определить тесты на разных уровнях для тестирования немного разных вещей:

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

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

3 - й уровень:На уровне приложения попросите команду контроля качества выполнить свои системные тесты.Эти тестовые примеры должны основываться на бизнес-предположениях или документах с требованиями, предоставленных менеджером по продукту.По сути, тестируйте так, как если бы вы были конечным пользователем, делая то, что конечные пользователи должны уметь делать, в соответствии с документированными требованиями int eh.Эти тестовые примеры должны быть написаны командой контроля качества и менеджерами по продуктам, которые (предположительно) знают, чего хочет клиент и как он должен использовать приложение.

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

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

Может ли QA просмотреть код и тестовые примеры и произнести "Недостаточно охвата - нужно больше примеров".Если это так, то программист, у которого сразу будет "достаточное" покрытие, станет Большой Кахуной.

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

Слишком сложно определить "достаточно"?Интересно.Вероятно, это и есть первопричина конфликта с программистами в первую очередь.Они могут чувствовать, что это пустая трата их времени, потому что они уже сделали "достаточно", а теперь кто-то говорит, что этого "недостаточно".

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

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

Блин, вам нужно больше доверять своему отделу контроля качества или какому-нибудь лучшему.Я имею в виду, представьте, что кто-то из вас сказал бы: "Мне не нравится, когда мои разработчики разрабатывают программное обеспечение.Мне не нравится идея о том, что они создают свою собственную работу ".

Как разработчик, я знаю, что при написании моих собственных тестов существуют риски.Это не значит, что я этого не делаю (я делаю, особенно если я занимаюсь TDD), но у меня нет иллюзий относительно тестового покрытия.Разработчики собираются написать тесты, которые показывают, что их код делает то, что, по их мнению, он делает.Не слишком многие собираются писать тесты, применимые к реальному бизнес-кейсу под рукой.

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

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

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

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

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

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

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

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

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

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

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

Тестовый пример начинается первым в карточке истории.

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

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

Критерии приемлемости карточки истории будут определять, какие автоматизированные модульные тесты должны быть закодированы разработчиками при разработке на основе тестирования.Это также приведет к автоматизированному функциональному тестированию, реализованному тестировщиками autoamted (и, возможно, при поддержке разработчика, если используются такие инструменты, как FIT).

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

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

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

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

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

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

Нам нужно отказаться от менталитета "вот как это было сделано или должно быть сделано", который терпит неудачу и терпит неудачу постоянно.Лучший способ решить проблему с написанием плана тестирования / кейсов - это написать тестовые кейсы в документе требований в waterfall или пользовательской истории в agile по мере написания этих запросов / пользовательских историй.Таким образом, не возникает вопросов о том, что необходимо протестировать, и команды контроля качества и UAT могут выполнить тестовый пример (ы) и уделить время фактическому тестированию и устранению дефектов.

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow