Beautiful Testing: Leading Professionals Reveal How They Improve Software (Theory in Practice) Review

Average Reviews:

(More customer reviews)Are you looking to buy Beautiful Testing: Leading Professionals Reveal How They Improve Software (Theory in Practice)? Here is the right place to find the great deals. we can offer discounts of up to 90% on Beautiful Testing: Leading Professionals Reveal How They Improve Software (Theory in Practice). Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Beautiful Testing: Leading Professionals Reveal How They Improve Software (Theory in Practice) ReviewThis is a great book for testers, leads, and managers to read to get a better picture of where your testing process can bring value to your work. A few sections of this book didn't get me much value, but the vast majority of the book left me frantically scratching notes and folding corners of pages over. I read the book over a weekend and came away with a large number of major additions to my QA roadmap I use at work.
Kamran Khan's chapter on fuzz testing reinforced my ideas that choking your system with invalid parameters and input data is a tremendous way to shore up that system's stability. I also really enjoyed Lisa Crispin's and Alan Page's separate chapters, both of which emphasized value-driven, sensible approaches to test automation.
If you want an amazing story around how testing can directly impact the lives of those around you, read Karen Johnson's chapter "Software in Use." Johnson ties a visit to an Intensive Care Unit to work she'd done on equipment in that ICU - it's rare anyone sees that practical a link to work we do in this industry.
Other highly worthwhile chapters include the piece on Python's development process, the overview on TDD, Mozilla's regression testing philosophy, and others. The Python chapter, in particular, is a tremendous testament to how a rigorous testing philosophy can guarantee very solid releases even with a broad, distributed team of varying skills.
As my examples above point out, there's a great amount of broad-stroke value in the book; however, a wealth of smaller, critical points abound in various chapters as well. Some weren't phrased exactly like this, but I've taken away these other concept as well:
* Track the source of your bugs (test plans, exploratory, developer, etc.) and pay special attention to bugs found by customers. These "escapees" point to areas to shore up in your test plan.
* Mindmaps are a great way to brainstorm out your test plan or test areas.
* Use small tools like fuzzers to help create your baseline input data.
* 100% passing rates for your automated tests isn't reasonable. Investigating 100% of your failing tests to determine whether the specific failure matters is reasonable. (I already firmly believed this, but it was nice to see in print!)
* Using image comparison to check formatting.
This is one of the better books I've read this year, and it's absolutely worth adding to your shelf.
Beautiful Testing: Leading Professionals Reveal How They Improve Software (Theory in Practice) OverviewSuccessful software depends as much on scrupulous testing as it does on solid architecture or elegant code. But testing is not a routine process, it's a constant exploration of methods and an evolution of good ideas. Beautiful Testing offers 23 essays from 27 leading testers and developers that illustrate the qualities and techniques that make testing an art. Through personal anecdotes, you'll learn how each of these professionals developed beautiful ways of testing a wide range of products -- valuable knowledge that you can apply to your own projects. Here's a sample of what you'll find inside:

Microsoft's Alan Page knows a lot about large-scale test automation, and shares some of his secrets on how to make it beautiful
Scott Barber explains why performance testing needs to be a collaborative process, rather than simply an exercise in measuring speed
Karen Johnson describes how her professional experience intersected her personal life while testing medical software
Rex Black reveals how satisfying stakeholders for 25 years is a beautiful thing
Mathematician John D. Cook applies a classic definition of beauty, based on complexity and unity, to testing random number generators

All author royalties will be donated to the Nothing But Nets campaign to save lives by preventing malaria, a disease that kills millions of children in Africa each year. This book includes contributions from:

Adam Goucher
Linda Wilkinson
Rex Black
Martin Schröder
Clint Talbert
Scott Barber
Kamran Khan
Emily Chen
Brian Nitz
Remko Tronçon
Alan Page
Neal Norwitz
Michelle Levesque
Jeffrey Yasskin
John D. Cook
Murali Nandigama
Karen N. Johnson
Chris McMahon
Jennitta Andrea
Lisa Crispin
Matt Heusser
Andreas Zeller
David Schuler
Tomasz Kojm
Adam Christian
Tim Riley
Isaac Clerencia



Want to learn more information about Beautiful Testing: Leading Professionals Reveal How They Improve Software (Theory in Practice)?

>> Click Here to See All Customer Reviews & Ratings Now

Read More...

xUnit Test Patterns: Refactoring Test Code Review

Average Reviews:

(More customer reviews)Are you looking to buy xUnit Test Patterns: Refactoring Test Code? Here is the right place to find the great deals. we can offer discounts of up to 90% on xUnit Test Patterns: Refactoring Test Code. Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

xUnit Test Patterns: Refactoring Test Code ReviewLet me start by stating the obvious: this is a patterns book about the organisation of tests and the workings of the xUnit family of unit testing frameworks. It is _not_ a book about Test Driven Development, although there is material that is pertinent to that. Given that the use of JUnit and TDD is pretty intertwined in the minds of many Java developers, it's worth making this distinction, so you know what sort of book you're getting. Speaking of JUnit, most of the code examples uses Java, although there are some examples in C#, VB and Ruby.
Like Martin Fowler's Patterns of Enterprise Application Architecture, the book is split into two main sections, a narrative that weaves together a lot of the patterns and strategies, and then a catalogue of individual patterns. Between the two, there is a catalogue of 'test smells', similar to the 'code smells' discussed by Fowler in Refactoring, which I would suggest can be read profitably with the narrative section, rather than used as reference material.
There are a lot of patterns here on the mechanics of xUnit, such as 'Test Runner', 'Garbage-Collected Teardown' and 'Named Test Suite'. I was a bit confused about who this material is aimed at -- maybe someone looking at porting xUnit to a new programming language would find it useful, but a lot of it is fairly obvious to anyone who's used an xUnit in a non-trivial fashion (and certainly, if you haven't done so, this book is not a format that makes for a good introduction), or requires playing against xUnit's strengths (e.g. not putting setup and teardown code in their eponymous methods), although there is good reason for doing so in some of the examples provided, such as databases.
Beyond this, there is some good stuff on design-for-testability patterns (e.g. dependency injection versus dependency lookup), value patterns to replace magic constants, custom assertions and custom creation and other utility methods to make the intent of tests more clear. This material, along with the test smells chapter, is where the real value of the book lies. It encourages the application of the same software engineering principles you would apply to your applications (encapsulation, intent-revealing names, Don't Repeat Yourself) as you would to your testing code, something that's surprisingly easy to overlook, at least in my experience.
Also, the material on 'Test Doubles' (mocks, stubs, dummies and their ilk) is extremely useful. It touches on designing with mocks only superficially, but it does provide a helpful taxonomy of what different classes of doubles do. Now, if only everyone would standardise on this nomenclature, it would make life a lot easier. I suggest we brandish this enormous book threateningly at anyone who refuses to toe the line, and that should do the trick.
Because, boy, this book is big (about 900 pages). To be honest, it's too big. I rarely complain about getting too much book for my money, but the likes of GoF, PoEAA and PoSA 1 manage to come in between 400-500ish pages, so there's no reason XTP couldn't. The advantage is that the patterns in the catalogue, which take up most of the space, stand alone, without requiring too much flicking backwards and forwards between patterns.
The disadvantage is that there is a lot of repetition, so unlike the three design patterns books I mentioned above, which I suspect most people read cover to cover (or maybe that was just me and I'm a complete freak), I would suggest only dipping into the catalogue as necessary. For instance, how much difference is there between the 'Testcase Class per Class', 'Testcase Class per Feature' and the 'Testcase Class per Fixture' patterns? Not a lot, as you might expect.
I definitely liked this book. I would have liked it even more if it came in at about half its size and I would have preferred more emphasis on test and assertion organisation than the mechanics of the xUnit framework, but maybe that would have been a different type of book to the one Gerard Meszaros intended. This is nonetheless a must buy for anyone who cares about unit testing.xUnit Test Patterns: Refactoring Test Code OverviewAutomated testing is a cornerstone of agiledevelopment. An effective testing strategy will deliver newfunctionality more aggressively, accelerate user feedback, and improvequality. However, for many developers, creating effective automatedtests is a unique and unfamiliar challenge.
xUnit Test Patternsis the definitive guide to writing automated tests using xUnit, themost popular unit testing framework in use today. Agile coach and testautomation expert Gerard Meszaros describes 68 proven patterns formaking tests easier to write, understand, and maintain. He then showsyou how to make them more robust and repeatable--and far morecost-effective.
Loaded with information,this book feels like three books in one. The first part is a detailedtutorial on test automation that covers everything from test strategyto in-depth test coding. The second part, a catalog of 18 frequentlyencountered "test smells," provides trouble-shooting guidelines to helpyou determine the root cause of problems and the most applicablepatterns. The third part contains detailed descriptions of eachpattern, including refactoring instructions illustrated by extensivecode samples in multiple programming languages.
Topics covered include

Writing better tests--and writing them faster
The four phases of automated tests: fixture setup, exercising the system under test, result verification, and fixture teardown
Improving test coverage by isolating software from its environment using Test Stubs and Mock Objects
Designing software for greater testability
Usingtest "smells" (including code smells, behavior smells, and projectsmells) to spot problems and know when and how to eliminate them
Refactoring tests for greater simplicity, robustness, and execution speed
Thisbook will benefit developers, managers, and testers working with anyagile or conventional development process, whether doing test-drivendevelopment or writing the tests last. While the patterns and smellsare especially applicable to all members of the xUnit family, they alsoapply to next-generation behavior-driven development frameworks such asRSpec and JBehave and to other kinds of test automation tools,including recorded test tools and data-driven test tools such as Fitand FitNesse.

Visual Summary of the Pattern Language Foreword Preface Acknowledgments Introduction Refactoring a Test PART I: The Narratives Chapter 1 A Brief Tour Chapter 2 Test Smells Chapter 3 Goals of Test Automation Chapter 4 Philosophy of Test Automation Chapter 5 Principles of Test Automation Chapter 6 Test Automation Strategy Chapter 7 xUnit Basics Chapter 8 Transient Fixture Management Chapter 9 Persistent Fixture Management Chapter 10 Result Verification Chapter 11 Using Test Doubles Chapter 12 Organizing Our Tests Chapter 13 Testing with Databases Chapter 14 A Roadmap to Effective Test Automation PART II: The Test Smells Chapter 15 Code Smells Chapter 16 Behavior Smells Chapter 17 Project Smells PART III: The Patterns Chapter 18 Test Strategy Patterns Chapter 19 xUnit Basics Patterns Chapter 20 Fixture Setup Patterns Chapter 21 Result Verification Patterns Chapter 22 Fixture Teardown Patterns Chapter 23 Test Double Patterns Chapter 24 Test Organization Patterns Chapter 25 Database Patterns Chapter 26 Design-for-Testability Patterns Chapter 27 Value Patterns PART IV: Appendixes Appendix A Test Refactorings Appendix B xUnit Terminology Appendix C xUnit Family Members Appendix D Tools Appendix E Goals and Principles Appendix F Smells, Aliases, and Causes Appendix G Patterns, Aliases, and Variations Glossary References Index


Want to learn more information about xUnit Test Patterns: Refactoring Test Code?

>> Click Here to See All Customer Reviews & Ratings Now

Read More...

Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer) Review

Average Reviews:

(More customer reviews)Are you looking to buy Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer)? Here is the right place to find the great deals. we can offer discounts of up to 90% on Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer). Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer) ReviewThe previous reviews I read about this book gave great praise. And all that they said is true, the book is well written, clear, concise, and easy to understand - with rich wonderful hands on examples and source code. A wonderful entry into the Microsoft offerings of testing right along with software development.
What makes this an even better buy or value added product is that if there is an issue with why things work (or don't work the way they should) the author(s) will follow up with you in an attempt to clear up any misunderstandings.
Not only is it a very good read, the authors can and do add additional value to the book long after it has been paid for - should there be any questions upon anything contained in the text - something that is very unusual in this realm or domain. I can not say enough about the quality of this book and the quality of the service one gets should they have a need to contact one of the authors - in my case it was Andy Leonard - who kept helping with something that wasn't even his issue - it was one of those undocumented Microsoft "features".Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer) Overview
Visual Studio 2005 Team System (VSTS) features a robust, integrated suite of test tools that work seamlessly in the Visual Studio development environment
Covering all phases of the development lifecycle, this book shows readers how to implement best practices for software testing using the appropriate components of VSTS
Readers will learn how to use the tools effectively, directly from those who helped design and develop the software
Shows how to catch common programming mistakes every time code is compiled, helping to shorten the time to market


Want to learn more information about Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer)?

>> Click Here to See All Customer Reviews & Ratings Now

Read More...