Browse Books

Reviewer: Fernando Berzal

Clarity and precision are the keys to improving communication between the people who need a software system and the people who must develop it. Clear and simple structures, such as tables to capture requirements, can help. Moreover, automating tests from these tabular data collections can provide immediate feedback and greatly support iterative software development processes (such as the agile development methodologies that are currently popular). These two observations are the cornerstone of Mugridge and Cunningham's framework for integrated tests (Fit). Fit was developed and released in 2002 by Cunningham with the goal of providing a technique nonprogrammers could easily employ to specify business requirements, and a tool programmers could resort to in order to automatically test such requirements. Technical and nontechnical members of a project can thus collaborate to ensure the business value of software. Fit helps close the "gap between the software that [is] written and the software the user [wants]" (an insightful aphorism by Dave Thomas). This book actually contains two separate books written for different audiences. The first half of the book is written for nonprogrammers, such as end users or customers. It shows us how to define the functionality of a system using tabular data (Fit tables). The second half is written for the programmers who will prepare the fixtures that mediate between the Fit tables and the system being tested. Fit fixtures interpret the data in Fit tables and automate system testing. In the first half of the book, readers will learn how to prepare Fit tables based on business rules. Nonprogrammers can read and write them, a feature that makes Fit stand apart from other popular testing tools. A variety of Fit tables can be prepared to test a system, from those containing traditional test cases (where actual inputs and desired outputs are specified to check calculations) to flexible tables describing scenarios that detail the complete workflow of business processes. The authors clearly describe how tests can be prepared as Excel spreadsheets or Hypertext Markup Language (HTML) tables, show us how to organize large test suites, and introduce a wiki-based interface to Fit named FitNesse, which can be useful for creating, managing, and running Fit tests. A case study is used to illustrate how to incorporate Fit into the development process. This part focuses on agile approaches, describing how Fit tables evolve over time (both in content and structure), how "story tests" can be used in test-driven development, and how "smells" (signs of trouble) indicate that Fit tables should be refactored. The second half of the book focuses on the development of the Fit fixtures needed by the examples scattered throughout the first half of the book. The fixture of a Fit table determines how the table will be used in automated testing. Ten short chapters provide a good tutorial on writing fixtures, which are usually derived by inheritance from core fixtures. Readers will also learn the basics of writing custom fixtures. Some issues that arise in connecting tests to the system being tested are also discussed. The authors briefly address common techniques in testing legacy systems, such as testing through the user interface, reducing dependencies among components, and introducing mock objects to facilitate testing. Finally, a short section is devoted to Fit internals, although this will only be relevant for readers interested in extending Fit (for instance, those who have test data in other formats that they don't want to convert to HTML tables). Here, the authors skim through model-based test generation, but they provide only a shallow description of a very valuable Fit application. I have no doubt that Fit is a useful tool. However, even though the authors do a great job motivating the reasons for using Fit, they tend to mix the benefits of using their particular tool with those coming from the application of good development practices. This is particularly evident in chapter 36, "Closing for Programmers at RPS," where the change in attitude and morale at the fictitious RPS company cannot be directly attributed to Fit in particular, but to a host of extreme programming practices that, when combined, produce the intended "getting fit" effect. In short, I would recommend this tutorial-style book to anyone interested in facilitating communication among businesspeople and software developers in the preparation of acceptance tests. However, its manifest tool orientation detracts from the more in-depth discussions of the truly relevant topics that would let this book stand the test of time. In any case, the book is clearly written and easy to follow, and its informal style makes learning Fit a breeze. Online Computing Reviews Service