Fit for Developing Software: Framework for Integrated Tests |
|
|
|
| Ward Cunningham |
| February 2009, Prentice Hall Professional, Kindle Edition, 384 pages, ISBN B001TKD4R6
|
|
|
|
 |
|
| This is the eBook version of the printed book. If the print book includes a CD-ROM, this content is not included within the eBook version. The Fit open source testing framework brings unprecedented agility to the entire development process. Fit for Developing Software shows you how to use Fit to clarify business rules, express them with concrete examples, and organize the examples into test tables that drive testing throughout the software lifecycle. Using a realistic case study, Rick Mugridge and Ward Cunningham--the creator of Fit--introduce each of Fit's underlying concepts and techniques, and explain how you can put Fit to work incrementally, with the lowest possible risk. Highlights include - Integrating Fit into your development processes
- Using Fit to promote effective communication between businesspeople, testers, and developers
- Expressing business rules that define calculations, decisions, and business processes
- Connecting Fit tables to the system with "fixtures" that check whether tests are actually satisfied
- Constructing tests for code evolution, restructuring, and other changes to legacy systems
- Managing the quality and evolution of tests
- A companion Web site (http://fit.c2.com/) that offers additional resources and source code
|
 |
|
Review-Date: 4/23/2009 Rating: 5 Summary: Excellent Test book
This book gives you a different approach to complete your test cycle better. The book is well written, concepts are explained clear and examples are easy to follow. After I red it, I started to apply on my development projects with great results in defining business rules and reducing defects between releases.
Review-Date: 8/25/2007 Rating: 5 Summary: Terrific book on a terrific testing concept
This book does a terrific job of making the value case for exploring and implementing FIT/Fitnesse in your software development projects. I‘ve been really intrigued by the tools for some time now and was very happy to get a copy of this book.
The layout of this book is as unique as FIT/Fitnesse are themselves. The book‘s first half is targeted to business analysts and customers who team together to write up the stories for the system. The second half targets developers who will write the fixtures to tie the tables to the system. The stories and use cases are all well–done and, unlike too many other books, are on real–world situations.
There are detailed descriptions of the various fixtures supported by FIT with good examples of when you‘d want to use them. The different parts of the book tie together perfectly in that the story is covered in the beginning and the developer–related sections later in the book amplify on the foundation laid earlier. I also like the Q&A portions scattered throughout the book.
The book‘s tone and style compliment the approach of the book, keeping it light and easy to read while laying out the immense value of FIT.
Review-Date: 3/8/2007 Rating: 4 Summary: Good solid tutorial
A good first book/overview. Good explanation of how FIT can fit into a testing environment. A more in depth discussion of more advanced features such as using variables within tests and to set up tests would have been helpful.
Review-Date: 11/5/2006 Rating: 5 Summary: Essential reading for what‘s likely to be a revolution in software development
Ward Cunningham invented CRC cards (which helped get us through the first decade of object–oriented design), many of the principles of Extreme Programming, and wikis (Wikipedia is a natural extension of his "Portland Patterns Repository").
Now he‘s pioneered a way to tie together the front end and tail end of software development efforts (requirements and testing), and to help technical and non–technical people work together to describe what software should do. Incidentally, he‘s provided a way to measure *real* progress, by tallying up what customer value has been successfully implemented.
FIT and Fitnesse haven‘t yet taken the software development profession by storm. Compare that to test–driven development and JUnit/xUnit, back in 1998: they took a while to catch on, but now they‘re an important part of the software development profession.
Want to get a heads start on the next "next thing"? Read this book.
Review-Date: 5/6/2006 Rating: 4 Summary: Closing the communication gap...
Facilitating communication among businesspeople and software developers in the preparation of acceptance tests is the mail goal of Fit, which also helps automate those tests. A tabular representation of tests provides the common language whose clarity and precision are key to improving communication between technical and non–technical people. As Dave Thomas says, Fit helps closing the "gap between the software that [is] written and the software the user [wants]".
Clearly written in an informal style and easy to follow, this is a good book for learning the use of an interesting tool: Fit. It actually contains two separate books written for different audiences. The first half of the book is written for non–programmers and teaches how to define the functionality of a system using Fit tables. The second half is written for the programmers who will prepare the fixtures that mediate between the Fit tables and the system under test, so that testing can be automated.
Hype warning: Although the authors do a great job motivating the reasons for using Fit, they tend to mix the benefits of using their tool with those coming from the application of good development practices (extreme programming practices, in particular).
Review-Date: 12/29/2005 Rating: 4 Summary: Good, not exactly great.
The first 175 pages of the book seem devoted to convincing management that the tool is worth using. The next 75 or so pages give details on writing tests. There are about 45 pages of the programmer‘s perspective. The rest of the book mainly deals with extending the system in ways that most people won‘t bother with. Finally there is a very brief word on non–Java tests that simply says to refer to the web sites.
The book is easy to read. It is a good book for a programmer to show their boss, or to circulate to the non–programmer staff. Developers should thumb through the book to become familiar with the topics, but use the online wikis to develop a serious understanding.
Review-Date: 11/23/2005 Rating: 3 Summary: Better structured than the online docu
The book describes in detail how to use Fitnesse for the combination of requirements management and automated testing. Though this is interesting, the book does not offer more information than the online docu to fitnesse (though certainly in a better structured way, as the structure of the online docu is a nightmare).
The book claimes that Fitnesse should be used to test the business code (model code), not the GUI. And I certainly agree, that this it much more easy to do and maintain, but as a tester I know that most of the big bugs do not occure simply on a method level (say a wrong calculation), but lie in the integration of modules. So, depending on the framework, most bugs will not be found by those tests!
The book uses some trivial examples. For those, Fitnesse works fine and is easy to use. Most tests, however require complex objects in a certain state to work on. It is the creation and maintenance of this objects, which is the tough thing. So, like usually, the trivial examples are hardly helpful.
The book does not give a structured introduction on how to actually use Fitnesse (as a WiKi). For a beginner, it can be very confusing, how to even create a page, why the TEST button appears on some pages, but not on others, etc.
Conclusion: The book does give a good overview on how to create tests with Fitnesse. Wether Fitnesse itself can help you will depend largely on things not covered in the book, though. It does not offer more than the online docu, but it gives more detail and is better structured.
Ah, and I really liked the layout of the book (green color, many links to other chapters, short chapters).
Review-Date: 10/28/2005 Rating: 5 Summary: Agile Testing of Business Rules
Software testing can be very difficult and time consuming. Using FIT along with XUnit for unit testing provides an excellent foundation for complete testing of any software application starting with business requirements / use cases through unit testing of methods. This book focuses on higher level business rules testing using FIT. With the test cases defined using FIT, it‘s a simple matter of writing code to connect with your XUnit tests. I need to point out that not only do the authors demonstrate how to use this when starting a new project, but most importantly, how to adapt it to and integrate it with an existing project. I would say FIT performs for business rules and requirements, what XUnit performs for methods and functions. This book is highly recommended along with one of the several good books on XUnit variants such as NUnit, CPPUnit, VBUnit or JUnit.
I would also like to mention that it‘s great not only for software developers but also for quality assurance and software management since it provides a fast and easy to use HTML reporting interface for quick analysis and tracking of progress for software projects and defect removal / prevention.
One other point, XUnit variants are not needed or required in order to use FIT. FIT can deliver tremendous benefits without it but can provide even greater benefits when used together.
Review-Date: 10/26/2005 Rating: 5 Summary: A valuable reference and a guidebook to using Fit
Even though Rick and Ward‘s book on Fit is the first book available on Fit–perhaps the most popular acceptance testing tool among the whole agile community–and one might be tempted to think it‘s selling well because of that alone, I‘m saying this book is a hit on its own merits.
I read the beta drafts of the book like many others at the time and was instantly gratified as I read through the table of contents. Ward and Rick didn‘t make the mistake of writing a pure tool book. They wrote a book that focuses not just on the tool itself but also on using the tool. I ordered a hardcopy as soon as it was released. I devoured it, loved it, and am still using it as a reference today on projects using Fit.
The first part is all about expressing tests with Fit‘s tables in a way that communicates well. The built–in fixtures are introduced one by one from the perspective of a test engineer wanting to test different kinds of aspects of a system. The first time the authors actually show how to run the tests is in chapter 7. This approached proved to be an excellent choice, as far as I‘m concerned. The focus really stays on creating tests without digressions into technical implementation.
After a brief tour through FitNesse, a display of Fitlibrary‘s power and flexibility, and some miscellaneous topics, Part 2 takes the reader to another level–the process of turning requirements into Fit tables and the strenghts and benefits of using a tool like Fit in developing software. This is delivered using an imaginary software project as a vehicle in illustrating the communication between people while they‘re honing their acceptance tests.
Part 3 turns the table and puts the developer hat on. In an action–packed 70 pages, the authors show how to write the Java code backing up all those different kinds of fixture tables we saw in Parts 1 and 2. The discussion is concise and to the point, covering the fixtures rather well. Having said that, I was left with some open questions regarding extending the built–in (and Fitlibrary) fixtures, mostly regarding Fit‘s internal API. That, however, has been a problem with me and Fit since day one so it‘s probably just my wiring that‘s incompatible. Besides, there‘s more on the internals in the last part of the book.
Part 4 is two–fold. First, we see how the fixtures created in Part 2 look like in Java. There‘s not too much explanation involved but I didn‘t feel like that was an issue. The rest of Part 4 is a mixture of topics such as mocking certain aspects of a system, making the system‘s architecture more testing–friendly, and such. I have to say I was a bit disappointed by the mocking section, having hoped for a more elaborate example rather than sticking to faking system time.
Part 5 starts with a very brief description of Fit‘s internal API (introducing concepts of Parse object, "more", and so forth, if you‘ve already taken a peek at Fit‘s source code) and how to develop custom fixtures. Personally, I would‘ve liked to have a lot more material on this exact topic but even the brief overview helped solidify some of the things I had picked up here and there while reading the Fit source code, trying to figure out how to write custom fixtures.
Trying to summarize all that, I‘d claim that "Fit for Developing Software" is a must read for anyone involved in using Fit. It‘s a tremendous resource, especially considering how little documentation on Fit is available online. The book does have its deficiencies as well, though. Whereas the (arguably most important) aspect of creating tests is covered extremely well, the poor fixture developer still has to figure out a lot of stuff out on her own as the custom development topic is not covered as thoroughly. Still, a great book and a warm recommendation from me.
Review-Date: 9/16/2005 Rating: 4 Summary: Great introduction to tools, technology, use, and rollout
This book is great not just because of the quality of the writing or the tool being targeted. The authors do an excellent job of motivating the reason for using their testing tools, how to use them in situations and applications that are realistic, and how to roll them out within organizations. The Fit framework is clearly presented, well documented, and this book is about all you should need in terms of education to use it.
I would highly recommend the book to anybody looking to bring a new integration testing strategy online for their product.
The only thing I would‘ve liked to see was a bit of broader–scope coverage. Some large shops actually have a significant amount of testing infrastructure, testing tools, and test case management software in place. How should this integrate? And how does it scale to hundreds of thousands of tests? And is there anything you wouldn‘t use it for – like, say, compiler conformance tests? I doubt that any testing framework is all things for all people, and would‘ve liked to see where the edges are.
|
|
