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


Содержание материала:

Проекты SetupAngularJS или Angular2 для непрерывной интеграции и непрерывного развертывания

В настоящее время у меня есть мой git, созданный для проектов AngularJS. Я тестирую локально, и если тесты проходят, я передаю код Git repo. То, что я хочу сделать, — это настроить проект пользовательского интерфейса с помощью CI и CD таким образом, что даже после тестирования локально, когда я передаю код Git repo, он должен запускать тесты, а затем строить (для Angular2 или minify, например, для AngularJS), проект готов к использоваться. Если тесты терпят неудачу, он должен отклонить push/изменения. Затем он должен автоматически передать полученный код в соответствующую папку развертывания.

Может Grunt/Gulp сделать это, или мне нужны другие приложения/инструменты CI/CD для этого. Если да, то кто-нибудь может объяснить, как это установить?

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

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

Локальный запуск тестов – персональная ответственность. Хорошие разработчики используют тесты непрерывно во время разработки и обязательно запускают их перед пушем ( git push ).

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

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

10 систем непрерывной интеграции, о которых стоит знать в 2020 году

Перевод статьи «10 Continuous Integration Systems your Dev Team should know about in 2020».

Что такое непрерывная интеграция

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

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

Обычно непрерывная интеграция сопряжена с непрерывной доставкой (Continuous Delivery), поэтому этапы непрерывной автоматизированной доставки исполняемого кода в продакшен часто обозначают CI/CD.

Преимущества непрерывной интеграции

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

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

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

Jenkins

Jenkins это инструмент непрерывной интеграции с открытым исходным кодом. Написан он на Java. Этот проект собрал больше 11 тысяч звезд на GitHub.

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

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

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

TeamCity

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

TeamCity создан командой JetBrains, которая дала нам такой инструмент как WebStorm.

Поставляется он с обширной поддержкой множества плагинов с открытым исходным кодом – как собственных продуктов JetBrains, так и сторонних приложений и инструментов. Также TeamCity предлагает потрясающую поддержку .NET.

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

Travis CI

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

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

Этот инструмент поставляется с очень мощным API и интерфейсом командной строки. Его легко настраивать, а инсталлировать и вовсе не нужно. Travis интегрирован с такими сервисами коммуникации как Slack, HipChat и даже с электронной почтой. Для сборки приложений используются виртуальные машины. Допускается параллельное тестирование.

Gitlab CI

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

Gitlab CI поставляется с реестром образов Docker, который называется реестром контейнеров. С помощью Gitlab вы можете изменять метаданные merge-реквеста без команд slash в комментарии.

Circle CI

Circle CI это гибкий сервер непрерывной интеграции, запускаемый в любой среде: в кросс-платформенном мобильном приложении, Python API сервере или кластере Docker. Инструмент нацелен на обозначение багов и улучшение качества приложения в целом (в долгосрочной перспективе).

Хорошо интегрируется с системами контроля версий, поддерживает много языков (JavaScript, C++, PHP, Python), а также Docker. Вы можете выбрать среду сборки и она будет поставлена вам в иде бесплатной версии, чтобы вы могли ее опробовать.

GoCD это сервер непрерывной интеграции, собравший больше 4,5 тысяч звезд на GitHub. Используется для моделирования и визуализации сложных рабочих процессов. GoCD также является инструментом непрерывной доставки, таким образом, это прекрасное решение для CI/CD процессов.

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

Bamboo

Bamboo создан командой Atlassian – очень крупной компании, занимающейся созданием программ промышленного уровня. Это build-сервер непрерывной интеграции, осуществляющий сборку, тестирование и релизы. Он создан для поддержки его «сестринского» инструмента Jira от Atlassian и систем контроля версий. Bamboo поддерживает много языков программирования и технологий, например, AWS Buckets.

Этот инструмент имеет простой в использовании интерфейс. Он содержит встроенный git branching, а также интегрируется с HipChat. Сборки могут запускаться по мере обнаружения изменений в кодовой базе.

Codeship

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

Buildbot

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

Помимо того что BuildBot имеет открытый исходный код, он поддерживает single-source репозиторий, автоматизированную сборку и даже деплоймент, т. е., это централизованные CI/CD. BuildBot поставляется с поддержкой разнообразных платформ тестирования.

Strider это CI-инструмент с открытым исходным кодом. Имеет больше 4 тысяч звезд на GitHub. Для его установки вам понадобится установить на свою машину Node.js и MongoDB, поскольку он написан на Node с MongoDB в качестве уровня для хранения данных. Этот инструмент предлагает поддержку различных плагинов, модифицирующих схему базы данных и регистрирующих маршруты HTTP.

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

Заключение

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

SetupAngularJS или Angular2 Проекты для непрерывной интеграции и непрерывного развертывания

December 2020

594 раз

В настоящее время я мой мерзавец создан для AngularJS проектов. Я тестирование локально, и если тесты проходят предаю код в Git репо. То, что я хочу сделать, это создать проект UI с CI и CD таким образом, что даже после тестирования на месте, когда я совершаю код в Git репо он должен вызвать тесты, а затем построить (для Angular2 или преуменьшать, например, для AngularJS) проект готов использоваться. Если тесты не следует отказываться от толчка / изменения. Затем следует нажать на принятый код в соответствующую папку развертывания автоматически.

Может Грунт / Gulp сделать это, или мне нужно другие CI / CD приложение / инструменты для этого. Если так может кто-нибудь объяснить, как настроить?

Непрерывная интеграция и тестирование Инструменты для проектов, использующих PHP, Javascript, JQuery, AngularJS

У меня есть базовый проект с я использую для настройки веб-сайтов с CMS. Она все больше и больше возможностей, и это все более и более трудно поддерживать код этого. Я планирую использовать некоторые Continuous Integration для него и, наконец, начать добавлять тесты. Эта система написана на PHP с базой данных MySQL и использует библиотеки, как JQuery и AngularJS.

Я думаю о таких инструментах, как показано ниже:

  • PHP: PHPUnit
  • Javascript / JQuery / AngularJS: Жасмин
  • Также Селен для тестирования во внешнем интерфейсе и в PHPUnit (Selenium WebDriver)

Subversion (он должен быть)

Я хочу спросить, если эти выборы хороши? Может быть TeamCity будет лучше? Кто имеет опыт работы с PHP / проектами Javascript и мог бы дать несколько советов.

Непрерывная интеграция в процессе гибкой разработки

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

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

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

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

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

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

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


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

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

Топ-пост этого месяца:  Для чего нужен атрибут title настройка работы со ссылками, изображениями и другими элементами

Так мы подходим к последней детали, которая делает процесс CI успешным. Если идея непрерывной интеграции ― быстро выявить проблемы, так чтобы каждый разработчик видел результат своей работы, то должен быть способ быстро оценить эту работу. Эту задачу решает разработка через тестирование. Вы создаете тест, и затем разрабатываете функциональность до тех пор, пока код этот тест не пройдет. При каждом дополнении к коду в набор тестов добавляются испытания для него, и этот набор применяется к результату. Это гарантирует, что дополнения не нарушат то, что уже сделано, а те разработчики, чей код «нарушает сборку», быстро узнают об этом. Типичное сочетание непрерывной интеграции и разработки через тестирование иллюстрируется на рисунке 1.

Рисунок 1. Гибкая разработка с помощью непрерывной интеграции и разработки через тестирование

Проекты, которые выигрывают от непрерывной интеграции

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

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

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

Использование гибких методов для разработки встраиваемых систем

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

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

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

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

Архитектура

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

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

Моделирование

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

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

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

Автоматизация сборки

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

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

Управление работой

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

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

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

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

Управление качеством

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

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

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

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

Автоматизированное тестирование

При создании множества сборок группа должна многократно тестировать функции, уже работающие в предыдущих сборках. Этот процесс повторного тестирования, который раньше называли «добротным кодом» (good code), носит имя регрессионного тестирования. Он гарантирует, что внесенные изменения не приведут к ошибкам в ранее протестированном коде. В случае CI в конце каждой сборки запускаются автоматические сценарии регрессионных тестов. Это позволяет разработчикам немедленно получать информацию об ошибках, найденных в новой сборке. Этот шаг предупреждает разработчиков, когда вновь созданный ими код не соответствует требованиям. Без регрессионных тестов разработчики знают только, что сборка выполнена. Поскольку тесты все равно должны создаваться, то TDD не добавляет дополнительную работу. Просто меняется порядок действий ― сначала создаются тесты, а затем код.

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

Сотрудничество

Подразделение IBM® Rational® ― давний сторонник сотрудничества как критически важного элемента успешной разработки и поставки систем. Но в процессе CI, в котором участвуют группы разработчиков программного и аппаратного обеспечения, сотрудничество предусматривает не только эффективную передачу артефактов из одной группы в другую, но и полное понимание компромиссов между требованиями, возможностями и сроками.

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

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

Заключение

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

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

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

СМИ о нас: 14 июля, 2011

Cnews — 14 июля 2011 — Владислав Жидков, Дмитрий Змитраченок, Ольга Полстюк, EPAM

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

Бизнес многих современных компаний довольно сильно зависит от работы информационных систем, которые применяются для обслуживания клиентов, поддержки работы бэк-офиса, ведения управленческого учета и ряда других задач. Досадные ошибки в ИТ-приложениях или некорректное выполнение функций может привести к финансовым или репутационным потерям. Так, в марте 2011 года технологический сбой в ИТ-решении нарушил работу практически всех отделений и банкоматов банка ВТБ24, а двумя годами раньше из-за неполадок в компьютерной системе была парализована деятельность почти трети московских филиалов Сбербанка. Какие шаги нужно предпринять, чтобы снизить риски появления подобного рода проблем при использовании информационных систем?

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

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

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

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

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

Как построить процесс непрерывной интеграции?

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

Топ-пост этого месяца:  Как убрать автора записей «admin»

Этапы процесса непрерывной интеграции

Создание исходного кода

Программный код будущей информационной системы может создаваться несколькими группами специалистов, причем находиться они могут в различных офисах компании-разработчика. Для повышения качества и эффективности совместной работы над кодом часто используются специальные ИТ-решения — системы контроля версий (Version Control System, VCS). К числу наиболее распространенных из них относятся open source-приложения Subversion (SVN) и Git. Подобные системы позволяют программистам составлять код, реализуя новый функционал, и при этом не мешать друг другу. Кроме того, всегда есть возможность посмотреть и проанализировать историю кода, в любой момент вернуться к предыдущему удачному варианту.

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

Жизненный цикл ветки кода

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

Компиляция и компоновка

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

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

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

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

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

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

На некоторых проектах иногда дополнительно применяется так называемый «анализ кода» (code review). Его смысл заключается в том, что программист, закончив разработку части функционала, которую он хочет включить в общий поток разработки, сначала передает ее для анализа своему коллеге, который специализируется в той же или смежной области. Такой взгляд со стороны зачастую позволяет быстро найти потенциальные проблемы, а иногда и способы их решения. Нелишним может быть и применение инструментов статистического анализа кода (PMD, FindBugs) — они помогают автоматически выявить стандартные и наиболее распространенные ошибки, которые могут допускаться разработчиками.

Кроме того, на данном этапе проверяется стилистика кода: его соответствие тем правилам оформления и формату, которые действуют на проекте. Это позволяет сделать код «читабельным», что значительно облегчает дальнейшую работу с ним. Подобное тестирование проводится в автоматическом режиме (например, с использованием программы Checkstyle). Частично ошибки исправляются также автоматически, но иногда это приходится делать вручную (определяются конкретные строки кода, где были сделаны ошибки, и дальше вносятся исправления). Стоит заметить, что провести подобную проверку можно только в рамках практики continuous integration. В других случаях, когда тестированию подвергаются уже готовые системы, QA-специалисты фокусируются на приведение кода в соответствие с требованиями заказчика и не смотрят, написан ли он в едином стиле или нет.

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

Подготовка установочного пакета


Скомпилированный код должен быть запакован соответствующим образом: это может быть zip-архив, установочная программа Windows или пакет для Unix/Linux дистрибутива. Для хранения готового пакета чаще всего используется файл-сервер (FTP, NFS, общая папка в сети и т.д.), который может быть как локальным (размещен в компании-разработчике системы), так и удаленным (например, располагаться у заказчика).

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

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

Автоматическая установка и подготовка к тестированию

Хорошим тоном при разработке программы считается предусмотреть в ней вариант так называемой «бесшумной» (silent) установки, когда система ставится на компьютер или сервер, не требуя каких-либо действий от ИТ-специалистов (без всплывающих окон и запросов). При этом она может использовать как заданные разработчиком параметры «по умолчанию», так и файл, предоставленный заказчиком, с аналогичными параметрами, но уже специально подобранными под конкретную ИТ-среду компании. Штатные пакеты для Unix/Linux- систем обладают такой возможностью по определению. Все это позволяет автоматизировать установку решений, снизить влияние человеческого фактора на этот процесс и существенно сэкономить время.

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

Отдельно стоит упомянуть об одном из перспективных направлений развития практики continuous integration, когда весь процесс полностью — от написания кода до запуска готового решения в эксплуатацию — выстраивается как «облачный» сервис. Заказчик обозначает свои требования — и после завершения проекта получает готовую систему. Все вопросы, связанные со сроками и рисками разработки и поддержки решения, выпуска релизов, регулируются с помощью заключения SLA (Service Level Agreement — соглашение об уровне услуг) между исполнителем и заказчиком. К примеру, SLA помогает снизить зависимость успешного проведения разработки и тестирования от конкретных специалистов, которые управляют процессом непрерывной интеграции. Даже в случае их временного отсутствия на проекте будет обеспечено выполнение всех запланированных операция точно в установленные сроки.

Итак, программный код скомпилирован, запакован и установлен. Что дальше? Функциональное тестирование.

Как провести функциональное тестирование?

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

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

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

Разработка функциональных тест-кейсов

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

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

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

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

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

В дальнейшем результаты автоматизированных тестов анализируются, определяются дефекты, которые привели к получению отрицательных результатов. Если в проекте используется гибкая модель разработки программного обеспечения, то найденные ошибки немедленно устраняются, и процесс тестирования запускается снова. В иных случаях дефекты регистрируются в системе для фиксации ошибок (bag tracking system) и исправляются после завершения всего тестирования.

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

Объем ручного тестирования во многом определяется тем, с какой степенью детализации и полноты автоматические тесты охватили функциональность создаваемой ИТ-системы. Если они были проработаны недостаточно детально, то сначала в ручном режиме проводится проверка работоспособности всех компонентов решения — с помощью «тестирования на дым» (Smoke-тесты). Затем найденные дефекты исправляются и проверяются еще раз — на предмет соответствия тем требованиям, которые были сформулированы изначально. По разработанным функциональным тест-кейсам прогоняются основные сценарии использования будущей системы.

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

Анализ результатов тестирования и обратная связь с заказчиком

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

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

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

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

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

Запустите транспортир на локальном сервере во время непрерывной интеграции

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

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

Вопрос заключается в следующем: как я могу запустить свои тесты на локальном веб-сервере?

Мой конфигурационный файл selenium

1 ответ

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

Пример: ./wait-for.sh && npm test

Другой способ сделать это — контейнировать все, используя docker и docker-compose , а затем запустить тесты.

Тестирование Angular компонентов с использованием Jasmine: часть 1

Russian (Pусский) translation by Ilya Nikov (you can also view the original English article)

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

Разработка с использованием тестов в Angular

Angular является полно-функциональной платформой для фронт-енд разработки и имеет собственный набор инструментов для тестирования. В этом учебнике мы будем использовать следующие инструменты:

  • Jasmine Framework. Jasmine — популярный фреймворк для тестирования JavaScript. С Jasmine вы можете написать тесты, которые будут более выразительны и понятны. Вот пример для начала.
  • Karma Test Runner. Karma — это инструмент, который позволяет тестировать ваше приложение в нескольких браузерах. У Karma есть плагины для браузеров, таких как Chrome, Firefox, Safari и многих других. Но я для тестирования предпочитаю использовать headless браузер. В headless браузере отсутствует графический интерфейс, и таким образом вы можете сохранить результаты теста внутри своего терминала. В этом уроке мы настроим Karma для работы с Chrome и, а также дополнительно с headless версией Chrome.
  • Angular Testing Utilities. Утилиты тестирования Angular предоставляют вам библиотеку для создания тестовой среды для вашего приложения. Классы, такие как TestBed и ComponentFixtures , и вспомогательные функции, такие как async и fakeAsync , являются частью пакета @angular/core/testing . Знакомство с этими утилитами необходимо, если вы хотите написать тесты, которые показывают, как ваши компоненты взаимодействуют со своими собственными шаблонами, сервисами и другими компонентами.
Топ-пост этого месяца:  Кириллица в произвольных типах записи

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

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

Наша цель

Цель этого учебника — создать интерфейс для приложения Pastebin в тестовой среде разработки. В этом уроке мы будем следовать популярной мантре TDD: «красный/зеленый/рефакторинг». Мы будем писать тесты, которые первоначально не выполняются (красные), а затем мы работаем над нашим кодом, чтобы они проходили (зеленые). Мы так же будем рефакторить наш код, когда он начнет вонять, что означает, что он раздувается и становится уродлив.

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

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

Вид компонента Pastebin Вид компонента AddPaste
Вид компонента ViewPaste

В этом уроке вы узнаете, как:

  • настроить Jasmine и Karma
  • создать класс Pastebin
  • создать каркас для PastebinService
  • создать два компонента, Pastebin и AddPaste
  • написать единичные тесты

Весь код для учебника доступен на Github.

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

Настройка Jasmine и Karma

Разработчики в Angular упростили создание нашей тестовой среды. Для начала нам нужно сначала установить Angular. Я предпочитаю использовать Angular-CLI. Это решение «все-в-одном», которое заботится о создании, генерации, сборке и тестировании вашего Angular проекта.

Вот структура каталогов, созданная Angular-CLI.

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

karma.conf.js — это файл конфигурации для тестировщика Karma и единственный файл конфигурации, который нам понадобится для написания модульных тестов в Angular. По умолчанию в качестве браузера для Karma используется Chrome. Мы создадим свой собственный ланчер для запуска headless Chrome и добавим его в массив browsers .

Другим типом файла, который нужно найти, является все, что заканчивается на .spec.ts . По соглашению тесты, написанные на Jasime, называются спецификациями. Все тестовые спецификации должны быть расположены внутри каталога приложения src/app/ , поскольку именно здесь Karma ищет тестовые спецификации. Если вы создаете новый компонент или службу, важно, чтобы вы размещали ваши тестовые спецификации в том же каталоге, в котором находится код компонента или службы.

Команда ng new создала файл app.component.spec.ts для нашего app.component.ts . Откройте его и хорошенько рассмотрите тесты Jasmine в Angular. Даже если этот код для вас не имеет никакого смысла, это нормально. Мы сохраним AppComponent так, как он выглядит сейчас, и используем его для размещения маршрутов далее в учебнике.

Создание класса Pastebin

Нам нужен класс Pastebin для моделирования нашего Pastebin внутри компонентов и тестов. Вы можете создать его с помощью Angular-CLI.

Добавьте в Pastebin.ts следующую логику:


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

Создайте еще один файл с именем pastebin.spec.ts для набора тестов.

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

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

Ожидания, реализованные с использованием функции expect , используются Jasmine для определения того, должна ли спецификация проходить или терпеть неудачу. Функция expect принимает параметр, который известен как фактическое значение. Затем он соединен цепью с другой функцией, которая принимает ожидаемое значение. Эти функции называются вспомогательными функциями, и в этом учебнике мы будем использовать функции матчинга, такие как toBeTruthy() , toBeDefined() , toBe() и toContain() .

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

Мы создали экземпляр класса Pastebin и добавили несколько ожиданий в нашу тестовую спецификацию. Запустите ng test , чтобы проверить, что все тесты зеленые.

Создание каркаса для службы

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

В PastebinService будет установлена логика отправки HTTP-запросов на сервер; однако у нас нет API-интерфейса сервера для создаваемого нами приложения. Поэтому мы собираемся моделировать связь с сервером с помощью модуля, известного как InMemoryWebApiModule.

Настройка Angular-in-Memory-Web-API

Установите angular-in-memory-web-api через npm:

Обновите AppModule до этой версии.

Создайте InMemoryDataService , который реализует InMemoryDbService .

Здесь pastebin представляет собой массив выборочных паст, которые будут возвращены или обновлены при выполнении действия HTTP, например http.get или http.post .

Метод getPastebin() выполняет запрос HTTP.get и возвращает обещание, которое разрешается в массив объектов Pastebin, возвращаемых сервером.

Если при запуске спецификации вы получаете сообщение No provider for HTTP error, то вам необходимо импортировать HTTPModule в соответствующий файл spec.

Начало работы с компонентами

Компоненты — это самый базовый строительный блок пользовательского интерфейса в приложении Agnular. Angular приложение представляет собой дерево компонентов.
— Angular документация

Как было отмечено ранее в разделе «Обзор», мы будем работать над двумя компонентами в этом уроке: PastebinComponent и AddPasteComponent. Компонент Pastebin состоит из таблицы, в которой перечислены все вставки, полученные с сервера. Компонент AddPaste содержит логику создания новых паст.

Проектирование и тестирование компонента Pastebin

Идем дальше и создаем компоненты с помощью Angular-CLI.

Параметр —spec = false указывает Angular CLI не создавать спецификационный файл. Это связано с тем, что мы хотим писать модульные тесты для компонентов с нуля. Создайте файл pastebin.component.spec.ts внутри папки pastebin-component.

Вот код для pastebin.component.spec.ts.

Здесь многое происходит. Давайте разложим его и рассмотрим по блокам. Внутри блока describe мы объявили некоторые переменные, а затем мы использовали функцию beforeEach . beforeEach() является глобальной функцией, предоставляемой Jasmine, и, как следует из названия, она вызывается один раз перед каждой спецификацией в блоке describe , в котором она вызывается.

Класс TestBed является частью утилит тестирования Angular, и он создает модуль тестирования, аналогичный модулю @NgModul e. Кроме того, вы можете настроить TestBed с помощью метода configureTestingModule . Например, вы можете создать тестовую среду для своего проекта, которая эмулирует фактическое приложение Angular, и затем вы можете вытащить компонент из вашего прикладного модуля и снова присоединить его к этому тестовому модулю.

Метод createComponent возвращает компонент ComponentFixture , дескриптор тестовой среды, окружающей созданный компонент. Фикстура обеспечивает доступ к самому экземпляру компонента и к DebugElement , который является дескриптором элемента DOM компонента.

Как уже упоминалось выше, мы создали фикстуру PastebinComponent , а затем использовали эту фикстуру для создания экземпляра компонента. Теперь мы можем получить доступ к свойствам и методам компонента внутри наших тестов, вызвав имя comp.property_name . Поскольку фикстура также обеспечивает доступ к debugElement , мы теперь можем запросить элементы DOM и селектора.

В нашем коде есть проблема, о которой мы еще не подумали. Наш компонент имеет внешний шаблон и файл CSS. Извлечение и чтение их из файловой системы — это асинхронная активность, в отличие от остальной части кода, которая является синхронной.

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

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

Нам нужно написать тесты со следующими ожиданиями.

  • Компонент Pastebin должен существовать.
  • Свойство title компонента должно отображаться в шаблоне.
  • Шаблон должен иметь таблицу HTML для отображения существующих паст.
  • pastebinService вводится в компонент, и его методы доступны.
  • Пасты не должны отображаться до тех пор, пока не вызывается onInit() .
  • Пасты не отображаются до тех пор, пока обещание в нашем Service не будет разрешено.

Первые три теста легко реализовать.

В тестовой среде Angular автоматически не связывает свойства компонента с элементами шаблона. Вы должны явно вызвать fixture.detectChanges() каждый раз, когда вы хотите связать свойство компонента с шаблоном. Запуск теста должен дать вам ошибку, потому что мы еще не объявили свойство title внутри нашего компонента.

Не забудьте обновить шаблон базовой структурой таблицы.

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

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

Во-первых, импортируйте PastebinService в наш тестовый набор.

Затем добавьте его в массив providers внутри TestBed.configureTestingModule() .

В приведенном ниже коде создается шпион Jasmine, который предназначен для отслеживания всех вызовов метода getPastebin() и возвращает обещание, которое немедленно разрешается в mockPaste .

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

Добавьте следующие тесты в pastebin.component.spec.ts .

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

Во втором spec компонент инициализируется (поскольку вызывается fixture.detectChanges() ), и ожидается, что шпион будет вызван, но шаблон не должен обновляться. Несмотря на то, что шпион возвращает разрешенное обещание, mockPaste пока недоступен. Он не должен быть доступен, если тест не является асинхронным.

В третьем тесте используется функция async() , обсуждавшаяся ранее, для запуска теста в тестовой зоне асинхронного тестирования. async() используется для синхронного тестирования асинхронного. fixture.whenStable() вызывается, когда все ожидающие асинхронные действия выполнены, а затем вызывается второй раунд fixture.detectChanges() для обновления DOM с новыми значениями. Ожидание в финальном тесте гарантирует, что наш DOM обновляется с помощью значений mockPaste .

Чтобы пройти тесты, нам необходимо обновить наш pastebin.component.ts следующим кодом.

Также необходимо обновить шаблон.

Добавление новой пасты

Создайте компонент AddPaste с помощью Angular-CLI. На рисунке ниже изображен дизайн компонента AddPaste.

Логика компонента должна соответствовать следующим спецификациям.

  • Шаблон компонента AddPaste должен иметь кнопку Create Paste.
  • Нажатие кнопки Create Paste должно отображать модальный блок с идентификатором ‘source-modal’.
  • Действие click также должно обновить свойство showModal компонента в true . ( showModal — это логическое свойство, которое становится истинным, когда модальное окно отображается и false, когда оно закрывается.)
  • Нажатие кнопки save вызовет метод addPaste() службы Pastebin.
  • При нажатии кнопки close следует удалить идентификатор ‘source-modal’ из DOM и обновить свойство showModal в false .

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

DebugElement.triggerEventHandler() — единственное новое для вас. Он используется для запуска события клика на элемент кнопки, на который он вызывается. Второй параметр — это объект события, и мы оставили его пустым, так как click() компонента не ожидает его.

Резюме

Вот и все. В этой первой статье мы узнали:

  • как настроить и настроить Jasmine и Karma
  • как написать базовые тесты для классов
  • как проектировать и писать модульные тесты для компонентов
  • как создать базовый сервис
  • как использовать утилиты тестирования Angular в нашем проекте

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

Angular 2 непрерывного развертывания с Дженкинс и отдельным производственным сервером

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

Что меня смущает, так это:

Мы не используем сервер разработки. Мы должны развернуть приложение и его зависимости на реальном производственном сервере. https://angular.io/docs/ts/latest/guide/webpack.html#!#production-configuration

Почему я должен запускать приложение на том же сервере?

В настоящее время я настроил сервер jenkins. Идея состоит в том, что когда происходят изменения (он опрашивает git каждые 15 минут), он тестирует программное обеспечение и при успешном запуске запускает сборку и автоматически развертывает ее на другом сервере. Но с Angular CLI команда build не создает развертываемую папку dist. Вы все еще должны пройти через ng serve.

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

Кто-нибудь реализовал что-то симулированное или есть идея, как это настроить?

2 ответа

Зависит от структуры вашего приложения, стратегии тестирования и развертывания. Angular реализует различные стратегии тестирования, такие как утилиты углового тестирования, jasmin, карма для юнит-тестов и / или транспортир для тестирования конца 2. Подробности смотрите в документах по угловому тестированию .

  1. GitHook или периодическая проверка, чтобы вызвать Дженкинс
  2. Сделать ng build
  3. выполнить карманный тест через карму с помощью ng test
  4. ng e2e испытание конца 2 через транспортир с помощью ng e2e
  5. Разверните Angular 2 App, например, для. страницы github

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

  1. Модульный тест сервера API
  2. API Сервер API / E2E Тесты
  3. API Server развертывание новой среды
  4. В зависимости от стратегии API среда тестирования spawn
  5. построить для теста
  6. нг тест (юнит тест)
  7. нг е2е (конец 2 конец тест)
  8. построить для производства
  9. Развертывание в новой среде
  10. Тестирование новой среды (Test + Healthcheck)
  11. Поменять URL CNAME на новую среду
  12. Прекратить старый API

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

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