JUnit Recipes: Practical Methods for Programmer Testing

Rating:
Summary: Wow!
Review: "JUnit Recipes" is a very thorough and comprehensive encyclopedia of excellent advice and examples on almost every coding situation I've ever wanted to test with JUnit.

J. B. Rainsberger has compiled a 700 page collection of scores of excellent recipes written in pattern-like fashion, clearly laying out testing problems in wont of solutions and the practical recipes for solving the problems, including annotated code examples, step-by-step instructions, and plenty of quality explanations.

"JUnit Recipes" is destined to be a classic, and has earned a most prominent place on my bookshelf, as I'm certain I'll be referencing it frequently for new and better ideas on formulating JUnit tests.

What's that? You'd like to borrow my copy of "JUnit Recipes?" No, get your own.


Rating:
Summary: this is an extremenly helpful book
Review: after you have been writing test cases for a while, all sorts of questions about how do to things come up (or your test code starts to get real ugly real fast). this book has most of the answers. i found it invaluable when writing tests for a bunch of data source layer and dao stuff (especially their test case abc).

Rating:
Summary: Excellent Tour Book and Reference book.
Review: Get this book both as an introduction to what JUnit can do for you and also as a reference when you are looking for information on how to solve a particular testing problem. The book covers the basics of using JUnit as well as issues around database and J2EE testing. It is filled with pointers to many frameworks and resources that can simplify your testing experience. This is not just a testing cookbook. J.B. also discusses issues such as how to design for testing (and how that can improve your architecture) as well as what to do when you need to test legacy code. This is an excellent guide to the details of how to use Unit effectively.

Rating:
Summary: Yet another must-have title
Review: J.B. recently replied jokingly, "buy them their own copies", to my mentioning that my team would be all over my copy of "JUnit Recipes" like vultures if I was to leave it on the desk at work. I have to say that's not a bad idea. In fact, that's what you should do if you're determined to make your development team learn how to write effective unit tests in those non-trivial settings you inevitably encounter out there.

"JUnit Recipes" is, as its name implies, not a tutorial for writing JUnit tests although it does start small with some 50 pages of basic conventions and fundamentals of writing JUnit tests. Instead, it's a huge collection of little recipes for tackling those everyday problems developers around the world encounter when trying to unit test their applications. Real world solutions to real world problems. The book is divided into chapters by coarse-grained topics such as organizing test suites, test data, XML, EJB's, JDBC, etc. all the way to testing web components and J2EE applications. The last hundred or so pages of the book talk about some more exotic topics such as unit testing design patterns, using certain popular JUnit Extensions such as GSBase and JUnit-Addons.

The recipe approach fits the domain perfectly. One doesn't need to reach 30 some pages of prose before "getting it", which is the case with certain types of books discussing other problem domains. The recipes go straight to the meat of the subject with concise and clear problem statements and then quickly proceed to show how to go about solving them. The formatting of the provided code snippets is excellent as usual, with strong visual highlighting of important sections and careful indentation.

Joe has managed to put out something that I believe will be known as the unofficial JUnit bible for years to come. What are you waiting for?

Rating:
Summary: Excellent guide and reference...
Review: JUnit. Nearly every Java developer has heard of it and many use it, but it is hard to say that it is used to its full potential. Sure, it is easy to set up and use in a basic way, but what happens when you want to extend it or use it in an unfamiliar way? You could just leap in try to figure it out yourself, but if you do, chances are, you'll be rediscovering something that J.B. Rainsberger has learned and documented in JUnit Recipes.

JUnit Recipes is a front-to-back roadmap of JUnit use. It is clearly written and it contains a wealth of information. This past week, I was creating an extension for FIT which runs JUnit tests, and I kept pulling J.B.'s book off my shelf. Finally, I stopped putting it back and left it on my desk. I think that was the right move because nearly every time I picked it up, I dog-eared another two pages.

J.B.'s advice is very good. It goes far beyond the mechanics of JUnit and its extensions. It extends to very direct concrete advice about testing. I recommend that everyone who uses JUnit get a copy. If you are like 90% of the JUnit users out there, you use JUnit but you aren't really using JUnit; not in the way that you will after reading this.

Rating:
Summary: Excellent 'howto' book
Review: Manning is one of my favorite technical book publishers, and this book is another reason why.

Everyone knows about JUnit by now, or at least knows they should be using it. But once you start using it, you are faced with a lot of 'best practice'-type questions... Should my unit tests be in the same package as the code it is testing? Should I keep the test code in the distributed jar file? How do I test for 'coverage' of my code? How do I test conplex things (like EJBS) that need infrastructure (like a container) in order to run? What common tests should I perform to guarantee well-behaced classes?

This book feels like it was written by someone who has had experience not only making these decisions and discovering how to do things, but also has experience communicating these decisions to others.

If you use JUnit, this book is for you. Undoubtedly you have either learned or have yet to learn the stuff in this book. If you have already learned it, there is surely some 'supplimental' material here for you... If you need to learn it, this book is a lot easier and cheaper than your own trial and error. (Even if you use any other xUnit frameworks, this book may have material of interest to you).

Rating:
Summary: Tasty recipes for success
Review: Sometimes the tiniest things are the most useful. Nails, screws, paperclips and post-its are all small, simple objects that are used a thousand different ways. So it is with JUnit -- a small and really very simple testing tool that can find its way into every corner of your Java development.

Rainsberger's book is a compendium of those thousand ways that JUnit can be used (well, OK, more like 130 ways). Each recipe starts with a solid motivation and includes a worthwhile discussion afterwards. You quickly realize that the author is sharing hard-won experience with you on every page. There are sections on testing standalone code of every description, as well as detailed sections on testing servlets, EJBs, and other less tractable components.

I've been using JUnit for years, but I picked up quite a few useful tips from this enjoyable book. Highly recommended.

Rating:
Summary: Test your code
Review: The unit testing framework is simple to use, but some code can be tricky to test.
In such a case you will find this book helpful for reference and given examples
in this book.
The book has covered testing objects, methods, data, XMl, EJB and web component, so
this book is fit for any one who wants their J2EE development being Unit test.
This book has covered one chapter that one can use ant for unit test.


Rating:
Summary: The Untimate for Testing Java Code
Review: There are several ways to test software. Perhaps the easiest on the tester is to simply ship it and let the customers find the bugs. It has been argued that this is the standard practice in the case of certain operating systems, but of course that isn't true.

JUnit -- the unit testing framework for Java -- is simple to use, but some code can be tricky to test. When you're facing this kind of challenge, this book is a good place to start looking for help. It has some one hundred and thirty-seven tested solutions to a wide range of testing problems.

Along with these recipes, there is some valuable discussion on how testing saves time - just in case your boss needs convincing, there are some recipes for servlets, JSP's, EJBs, database code and much more.

This is one of those books that you'll keep down off the book shelves on a corner of your desk so that you can reach it easily.

Rating:
Summary: Excellent JUnit examples
Review: This book is great for two reasons. First it provides practical insights in how to test various forms of code, from servlets all the way through to stored procedures. Second, by giving you all of these examples it will stretch your testing brain by giving you ideas that will extend your testing beyond what even this thick book manages to pack in.

The first part of the book gives you the basics of JUnit. After that it's all recipes which come in the form of presenting a problem, then the solution and a discussion of the solution.

If I had to find fault it would be that GUI testing is not covered. But that's a minor flaw since it's hard to find anything that covers that difficult topic in any way. A must own for an test-first JUnit developer.