Patterns oriented approach to testing
If you are a patterns buff you will probably love this book. It takes a Gang of Four Design Patterns approach to various types of testing, starting with unit testing in the abstract, but then covering use of mock objects, test database, exception testing and other areas. It's a wide coverage area but the patterns remain fairly abstract. For those of a more pragmatic mind you should look at Manning's JUnit Recipes.
A Welcome Take on Patterns
"Java Testing Patterns" is a welcome take on maximizing the use of patterns in your Java development and testing process. The book begins with a very crisply written description of what testing is and what it is not. There are some absolutely vital concepts in this chapter that anyone responsible for testing code should read and understand.
The next chapters each describe the concepts involved in a particular type of testing: unit, integration, end-to-end, and database. These chapters do an excellent job of isolating discussing the purpose, process, and pitfalls involved in each type of testing.
From there the book dives into the actual patterns. These chapters are full of good testing advice, and they contain code and sample applications that demonstrate a realistic employment of each pattern. My only nit with this book is that a couple chapters are not quite as well written as others (I thought Self-Shunt would have benefitted from additional description and analysis).
The book also does an excellent job of placing patterns within the entire development/testing context; it describes not only the patterns, but also the tools and processes you need to use with these patterns to fully test your application.
This is not your usual patterns book, which makes it a welcome addition to the literature.
Great practical patterns book
I've only read a couple patterns books, including the classic GoF. The only thing I don't like about the GoF book is that the explanations are very academic and the examples are far from useful in my work.
What I like about this Java testing patterns book is that it is extremely practical and therefor useful. For me it bridged the gap from a highly theoretical treatment of patterns to a detailed understanding of how to really employ patterns while coding in Java. The examples are rich and detailed and reflect the kind of development work I do (ie the examples are not simple strawmen set up to demonstrate an isolated concept).
Also, this book does a very good job of presenting a selection of patterns that you are likely to use *in combination* and with popular development tools. For instance the book not only describes the Mock Object, MockDAO, and Test Database patterns but also explains best practices for using DbUnit, JUnit, and other tools when testing code written with these patterns. I'm extremely thankful for that advice which is the kind of thing I've not found anywhere else.
The code actually works (amazing!) and is very useful. The formatting is at times a little odd in the book but it is defintitely readable.
I also appreciate the size of the UML diagrams and their readability...thank you for not squeezing them all on one page!
The only downside to this book is that I wish it covered more patterns. Hopefully the authors will cover more in the next edition or release more material on the Web site.
poor editing, not worth buying
"Java Testing Patterns" is one of those books where it appears nobody edited. Java class/method names and acronyms are used in lower/upper case interchangeably. Writing class names in all lowercase in a Java book doesn't inspire much confidence in the accuracy of the rest of the book. There are many typos and inconsistencies that make it hard to read.
The formatting is also very poor. The code looks good in Eclipse, but not in the book. Lines wrap without indentation. Similarly, UML diagrams are randomly split into pages. They are supposed to be on the web, but they aren't yet.
The intro states a target audience of "software engineers, engineering managers and software testers." This book is heavily reliant on reading code. After the first few chapters, I don't think managers or testers would benefit.
Speaking of code, I think the code is too verbose and complicated - especially for a book. A few times, a simple JavaBean's source takes up one to two pages. One DAO takes up 12 pages. There is a test method with 16 branches. These examples make understanding quite difficult.
Now as for what the book does well. There are five good chapters on patterns. However, two are in essence the Factory and State patterns. The appendices are very good too. I wouldn't buying a book for three chapters and some appendices. Other books cover the material better. I would not recommend this book in its current edition.
