- Jubilee offer: spend £10 or more on any product sold by Amazon.co.uk on or before June 6 and you can buy The Diamond Jubilee A Classical Celebration Album for just £2.50 Here's how (terms and conditions apply)
| ||||||||||||
 Trade In this Item for up to £0.25
Get an extra £5 when you trade in books worth £10 or more until June 30, 2012. Trade in JUnit in Action for an Amazon.co.uk gift card of up to £0.25, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Find more products eligible for trade-in.
|
|
There is a newer edition of this item:
|
Special Offers and Product Promotions
Frequently Bought Together
Product details
|
More About the Authors
Discover books, learn about writers, and more.
Product Description
Product Description
JUnit in Action is an example-driven, how-to book about unit testing Java applications (including J2EE applications) using the JUnit framework and its extensions. Intended readers are software architects, developers, testing teams, development managers, Extreme Programmers, or anyone practicing any Agile Methodology.
JUnit in Action is about solving tough real-world problems such as unit testing legacy applications, writing real tests for real objects, automating tests, testing in isolation, unit testing J2EE and database applications, and more.
About the Author
Vincent Massol is the creator of the Jakarta Cactus framework. He is also an active member of the Maven, Gump, Struts and MockObjects development teams. After having spent 4 years as a Technical Architect on several major projects (mostly J2EE), Vincent is now the co-founder and CTO of Pivolis, a company specialized in applying Agile Methodologies to Offshore Software Development. Consultant and lecturer during the day and open source developer at night, Vincent dreams of the time when he will be wise enough to devote all his time to his wife and two children. Vincent currently lives in Paris, France.
Ted Husted is the lead author of the best-selling Struts in Action, an active member of the Struts development team, and manager of the JGuru Struts Forum. As a consultant and lecturer, Ted has worked with Java development teams throughout the United States. Ted's most recent development project uses Test-Driven Design throughout and is available as open source [wqdata]. Ted lives in Fairport NY with his wife, two children, four computers, and anaging cat.
Inside This Book
(Learn More)
Browse and search another edition of this book.
Browse and search another edition of this book.
Tags Customers Associate with This Product(What's this?)Click on a tag to find related items, discussions, and people.
|
Sell a Digital Version of This Book in the Kindle Store
If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store.
Learn more
What Other Items Do Customers Buy After Viewing This Item?
Customer Reviews
Most Helpful Customer Reviews
20 of 23 people found the following review helpful
Format:Paperback
think we can all agree that unit testing is a good thing that can be painful to implement. The main problem with unit testing is building tests that are easy to run and maintain. That is where JUnit enters the picture. JUnit simplifies the task of creating unit tests and this book simplifies the task of understanding and using JUnit.
The book starts with the basics of using JUnit but then moves on to explaining the intricacies of JUnit. UML diagrams clearly show the flow of control within JUnit and your unit tests. The author gives a good description of how to integrate JUnit with Ant, Maven, and Eclipse. The book also shows how to do unit testing of Servlets and JSPs which can be much more complex to test. The author demonstrates both the use of Cactus as well as the use of mock objects for J2EE testing. In fact, the best part of the book is that the author helps you determine how to decide what type of testing strategy is right for your application.
I thoroughly enjoyed this book and found the author's comments clear and insightful. The author supplies plenty of code samples with explanations of not just how but why we do our testing a certain way. The author's own experience is passed on to us with his "best practices". Anyone who is writing Java code should read and understand this book. The quality of the code you produce will vastly improve.
Format:Paperback
This is an the best introduction I have found to JUnit and to testing Java software in general. One reading has provided all the help I needed to implement a unit test framework for my current project, a few pointers for the next steps to build on this foundation, and some background knowledge about tools that I don't need yet but may well use in the future.
The authors take the view that "an example is worth several pages of explanation", and their examples are simple enough to understand quickly, but complete enough to be adapted for use in a real project. The explanation, which is of course also necessary, is clearly written.
JUnit itself is introduced in Part 1 of the book, followed by a more general guide to unit testing in Part 2, which covers such topics as using stubs and mocks. Part 3 explains how to include a test stage in the build process using Ant or Maven, and finally Part 4 covers extensions to JUnit. This final part is less detailed than the rest of the book, but gives some understanding of more specialised topics such as testing web applications and database access, and provides pointers to further information and software.
The authors take the view that "an example is worth several pages of explanation", and their examples are simple enough to understand quickly, but complete enough to be adapted for use in a real project. The explanation, which is of course also necessary, is clearly written.
JUnit itself is introduced in Part 1 of the book, followed by a more general guide to unit testing in Part 2, which covers such topics as using stubs and mocks. Part 3 explains how to include a test stage in the build process using Ant or Maven, and finally Part 4 covers extensions to JUnit. This final part is less detailed than the rest of the book, but gives some understanding of more specialised topics such as testing web applications and database access, and provides pointers to further information and software.
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com:
25 reviews
19 of 19 people found the following review helpful
A quality and indepth view into the world of Unit Testing
20 Nov 2003
Format:Paperback
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).
17 of 17 people found the following review helpful
the first edition was better
20 Aug 2010
Format:Paperback
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.
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.
12 of 12 people found the following review helpful
A joy to read but...
20 Feb 2005
Format:Paperback|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...
Were these reviews helpful?
Let us know
Listmania!
|
|
Look for similar items by category
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
|
