I was reminded of the power of automated testing by this talk by Rod Johnson, the original creator of the Spring framework.
It is a little dated (2007), but what he says is still highly relevant. The content mainly covers things we should already be practicing as developers, but it’s worth a reminder every now and then. Following are the main points I took away from the presentation.
First, there are several key concepts to bear in mind. These came up again and again in the talk:
- Test Early, Test Often
- Test at Multiple Levels
- Automate Everything
Unit Testing
As developers, we know we should do lots of unit testing. We do this by targeting classes in isolation, and mocking out collaborators.
To be clear, unit testing is looking at your class “in the lab”, not in the real world. A unit test should not interact with Spring, or the database, or any infrastructure concerns. Therefore, unit tests should run extremely fast: of the order of tens of thousands of tests per minute. It shouldn’t be painful to run a suite of unit tests.
Do Test-Driven Development. Not only does this help you discover APIs organically, but it’s a way of relieving stress. Once a defect is detected, you can write a failing test for it, then come back to fix it later on. The failing test is a big red beacon reminding you to finish the job.
Use tools such as Clover to measure the code-coverage of your tests. 80% is a useful rule of thumb. Any more than this, and the benefits are not worth the cost. Any less than 70%, and the risk of defects becomes significant.
Integration Testing
We should also do integration testing - for example to ensure our application is wired up correctly, and SQL statements are correct.
But how many of us are still clicking through flows in a browser? Ad-hoc testing by deploying to an application server and clicking around is very time-consuming and error-prone. If it’s not automated, chances are it won’t happen. If it doesn’t happen or occurs late in the project cycle, defects will be expensive to fix.
So instead, maintain a suite of integration tests. It should be possible to run hundreds or thousands of these per minute and again, they should be automated so they just happen.
Use Spring’s Integration Testing support. Among other things, this provides superclasses which can perform each test in a transaction, and roll it back upon completion to avoid side-effects across tests. This avoids the need to re-seed the database upon each test.
Another benefit of Spring Integration Testing is that the Spring context is cached between tests. This means that the highly expensive construction of the Hibernate SessionFactory (if you use one) only happens once. This context caching is usually impossible, because the test class is reconstructed by JUnit upon each test.
Remember to test behaviour in the database. Stored procedures, triggers, views - regressions at the schema level should be caught early, in an automated fashion.
Integration tests should be deterministic - that is, they should not rely on the time of day, or random side-effects from previous tests. This should be obvious, but when testing concerns such as scheduling, this can become difficult. One strategy is to abstract out the concept of the current time of day. This could be done by replacing a literal call to System.getCurrentTime() with a call to a private method. This method would check for an override property set only during testing, the existence of which would cause a static Date to be returned to your application code.
Performance Testing
This should begin as early as possible. Use scriptable frameworks such as The Grinder, so performance testing is cheap to execute early and often. This means performance regressions will be caught immediately, for example if somebody drops an index.
Many performance problems are due to lack of understanding of ORM frameworks. Learn to use your framework, for example relating to fetch strategies. A common idiom is to eagerly fetch a collection of child entities up-front, rather than invoking the “N+1 Selects” problem by lazily loading each child record in a loop. Additionally, consider evicting objects from the Session at appropriate points, to avoid memory overhead and to prevent the need for dirty-checking upon flushing of the Session.
One strategy to dive deeply into database performance concerns, is to enable SQL logging in your persistence framework. A large number of SELECT statements per-use case will quickly become apparent.
Conclusion
Developers should Invest time into writing automated tests at multiple levels. Even with a dedicated QA team in place, defects will only be caught early and fixed cheaply through an intelligent approach to automation. Along with adoption of best practices such as Dependency Injection and separation of concerns, the industry has many tools on offer to make comprehensive testing cheap and easy.
References / Further Reading