26 of 28 people found the following review helpful:
5.0 out of 5 stars
building, testing, and deploying J2EE applications, January 13, 2002
By A Customer
This review is from: Java Tools for Extreme Programming: Mastering Open Source Tools Including Ant, JUnit, and Cactus (Paperback)
I find if you are doing J2EE development this book is a must-have! Even if you are not doing XP. Don't let the XP title turn you off from this book.
At first glance at this book, I thought it was trying to be too many things to too many people. It seems to contain every buzzword: Opensource, Extreme Programming, Java, JSP, TagLibs, EJB, etc.
However the book focuses on applying Ant, JUnit and Cactus to J2EE development.
The book is very J2EE and web application centric. A small part of the book had very choppy flow--a few rough spots. Mostly (95%) the book is well written. Generally the book is easy to follow.
My favorite chapters are the ones on JUnitPerf and Cactus.
The case studies are a little long, but they can be skipped and returned to later.
The source code on the website is hidden in plain site. It took a while to find it.
The description above and title miss an important point. The book is J2EE/Jakarta centric. J2EE testing and continous integration can be very difficult without the use of Ant, JUnit, HttpUnit and Cactus.
The description of the book on the companion website clears up the missing points well. I found the description while searching for the source code.
From the companion website:
"Java Tools for eXtreme Programming describes techniques for implementing the Extreme Programming practices of Automated Testing and Continuous Integration using Open Source tools, e.g., Ant, JUnit, HttpUnit, JMeter, and much more."
"The book contains small examples and tutorials on each tool. The examples cover building, deploying, and testing Java and J2EE applications."
"In addition to small examples, there are larger case studies. The case studies are larger more realistic examples. We have case studies involving XSLT, EJB, Struts, JDBC, etc."
"Each case study is complete with an ant build script and several tests, written with JUnit, HttpUnit, Cactus, JUnitPerf and/or JMeter. The case studies focus on building, deploying and testing J2EE applications with Ant and JUnit."
"There is also a reference section for APIs. Instead of rehashing the API documentation, the reference section has example usage, i.e., code examples for the important classes and methods."
"Although this book speaks from an XP perspective, you need not practice XP to benefit from it. For example, you do not have to adopt the entire XP methodology to get value out of this book. Automated testing, for example, can help you refactor code regardless of whether you are doing pair programming or not. Continuous integration can help you detect and fix problems early in the lifecycle of the system regardless of whether your customer is on site or not."
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
20 of 21 people found the following review helpful:
4.0 out of 5 stars
Java Open Source tools power XP!, April 9, 2002
This review is from: Java Tools for Extreme Programming: Mastering Open Source Tools Including Ant, JUnit, and Cactus (Paperback)
This book is not about extreme programming (XP). Rather it teaches open source software tools we can use to utilize one important aspect of XP: Continuous testing. XP principles say that you should write your unit test code according to the requirements *before* you write any application code. That guarantees that your software meets the minimum requirements for now. And if refactoring is needed in the future (likely), you will have a set of unit tests that can guarantee the changes you make are correct. In this book, the authors discuss frameworks and tools to write and automate the testing process for sophisticated application server software.
The authors started with Jakarta build tool ANT. As a build automation tool, ANT is used throughout the rest of the article to provide an integration point for other test tools. ANT itself is not very complicated (It is designed to be easy-to-use!). The book goes through simple ANT syntax and build processes. The authors also give an advanced example of automating the build and deployment process of a complex J2EE web application. It is a nice review of different components of a J2EE application and how they work together.
After ANT, the authors move on to discuss the popular Java unit test framework JUnit. JUnit is not really so much a "tool" since it only offers very simple implementing classes. But rather, it is a "framework" that provides the conceptual basis of object oriented unit testing. It defines the steps to setup and execute tests. JUnit can be extended to make specialized and automated tests for complex circumstances.
One such specialized, JUnit based testing tool is Jakarta Cactus for J2EE application unit testing. This book really shines in its explanation and extensive examples on how to install, setup and use Cactus. The difficulty of J2EE unit tests is that all components have to run inside J2EE containers. Cactus counter this by running tests on both client side and server side. Once ANT automatically redelopyed and restarted the server, the client side Cactus test engine sends out requests to the server using customized request/response connectors. The connectors pass the information to server side Cactus and allow it to setup server side environments such as session objects and context objects, according to the test requirements. Then the server runs the test case and sends the results back to the client. The client tests assertions and and reports to the tester. That process guarantees the server side test code runs under a controlled environment.
Cactus unit testing can be quite complex due to the multiple parties involved. So, the authors give a good example on how to test JSP custom tags. It illustrates how to setup those tests and test the life cycle methods for each tag handler step by step. This is an example on how to use Cactus in real life.
Unit testing is an important development method. But in complex in-container J2EE applications, we also need to make sure all units work together in integration (function) tests. The authors discussed integration test tool HttpUnit, performance test tool JUnitPref and JMeter.
Overall, this is an excellent book covering a wide range of Java build and testing issues. It would be even better if you can provide more examples outside of J2EE area. Examples on automated testings in GUI applications and even J2ME applications can be very useful.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
14 of 14 people found the following review helpful:
4.0 out of 5 stars
Put XP theory into practice, December 8, 2001
This review is from: Java Tools for Extreme Programming: Mastering Open Source Tools Including Ant, JUnit, and Cactus (Paperback)
I have been struggling with turning XP methodology into a solid development process. We've had some success at my company but most times we've met frustrations primarily because we were trying to teach old tools new tricks.
Rick Hightower's java Tools for XP has made a big difference for us. My team has been able to use the tools described in this book to actually DO unit testing, and we've already automated a significant portion of our testing and deployment processes. Its also let us make a good case for open source tools at my company.
I agree with one reviewer that the chapter on the sample application is tough to get through. This chapter is LONG!!! But it was worth it because obviously you have to understand you application to build appropriate tests. The tests in the book did a great job of showing us what we should be doing with our own applications.
Maybe it's a learning style difference but I disagree with the reviewer who complained about the API chapters. I found them useful because 1) they weren't a lame rehash of the docs, and 2) they have a ton of code snippets. So I read the chapters to get the overall gist of the tool and see examples of it working, and then mainly used the API chapters at the back to build my tests.
One small complaint about the book: I was suprised when I got it that the cover was washed out. It looked like Amazon had it sitting in their window for a while before they sent it to me. But hey, the inside sure is easy to read!
Overall I definitely recommend this book as the first book to make XP real.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
