7.9: Some Advice on Testing
- Page ID
While the mechanics of testing are easy, writing good tests is not. Here is some advice on how to design tests.
Feathers’ Rules for Unit tests. Michael Feathers, an agile process consultant and author, writes1:
A test is not a unit test if:
- it talks to the database,
- it communicates across the network,
- it touches the file system,
- it can’t run at the same time as any of your other unit tests, or
- you have to do special things to your environment (such as editing config files) to run it.
Tests that do these things aren’t bad. Often they are worth writing, and they can be written in a unit test harness. However, it is important to be able to separate them from true unit tests so that we can keep a set of tests that we can run fast whenever we make our changes.
Never get yourself into a situation where you don’t want to run your unit test suite because it takes too long.
Unit Tests vs. Acceptance Tests. Unit tests capture one piece of functionality, and as such make it easier to identify bugs in that functionality. As far as possible try to have unit tests for each method that could possibly fail, and group them per class. However, for certain deeply recursive or complex setup situations, it is easier to write tests that represent a scenario in the larger application; these are called acceptance tests or functional tests. Tests that break Feathers’ rules may make good acceptance tests. Group acceptance tests according to the functionality that they test. For example, if you are writing a compiler, you might write acceptance tests that make assertions about the code generated for each possible source language statement. Such tests might exercise many classes, and might take a long time to run because they touch the file system. You can write them using SUnit, but you won’t want to run them each time you make a small change, so they should be separated from the true unit tests.
Black’s Rule of Testing. For every test in the system, you should be able to identify some property for which the test increases your confidence. It’s obvious that there should be no important property that you are not testing. This rule states the less obvious fact that there should be no test that does not add value to the system by increasing your confidence that a useful property holds. For example, several tests of the same property do no good. In fact they do harm: they make it harder to infer the behaviour of the class by reading the tests, and because one bug in the code might then break many tests at the same time. Have a property in mind when you write a test.
- See http://www.artima.com/weblogs/viewpost.jsp?thread=126923. 9 September 2005