JUnit in Action (Paperback)

~ (Author), Ted Husted (Author)

Editorial Reviews

Product Description

A guide to unit testing Java applications (including J2EE applications) using the JUnit framework and its extensions, this book provides techniques for solving real-world problems such as unit testing legacy applications, writing real tests for real objects, automating tests, testing in isolation, and unit testing J2EE and database applications. Using a sample-driven approach, various unit testing strategies are covered, such as how to unit test EJBs, database applications, and how to unit test JSPs, and Taglibs. Also addressed are testing strategies using freely available open source frameworks and tools, and how to unit test in isolation with Mock Objects. Testing J2EE applications by running tests from inside the container for performing integration unit tests is discussed, as is how to automate unit testing in automated builds (such as Ant and Maven) for performing continuous integration.

About the Author

Vincent Massol is the creator of the Jakarta Cactus framework and an active member of the Maven, Gump, Struts, and MockObjects development teams. He is the cofounder and CTO of Pivolis, a company that specializes in applying agile methodologies to offshore software development. Ted Husted is an active member of the Struts development team and the manager of the JGuru Struts Forum. His most recent development project uses test-driven design throughout and is available as open source [wqdata]. He is the author of Struts in Action. He lives in Fairport, New York

Product Details

• Paperback: 384 pages
• Publisher: Manning Publications (October 1, 2003)
• Language: English
• ISBN-10: 1930110995
• ISBN-13: 978-1930110991
• Product Dimensions: 9.1 x 7.3 x 1 inches
• Shipping Weight: 1.3 pounds (View shipping rates and policies)
• Average Customer Review: 4.5 out of 5 stars  See all reviews (20 customer reviews)
• Amazon.com Sales Rank: #217,485 in Books (See Bestsellers in Books)

  Popular in this category: (What's this?)

  #67 in

  Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Testing

Customer Reviews

Most Helpful Customer Reviews

37 of 40 people found the following review helpful:

5.0 out of 5 stars The definitive how-to manual for unit testing J2EE code, November 5, 2003

By	Jason Menard - See all my reviews (REAL NAME)

If you've ventured into a bookstore lately, you may have noticed that the number of titles available on agile methodologies is multiplying more rapidly than the populations of some third-world countries. Leafing through any one of these titles while sipping an espresso in the bookstore's coffee bar, you'll quickly figure out that repeatable, automated unit tests are a good thing, and that JUnit is the unit testing framework most often used for Java unit testing. A couple of mochachino grande's later, and you've read enough to convince you that your continued survival rests on writing these automated unit tests. Unfortunately, and before your caffeine buzz even wears off, you're struck with the realization that while you're motivated and ready to go, you're just not sure exactly how to go about writing tests for many of your J2EE components.

"JUnit in Action" picks up where these other texts leave off. This is not a book on test-driven development, and it's not a book trying desperately to convince you of the value of tests. The book's goal is to demonstrate exactly how to write comprehensive unit tests for the various components of your J2EE applications. Writing tests for servlets, filters, JSPs, taglibs, database components, and EJBs are all covered in detail, as are testing strategies using mock objects and Cactus. Not only are you shown how to write the tests, but also how to write testable code. Along the way, the author points out useful "best practices" and how to use design patterns to improve your tests and the code you are testing. Code examples are thoroughly documented throughout the text in order to illustrate the techniques being discussed.

"JUnit in Action" is the definitive how-to manual for unit testing J2EE components. Pick up one of the other books if you're looking for something more motivational, but when you're ready to sit down and bang out some code, you'll want this book at your side.

13 of 13 people found the following review helpful:

5.0 out of 5 stars A quality and indepth view into the world of Unit Testing, November 20, 2003

By	Dion G Almaer (Cambridge) - See all my reviews

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

8 of 8 people found the following review helpful:

4.0 out of 5 stars A joy to read but..., February 20, 2005

By	Riccardo Audano (Chiavari, Italy) - See all my reviews (REAL NAME)

Amazon Verified Purchase

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