Процесс разработки веб-приложений - контроль версий, отслеживание ошибок, модульное тестирование, развертывание - PullRequest
5 голосов
/ 19 марта 2009

Опишите процесс, который вы используете для разработки веб-приложений на не очень высоком уровне, с акцентом на VC, отслеживание ошибок, QA, модульное тестирование, развертывание и все остальное подобное (минус аспекты планирования / связи с клиентом).

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

Например.

  1. Создание репозитория проекта на локальном сервере SVN.
  2. Создание пакетных сценариев / сценариев оболочки для сопоставлений DNS.
  3. Проверить проект, начать работу над локальной рабочей копией.
  4. Разработка функций в виде веток.
  5. Отслеживание ошибок с помощью Mantis (ссылка фиксирует ошибки через SVN-интеграцию (не знаю, существует ли она)).
  6. Документ на ходу.
  7. Провести QA на ветке.
  8. Слияние с туловищем, когда оно стабильно.
  9. Модульное тестирование?
  10. Фиксация в хранилище, когда функция реализована и стабильна.
  11. Копировать релизы в теги в хранилище. Например. / Проект / теги / отн-123 /
  12. Используйте Phing для загрузки на промежуточный сервер. (Может кто-нибудь уточнить, для чего конкретно используется промежуточный сервер за пределами «тестирования»?)
  13. Используйте Phing для подготовки сайта к обновлению, настройки БД / развертывания и т. Д.

Ответы [ 3 ]

2 голосов
/ 20 марта 2009
  1. Создание / проверка версии HEAD ("основная ветка")
  2. Разработка кода и синхронизация с основной веткой - как минимум - ежедневно
  3. После завершения разработки напишите и запустите модульные тесты
  4. Пройдите проверку кода и отправьте код / ​​изменения в основную ветку
  5. Разрешить непрерывному сборщику запускать все модульные и системные / интеграционные тесты в основной ветке
  6. Когда все будет готово, выберите вишню ревизии и интегрируйте их в ветку QA
  7. Запуск системных и интеграционных тестов, исправление обнаруженных ошибок или откат при необходимости; это повторяет шаги 4-7
  8. После выхода из QA интегрируйте изменение QA в ветвь релиза
  9. Запуск модульных тестов, системных / интеграционных тестов в ветке релиза
  10. Развертывание в производство и запуск тестов работоспособности.

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

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

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

Для пояснения есть стек разработки, стек QA и Staging stack. В зависимости от размера вашего проекта, QA может быть поэтапным, Production может быть поэтапным или какой-либо их комбинацией. Разделение стеков Dev и QA является наиболее важным.

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

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

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

1 голос
/ 28 февраля 2014

Старый пост, но интересный вопрос!

В моей компании сейчас:

  1. Создание нового репозитория Github
  2. Настройка Jenkins
  3. локально клонировать
  4. Начать ветку
  5. Разработка и добавление тестов (сервер, клиент и e2e)
  6. Фиксация для каждого шага и выборка + перебазирование для поддержания синхронизации ветки
  7. Когда все будет готово, отправьте ветвь на сервер: перед проверкой проверьте исправность, проверьте и заблокируйте, если не в порядке
  8. Создание запроса на извлечение для филиала
  9. Здесь jenkins автоматически запускает тесты для ветви и помечает ее как «зеленые» или «неработающие тесты» непосредственно в запросе на извлечение
  10. Наконец 2 коллеги просматривают запрос на удаление и исправляют свои выводы (возврат к шагу 5)
  11. Когда все зеленое и 2 коллеги согласились, последний объединяет запрос на извлечение
  12. Удалить ветку на сервере
  13. Когда будете готовы, нажмите новую версию
  14. Последняя версия немедленно развертывается на платформе тестирования
  15. QA проверяет исправления и введенные функции (возврат к 5, если проблема)
  16. (TODO) развертывание в pre-prod с параметрами, идентичными производственным
  17. Развертывание в производство
  18. Идите, извинитесь перед пользователями за обнаруженные ошибки;) и сообщите о них в диспетчере проблем
  19. получать запросы функций и сообщать о них в диспетчере проблем
  20. цикл перезапуска на шаге 2
1 голос
/ 19 марта 2009

Очень грубо:

  1. Создание хранилища в SVN
  2. Проверка локальной рабочей копии в среде разработчика
  3. Обновление / принятие изменений часто
  4. Развертывание на этапе из ствола SVN с использованием пользовательского сценария развертывания
  5. QA тесты на сцене, отчеты об ошибках в Mantis
  6. Разработчики исправляют ошибки, помечают их как исправленные
  7. Повторно развернуть на этапе
  8. QA проверяет ошибки, закрывается, если исправлено
  9. ОК закончен, проведите регрессионное тестирование
  10. Развертывание в производство с использованием пользовательского сценария развертывания
  11. немного потанцевать

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

Мы синхронизируем наши структуры БД с помощью специального инструмента сравнения БД, который выполняется во время развертывания.

...