Topic relevant selected content from the highest rated entries, typeset, printed and shipped.

Transcription

1 Topic relevant selected content from the highest rated entries, typeset, printed and shipped. Combine the advantages of up-to-date and in-depth knowledge with the convenience of printed books. A portion of the proceeds of each book will be donated to the Wikimedia Foundation to support their mission: to empower and engage people around the world to collect and develop educational content under a free license or in the public domain, and to disseminate it effectively and globally. The content within this book was generated collaboratively by volunteers. Please be advised that nothing found here has necessarily been reviewed by people with the expertise required to provide you with complete, accurate or reliable information. Some information in this book maybe misleading or simply wrong. The publisher does not guarantee the validity of the information found here. If you need specific advice (for example, medical, legal, financial, or risk management) please seek a professional who is licensed or knowledgeable in that area. Sources, licenses and contributors of the articles and images are listed in the section entitled References. Parts of the books may be licensed under the GNU Free Documentation License. A copy of this license is included in the section entitled GNU Free Documentation License All used third-party trademarks belong to their respective owners.

2 Contents Articles Continuous integration 1 AnthillPro 6 Apache Continuum 8 Apache Gump 9 Bamboo (software) 11 BuildBot 12 BuildMaster 14 CABIE 15 Cascade (software) 15 Comparison of Continuous Integration Software 16 CruiseControl 20 CruiseControl.rb 22 Go (release management) 23 Hudson (software) 25 Jenkins (software) 27 Multi-stage continuous integration 29 Serenity Code Coverage 31 TeamCity 32 ThoughtWorks Studios 33 Tinderbox (software) 35 Extreme Programming 36 Dave Astels 45 Kent Beck 46 Chrysler Comprehensive Compensation System 47 Class-responsibility-collaboration card 49 Code refactoring 50 Mike Cohn 54 Concutest 55 CppUnit 58 csunit 59 Ward Cunningham 61 Daily build 63 Database refactoring 63 DUnit 64

3 Extreme programming practices 65 Extreme project management 70 FireBenchmarks 72 Martin Fowler 75 FUnit 77 Google Guice 78 Itch-scratchware 79 Ron Jeffries 79 JRipples 80 Jtest 83 JUnit 84 Mauve (test suite) 87 Mock object 88 MSTest 91 NMock 91 NUnit 92 NUnitAsp 94 Pair programming 95 PHPUnit 99 PyUnit 100 Regression testing 101 Ken Schwaber 103 SUnit 104 Jeff Sutherland 104 Test-driven development 105 Test-Driven Development by Example 111 TestDox 111 Unit testing 112 unit UquoniTest 118 User story 119 Visual Studio Unit Testing Framework 122 References Article Sources and Contributors 124 Image Sources, Licenses and Contributors 127 Article Licenses

4 License 128

5 Continuous integration 1 Continuous integration In software engineering, continuous integration (CI) implements continuous processes of applying quality control small pieces of effort, applied frequently. Continuous integration aims to improve the quality of software, and to reduce the time taken to deliver it, by replacing the traditional practice of applying quality control after completing all development. Theory When embarking on a change, a developer takes a copy of the current code base on which to work. As other developers submit changed code to the code repository, this copy gradually ceases to reflect the repository code. When developers submit code to the repository they must first update their code to reflect the changes in the repository since they took their copy. The more changes the repository contains, the more work developers must do before submitting their own changes. Eventually, the repository may become so different from the developers' baselines that they enter what is sometimes called "integration hell", [1] where the time it takes to integrate exceeds the time it took to make their original changes. In a worst-case scenario, developers may have to discard their changes and completely redo the work. Continuous integration involves integrating early and often, so as to avoid the pitfalls of "integration hell". The practice aims to reduce rework and thus reduce cost and time. The rest of this article discusses best practice in how to achieve continuous integration, and how to automate this [2] [3] practice. Automation is a best practice itself. Recommended practices Continuous integration as the practice of frequently integrating one's new or changed code with the existing code repository should occur frequently enough that no intervening window remains between commit and build, and such that no errors can arise without developers noticing them and correcting them immediately. [4] Normal practice is to trigger these builds by every commit to a repository, rather than a periodically scheduled build. The practicalities of doing this in a multi-developer environment of rapid commits are such that it's usual to trigger a short timer after each commit, then to start a build when either this timer expires, or after a rather longer interval since the last build. Automated tools such as CruiseControl or Jenkins or Hudson offer this scheduling automatically. Another factor is the need for a version control system that supports atomic commits, i.e. all of a developer's changes may be seen as a single commit operation. There is no point in trying to build from only half of the changed files. Maintain a code repository This practice advocates the use of a revision control system for the project's source code. All artifacts required to build the project should be placed in the repository. In this practice and in the revision control community, the convention is that the system should be buildable from a fresh checkout and not require additional dependencies. Extreme Programming advocate Martin Fowler also mentions that where branching is supported by tools, its use should be minimised. [4] Instead, it is preferred that changes are integrated rather than creating multiple versions of the software that are maintained simultaneously. The mainline (or trunk) should be the place for the working version of the software.

6 Continuous integration 2 Automate the build A single command should have the capability of building the system. Many build-tools, such as make, have existed for many years. Other more recent tools like Ant, Maven, MSBuild or IBM Rational Build Forge are frequently used in continuous integration environments. Automation of the build should include automating the integration, which often includes deployment into a production-like environment. In many cases, the build script not only compiles binaries, but also generates documentation, website pages, statistics and distribution media (such as Windows MSI files, RPM or DEB files). Make the build self-testing Once the code is built, all tests should run to confirm that it behaves as the developers expect it to behave. Everyone commits to the baseline every day By committing regularly, every committer can reduce the number of conflicting changes. Checking in a week's worth of work runs the risk of conflicting with other features and can be very difficult to resolve. Early, small conflicts in an area of the system cause team members to communicate about the change they are making. Many programmers [5] recommend committing all changes at least once a day (once per feature built), and in addition performing a nightly build. Every commit (to baseline) should be built The system should build commits to the current working version in order to verify that they integrate correctly. A common practice is to use Automated Continuous Integration, although this may be done manually. For many, continuous integration is synonymous with using Automated Continuous Integration where a continuous integration server or daemon monitors the version control system for changes, then automatically runs the build process. Keep the build fast The build needs to complete rapidly, so that if there is a problem with integration, it is quickly identified. Test in a clone of the production environment Having a test environment can lead to failures in tested systems when they deploy in the production environment, because the production environment may differ from the test environment in a significant way. However, building a replica of a production environment is cost prohibitive. Instead, the pre-production environment should be built to be a scalable version of the actual production environment to both alleviate costs while maintaining technology stack composition and nuances.

7 Continuous integration 3 Make it easy to get the latest deliverables Making builds readily available to stakeholders and testers can reduce the amount of rework necessary when rebuilding a feature that doesn't meet requirements. Additionally, early testing reduces the chances that defects survive until deployment. Finding errors earlier also, in some cases, reduces the amount of work necessary to resolve them. Everyone can see the results of the latest build It should be easy to find out whether the build breaks and, if so, who made the relevant change. Automate deployment Most CI systems allow the running of scripts after a build finishes. In most situations, it is possible to write a script to deploy the application to a live test server that everyone can look at. A further advance in this way of thinking is Continuous Deployment, which calls for the software to be deployed directly into production, often with additional automation to prevent defects or regressions. [6] History Continuous Integration emerged in the Extreme Programming (XP) community, and XP advocates Martin Fowler and Kent Beck first wrote about continuous integration circa Fowler's paper [7] is a popular source of information on the subject. Beck's book Extreme Programming Explained, [8] the original reference for Extreme Programming, also describes the term. Advantages and disadvantages Advantages Continuous integration has many advantages: when unit tests fail or a bug emerges, developers might revert the codebase back to a bug-free state, without wasting time debugging developers detect and fix integration problems continuously - avoiding last-minute chaos at release dates, (when everyone tries to check in their slightly incompatible versions). early warning of broken/incompatible code early warning of conflicting changes immediate unit testing of all changes constant availability of a "current" build for testing, demo, or release purposes immediate feedback to developers on the quality, functionality, or system-wide impact of code they are writing frequent code check-in pushes developers to create modular, less complex code metrics generated from automated testing and CI (such as metrics for code coverage, code complexity, and features complete) focus developers on developing functional, quality code, and help develop momentum in a team

8 Continuous integration 4 Disadvantages initial setup time required well-developed test-suite required to achieve automated testing advantages large-scale refactoring can be troublesome due to continuously changing code base hardware costs for build machines can be significant Many teams using CI report that the advantages of CI well outweigh the disadvantages. [9] The effect of finding and fixing integration bugs early in the development process saves both time and money over the lifespan of a project. Software To support continuous integration, software tools such as automated build software can be employed. Software tools for continuous integration include: AnthillPro continuous integration server by Urbancode Apache Continuum continuous integration server supporting Apache Maven and Apache Ant. Supports CVS, Subversion, Ant, Maven, and shell scripts Apache Gump continuous integration tool by Apache Automated Build Studio proprietary automated build, continuous integration and release management system by AutomatedQA Bamboo proprietary continuous integration server by Atlassian Software Systems BuildBot Python/Twisted-based continuous build system BuildMaster proprietary application lifecycle management and continuous integration tool by Inedo CABIE - Continuous Automated Build and Integration Environment open source, written in Perl; works with CVS, Subversion, AccuRev, Bazaar and Perforce Cascade proprietary continuous integration tool; provides a checkpointing facility to build and test changes before they are committed codebeamer proprietary collaboration software with built-in continuous integration features CruiseControl Java-based framework for a continuous build process CruiseControl.NET.NET-based automated continuous integration server CruiseControl.rb - Lightweight, Ruby-based continuous integration server that can build any codebase, not only Ruby, released under Apache Licence 2.0 ElectricCommander proprietary continuous integration and release management solution from Electric Cloud FinalBuilder Server proprietary automated build and continuous integration server by VSoft Technologies Go proprietary agile build and release management software by Thoughtworks Jenkins (formerly Hudson); MIT-licensed, written in Java, runs in servlet container, supports CVS, Subversion, Mercurial, Git, StarTeam, Clearcase, Ant, NAnt, Maven, and shell scripts Software Configuration and Library Manager software configuration management system for z/os by IBM Rational Software QuickBuild - proprietary continuous integration server with free community edition featuring build life cycle management and pre-commit verification. TeamCity proprietary continuous-integration server by JetBrains with free professional edition Team Foundation Server proprietary continuous integration server and source code repository by Microsoft Tinderbox Mozilla-based product written in Perl Rational Team Concert proprietary software development collaboration platform with built-in build engine by IBM including Rational Build Forge See comparison of continuous integration software for a more in depth feature matrix.

9 Continuous integration 5 Further reading Duvall, Paul M. (2007). Continuous Integration. Improving Software Quality and Reducing Risk. Addison-Wesley. ISBN References [1] Cunningham, Ward (05 Aug 2009). "Integration Hell" ( c2. com/ cgi/ wiki?integrationhell). WikiWikiWeb.. Retrieved 19 Sept [2] Brauneis, David (01 January 2010). "[OSLC ( open-services. net/ pipermail/ community_open-services. net/ 2010-January/ html) Possible new Working Group - Automation"]. open-services.net Community mailing list.. Retrieved 16 February [3] Taylor, Bradley. "Rails Deployment and Automation with ShadowPuppet and Capistrano" ( blog. railsmachine. com/ articles/ 2009/ 02/ 10/ rails-deployment-and-automation-with-shadowpuppet-and-capistrano/ ).. [4] Fowler, Martin. "Continuous Integration" ( martinfowler. com/ articles/ continuousintegration. html#practicesofcontinuousintegration).. Retrieved [5] Wiki:ContinuousIntegration [6] See / radar. oreilly. com/ 2009/ 03/ continuous-deployment-5-eas. html and / timothyfitz. wordpress. com/ 2009/ 02/ 10/ continuous-deployment-at-imvu-doing-the-impossible-fifty-times-a-day/ [7] Fowler, Martin. "Continuous Integration" ( www. martinfowler. com/ articles/ continuousintegration. html).. [8] Beck, Kent (1999). Extreme Programming Explained. ISBN [9] Richardson, Jared (September 2008). "Agile Testing Strategies at No Fluff Just Stuff Conference" ( www. nofluffjuststuff. com). Boston, Massachusetts.. External links Continuous integration ( www. martinfowler. com/ articles/ continuousintegration. html) by Martin Fowler (an introduction) Continuous Integration at the Portland Pattern Repository ( www. c2. com/ cgi/ wiki?continuousintegration) (a collegial discussion) Cross platform testing at the Portland Pattern Repository ( c2. com/ cgi/ wiki?crossplatformtesting) Continuous Integration Server Feature Matrix ( confluence. public. thoughtworks. org/ display/ CC/ CI+ Feature+ Matrix) (a guide to tools) Continuous Integration: The Cornerstone of a Great Shop ( www. methodsandtools. com/ archive/ archive. php?id=42) by Jared Richardson (an introduction) A Recipe for Build Maintainability and Reusability ( jayflowers. com/ joomla/ index. php?option=com_content& task=view& id=26) by Jay Flowers Continuous Integration anti-patterns ( www. ibm. com/ developerworks/ java/ library/ j-ap11297/ ) by Paul Duvall Extreme programming ( www. extremeprogramming. org/ rules/ integrateoften. html)

10 AnthillPro 6 AnthillPro AnthillPro Developer(s) Urbancode Stable release 3.7 / Sep, 2009 Operating system Type License Website Cross-platform Continuous Integration Proprietary [1] AnthillPro is a continuous integration server from Urbancode. Released in 2001, AnthillPro is one of the original Continuous Integration servers. Currently in its third generation, it supports distributed as well as cross-platform builds in.net, Java, C/C++ and other languages. Additional information is available on the AnthillPro website [1]. History The original Anthill was a simple continuous integration server released in 2001 and still available today. Along with tools such as CruiseControl it helped provide the tooling backbone of continuous integration practices. In 2002 Urbancode released the first commercial edition of AnthillPro. Unlike CruiseControl which at the time was focused purely on providing developers feedback about the health of their builds, AnthillPro was focused on build management and using the results of one project's build as a dependency for other projects. In 2006, Urbancode released the third generation of AnthillPro. This complete rewrite added support for distributed builds, and control over post build lifecycle. Unlike most CI servers that are build centric, AnthillPro began to use the build only as an initial test and to create binary artifacts that are then tested, deployed and promoted through a lifecycle on their way to production release. Continuous Integration The practice of continuous integration is one where developers integrate their changes to a common code line frequently (generally at least once a day) and those integrations are rapidly verified by tests. AnthillPro supports this practice by monitoring (or listening to) the organization's various source control systems and triggering a build when it detects a developer commit. The build provides the first (and usually the most critical) test that verifies the integration. Once the build is complete, AnthillPro captures the build product so that secondary processes like functional tests or deployments to manual QA areas can act on the build. As additional tests are executed, the team can gain greater confidence in the changes.

11 AnthillPro 7 Reporting AnthillPro can gather any reports generated by build or test process and display them on the AnthillPro server's web interface for review by developers, testers or management. Deployment Automation AnthillPro supports automated deployment of a build to a user-configured environment (for example: DEV, QA, STAGE, PROD). Administrators can set up gates between each environment, requiring manual user intervention and providing an audit trail. Role-based security can be set up to control what roles (and thus what users) can deploy to which environment. Release Management AnthillPro is designed to support the release management team's efforts. It provides an audit trail linking a build back to source code and to every deployment and test executed against that build. This helps a release manager asses the readiness of a build to enter production. AnthillPro encourages teams to use a similar automated process for production deployments to those used in earlier environments lowering the risk in a deployment through testing the process. External links AnthillPro Blog [2] References [1] / www. anthillpro. com/ [2] / www. anthillpro. com/ blogs/

12 Apache Continuum 8 Apache Continuum Apache Continuum Developer(s) Apache Software Foundation Stable release / April 6, 2010 Preview release (Beta) / May 6, 2010 Written in Operating system Type License Website Java Cross-platform Continuous integration Apache 2.0 licence / continuum. apache. org Apache Continuum, a partner to Apache Maven, is a continuous integration server, which runs builds on a configurable schedule. Much like CruiseControl, Continuum s developers when the build is broken, requesting that the culprit fix the problem. To add a project to Continuum, point to the pom.xml in the source control system, and it automatically does the rest: Check out from source control Run clean build Deploy to integration server Run unit tests External links / continuum. apache. org/

13 Apache Gump 9 Apache Gump Apache Gump Developer(s) Written in Operating system Type Apache Software Foundation Python Cross-platform Continuous integration License Apache License 2.0 Website / gump. apache. org Apache Gump is an open source continuous integration system, which aims to build and test all the open source Java projects, every night. Its aim is to make sure that all the projects are compatible, at both the API level and in terms of functionality matching specifications. It is hosted at gump.apache.org [1], and runs every night on the official Sun JVM. Usage To join Gump, a project must provide two XML files. One describes how to access the live CVS or Subversion repository; the other what to build from the repository, and the artifacts produced. Each project can be dependent upon other projects; these dependencies are declared so that Gump knows the correct order to build things. Gump can build shell script, Ant and Maven 1 projects, setting up the classpath appropriately. Ant and Maven 1 have special hooks built in them to give Gump complete control of the classpaths used to build and test the applications. This allows Gump to build the projects against the latest versions, even if the project's own build files have hard coded dependencies against static libraries in their own CVS or subversion repository. If a build on Gump is successful, then a report is placed on the site, and all projects that declare themselves dependencies are eligible to be built. If a project fails to build, error reports are published, an error is sent, and all dependent projects are blocked from building. History Gump was created by Sam Ruby, based on his experience in the Perl community. It was originally written in Java Gump 3 is a complete rewrite in Python. It is the live version. Limitations There is no way to force developers to act on the you broke the build , other than informal peer pressure. Until Maven support is added, there is a large swathe of Java projects that cannot be built. All projects downstream of these are only able to build on gump with static versions of the previous releases, removing one of the key features of the project: to build and test against nightly code. Diagnosing why something has failed can be hard, because developers on projects built by gump do not have access to the machine, only the nightly status reports. Because it is an open service for all open source projects, the project has invested less effort in making it easy to bring up a new gump installation. This makes private use harder. Of particular note, there is no automated way to provision a gump server with all the static JAR files that many projects depend upon.

14 Apache Gump 10 If a foundational project such as Ant, Xerces or JUnit fails to build, then most of Gump is blocked until a fix is made. Depending on the nature of the failure, this can be a quick fix, or it could take longer. [2] References [1] / gump. apache. org [2] BATCH: All dressed up, with nowhere to go ( mail-archives. apache. org/ mod_mbox/ gump-general/ mbox/ < AB4318@vmgump. apache. org>) External links Apache Gump ( / gump. apache. org/ )