Customer Reviews

JUnit in Action

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

 

 

When I first started to read JUnit in Action, I was hoping that it wouldn't be a tutorial on the open source tool JUnit. I am glad to say that it is much more. I think the book's name could really be "Testing in Practice". Sure, JUnit is covered in a lot of detail, but so are other tools such as:

- Integration with: Ant, Maven, and Eclipse
- Mock Objects (via both EasyMock and DynaMock)
- Cactus for testing in a container
- And other small helper tools (nice ant tasks, etc.)

What made me really enjoy this book is the way it is written, coupled with the practical look at the many technologies involved in testing. It is a fresh read, that doesn't get bogged down. The book flows really well, giving you best practices throughout. They don't just say "Do X", they actually show you where these best practices come from as they refactor their own code. You are really aware that these authors know their stuff, and are drawing from a lot of experience (compared to the online FAQs).

I truly enjoyed reading the first edition of "JUnit in Action" and was somewhat disappointed by the second edition. It wasn't even that the second edition was bad. It's that my expectations were too high from the first edition.

I think there were too many authors on the book. The different styles were apparent which is awkward in a book. The cover says the book covers JUnit 4.8 while the contents of the book are JUnit 4.6. (This one is probably marketing's fault, but it stands out extra on a book about quality.)

I also think the scope of the book was too large. Many things are covered, but not enough things are covered well. I expect a book titled "JUnit in Action" to cover the core of JUnit well. While most things were mentioned, there were only 3 pages on Hamcrest matchers. I felt other core concepts were breezed through and not enough space was spent on the fundamentals. The first edition had more pages on core JUnit and there was less to cover then!

I was also surprised not to see Mockito mentioned in the mock testing section or Emma in the coverage section. Not featured, mind you. Just mentioned. And finally, I found one factual error that I consider significant because it is a fallacy. I posted it in the Manning forum 8/3 and haven't received a reply. Nor have many people who posted since May or beyond. Why is there a forum if nobody reads it?

Many things were done well - examples, best practices, available tools. I just had the bar so high from the previous edition that I was let down.

If you already own the first edition or are familiar with what is out there, you don't need this book. If you've never done anything in JUnit, it is still useful. Just remember that the order unit tests are run is not guaranteed!

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch.

This book is required reading for any professional Java developer. Even if you are not convinced of the benefits of test driven development and unit testing you owe it to yourself to check what this is all about. This book will serve as a very hands-on introduction to a lot of APIs, libraries and techniques in the field of unit and integration testing. My only complaint is that it tries to cover too many subjects in too little space. The introductory part on JUnit is superb. I found the treatment of Cactus, surprisingly, too superficial (Vincent Massol is the cactus creator) : the author makes you first (after a brief interlude with Jetty) run the cactus test using Maven, and that would be ok with me if he gave a through introduction to this tool, but instead all you get is a "run the tests typing maven cactus:test". Now this kind of monkey work is not what an intelligent developer loves to do.. and besides when things go even slightly wrong (and you know they will...) you are left clueless. You also get a chance to run cactus tests with ant but the treatment is not general enough to give you a solid understanding of this procedure. Anyhow after reading this book you will be much more competent on software development best practice and testing, but probably wondering if, having to learn and employ all these tools and APIs, unit testing is still useful or is monstrously transforming into a heavy and complex part of your application...

This is a strong book on a worthy topic. It's short but that doesn't stop it from covering the topic well. The authors just stay on track and cover the required material in a brief and balanced manner.

On the down side there could have been more context about JUnit and it's alternatives. The first chapter covers this somewhat but after that it is JUnit all the way.

On the upside, the book is well written and edited. It is concise and sometimes witty but not to the level of going off track.

The interesting chapters:

Chapter one introduces JUnit and shows some alternatives, mainly doing tests by hand.

Chapter two covers JUnit completely in detail. Which is almost a bit too much too fast and I found myself a little lost in the detail. It could stand to be broken up a little.

Chapter four is an excellent introduction to test driven development. This section alone is almost worth the price of the book.

Chapter five covers integrating JUnit into existing tools like Ant and Eclipse.

The second part then applies JUnit to each of a number of different types of code, including web pages, tag libraries, data access, etc. This is the heart of the matter and it's done very well. This connects the code you have to the JUnit test framework step by step. It's very well done.

If you are using JUnit or are interested in test driven development in Java this is a fantastic book and is well worth the money.

(Full disclosure: I am a Manning author but I in no way allow that to effect my reviews.)

First things first --> Test Driven(First) Development (TDD) is a *beaten to death* buzz phrase in the IT industry today. There are various proponents and opponents to this agile concept. Let me tell you that this book is neither a proponent nor an opponent to TDD, it just teaches you plain vanila unit-testing and how it will make you develop quality solutions.

Won't you agree if i say that we see or hear a few of the following during our typical work day.
1. JUnit, HttpUnit, DbUnit etc
2. Mock/Stub testing strategy
3. Repeatable tests, Continuous Integration
4. Innovative Testing frameworks like EasyMock, TestNG, Cactus etc
5. Designing and writing code for testability


Often, when we try to find out what exactly they are and how they are used in real projects, we are left with uninspiring documentation(if there is one) or we are left with a plethora of frameworks that do overlapping tasks. Without knowing *what, when and why's* of unit testing, we thrash it at the end of the day.

This book is an excellent resource in that it addresses the above questions and the questions that follow really well in a developer friendly manner.

1. Why to unit-test code? What advantages do you get by doing so? --> Quality, Confidence, Merciless Refactoring
2. What are the different types of tests that a software needs and how does unit testing fit into the overall picture? --> Unit, Integration, Functional and Acceptance tests
3. What is JUnit and how it fits into the unit-testing phase of our development process? --> Makes unit-testing a breeze
4. What tasks are not do-able with JUnit and how other frameworks and JUnit extensions address these issues? --> Cactus, EasyMock, HttpUnit, DbUnit etc
5. What are the different testing strategies that are available and when to use them? --> Stub, Mock, In-Container
6. What are the problems that you will encounter while unit testing and how to overcome them? --> Demotivation,
7. What are the different reasons that you will find to not do unit testing? Why and how to overcome them? --> Time Pressure, Not Applicable in my scenaro etc
8. How to test different types of artefacts? --> POJOs, Servlets, JSPs, Taglibs, Database Access, EJBs
9. How unit testing can be made fun? --> Profiling, metrics
10. All of these in a simple yet effective case study. --> Adminstration App.


There are a few *nice to have's* that this book missed:

1. Though it covers a lot of detail, i think the authors tried to cover too much ground in 350+ pages. Cactus was covered, but very superficially, particularly in the TestRunner area. I would expect greater detail in that area, because that is the most diffuclt part of cactus.

2. It would have been better if the authors concentrated more on *what to test* after the initial *how to test* chapters. I mean, since the authors are expert in this arena, it would have been better if they identified a few patterns on what gets commonly tested and put it forward to us. That would have been very useful.


Overall, this is a very well written book. The authors are not only technical experts, they are good writers as well. If you are even vaguely interested in trying out unit testing for your projects, you owe yourself to try this book and get enlightened.


Any program feature without an automated test simply doesn't exist. -- Kent Beck

Of the half dozen book I've seen that deal with Java testing this is the best. Massol is a technical expert. He talks about testing tool, test design and strategy, and deals realistically with installation and configuration issues. He deals with JUnit, does a little with Maven, and talks quite a bit about J2EE testing strategies including the use of mock objects and Cactus to test JSP, taglibs, servlets, and EJBs.

This book is much more than the "hot to use the tool" approach of many current books as it deals very thoughtfully with test design and architetcure issues.

This book is a great intro to JUnit and quickly advances to intermediate level stuff (Cactus etc.). Lots of best practices are littered throughout the book and there's a good balance of code and discussion. A combination of this book with "Junit Recipes" by Rainsberger and "Java Development with Ant" by Hatcher will take you from newbie to JUnit guru in no time. Written in 2004 it's begun to get a little dated with JUnit 4.0 released (using annotations is quite a change) - however I'm sticking with JUnit 3.8 which this book is great for.

This is one of the best books for understanding a programming tool I have ever read. Code is well commneted and writing is very clear. It does a great job of explaining junit and why you should use it. Hightly recomended.

This is a great book for any Java developer who has heard about JUnit but hasn't really worked with it. The examples are plausible for real-world development, although by being "real-world" they tend to be slightly less simple than you would want for an introductory book. Still, the discussion of why and how tests can improve the code they are testing is very good. The techniques for in-container testing and testing J2EE components are useful, because these tend to be the most difficult components to unit test. All in all, this is a valuable resource for learning JUnit.

Do you write code? Do you develop software? Do you think about writing software? Then you need this book. This book should become your friend, your companion, a part of your family. Even though the title is "JUnit in Action", many of the topics in this book apply to the other xUnit frameworks.

Vincent Massol takes the reader on a journey though the JUnit framework, the Cactus extension, Ant, and Mock Objects. He explains each topic in detail and leaves me with a good understanding of the topics. The book is liberally sprinkled with JUnit best practices that every reader should take to heart. The examples are clear and real world. The author addresses the complex issues of unit testing EJBs, and web apps head on. He does not shy away from the real issues that come with testing these kinds of applications.

The author also writes about how to integrate your unit testing into you build and configuration management systems. Personally, this is an area that most projects I have worked on needed the most help. It is all fine to have unit tests, but if they are not automated and part of your build process, there value is significantly decreased. Vincent deals with the complex problems of automating deployment of web apps and EJB components and testing them with your build system.

Another area that gets much needed attention is test database applications. The author presents a great chapter and example of using DBUnit and how to address the typical problems associated with database testing.

One flaw in the book has to be the snapshots of the JUnit GUI results screen. The author tells me the bar is green, but as hard as I squint it still looks dark grey.

To sum up, I think every Java software developer needs this book on their shelf. I am currently doing C# and I am happy that I have this book on my shelf as many of the ideas and best practices translate directly into NUnit testing.