- Continuous Integration Tutorial
- CI - Home
- CI - Overview
- CI - Software
- CI - Reducing Risks
- CI - Version Control
- CI - Features
- CI - Requirements
- CI - Building a Solution
- CI - Build Scripts
- CI - Building On the Server
- CI - Checking in Source Code
- CI - Creating a Project in TeamCity
- CI - Defining Tasks
- CI - Build Failure Notifications
- CI - Documentation and Feedback
- CI - Testing
- CI - Inspection
- CI - Database
- CI - Deployment
- CI - Best Practices
- Continuous Integration Resources
- CI - Quick Guide
- CI - Useful Resources
- CI - Discussion
Continuous Integration - Requirements
Following is the list of the most significant requirements for Continuous Integration.
Check-In Regularly − The most important practice for continuous integration to work properly is frequent check-ins to trunk or mainline of the source code repository. The check-in of code should happen at least a couple of times a day. Checking in regularly brings lots of other benefits. It makes changes smaller and thus less likely to break the build. It means the recent most version of the software to revert to is known when a mistake is made in any subsequent build.
It also helps to be more disciplined about refactoring code and to stick to small changes that preserve behavior. It helps to ensure that changes altering a lot of files are less likely to conflict with other people’s work. It allows the developers to be more explorative, trying out ideas and discarding them by reverting back to the last committed version.
Create a Comprehensive Automated Test Suite − If you don’t have a comprehensive suite of automated tests, a passing build only means that the application could be compiled and assembled. While for some teams this is a big step, it’s essential to have some level of automated testing to provide confidence that your application is actually working.
Normally, there are 3 types of tests conducted in Continuous Integration namely unit tests, component tests, and acceptance tests.
Unit tests are written to test the behavior of small pieces of your application in isolation. They can usually be run without starting the whole application. They do not hit the database (if your application has one), the filesystem, or the network. They don’t require your application to be running in a production-like environment. Unit tests should run very fast — your whole suite, even for a large application, should be able to run in under ten minutes.
Component tests test the behavior of several components of your application. Like unit tests, they don’t always require starting the whole application. However, they may hit the database, the filesystem, or other systems (which may be stubbed out). Component tests typically take longer to run.
Keep the Build and Test Process Short − If it takes too long to build the code and run the unit tests, you will run into the following problems.
People will stop doing a full build and will run the tests before they check-in. You will start to get more failing builds.
The Continuous Integration process will take so long that multiple commits would have taken place by the time you can run the build again, so you won’t know which check-in broke the build.
People will check-in less often because they have to sit around for ages waiting for the software to build and the tests to run.
Don’t Check-In on a Broken Build − The biggest blunder of continuous integration is checking in on a broken build. If the build breaks, the developers responsible are waiting to fix it. They identify the cause of the breakage as soon as possible and fix it. If we adopt this strategy, we will always be in the best position to work out what caused the breakage and fix it immediately.
If one of our colleagues has made a check-in and has as a result broken the build, then to have the best chance of fixing it, they will need a clear run at the problem. When this rule is broken, it inevitably takes much longer for the build to be fixed. People get used to seeing the build broken, and very quickly you get into a situation where the build stays broken all of the time.
Always Run All Commit Tests Locally Before Committing − Always ensure that the tests designed for the application are run first on a local machine before running them on the CI server. This is to ensure the right test cases are written and if there is any failure in the CI process, it is because of the failed test results.
Take Responsibility for All Breakages that Result from Your Changes − If you commit a change and all the tests you wrote pass, but others break, the build is still broken. Usually this means that you have introduced a regression bug into the application. It is your responsibility — because you made the change — to fix all tests that are not passing as a result of your changes. In the context of CI this seems obvious, but actually it is not a common practice in many projects.