{"id":8557,"date":"2013-01-17T09:22:49","date_gmt":"2013-01-17T09:22:49","guid":{"rendered":"https:\/\/blog.jetbrains.com\/webide\/?p=4777"},"modified":"2013-01-17T14:32:42","modified_gmt":"2013-01-17T14:32:42","slug":"continuous-integration-for-php-using-teamcity","status":"publish","type":"webide","link":"https:\/\/blog.jetbrains.com\/fr\/webide\/2013\/01\/continuous-integration-for-php-using-teamcity","title":{"rendered":"Continuous Integration for PHP using TeamCity"},"content":{"rendered":"

\"\"<\/a><\/a>If you have multiple team members, you should be doing Continuous Integration (CI). By building the desired output artifacts on a frequent basis and analyzing their quality using unit tests and code coverage, you will find that there are fewer integration problems in working on a software project.<\/p>\n

In this blog post, we\u2019ll be using the open-source PHP project PHPExcel<\/a> as a sample project to set up Continuous Integration using TeamCity<\/a>. This project features a large amount of code, PHPUnit tests and uses Phing to create build artifacts. We\u2019ll use TeamCity to get this process completely automated and ready for immediate feedback once the source code on GitHub changes.<\/p>\n

<\/p>\n

Installing the TeamCity environment<\/h2>\n

TeamCity can be downloaded and installed<\/a> on various platforms such as Windows, Mac OSX and Linux. The installer contains two applications: the TeamCity web interface which we will be using to set up our continuous integration process and a build agent, a small service that listens for build commands and can run the CI configuration. Every TeamCity setup can have one or more build agents on one or more machines.<\/p>\n

Since installing TeamCity on various platforms is a bit different, we\u2019ll not go into detail on the installation. We have an installation guide<\/a> available that can be used to get TeamCity up and running.<\/p>\n

Before setting up our CI process, we\u2019ll assume that you already have a PHP environment with PEAR<\/a>, PHPUnit<\/a> and Phing<\/a> installed. If not, now is the time. You can find more info on installing TeamCity on Linux and\u00a0on configuring your PHP environment through this blog post<\/a>.<\/p>\n

<\/a><\/p>\n

Setting up the project<\/h2>\n

After installing TeamCity, log in via the web interface. The first thing you will see after logging in is the projects overview. This screen will show you the various projects you have configured in TeamCity and gives immediate feedback on the status of these projects.<\/p>\n

\"\"<\/a><\/p>\n

Since we\u2019re on a clean install, let\u2019s create a project. Under Administration |\u00a0Projects<\/em>,\u00a0click the Create project <\/em>button. The first thing we\u2019ll have to do is give the project a name and a description.<\/p>\n

\"\"<\/a><\/p>\n

The next thing to do is creating a build configuration. This can be anything meaningful to your team: a build configuration per branch (although it\u2019s better to use TeamCity\u2019s feature branching<\/a>), a build configuration for code and a separate one for documentation, or a build configuration per release.<\/p>\n

We\u2019ll create a build configuration named \u201cMain\u201d. Every build will be named with a number. This can be anything you want but since PHPExcel is currently in the 1.7.6.x range, let\u2019s go with \u201c1.7.6.{0}\u201d. TeamCity will automatically increment the revision version for every build. The build counter starts at 1, so our first build will be versioned 1.7.6.1.<\/p>\n

PHPExcel\u2019s build script creates build artifacts under the \u201dbuild\/release\/*\u201d folder. TeamCity can grab these from the configured artifact paths and display them in the TeamCity web interface once the build is finished. Don\u2019t worry: we can configure artifact paths later.<\/p>\n

\"\"<\/a><\/p>\n

In the next step, we have to provide Version Control System (VCS) settings. TeamCity supports a variety of version control systems such as Git, Mercurial, CVS, Subversion and many more. We\u2019ll go with Git and configure TeamCity to fetch sources from https:\/\/github.com\/maartenba\/PHPExcel.git<\/a>. Note that if required we could add a number of options to the VCS settings: which branch to clone, whether to include submodules, at what interval TeamCity should check for changes, and so on.<\/p>\n

\"\"<\/a><\/p>\n

After adding the version control we can start adding build steps. We\u2019ll start with…<\/p>\n

Unit tests<\/h2>\n

As a first step in the build process we\u2019re creating, we want to make sure all tests are green. Whenever there is a failing unit test, we want to fail the entire build and not provide any build artifacts. TeamCity comes with a number of predefined build steps for Java and .NET, but since we\u2019re on PHP we\u2019ll have to select the Command Line<\/em> build runner.<\/p>\n

\"\"<\/a><\/p>\n

Since we want to run unit tests, the custom script could read something like phpunit -c phpunit.xml<\/em> to run the PHPUnit configuration that\u2019s in PHPExcel\u2019s source code. Since there are a lot of unit tests to be run, why not report test results to TeamCity real-time so that our team members can see what\u2019s happening? I\u2019ve created a wrapper around PHPUnit which uses service messages<\/a> to report build results. You can download this wrapper here <\/a>and locate it somewhere on the build agent or\u00a0have the build agent download it from the above GitHub repository directly using a second VCS root. If you want to use standard PHPUnit, add an XML report processing\u00a0build feature which processes PHPUnit\u2019s JUnit compatible XML report. This can be done after storing the current build step.<\/p>\n

We can now run our build: click the Run… <\/em>button to start a build, go to the project dashboard and watch in real time which unit tests are passing or failing.<\/p>\n

\"\"<\/a><\/p>\n

Congratulations on your first build for a PHP project using TeamCity! Now let\u2019s add some more build steps since just running unit tests is only the first step…<\/p>\n

Build using Phing<\/h2>\n

Our next build step will be invoking Phing<\/a>, a PHP project build system or build tool based on\u00a0\u200bApache Ant<\/a>. PHPExcel comes with a Phing build script which we\u2019ll invoke after all unit tests have passed. Find the Build Steps<\/em> again by clicking the Edit Configuration Settings <\/em>link at the top-right in this screen.<\/p>\n

Next, add a new Command Line <\/em>build step. This time we\u2019ll invoke Phing\u2019s command-line tool and pass some parameters to it:<\/p>\n

phing -f build\\build.xml -DpackageVersion=%system.build.number%\r\n    -DreleaseDate=CIbuild -DdocumentFormat=doc release-standard<\/pre>\n
PHPExcel has four build targets defined (release-standard<\/em>,\u00a0release-documentation<\/em>, release-pear<\/em> and release-phar<\/em>), all providing different build artifacts. The release-standard\u00a0target which we\u2019ve now specified at the command line is the default build for PHPExcel which generates a ZIP file containing all source code and phpDocumentor<\/a> output.<\/p>\n
We are also passing Phing the current build number from TeamCity using Phing\u2019s -D<\/em> command line switches. The build script can use these to create the correct file names. TeamCity actually provides a lot of variables you can use, including source control details like revision number and so on.<\/p>\n
\"\"<\/a><\/p>\n
If you haven\u2019t configured the artifact paths while creating our build project, it\u2019s best to do so now (see \u201cSetting up the project<\/a>\u201d). We want to make sure that the ZIP file generated in this build script is available from TeamCity\u2019s web interface.<\/p>\n
Try running another build. You\u2019ll now see that unit tests are being run and afterwards the Phing build script is being run. From the project dashboard, navigate to the build that\u2019s running and open the Artifacts <\/em>tab. Once the entire build is completed, you will find the ZIP file generated by the Phing build script is now available for download. The best thing is that you can even configure guest access<\/a> to TeamCity so the users of your project can come and download continuous integration artifacts.<\/p>\n
\"\"<\/a><\/p>\n
Nice, isn\u2019t it? Let\u2019s see what else is possible. How about…<\/p>\n
Code Coverage<\/h2>\n
The first build step we created was running unit tests using PHPUnit. The nice thing about PHPUnit is that it can provide code coverage information as well, nicely formatted as an HTML report. What\u2019s even nicer is that TeamCity can display HTML reports on a custom tab in the build results.<\/p>\n
Let\u2019s first make sure code coverage is enabled. Edit the first build step (running PHPUnit) and make sure it uses PHPExcel\u2019s phpunit-cc.xml <\/em>configuration file for configuring PHPUnit. This configuration file which is specific to PHPExcel outputs its code coverage report in the  unitTests\/codeCoverage<\/em> folder. While it is possible to add all generated files to TeamCity as a build artifact, it\u2019s cleaner to ZIP that entire folder and make it available as one single file. We can have TeamCity create this ZIP file for us by using a special artifact path pattern<\/a>! Edit the build artifacts again and make sure the following two artifact paths are specified:<\/p>\n
build\/release\/*%system.build.number%*\r\nunitTests\/codeCoverage => coverage.zip<\/pre>\n
That\u2019s right: we can make TeamCity create a ZIP archive from the unitTests\/codeCoverage<\/em> path by simply using =><\/em> and specifying a target artifact name.<\/p>\n
Next, navigate to Administration <\/em>and edit the PHPExcel – CI <\/em>project. Under Report Tabs<\/em>, we can add a custom report tab and point it to a file in the ZIP file we\u2019re creating every build.<\/p>\n
\"\"<\/a><\/p>\n
Run the build again.\u00a0Once it completes, the Artifacts <\/em>tab should contain the coverage.zip<\/em> file we\u2019ve just created. Next to that, there should now be an additional tab Code Coverage<\/em> available which displays code coverage results:<\/p>\n
\"\"<\/a><\/p>\n
\"\"<\/a><\/p>\n
Using the same approach (zipping HTML files and adding a custom report tab), it\u2019s very easy to add additional build reporting and display results from PHP mess detector, PHPLint<\/a> or even have a tab available which displays phpDocumentor<\/a> contents.<\/p>\n
What else is there?<\/h2>\n
TeamCity is a very versatile product. In this post, we\u2019ve seen that while there is no PHP support out-of-the-box, it is very easy to configure Continuous Integration for PHP with it. Next to this flexibility, a number of additional reports are available. For example, build history is tracked and you can check what happened in previous builds:<\/p>\n
\"\"<\/a><\/p>\n
Another interesting tab is Statistics<\/em>. This tab shows general build statistics such as success rate, build duration and test count in a graphical format.<\/p>\n
\"\"<\/a><\/p>\n
Another thing I like when reviewing build results is the possibility to dive into the changes that are included in a specific build. For example, we can get a global overview of all changes:<\/p>\n
\"\"<\/a><\/p>\n
Note that we can drill down in the changes and inspect in which build a specific change was included for the first time or diff\u00a0with a previous version:<\/p>\n
\"\"<\/a><\/p>\n
When working with an environment based on the IntelliJ Platform, like PhpStorm or WebStorm, it\u2019s easy to link TeamCity with the IDE. After installing the TeamCity plugin into your IDE<\/a> you\u2019ll notice that there are some useful little things like opening a unit test in the IDE from within TeamCity:<\/p>\n
\"\"<\/a><\/p>\n
Feel free to experiment with TeamCity<\/a>: it\u2019s 100% free for up to 20 build configurations!<\/p>\n
Develop with pleasure!<\/em>
\n\u2013 JetBrains Web IDE Team<\/em><\/p>\n","protected":false},"author":118,"featured_media":0,"comment_status":"open","ping_status":"open","template":"","categories":[808,2347],"tags":[379,743,190,45,359,72,443],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/webide\/8557"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/webide"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/types\/webide"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/users\/118"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/comments?post=8557"}],"version-history":[{"count":0,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/webide\/8557\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media?parent=8557"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/categories?post=8557"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/tags?post=8557"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/cross-post-tag?post=8557"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}