Стратегия ветвления Git, интегрированная с процессом тестирования / QA

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

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

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

на какой ветке тестер должен тестировать новые функции ?

очевидно, есть два варианта:

  • на отдельной ветке функции
  • на develop филиала

Тестирование На Ветке Разработки

Первоначально мы считали, что это верный путь, потому что:

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

самые большие проблемы с этим это:

  • The develop ветка загрязнена ошибками.

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

Тестирование На Ветке Функции

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

  • вы все еще тестируете функцию с другими функциями в основной
  • дальнейшее развитие (например, исправление ошибок, разрешение конфликтов ) не будет загрязнять develop филиала;
  • вы можете легко решить не выпускать функцию, пока она не будет полностью протестирована и одобрена;

однако, есть некоторые недостатки

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

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

5 91
github unit-testing git-flow eqatec

5 ответов:

Как мы делаем это следующим образом:

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

  1. разработчик создает отдельную ветку для каждой новой функции.
  2. ветвь функций (автоматически) развертывается в нашей тестовой среде с каждой фиксацией для тестирования разработчиком.
  3. когда разработчик завершает развертывание и функция готова к тестированию, он объединяет ветвь разработки в ветви функций и развертывает ветвь функций, содержащую все последние версии разработайте изменения на тесте.
  4. тестер тестирует на тесте. Когда он закончит, он "принимает" историю и сливает ветку функций на разработку. Поскольку разработчик ранее объединил ветку разработки на функцию, мы обычно не ожидаем слишком много конфликтов. Однако, если это так, разработчик может помочь. Это сложный шаг, я думаю, что лучший способ избежать этого-сохранить функции как можно меньше/специфичнее. Разные функции должны быть в итоге объединены, так или иначе. Из конечно, размер команды играет определенную роль на сложности этого шага.
  5. ветвь разработки также (автоматически) развертывается при тестировании. У нас есть политика, что даже если ветвь функций строит может потерпеть неудачу, ветвь разработки никогда не должна терпеть неудачу.
  6. как только мы достигли замораживания функции, мы создаем релиз от разработки. Это автоматически развертывается на промежуточном этапе. Обширные сквозные тесты проходят там перед развертыванием производства. (хорошо, может быть, я немного преувеличиваю они не очень обширны, но я думаю, что они должны быть). В идеале бета-тестеры / коллеги, т. е. реальные пользователи должны тестировать там.

Что вы думаете о таком подходе?

69

перед тестом мы объединяем изменения из ветки разработки в ветку функций

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

заставьте разработчика сделать перебазировать его/ее feature ветку сверху devel и нажми feature филиала (который был проверен разработчиком как компиляция и работа поверх самого последнего devel филиала Государственного).
Это позволяет:

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

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

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

28

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

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

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

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

8

мы используем то, что мы называем "золото", "серебро" и "бронзу". Это можно назвать prod, staging и qa.

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

когда ошибка или функция готова к тестированию, она переходит в"бронзу". Это запускает сборку Дженкинса, которая перемещает код в предварительно созданную среду. Наш тестер (кстати, не супер технари) просто нажмите ссылку и не заботьтесь о системе управления версиями. Эта сборка также выполняет тесты и т. д. Мы ходили взад и вперед по этой сборке, фактически подталкивая код к среде testing\qa, если тесты (unit, integration, selenium ) терпят неудачу. Если вы тестируете на отдельной системе (мы называем ее lead), вы можете предотвратить внесение изменений в вашу среду qa.

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

Как только функция проходит QA, мы перемещаем ее в "серебро" или постановку. Сборка выполняется и тесты выполняются снова. Еженедельно мы вносим эти изменения в наше" золотое " или prod дерево, а затем развертываем их в нашей производственной системе.

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

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

после нашего релиза мы нажимаем изменения в золоте (prod) на бронзу(тестирование), чтобы все было синхронизировано.

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

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

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

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

3

Я бы не полагался только на ручное тестирование. Я бы автоматизировал тестирование каждой ветви функций с помощью Jenkins. Я настраиваю лабораторию VMWare для запуска тестов Jenkins на Linux и Windows для всех браузеров. Это действительно удивительный кросс-браузер, кросс-платформенное решение для тестирования. Я тестирую функциональность / интеграцию с Selenium Webdriver. Мои тесты Selenium выполняться под вас. И я написал их специально для загрузки jRuby на Windows. Я запускаю традиционные модульные тесты под Rspec и Javascript-тесты под Jasmine. Я настройка безголовое тестирование с Phantom JS.

1