Review By: Harmon Avera, Jr.
07/09/2010

"JUnit in Action" is an excellent introduction to using JUnit for testing all parts of a J2EE application. The book presents strategies and solutions to real-world testing scenarios in a readable and useful format. It will help developers implement a comprehensive and automated Java-based testing environment using the philosophy of test driven design.

This book is fairly short (375 pages including index), easy to read, and organized into three major sections: “JUnit Distilled,” “Testing Strategies,” and “Testing Components.”

There are two appendices--one on obtaining the book’s source code and another on using the Eclipse IDE with the testing and automation tools introduced in the book. The book is about twenty-five percent source code, which is simple enough to follow and “real-world” enough to adequately illustrate the testing concepts.

The “JUnit Distilled” section explains the mechanics of JUnit testing--how to obtain and install the JUnit framework, using the core JUnit classes, and the JUnit test execution life-cycle. The author gives JUnit “best-practices” to make test setup, execution, and maintenance easer and also describes a recommended project infrastructure to organize production and test code. The chapter on testing philosophy gives reasons why unit testing is needed, describes where unit testing fits within the typical levels of application development testing, describes test coverage, and introduces test-driven development. The last chapter covers integrating JUnit into the development environment and running JUnit from tools such as Ant, Maven, and Eclipse.

The basic goal of unit testing is to verify correct component functionality in isolation from other components. JUnit alone, however, is insufficient for testing all of a real application. The “Testing Strategies” section explains techniques that allow testing of coarse-grained portions of code in isolation using stubs, finer-grained testing using mock objects, and a strategy for testing J2EE code that runs in a container (Cactus). The author explains advantages and disadvantages for all these strategies.

The author is the creator of the Jakarta Cactus framework and an active member of the Maven, Gump, Struts, and MockObjects development teams. The chapter on using JUnit within the Cactus framework just skimmed the surface of this kind of testing. At the risk of making the book longer, more detail and examples would have been appreciated.

The “Testing Components” section shows how to unit test a J2EE application completely. One chapter describes testing servlets and filters, and another focuses on JSPs and taglibs. There is a chapter on unit testing code that interacts with a database and the final chapter covers EJB unit testing.

The sample code--all of which is available for download--is well annotated to explain key concepts. But actually running the samples often requires obtaining, installing, and configuring outside tools such as Eclipse, Maven, or Cactus. I tried this for several samples and was eventually successful, but I spent almost as much time on tool setup as I did reading the book. This is not a failure of the book; the concepts being tested are complex and require an equally complex test/automation environment.

This is one of the best books on testing with JUnit that I have read. As a developer currently using Java and JUnit, I feel the book provides an excellent review of the design patterns and class structure used in JUnit. I also think it would help anyone understand and implement a Java-based development environment using the test driven design (TDD) philosophy. I especially enjoyed the “Testing Strategies” section for its clear discussion of stubs and mock objects, where each strategy is useful, and how TDD can drive refactoring of the system architecture.