|
Your search returned 13 matching documents
Testing Applications on the Web
by
Hung Quoc Nguyen
|
Wiley
1 edition
October 2000
400 pages
|
Reviewed by Ersin Eser, May 2002
         (9 of 10)
I grabbed this book to improve my understanding of web applications testing, and to start exploring the field. Well, it was a great decision. The book thoroughly explains the terms, steps, and approaches involved in web applications testing while providing an excellent introduction to gray-box testing. As we all know, web apps run on a variety of platforms and anything can change in the system. So be prepared for the unexpected.
The Author's point is that testers should learn more about the technical details of the system and understand how things interact with the specific application while building the test plans.
I liked the book a lot; it gives a perceptive to very valuable information. If you are serious about web application testing, you must have this book. It is a great companion for a web application tester. At the end of each testing sample, the author provides tips that you will appreciate, and you also will be able to find testing-related links at the end of book.
The author supports his approach with his experience in the field, and I was not surprised to learn that he is president of a software testing company.
Discuss book in the Saloon —
More info at Amazon.com
|
Unit Testing in Java
by
Johannes Link, Peter Froehlich
|
Morgan Kaufmann
1 edition
April 2003
325 pages
|
Reviewed by Jason Menard, February 2004
(8 of 10)
Johannes Link's "Unit Testing in Java: How Tests Drive the Code" bills itself as "a practical introduction to unit testing for software developers." Link's book is very comprehensive and touches on most of the topics a developer will need to know about before setting off on his own, including some topics that have not been addressed in similar titles.
The first half of the book addresses basic techniques for unit testing. The author is a proponent of eXtreme Programming and test-driven design, and those concepts are explored as they relate to unit testing. This first part of the book is quite exhaustive and contains in great detail pretty much everything you would expect. One pleasant surprise here was a nice chapter on inheritance and polymorphism as it relates to unit testing. Link offers some excellent advice on this rarely addressed topic.
Once you've mastered the basic techniques, Link kicks it up a notch and addresses some more advanced topics relevant to our day-to-day lives as Java developers. The book discusses unit testing persistent objects, web applications, and GUIs, as well as rarely examined topics such as concurrent programs and distributed applications. As if that weren't enough, Link throws in an outstanding chapter on the role of unit tests in the software process which is necessary reading if you are attempting to integrate the book's practices into your own organization.
"Unit Testing in Java" isn't an overly large book, but it is certainly a dense book. The tone is academic and some of the phrasing is awkward, although it should be kept in mind that it is a translation from German. I like to think of "Unit Testing in Java" more as a text to be studied, rather than as a reference. However, there is so much that is good in here, that it is definitely worth the effort spent reading it.
Discuss book in the Saloon —
More info at Amazon.com
|
Morgan Kaufmann
1 edition
April 2003
325 pages
|
Reviewed by Frank Carver, July 2003
(9 of 10)
This book starts by covering general techniques in unit testing, including when and why to do it, how to know if you are doing it right, and how it integrates with other development practices. This is good stuff, but mostly also covered in other books. The section on Mock Objects is especially well done though, illuminating an often misunderstood topic area.
The latter half is where this book shines. It tackles some of the really tough areas and does it very well. Singletons, database persistence, asynchronous services, concurrent and distributed systems, web applications and graphical user interfaces; all these are often skipped over as "too hard to test". If you've ever found yourself thinking something like that, you need this book.
This book is a translation from a German original. Although the translators have done a tremendous job with the technical content, sometimes a phrase or section title, especially in the initial introduction can seem very unusual. Don't be put off by the quirky language in the early chapters, the meat of the book is well worth reading and putting into practice. This book is a masterly example of how to convert programming theory into solid, practical advice.
Discuss book in the Saloon —
More info at Amazon.com
|
Java Testing and Design
by
Frank Cohen
|
Prentice Hall PTR
1 edition
March 2004
544 pages
|
Reviewed by Andrew Monkhouse, April 2004
(9 of 10)
This book is an excellent guide to testing web applications and web services, and will benefit all readers from someone just starting testing, through to experienced testers trying to test a particular service.
The first third of the book describes testing in general, and how it can be applied to web applications. The second part tackles different connectivity methods, from HTTP through XML & SOAP; from one off messages, through testing sequences of messages (including maintaining session data), from user testing, through performance testing. Each chapter describes the issues and the potential problems with testing, then provides a clearly detailed description of testing using the PushToTest open source test tool. The final third of the book details some case studies of tests that Mr. Cohen has been asked to devise.
My biggest concern with this book is that, despite it's title, it really has very little to do with Java. The tests definitely apply to applications written in Java, and java classes can be used by Mr. Cohen's test application, however the book equally applies to testing any networked service, regardless of the language it was written in! Of lesser concern is that there is practically no discussion about testing outside PushToTest testing framework (not a big concern since PushToTest is open source).
This does provide excellent insights into testing, and easy to use tools and explanations for performing the tests. I have no hesitation in recommending this book to anyone involved in testing networked applications.
Discuss book in the Saloon —
More info at Amazon.com
|
Java Testing Patterns
by
Jon Thomas, Matthew Young
|
Wiley
1 edition
October 2004
424 pages
|
Reviewed by Jeanne Boyarsky, October 2004
(4 of 10)
"Java Testing Patterns" is one of those books where it appears nobody edited. Java class/method names and acronyms are used in lower/upper case interchangeably. Writing class names in all lowercase in a Java book doesn't inspire much confidence in the accuracy of the rest of the book. There are many typos and inconsistencies that make it hard to read.
The formatting is also very poor. The code looks good in Eclipse, but not in the book. Lines wrap without indentation. Similarly, UML diagrams are randomly split into pages. They are supposed to be on the web, but they aren't yet.
The intro states a target audience of "software engineers, engineering managers and software testers." This book is heavily reliant on reading code. After the first few chapters, I don't think managers or testers would benefit.
Speaking of code, I think the code is too verbose and complicated -- especially for a book. A few times, a simple JavaBean's source takes up one to two pages. One DAO takes up 12 pages. There is a test method with 16 branches. These examples make understanding quite difficult.
Now as for what the book does well. There are five good chapters on patterns. However, two are in essence the Factory and State patterns. The appendices are very good too. I wouldn't buy a book for three chapters and some appendices. Other books cover the material better. I would not recommend this book in its current edition.
Discuss book in the Saloon —
More info at Amazon.com
|
Exploratory Software Testing
by
James A. Whittaker
|
Addison-Wesley Professional
1 edition
September 4, 2009
224 pages
|
Reviewed by Jeanne Boyarsky, October 2009
(9 of 10)
"Exploratory Software Testing" was a very enjoyable read. It is geared towards testers, but I think developers and informal testers can benefit from it as well.
My favorite section of the book was the "tours." This extended analogy compares vacation and testing. It points out different types of testing in a creative and memorable way. Examples:
- "morning commute" = startup
- "arrogant American" provides silly inputs
- "tourist district" differences between experienced/novice users
The author then provides case studies of how the tours were used at Microsoft. I really liked how he showed the importance of focusing on a completely different point of view in different tests.
The first 136 pages provide enough reasons to buy the book. The rest is the author's background, newsletter type posts from university and his Microsoft blog (http://blogs.msdn.com/james_whittaker). While I'm not a fan of blog posts verbatium in a book, it was in an appendix at least.
If I could change three things about the book:
1) A list or table of the tours in one place
2) More consistency in the format of each Microsoft tester's description
3) Order the blog posts by topic rather than chronologically. Posts in a "series" should be together in printed form
As you can see, my biggest "complaints" about the book are quite minor.
And to make the FTC happy: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch.
More info at Amazon.com
|
Selenium Testing Tools Cookbook
by
Gundecha Unmesh
|
Packt Publishing
edition
November 2012
326 pages
|
Reviewed by Jeanne Boyarsky, May 2014
(8 of 10)
"Selenium Testing Tools Cookbook" covers a lot of ground. I've written some Selenium tests and still learned new things in chapter 1.
It's not meant to be an introduction book so you should have written a test before. I like the depth on foundations though. From browser plugins to advanced selectors, there is a lot to see. I particularly liked the CSS selector syntax summary.
It was good to see JSExecutor covered - I wasted a good amount of time with this on a problem in the past. I liked seeing the page object pattern (which looks like a DSL) and the Actions framework. I like the example of a parameterized test case in chapter 4. I would have liked to see it broken up so not a ton of code in a row though.
There are warnings as needed when showing a feature that you might not want to use. Or when showing a feature that is only available in some cases. For example, the HtmlUnitDriver doesn't support taking screenshots.
I could write a review without mentioning the JDBC example has a resource leak. It may be "just" test code, but I still remember the time (a decade ago) that I locked out the test database server because my integration test had a resource leak in it.
I was skeptical when the book said it covered Java, C#, Python and Ruby. But it really does. This book is going to be a helpful reference to have around when I'm writing future tests.
Discuss book in the Saloon —
More info at Amazon.com
|
Automated Web Testing Toolkit: Expert Methods for Testing and Managing Web Applications
by
Diane Stottlemyer
|
Wiley
unknown edition
July 2001
304 pages
|
Reviewed by Frank Carver, December 2001
(2 of 10)
I tried real hard to find something to like about this book. I was disappointed. Testing of web sites and web applications is an area which desperately needs some good books, but this is not one of them.
The author seems to have cobbled this book together from some old course notes, inserted the word "web" here and there and put some obviously obsolete material in the past tense. It baldly assumes a heavyweight and ill-considered development process, and makes unsubstantiated statements about an unrepresentative selection of software packages. Automated testing is mentioned only in passing, between superficial descriptions of project- and risk- management. Virtually no mention is made of the things which make web applications hard to test - browser differences, massive concurrency, stateless protocols, network issues ...
It lacks the depth for a developer or tester, but I can't even recommend this book as a management overview - so much of the content is either dangerously misleading, obsolete, or just plain wrong.
Discuss book in the Saloon —
More info at Amazon.com
|
Pragmatic Unit Testing in Java with JUnit
by
Andy Hunt, Dave Thomas
|
JUnit Recipes: Practical Methods for Programmer Testing
by
J.B.Rainsberger, Scott Stirling
|
Manning Publications
1 edition
July 2004
752 pages
|
Reviewed by Lasse Koskela, October 2004
 (10 of 10)
J.B. recently replied jokingly, "buy them their own copies", to my mentioning that my team would be all over my copy of "JUnit Recipes" like vultures if I was to leave it on the desk at work. I have to say that's not a bad idea. In fact, that's what you should do if you're determined to make your development team learn how to write effective unit tests in those non-trivial settings you inevitably encounter out there.
"JUnit Recipes" is, as its name implies, not a tutorial for writing JUnit tests although it does start small with some 50 pages of basic conventions and fundamentals of writing JUnit tests. Instead, it's a huge collection of little recipes for tackling those everyday problems developers around the world encounter when trying to unit test their applications. Real world solutions to real world problems. The book is divided into chapters by coarse-grained topics such as organizing test suites, test data, XML, EJB's, JDBC, etc. all the way to testing web components and J2EE applications. The last hundred or so pages of the book talk about some more exotic topics such as unit testing design patterns, using certain popular JUnit Extensions such as GSBase and JUnit-Addons.
The recipe approach fits the domain perfectly. One doesn't need to reach 30 some pages of prose before "getting it", which is the case with certain types of books discussing other problem domains. The recipes go straight to the meat of the subject with concise and clear problem statements and then quickly proceed to show how to go about solving them. The formatting of the provided code snippets is excellent as usual, with strong visual highlighting of important sections and careful indentation.
Joe has managed to put out something that I believe will be known as the unofficial JUnit bible for years to come. What are you waiting for?
Discuss book in the Saloon —
More info at Amazon.com
|
Manning Publications
1 edition
July 2004
752 pages
|
Reviewed by Ernest Friedman-Hill, September 2004
(9 of 10)
Sometimes the tiniest things are the most useful. Nails, screws, paperclips and post-its are all small, simple objects that are used a thousand different ways. So it is with JUnit -- a small and really very simple testing tool that can find its way into every corner of your Java development.
Rainsberger's book is a compendium of those thousand ways that JUnit can be used (well, OK, more like 130 ways). Each recipe starts with a solid motivation and includes a worthwhile discussion afterwards. You quickly realize that the author is sharing hard-won experience with you on every page. There are sections on testing standalone code of every description, as well as detailed sections on testing servlets, EJBs, and other less tractable components.
I've been using JUnit for years, but I picked up quite a few useful tips from this enjoyable book. Highly recommended.
Discuss book in the Saloon —
More info at Amazon.com
|
Manning Publications
1 edition
July 2004
752 pages
|
Reviewed by Dirk Schreckmann, August 2004
(10 of 10)
"Wow!" on two accounts: 1. I'm actually giving a 10 horseshoe rating to a book, and 2. "JUnit Recipes" is a very thorough and comprehensive encyclopedia of excellent advice and examples on almost every coding sitution I've ever wanted to test with JUnit.
J. B. Rainsberger has compiled a 700 page collection of scores of excellent recipes written in pattern-like fashion, clearly laying out testing problems in wont of solutions and the practical recipes for solving the problems, including annotated code examples, step-by-step instructions, and plenty of quality explanations.
"JUnit Recipes" is destined to be a classic, and has earned a most prominent place on my bookshelf, as I'm certain I'll be referencing it frequently for new and better ideas on formulating JUnit tests.
What's that? You'd like to borrow my copy of "JUnit Recipes?" No, get your own.
Discuss book in the Saloon —
More info at Amazon.com
|
Next Generation Java Testing: TestNG and Advanced Concepts
by
Cedric Beust, Hani Suleiman
|
Addison-Wesley Professional
1 edition
October 2007
512 pages
|
Reviewed by David O'Meara, January 2008
(6 of 10)
The first thing to note about the book Next Generation Java Testing is that while it does indeed cover advanced testing concepts in Java, these concepts are largely geared towards the use of the free TestNG (www.testng.org) product, and I think it is worth being aware of and accepting this from the beginning. The book contains valuable information on testing alone, just not enough to make it worth while if you're not interested in at least evaluating TestNG.
Possibly unfairly, this book will be judged based on a comparison between JUnit and TestNG themselves, rather than being able to judge the book on its own merits. The TestNG product is aimed at a complete redesign of the Java unit testing process, so it surprised me that the only real discussion on JUnit was a nod towards them in the first chapter, and a mention that some of the TestNG features had been incorporated into JUnit. Strange then that there wasn't greater effort placed on comparing and contrasting their tool against the industry standard.
When treated as a stand-alone book, it is a good reference for TestNG, and if you have already evaluated the product and would like to use it then this is a good book to help you do that. It won't, however, help you make this decision, and while the TestNG product has some intriguing features and different ways to test than that of JUnit, I believe you'll already need to be experienced in JUnit to get full use of both the book and the product.
Discuss book in the Saloon —
More info at Amazon.com
|
Addison-Wesley Professional
1 edition
October 2007
512 pages
|
Reviewed by Jeanne Boyarsky, November 2007
(7 of 10)
"Next Generation Java Testing" has a subtitle: "TestNG and Advanced Concepts." This isn't surprising given the creator of TestNG is an author, but is important to realize. It starts with 6.5 pages on why TestNG is better than JUnit 3.8. Then only two paragraphs on JUnit 4. This has been a pet peeve of mine for some time. It's like comparing the current version of C# to Java 1.3 and then saying Java is worse because it doesn't have generics.
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.
Discuss book in the Saloon —
More info at Amazon.com
|
Agile Testing: A Practical Guide for Testers and Agile Teams
by
Lisa Crispin, Janet Gregory
|
Addison-Wesley Professional
1st edition edition
January 9, 2009
576 pages
|
Reviewed by Katrina Owen, May 2010
(9 of 10)
Agile Testing takes a look at quality from nearly every angle there is, and not just from the tester's perspective. It is not a nitty-gritty how-to test software -- it is assumed that if you are a tester you already have experience with this. It is comprehensive, starting with a 30,000 foot overview of agile and the different types of testing in an agile project, and then proceeding to cover various aspects of producing quality software, mostly from the point of view of testers. Testers are seen as a core part of the development team, and quality is seen as everyone's responsibility.
The book covers many different types of testing, both in terms of how tests are performed (manual vs automated, scripted vs exploratory), or for different purposes (testing correctness vs robustness, ferreting out bugs, solving the right problem, and solving the problem right), or to test different layers of an application (functionality, scalability, usability, performance, load, security). There is an excellent deep dive into automation -- both in terms of how-to automate, and what to automate. The book goes beyond just the mechanics of testing, covering people issues, process issues, and tool issues.
Highly recommended for anyone who works on an agile team, who would like to work on an agile team, or who would like to help transition their team to more agile processes.
Discuss book in the Saloon —
More info at Amazon.com
|
Effective Unit Testing: A guide for Java Developers
by
Lasse Koskela
|
Manning Publications
edition
February 2013
248 pages
|
Reviewed by Jeanne Boyarsky, March 2013
(10 of 10)
"Effective Unit Testing" felt familiar to me. I think it is because I read "Test Driven" and saw the author present some of the content from this title at the 2012 Server Side Java Symposium. You can get a feel for some of the smells from my live blog post of that session http://www.selikoff.net/2011/03/16/test-smells-breakout-at-the-server-side-java-symposium/
Part one sets the stage. It walks you through a hypothetical teams journey - no tests → tests → test driven! I liked the examples of bad code and bad test examples. And I really like the explanation of different types of test doubles. I also liked the example of jMock vs Mockito to do the same thing.
Part two shows you a series of test smells and how to fix them. One of my favorites is something really simple. How to make a bowling example more readable by using method names so you can embed "magic values" in the code. I also particularly liked the segment on how parameterized tests can be an anti-pattern along with how to avoid this problem.
Part three is "other things." It covers using other JVM languages to test and how to make your tests faster. Both via the tests and running them in the cloud. I really liked the part on how to profile in both Ant (which I knew) and Maven (which I haven't needed to yet.)
While there is an appendix to get you up to speed on JUnit, you should read a different book if you are trying to get up to speed on JUnit. I recommend "JUnit in Action" or "Test Driven" for that. Once you know any unit testing framework, it is time to come back to this book so you can write better tests.
It was a great book. My only problem was that having seen the session some was repetitive. But I highly recommend both the book and the talk.
---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
Discuss book in the Saloon —
More info at Amazon.com
|
Implementing Automated Software Testing: How to Save Time and Lower Costs While Raising Quality
by
Elfriede Dustin, Thom Garrett, Bernie Gauf
|
Addison-Wesley Professional
1 edition
March 2009
368 pages
|
Reviewed by Jeanne Boyarsky, April 2009
(9 of 10)
"Implementing Automated Software Testing" is meant for software test professionals and managers. The authors also list developers and project managers in the target audience. If an organization has developers/pms in a dual role, this makes sense. The book really is written from a QA viewpoint.
At least one of the authors has done work for the Department of Defense and the other two sound like they have worked closely with it. The writing style reminds me of the CMM documents - a government research paper style leaks through. This isn't a bad thing - I thought it was a very good book - just something to be prepared for.
I particularly liked the distinction between Automated Software Testing and playback/record testing. The book really walks you through setting up an Automated Software Testing program. It contain recipes (which are more like requirements), each of the phases and how to respond to roadblocks. There was a whole chapter dedicated to myths and best practices. For someone setting this up, there are checklists and a job description (skills and roles) needed for each of the phases.
Overall, this book is like a field guide for someone about to start an Automated Software Testing program. My only criticism is that it is acronym heavy - remember the government paper comment - and could have used a glossary.
More info at Amazon.com
|
|
