Customer Reviews

Java Testing and Design: From Unit Testing to Automated Web Tests

5 star:		(5)
4 star:		(1)
3 star:		(1)
2 star:		(1)
1 star:		(0)

 

 

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

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.

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

Reference/Textbook
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.

The testing of any computer code should ideally be as systematic and logical as the code itself. But given the parlous nature of some code, this is scarcely reassuring about the testing.

For Java code, Cohen attempts to inject some discipline. He describes the by now well known need for comprehensive unit testing. But this is just the lowest level. Above these are functional tests, scalability and performance tests, and quality of service tests. These require that you consider what users will typically do. In practice, he suggests that the users' collective behaviour might be considered polymodal. You try to divide the users into different categories of behaviour, and then represent each category by a generic user. He calls these archetypes. This effort is not trivial in most cases.

But, in his experience, the main difficulty is in the next step. You should try to build programs, called test agents, which can simulate each archetype. The test agents then access the main program in such a way that the latter cannot distinguish between these and real users. This takes automated unit testing to the next level.

If you are a programmer, you can appreciate the amount of work needed to do this. Much of the book revolves around explaining how to make a test agent and the various test automation tools available to help you.

This book is an excellent guide to testing web applications and web services. I expect it will benefit all readers, from the software developers or QA tech just getting started, through to the experienced coders and testers.

Java Testing and Design comes in three parts. The first part describes the things we developers, QA techs and IT folks deal with everyday - tough schedules, user needs, messed up management and test methodologies past and present. All this is shown being applied to building Web applications. The second part takes on the nuts-and-bolts aspect of building networked applications, including different connectivity methods (from http through XML and SOAP), from functional unit tests to testing sequences of messages and session data. It puts a whole new light on testing from the user's perspective using a new method called user archetypes - basically test scripts that mimic a user's behavior. It's a cool technique to make testing a lot more simpler.

The chapters describe the issues and the common areas where things go wrong. Then each chapter provides a detailed description of testing using the TestMaker free open-source test tool.

The third part of the book covers some case studies of tests that Frank Cohen had to devise. These include tests for scalability and throughput of SOAP-based Web Services. He also uncovers a huge scalability problem with Web Services that every Service Oriented Architecture (SOA) developer should know about. RPC-based Web Services do not scale and the book shows why and how anyone can find the results.

The book's title is a little weird since the book has little to do with Java itself. You could be a .NET developer and get just as much from the book. I would have liked to see more coverage of other test tools but since TestMaker is free and open source that's no problem for me.

Java Testing and Design provides excellent insights into testing and gives you tools and explanations for performing tests of Web-enabled applications. I recommend this book highly.

I love a good technical book. Over the years I've bought a lot of them. Some have been the kind of book that is basically a detailed reference guide to a very specific topic. Others are an introduction to a new technology or a new way of doing something. Java Testing and Design (JTD) covers the high level issues of testing services and also gives you code-level examples.

The goal of the book is to make this case: Delivering service excellence requires a new level of cooperation between software developers, QA technicians, and IT managers. JTD defines services as any software application that is accessible over a routed network using open protocols. JTD is a book about testing services, including Web applications, Service Oriented Applications, and n-tier applications. JTD begins with testing methodology, covers protocols and architecture decisions, and delivers code-level examples in TestMaker scripts.

TestMaker is a framework and utility that is composed of a number of open-source libraries and tools. The book uses TestMaker to show you by example how to accomplish testing tasks. The examples can easily be applied to other testing tools, languages and platforms.

For example, chapter 7 talks about the move developers made from HTTP applications through XML-RPC and into SOAP-based Web Services. The chapter shows the reasons why XML-RPC is cool and appropriate applications for XML-RPC. It then covers the things that typically go wrong with XML-RPC to give you some thoughts on how to test an XML-RPC application. The chapter then presents a TestMaker script showing how to make an XML-RPC call. TestMaker uses the Apache XML-RPC library. So, the example script shows by example how Apache XML-RPC could be used in a Java application too.

The book breaks down into three parts: JTD starts with an understanding of the reasons the existing testing methodologies fail to deliver excellent services. This part describes a test methodology and several techniques for measuring service excellence. The second part introduces the technologies used to deliver scalable and well performing services, make the case for where they are appropriately used, talks about the problems, and then shows a how-to example in code. The third part of JTD shows three case studies of how the methodology is applied to solving enterprise scalability, regression, functionality, and quality-of-service problems in information services.

I recommend Java Testing and Design to anyone needing to understand the scalability and performance characteristics of SOA.

-Walk

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.

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.