Customer Reviews

Unit Testing in Java: How Tests Drive the Code (The Morgan Kaufmann Series in Software Engineering and Programming)

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

 

 

This book starts by covering general techniques in unit testing, including when and why to do it, how to know if you are doing it right, and how it integrates with other development practices. This is good stuff, but mostly also covered in other books. The section on Mock Objects is especially well done though, illuminating an often misunderstood topic area.

The latter half is where this book shines. It tackles some of the really tough areas and does it very well. Singletons, database persistence, asynchronous services, concurrent and distributed systems, web applications and graphical user interfaces; all these are often skipped over as "too hard to test". If you've ever found yourself thinking something like that, you need this book.

This book is a translation from a German original. Although the translators have done a tremendous job with the technical content, sometimes a phrase or section title, especially in the initial introduction can seem very unusual. Don't be put off by the quirky language in the early chapters, the meat of the book is well worth reading and putting into practice. This book is a masterly example of how to convert programming theory into solid, practical advice.

Let me first say that this book has not been my first contact with unit testing and test-driven programming: I recently read Kent Beck's "Test-Driven Development" and followed some of the unit testing threads in the Extreme Programming discussion group. Beck's book left me somewhat helpless and thinking "And how do I use that in real work?" Johannes Link's book had much more to offer for me in that respect, especially in the second part where he tackles the problems of web apps, database programming, user interfaces and distributed programs. I certainly liked his treatment of mock objects. Mr Link seems to be a pragmatic proponent of test-driven development - a good thing as far as I'm concerned - and he also has lots of reasonable advice for those testing their programs after the fact.
On the downside there is this chapter about unit testing within more traditional software development. These pages might be useful for others; I don't think they belong in this otherwise very enjoyable book.

This is a very readable introduction to unit testing, a good first book for anyone wanting a sound approach to software testing.

The main text is divided into two parts. The first is a clear introduction to the basics of the JUnit test framework. The pace is gentle, and the entire discussion is built around sample code - very helpful for the beginner who thinks in concrete terms. Link (the author) omits the JUnit API information that's already available in JUnit's JavaDoc pages. Those are just the basic words available in the framework; Link's goal is to put them together into meaningful test phrases. Throughout this half of the book, the reader is shown a number of common situations with non-obvious solutions. At each step, Link presents a little theory (plus some nice references), a little refactoring to improve the system's testability, and enough sample code to make the solution clear. This isn't a textbook on the theory of testing. Still, by the end of this first section, the reader has been exposed to many ideas: coverage metrics, internet resources, design and implementation for testability, and a lot more.

The book is heavily oriented towards Java, partly because of the relative wealth of test tools available and because of Java features and APIs that support automated testing. Having chosen Java, it is natural to ask testing for unique features of the Java environment: GUIs, persistence, EJB, servlets, RMI, and more. Link covers those in the book's second half. Many of these chapters are specific to Java technologies and APIs. Some, like the GUI discussion, have value beyond the Java specifics they discuss. Even if the language and APIs change, many of the techniques will work well in any GUI programming environment. This section ends at a strategic level: introducing testing into existing workflows, handling of legacy systems, and management issues.

Link has written a very helpful introduction to testing. It has enough specifics to get a beginner started, or to help an old hand deal with the problems of complex systems. The book's practical orientation skips a lot of the history and theory of testing, including tests that deal with qualitative performance issues rather than basic correctness. Anyone reading this book by itself might not realize just how broad and deep the subject really is. Link does at least mention the major ideas in the field, though, and prepares the reader for more advanced discussions.

//wiredweird

Johannes Link's "Unit Testing in Java: How Tests Drive the Code" bills itself as "a practical introduction to unit testing for software developers." Link's book is very comprehensive and touches on most of the topics a developer will need to know about before setting off on his own, including some topics that have not been addressed in similar titles.

The first half of the book addresses basic techniques for unit testing. The author is a proponent of eXtreme Programming and test-driven design, and those concepts are explored as they relate to unit testing. This first part of the book is quite exhaustive and contains in great detail pretty much everything you would expect. One pleasant surprise here was a nice chapter on inheritance and polymorphism as it relates to unit testing. Link offers some excellent advice on this rarely addressed topic.

Once you've mastered the basic techniques, Link kicks it up a notch and addresses some more advanced topics relevant to our day-to-day lives as Java developers. The book discusses unit testing persistent objects, web applications, and GUIs, as well as rarely examined topics such as concurrent programs and distributed applications. As if that weren't enough, Link throws in an outstanding chapter on the role of unit tests in the software process which is necessary reading if you are attempting to integrate the book's practices into your own organization.

"Unit Testing in Java" isn't an overly large book, but it is certainly a dense book. The tone is academic and some of the phrasing is awkward, although it should be kept in mind that it is a translation from German. I like to think of "Unit Testing in Java" more as a text to be studied, rather than as a reference. However, there is so much that is good in here, that it is definitely worth the effort spent reading it.

I like this kind of book. It is practical and informative without being wordy or pretentious. It introduces test-driven development with a focus on Java and Java tools, but its lessons can be applied fairly well to any OO language such as C#, C++, Python etc. The book covers a pretty broad range of topics including an introduction to the principles of test-first development, mock objects, persistence, Web development, EJBs, and user interfaces, among others. Each topic is covered in sufficient detail to get started and points out the hazards one should be aware of. This book is also well-researched and contains a good list of references. Overall this is a solid, well-organized effort that deserves space on the bookshelf of any developer getting into test-driven development.

For a short book like this I'm very impressed with it's breadth of coverage. It stars by covering JUnit and the test first methodology. It then covers testing a variety of types of code, including very notably HTML and GUI code. The last chapter, which is one of it's best is on the importance of unit testing in the entire lifecycle of development. This is an instant classic in the under-covered world of unit testing. A must buy for both QA and Developer alike.

This was the second unit testing book that I read after Hunt & Thomas's /Pragmatic Unit Testing/, and it did an admirable job helping me progress beyond the basics. It has especially good overviews of Test-Driven Development, the guts of JUnit, and mock objects. I found it less useful (i.e. less detailed) when it turned to testing J2EE and database functionality. I found J.B. Rainsberger's /JUnit in Action/ a much more authoritative reference. But this book got back on track at the end with its sections on HTML and GUI testing, which fill in a lot of the gaps in Rainsberger's book. In the end, I give both books 4 stars because they complement each other well, although /JUnit in Action/ is, by far, a much better overall reference.

I have found this book very helpful. It is not thick, but it covers a lot of important areas. Topics like test driven design, JUnit, Mock Objects etc are explained in a simple way with nice examples. For me this book was perfect because it describes the topics just enough to understand the principles without making me bored. Then there are a lot of references to more detailed infromation on the web. I have worked with unit testing using JUnit for a couple of years and by reading this book I now got some good hints on how to improve the way I'm working with unit tests.

Very good book for mastering the basics. Covers quite a bit of ground in a short period. Lots of references and examples make it easy to understand. I have worked with unit testing using JUnit for a couple of years and also enjoy the site www.developertesting.com by the folks at Agitar Software. I have recently taken unit testing to a new level using the Agitator, see www.agitar.com I highly recommend it!