Hudson Valley Sudbury School

            Shopping Cart  Cart  |  Help
AllBooksVideoDVDMusicVideo GamesGames and ToysElectronicsSoftwareComputersToolsKitchenApparel

Java Testing and Design : From Unit Testing to Automated Web Tests
by Frank Cohen
Publisher: Prentice Hall PTR
List Price: $49.99
Price: $43.78
You Save: $6.21 (12.42%)
Availability: Usually ships in 24 hours
Edition: Paperback
35 used & new from: $31.90
Ready to Buy?
Price: $43.78
Availability: Usually ships in 24 hours
22 New from $39.41
13 Used from $31.90
Customers who bought this also bought:
1. Unit Testing in Java: How Tests Drive the Code by Johannes Link, Peter Fröhlich
2. Hibernate in Action (In Action series) by Christian Bauer, Gavin King
3. Expert One-on-One J2EE Development without EJB by Rod Johnson, Juergen Hoeller
4. Better, Faster, Lighter Java by Bruce A. Tate, Justin Gehtland
5. Pragmatic Project Automation: How to Build, Deploy, and Monitor Java Apps by Mike Clark
Product Details
  • Paperback: 544 pages
  • Publisher: Prentice Hall PTR; edition (Mar 16, 2023)
  • ISBN: 0131421891
  • Average Customer Review: 4.0 Based on 7 reviews.
  • Sales Rank: 397071

Customer Reviews

2 of 2 people found the following review helpful:

5Highly recommended for advanced developers and IT managers, Nov 10, 2022
It is really rare book with amazing combination of theoretical insight and practical experience. No doubts that his entire recommendations author found not in books, but as result of numerous successful projects he participated in. Author teaches not only how to use one particular product, doesn't follow some primer book example, but shares with reader his insight. Careful reader may save a lot of money and time, by avoiding buying of expensive products with limited feature, but rather starting creation of efficient and robust testing scripts on basis of fruits given by open source community.

6 of 6 people found the following review helpful:

5Lot of controvery here, this is an awesome book!, Jul 15, 2023
Boy! For a book on testing for geeks the reader reviews show there's some controvery here.

Ok, so here is what I loved about this book: It shows the geeks a way to deliver SOA (meaning J2EE apps, .NET apps, Web sites, Web Services, Web applications, and anything else that uses a network) that runs 24x7 and won't fall over when a lot of users show up all at once.

The book's central argument is that businesses operating SOA need to have the cooperation of coders, QA, and network managers to really be successful.

So do I recommend this book to a hard core J2EE engineer? Yes, because the QA geek that tests the J2EE engineer's code doesn't code in Java. They need something just as powerful but not as complex as Java. The book gives us a dozen reasons why the Jython scripting language is an ideal medium between the J2EE engineer and the QA geek. For example, the unit tests the J2EE engineer writes can be reused as scalability and load tests by QA. The same goes for network managers who use the unit tests as service monitors. All that has been missing is a common framework coders and QA can use! Very cool stuff.

Why else did I like this book... Because after reading the book my boss finally understands why testing is important for the services we are deploying. He uses this book to explain to his bosses how we should be going about testing our services: The book says everything should be tested against the user's goals and it shows how to do it. That's awesome!

I very much liked that all of the example scenarios presented in the book come with real, live, working test code. And if I'm not happy with using TestMaker (which is free! duh!) I can take the examples to any of the other test utilities out there.

Java Testing and Design is an awesome book.

9 of 10 people found the following review helpful:

3Some good information, but..., Jul 2, 2023
I recently received a review copy of Java Testing And Design - From Unit Testing To Automated Web Tests by Frank Cohen (Prentice Hall). While there is some good information to be gleaned from the book, there were a few things that got in the way.

The chapter layout: The Forces at Work Affecting Your Web-Enabled Software; When Application Performance Becomes A Problem; Modeling Tests; Java Development and Test Automation Tools; Bridging from Methodology to Design; Design and Test in HTTP/HTML Environments; Tuning SOAP and XML Web Services; State, Design, and Testing; Integrating with .NET Web Services; Building and Testing Intranets and Secure Environments; A Web Application Framework from Construction to Test; Turning Test Agent Results into Actionable Knowledge; Concurrency and Scalability in a High-Volume Datacenter; Making the Right Choices for SOAP Scalability; Multiprotocol Testing in an Email Environment; Index

When I first requested the book, I was thinking it would help me to understand how to adequately test my Java programs using software like JUnit and such. Throw in some methodology and best practices, and I was ready to go. To be fair, the author does cover the topics of testing quite throughly, and especially testing of web-based HTTP applications. If you're not looking for software how-to or detailed discussion of many different products, then you'll benefit from the book.

Where I had problems is that most of the technical parts of the book involve showing the reader how to use an open source package that he wrote called TestMaker by PushToTest. There is, in my view, too much "using the software that we wrote" material. All the code uses JavaDoc comments that show the particular PushToTest developer who wrote the code. Before too long, I felt as if I was in a 500 page infomercial for TestMaker. The software might well be excellent, but I felt somewhat lead astray in that I felt as if I was being pushed towards TestMaker rather than towards a variety of tools that one could use. I would have felt better about the whole thing had the title been "Java Testing And Design Using TestMaker".

7 of 10 people found the following review helpful:

2This book disappointed me ?, Jun 11, 2023
The complexity of Java technology compounds the challenges associated with web-based applications testing. That's why I was excited when I noticed this book. However, the book disappointed me once I read it.

The complexity of Java technology compounds the challenges associated with web-based applications testing. That's why I was excited when I noticed this book. However, the book disappointed me once I read it.

The Name
The first disappointment was the book's title. The first word of the title is "Java," but the author avoids showing any Java code. The closest he gets to Java is Jython, a scripting language implemented in Java. If you are designing or testing performant Java applications, you will be better off reading Enterprise Java Performance by Steve L. Halter and Steven J. Munroe, also from Prentice Hall. If I were to name this book, I'd call it "Testing Webservices with TestMaker & Jython."

Topic Organization
This book is a collection of very wordy, unclear, and unrelated notes. The diary-like organization of topics, left me wondering, "where is the meat." Repetition of subject matter, unfocused discussion and abrupt transition of topics will bound to make you lose your attention. Examples don't build upon one another. If you are very dedicated and focused, you are left with tons of irrelevant text to skim through to derive any real value. Some ancillary topics could have been better located in an appendix. A list of acronyms or glossary of terms would be nice.
You will notice frequent typo/errors in this book.

Vague Notions
While building the context to promote TestMaker and "intelligent agent" as the be all and end all of Software Engineering (Part I, about 200 pages), the book cared less to define the term itself. TestMaker is a free, open-source tool for unit testing, load testing, and system monitoring developed by the book's author.

Target Audience
Contrary to a few comments about this book, this book provides little value to Java developers. However, Web Rubrics (an objective performance grading matrix), User Archetype (a Prototypical User, modeling user behavior and habit. Is an extension of UML Actor), WAPS (Web-enabled Application Points System - A matrix to measure software quality based on functionality, performance and scalability) and The Micromax Lifecycle (many small improvement to software application and techniques to categorize and prioritize micro-tasks) might be of interest to "QA technicians" and "IT Managers."

I normally look for two qualities to assess a book. First, does the book cover a generic ground in sufficient depth to serve as a reference? Poor organization and shallow coverage of concepts doesn't put this book on my reference bookshelf. Secondly, I look for hands-on examples that can serve as a tutorial for the reader. This book doesn't provide a single line of Java code.

To summarize, I do not recommend this book for Java developers interested in learning more about Java testing and design.

3 of 4 people found the following review helpful:

5Improve your web apps, May 24, 2023
Despite the curious title, this book focuses on the value that well planned and executed testing brings to a project. The subtitle "From Unit Testing to Automated Web Tests" does the book more justice, but still there is a lot more here.

In the first part of the book, the author focuses on a philosophy of testing. This includes a variety of testing protocols (i.e. unit testing, functional testing, performance testing), how they should be executed, and how to evaluate the results. He introduces a web rubric to use in the assessment of testing results. This gives the development staff an objective way to determine where to focus their corrective efforts. Testmaker, a toolset for intelligent test agents, is introduced. Testmaker is an open source product that can be used to automate much of the testing process and to evaluate the results. The author's concept of user archetypes for building the intelligent test agents is very effective.

In the second part of the book, the author brings the concepts of the first part to address some specific technologies like http/html, SOAP, and integrating with .Net web services. In each section, the author builds a little insight into the specific technology and addresses testing challenges that one may face. Finally, he addresses the big issue of turning these test results into actionable items. The final section of the book focuses on case studies of the successful implementation of the principles and toolset as described in the book.

This book has convinced me that automated testing can be an invaluable asset to a development project. It should be on your bookshelf along with "User Interface Design for Programmers" by Spolsky for practical advice on application development.

Look for similar items by category in Books

Copyright © 2004 Hudson Valley Sudbury School