- Amazon Student members save an additional 10% on Textbooks with promo code TEXTBOOK10. Enter code TEXTBOOK10 at checkout. Here's how (restrictions apply)
Next Generation Java Testing: TestNG and Advanced Concepts Paperback – Oct 15 2007
|New from||Used from|
Special Offers and Product Promotions
Customers Who Bought This Item Also Bought
No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
To get the free app, enter your e-mail address or mobile phone number.
From the Back Cover
Enterprise Java developers must achieve broader, deeper test coverage, going beyond unit testing to implement functional and integration testing with systematic acceptance.Next Generation Java™Testingintroduces breakthrough Java testing techniques and TestNG, a powerful open source Java testing platform.
Cédric Beust, TestNG's creator, and leading Java developer Hani Suleiman, present powerful, flexible testing patterns that will work with virtually any testing tool, framework, or language. They show how to leverage key Java platform improvements designed to facilitate effective testing, such as dependency injection and mock objects. They also thoroughly introduce TestNG, demonstrating how it overcomes the limitations of older frameworks and enables new techniques, making it far easier to test today's complex software systems.
Pragmatic and results-focused,Next Generation Java™Testingwill help Java developers build more robust code for today's mission-critical environments.
- Illuminates the tradeoffs associated with testing, so you can make better decisions about what and how to test
- Introduces TestNG, explains its goals and features, and shows how to apply them in real-world environments
- Shows how to integrate TestNG with your existing code, development frameworks, and software libraries
- Demonstrates how to test crucial code features, such as encapsulation, state sharing, scopes, and thread safety
- Shows how to test application elements, including JavaEE APIs, databases, Web pages, and XML files
- Presents advanced techniques: testing partial failures, factories, dependent testing, remote invocation, cluster-based test farms, and more
- Walks through installing and using TestNG plug-ins for Eclipse, and IDEA
- Contains extensive code examples
Whether you use TestNG, JUnit, or another testing framework, the testing design patterns presented in this book will show you how to improve your tests by giving you concrete advice on how to make your code and your design more testable.
About the Author
Cédric Beust, a senior software engineer at Google, is an active member of the Java Community Process who has been extensively involved in the development of the latest Java release. He is the creator and main contributor to the TestNG project.
Hani Suleiman is CTO of Formicary, a consulting and portal company specializing in financial applications. He is one of two individual members who has been elected to the Executive Committee of the Java Community Process.See all Product Description
Most Helpful Customer Reviews on Amazon.com (beta)
I liked the code snippets in the TestNG sections as they focused on relevant pieces. The examples were to the point. Especially the performance and J2EE sections. I liked the concepts described in chapter 2 (over 100 pages.)
The authors describe open source libraries that integrate with TestNG. I liked this coverage although JMock could have used a code example for comparison (easyMock had one.) Ant targets were provided for the code coverage examples.
Chapter seven is titled "digressions." Some quotes from the text on this: "pet peeves, rants, annoyances and musings", "much ... very tangentially relevant", "some ... outright irrelavant." I agree with some and disagree with some. I think this chapter would have been better as a series of blog posts than a chapter in a book.
If you are using/planning to use TestNG and can ignore the rants, this is a good book.
So it makes sense that this book is a kind of exhaustive compendium of testing approaches, and as such, it succeeds, in most ways. There are a few things that don't show up, for instance, there is discussion of container testing, but Shale is not mentioned (unit testing JSF is made much better by it, and JSF is part of JEE5 so it deserves attention). The section on testing XML was good, considering dom4j, XMLUnit, etc., but it ends too quickly. For instance, what about using XPath statements? or some schema tools?
Given that Cedric's partner in crime, of Bileblog fame, was aboard for this outing, rants were bound to ensue, and they are mostly useful and add value, if they are rather tame. The one about logging left me just totally perplexed. Logging is not good? It's made out to be even possibly harmful? Say what? On the other hand, the rants about JUnit are on target. Their rant about using test coverage as a badge of honor is right on the money.
They even go into Spring's test mechanisms, and do a good job with it. Then they skate through Guice to discuss some of the advantages of preventing the spread into XML. Now, the lead argument here is that not only does the metadata produce bloat, but it puts logic out of the grasp of refactoring tools (an argument Cedric has used v. dynamic languages).
In an age where computer books are usually long articles, this book goes through a dizzying range of subjects, and does so without resorting to the bland repetition of documentation that is already out there. I could only have wished for a greater emphasis on innovation. The reason is that this book I am afraid will scare people who really need to be brought into the fold. It's pathetic, really, but most teams are still either not testing or doing crazy things like writing a few tests after delivering the code. For people who have dug around trying to get a lot of the right things into their test diet, this is the best guide available right now.
This book describes using TestNG along with some advanced TestNG concepts and goes on to show how to use the framework to test out JEE projects. There are also chapters showing the developer how to integrate TestNG with other frameworks (like spring, DBUnit, jwebunit etc) which is useful as this is perhaps the only place where JUnit is better than TestNG. Inspite of the fact that TestNG documentation is pretty good, this book is worthwile buying (even if you use JUnit as your testing tool of choice).
There is useful coding and refactoring advice along the way(also a commentary on TDD), and a miscellaneous chapter of sorts which seems to have been written by Hani and edited by Cedric to remove all profanities!.
I do hope the author's expand the testing enterprise application bits to cover more testing scenarios and examples in later additions.
Covering all of the essentials, this book will get you started right away in testing your source in a useful, organized manner. It will also help you find many of the traps that we have *ALL* allowed ourselves to fall into. There's just about no question left unanswered by this text in regards to working with TestNG and its associated technologies, concepts, etc.
The only two things I disliked about the book should be obvious to even the novice skill sets out there, but are easily breezed through if they annoy you that much. The first is that the rants about JUnit and other things were slightly too long. The second is that it does not acknowledge when it sticks its foot in its mouth.
Testing is loaded with "Do as I say, not as I do" mentalities/concepts. It's also faced with many "Sometimes you just *HAVE* to break the rules" scenarios. The book DOES break its own rules and, while it is obvious to the reader, does not take the time to truly justify why their own rule was being broken.
Great book... easy to read, follow and take to the real world.
Recommended read for all, but I recommend skipping the rants.
There are some claims that I found hard to follow: For example, the authors advise against using mock objects to stub out external classes, then later state that servlets are hard to test outside of a container because they depend on a few external classes -- never mind that these are simple to mock out, and that the Spring testing library (which they mention elsewhere) even provides mock implementations for these classes. There are also some minor factual errors that should have been caught in the reviewing process (e.g. contrary to what is claimed, annotations can be inherited).
Then there is the "Digressions" chapter, which, as others have pointed out, should have been posted as a series of blog posts. Instead, there are some areas where more detail could have been provided. e.g. on how groups work in TestNG, or the exact semantics of the parallel test execution options. Now that TestNG has been out for a while and gained a lot of popularity, I'm sure there is also a lot more information on common problems that could be included in a future 2nd edition!
Look for similar items by category
- Books > Computers & Technology > Computer Science > Systems Analysis & Design
- Books > Computers & Technology > Programming > Java
- Books > Computers & Technology > Programming > Languages & Tools
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Development
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Testing
- Books > Computers & Technology > Software
- Books > Textbooks > Computer Science & Information Systems > Programming Languages