Customer Reviews

JUnit Recipes: Practical Methods for Programmer Testing

5 star:		(16)
4 star:		(6)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

J. B. Rainsberger's JUnit Recipes is a wonderful compendium of tips and tricks that can quickly take anyone from novice to expert at JUnit. The organization of the book should make it appealing to unit-testing programmers of all levels. Early chapters are highly introductory, covering the installation and first uses of JUnit. Later chapters cover testing of JDBC, Enterprise Java Beans, XML, and more.

JUnit Recipes includes the best discussions I've read on how to test database applications and on the complicated art of managing test data. This is probably not a book you will read every chapter of. In my programming, for example, I don't use EJB so I only skimmed that chapter. But at over 700 pages is much more of an encyclopedia of wonderful testing techniques than a book that is meant to be read cover to cover. As its title implies, JUnit Recipes is a cookbook of ideas that will allow you to serve up better, and better-tested, applications.

This isn't necessarily the best introduction for absolute beginners (I would recommend /Pragmatic Unit Testing/ for that), but it is required reading for server-side Java, as most other reviewers have pointed out. But it's more than that--it's one of those rare computer books that transcends its subject matter. Why? Because it can make you a better programmer. While some of the credit can rightly be given to unit testing and Test-Driven Development in general, Rainsberger's book makes you /see/ better ways to write and refactor your code. The breadth and depth of examples is astonishing--he convincingly shatters "but it's too hard to test that" arguments with well-researched, non-trivial examples. In fact, I'd say that this is almost a better J2EE tutorial than most books about J2EE proper.

I'm withholding a star for one reason: the book doesn't cover GUI testing tools like Jemmy, JFCUnit, or Abbot/Costello. These JUnit extensions are ripe for a book with this depth; it's just too bad that this couldn't be that book. Other than that, I find that I turn to Rainsberger's book far more often than any other testing book or online reference.

This review also appears on StickyMinds at http://www.stickyminds.com/s.asp?F=S767_BOOK_4

JUnit Recipes is a comprehensive tome of practical methods and techniques for the opensource JUnit tool to develop automated unit-tests for Java/J2EE applications. The book is split into four parts: Building Blocks, Testing J2EE, Additional JUnit Techniques, and Appendices. The Building Blocks cover the basics of using JUnit to create basic tests, organize and manage test suites and test data, running JUnit tests and reporting the results. It even includes a section on troubleshooting. Testing J2EE covers XML, JDBC, EJB, web components (including JSPs), and J2EE applications. Additional techniques include testing some well known design patterns, using JUnit add-ons and JUnit libraries (like GSBase). The Appendices include complete solutions (including code of course), some short and sweet essays on testing, and a modest recommended reading list.

The organization of the book flows very logically and the writing style is very clear and easy to follow. Along the way many insights into important design principles and testing techniques are revealed: the reader will learn about the "Hollywood principle", the Open-Closed principle, design patterns, POJOs, Mock Objects, Private and Parameterized Test-Cases, Abstract Test-Cases, Self-Shunts, and Spys. The book's coverage is very comprehensive and touches on many other popular Java/Enterprise projects and frameworks such as Struts, JBOSS, Prevayler, XDoclet, Tomcat, XPath, XMLUnit, HTTPUnit, Ant, Jakarta, and others.

Even though JUnit is often associated with "Agile" development and much of the wisdom apparent in the book applies to agile Java development, the book is useful to any Java developer on any Java project (agile or otherwise). The book also goes into considerable detail, with working code examples, to spell out exactly how to perform and apply the techniques it describes.

The book's primary audience is Java developers. Java Tester's will still find some good nuggets of information but it's quite clear that Java programmers and developers are the target audience. This isn't some high-level theoretical book mostly of concepts and ideas. This is an imminently pragmatic guide that not only conveys a great deal of highly practical wisdom but also clearly and comprehensively walks you through the explanations and the code to accomplish and apply the techniques it describes. The book is also not a "How To" for coming up-to-speed on setting up and running JUnit.

Another book from the same publisher, "JUnit in Action" is a great overview on learning more about the basics of running and using JUnit and on using JUnit to tackle a number of basic challenges with unit-testing Java and J2EE code. JUnit Recipes has some overlapping material but pretty much "picks up" where "JUnit in Action" leaves off, and JUnit Recipes goes into much more breadth and depth of coverage of JUnit methods, practices and techniques and use with other Java projects and frameworks.

I would say JUnit Recipes should probably be required reading for anyone attempting to use Java, J2EE and JUnit in the real-world.

This is a good book. It was very important when it came out. It is dated however and we need a new book on the subject since JUnit is up to version 4.6 as of this writing. Following examples from this book from the start you would want JUnit 3.8 to avoid the confusion. Then you would have to learn the differences between 3.8 and 4.6 which are substantial. Where have all the programmers gone? Books use to be up to date, now we are stuck with many 5 year old books with reviews from 2004. This does not keep programmers informed and secure in their jobs. Time for a new updated edition on this one to make it truly useful.

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.

This thick volume (700 pages including good references and reading list) is aimed at three groups: Java developers in general, JUnit users, and lastly software testers. It is very useful to all three groups, and is marked as **** as a software tester (am I in a minority of one?). It may merit top marks for the other two readership groups.

JUnit is one of a series of language-dependent packages for those engaged in Test Driven Development. Important points to draw out are that this is describing both the building blocks for JUnit, and a process. The authors (important contributions from Scott Stirling and others, in addition to J. B. Rainsberger) make little in the way of assumptions. Not every reader will be an expert Java programmer, nor will everyone have used JUnit before.

Starting from the notion of building little tests as coding progresses, some tough questions are introduced early-on. How is production code to be separated from testing code? It is great having a fully rounded regression pack available, but is it possible to invoke only a subset of the tests available? Real questions from genuine situations that scratch where it itches! All this from the three principles of JUnit; create an object, invoke a method and test the result. Practical examples abound, and there are coded examples, for the most part very clear. Later on, some parts were beyond my level of Java technical understanding (particularly testing JavaBeans), but some testing points still emerge.

To build in the future-proofing of test packs, 're-factoring' is mentioned both early, and often. There are also some very common testing items. Here is one for a taster: if a module / class / object has no noticeable effect, why test it (and perhaps more pertinently, why code it!) There is also the idea that some items are not building blocks, and are too simple to test. This is surely worth considering.

Development can learn from testing. This volume shows that all the traffic is not one way, and is a valuable addition to (some of) those engaged in software development.

Peter Morgan, Bath, UK (morganp@supanet.com)

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).

After you've mastered the basics of JUnit, this book is the book to get.

However, even if you're new to JUnit, this is still an excellent book to get, as the first few chapters will get you acquainted with JUnit, such as setting it up, and with some simple, basic tests to get you started.

The rest of the book contains the most valuable and useful information that you can apply to your projects. They describe the more complex situations/environments (J2EE application server, standalone, etc.) that you encounter everyday and how to write tests for each situation. It is these chapters that will have you coming back for more, when you're stumped on how to write a JUnit test for your specific problem.

Junit Recipes also gives you tips on organizing your tests, testing legacy code, and much more. Each recipe is written in a similar format, describing the problem, background, and finally, the recipe itself, making this book easy to read. This book definitely belongs on your desk at work (or your bookshelf at home) -- it comes in handy when you are having trouble coming up with tests for difficult situations. I highly recommend it if you would like to learn how to write better tests and learn how to test code in complex environments.

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.

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?