Before writing the production code, developers write automated tests that should pass once the production code is implemented.
Benefits
- Testing is Cheaper: Bugs are expensive, writing tests is cheap.
- High Quality: Writing testable code forces the developer to apply design best practices on the fly, resulting in a testable design.
- Speed and Safety: Code changes that inadvertently introduce new bugs are caught immediately, ensuring correct code behavior at all times, enabling faster overall development.
- Courage: There should be no fear of making changes to the code, such as refactorings. Testing ensures behavioral stability while leaving the implementation open to change.
- Fun: Writing tests before writing production code is more fun because writing production code becomes a challenge to be solved by trying to pass the test. On the other hand, writing production code first makes writing test code boring and feels like an unnecessary burden because we already know how the code works.
Three Laws of TDD
- Write no production code except to pass a failing test.
- Write only enough of a test to demonstrate a failure.
- Write only enough production code to pass the test.
Remarks
- Not compiling is a failure: For example, if the test code requires a function from the production code that has not yet been defined, compilation will fail.
- Workflow: In practice, you start writing a test until it fails, then switch to production until it passes, switch back to test code until it fails, and so on until the feature is complete. This leads to a very fast oscillation of switching between test code and production code. Ideally, the last test passed within the last few minutes. The less the better.
- Debugging: The very short TDD cycles result in far fewer bugs. Bugs may still occur, but they are often trivial and don't require debugging. Experienced developers are capable of debugging, but they do not spend much time on it because of the consistent use of TDD.
Code Coverage
- Incomplete Validation: Passing tests doesn't mean that everything works, just that the tested parts aren't broken. Code coverage is a good first indicator of whether there are enough tests.
- Almost 100% Code Coverage: Code coverage needs to be high, ideally 100%, but in reality the practical achievable is in the high 90s. But code coverage alone is no guarantee of useful tests, so it should be taken with a grain of salt. It is better to look at the tests to get an idea of the actual quality of the test suite.
- Team Metric: TDD is a technical agile practice, and therefore code coverage is a metric for developers to make decisions about, not the business.