Customer Reviews: The Art of Unit Testing: with Examples in .NET
Your Garage Best Books of the Month Amazon Fashion Learn more nav_sap_plcc_ascpsc $5 Albums Fire TV Stick Subscribe & Save Patriotic Picks Shop-by-Room Amazon Cash Back Offer roadies roadies roadies  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Introducing new colors All-New Kindle Oasis AutoRip in CDs & Vinyl Segway miniPro

Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on June 9, 2009
This book covers unit testing in .NET from a pragmatic, yet thourough and passionate, perspective. In brief, it covers many important dimensions of unit testing from simple "hello world" tests over the use of Stubs and Mocks to how you write maintainable test code. It also covers organizational topics such as how you introduce unit testing in an organization and how to do code reviews of tests.

Although unit testing has become somewhat synonymous with Agile practices, such as Test-Driven Development (TDD), the book never assumes that you will be using TDD. It is valuable wether you write your tests before or after your code.

Roy Osherove clearly has a lot of experience with unit testing, and he willingly shares so we can learn from his mistakes and successes. As a long-term practitioner of TDD myself, I can vouch for most of the advice imparted by this book: It is based on established patterns and best practices that the unit testing community have arrived at through years of experimentation.

Being the anal-retentive perfectionist that I am, I would have liked to see the book adopt the Pattern Language of xUnit Test Patterns: Refactoring Test Code (Addison-Wesley Signature Series), but at least the guidance of those two books are very much in harmony, even if the terminology differs.

In summary, you can say that this book is a very readable and useful introduction to unit testing. If you are a beginner to intermediate unit test developer, you should definitely read this book - and then, as you become more advanced, you should still read xUnit Test Patterns :)
0Comment|30 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 5, 2009
This book is not an evolutionary book to other unit testing books out there; it's revolutionary.

First of all it's not a thinly disguised book trying to sell you on TDD (as some unit testing books that I've read are), but rather it's a book that truly lives up to it's title - the art of unit testing.

Secondly, the discussions and examples in the book take real world considerations in mind. These are not simple contrite 'Hello World' tests, or 'perfect world' sets of code. It discuss' writing tests on both green and brown field applications.

A third aspect that is truly helpful is that there is an entire section for dealing with implementing unit testing in an organization and the politics you might face while doing so. Because the book isn't biased towards a particular software discipline, tool, or language, but on the 'art' of unit testing, these are tips and tricks you can take with you anywhere.

If you found books like 'The Pragmatic Programmer' or 'The Inmates are Running the Asylum' getting you revved up to write better software, then this book will drive you to a whole new level of unit testing.

I've been doing unit testing for several years now, but it wasn't until after I read this book, that it no longer was a chore that I checked off my 'TODO' list.
0Comment|18 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 17, 2010
Ok yes i didn't rate it at 5 stars but i think its definitely a book everyone should have on their shelf. A lot of books i read go up for sale after i'm done this won't happen to this book. Its a keeper. Don't kid yourself. Unit testing is hard especially if your working on a system that wasn't designed / architected for unit testing. This book allowed me to "start" implementing unit testing in our internal app that i thought in the past would be impossible to add unit test to. Roy does a lot show you how to break down a system (dependencies mainly) to be able to unit test it. He has great standards to start from (naming, construction, ect...). He also adds enough info about TDD (Test-Driven Development) to show the advantages but doesn't turn into a testing zealot.

That being said the book isn't perfect (reason for 4 instead of 5 stars). First he talks very briefly in the early chapters (forgot which one) about Inversion of Control containers (IOC). He talks about IOC somewhere around where he is talking about constructor injection. He then goes on to say that IOC are beyond the scope of the book. I definitely disagree with this and think a good amount of space in the book (maybe a chapter or part of a chapter) should have been taken discussing the principles of IOC and where/why/how to use it. Its an integral part of constructor injection. If its beyond the scope of a unit testing book then where does it belong? IOC is beyond the scope of the book yet a discussion on a productivity tool (resharper) is (which i have to say i didn't mind because i found it interesting)? I just think this is a big omission in this book and is the main reason for the (-1 star) and not my 2nd point i'm about to make.

Ok the 2nd thing is the author works for TypeMock. He finally tells you that in later chapters. He seems to push Typemock a wee to much i think. Yes TypeMock is definitely the best mocking framework out there. It will allow you to mock things that you generally couldn't mock with other frameworks (Static/Shared methods) but after looking at the cost its more than a little expensive. It would have helped us greatly but the licensing cost are unreasonable (especially when you compare it to the other frameworks...FREE). Anyways, back to the topic at hand. I think the author seems to push it a little to much in the book though i will have to give it to him for using RhinoMock (free) for almost all his examples in the book.
11 comment|9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 19, 2009
The Art of Unit Testing: with Examples in .NET

In short, if you want a tactical book on unit testing that distills the passion and love of an expert practitioner into a very readable yet reference-friendly text on unit testing, this is it.

If you are new to unit testing or TDD, this book will demystify the practices, tools and techniques that would otherwise take years and lots of frustration to get right.

If you are an experienced practitioner of unit testing and TDD, and are already practicing SOLID, TOOD, and BDD not just as a flavor of the week but as a way of life, this book will provide unambiguous insight into different approaches that will help you refine your existing techniques or at a minimum, validate your approach which is always valuable to any developer who has an opportunity to review his/her techniques with a seasoned master. This book will afford you that opportunity.

While the book cites excellent references for TDD and design patterns, if there is one thing that I thought was missing was a narrative- even if by way of an appendix- that ties all of the techniques covered together in an example of building the example Logger component using TDD. I understand that this book is not about TDD, but at the same time, that's like a book on scuba equipment that teaches you precisely how to pressurize your CO2 tank, keep your mask from fogging up and care and maintenance of your scuba suit not being about scuba diving.

That said, knowing Roy, it must have been painful to resist a detailed examination on TDD, but, for this book to be effective, it had to be relatively short, to the point and most of all pragmatic for it to succeed at filling the void on the topic of unit testing techniques and practices. To that end, Roy hits the mark very elegantly without being pretentious, catering to those who test first, test last or don't (yet) test at all. While I would love for everyone to pick this book up and start doing TDD today, even if you aren't yet convinced on TDD, applying these techniques to writing code that is testable, and learning how to test the right things will be an instant asset to your product, your team and your organization.
0Comment|9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on June 9, 2012
I work on a 75 programmer project in C++ and this book has had a noticible effect on the quality of our unit tests. I read the book after one year of unit testing experience. I was able to immediately clean up many of my own bad practices by taking advantage of the many years of experience related by the author in this book.

We bought half a dozen more copies for the team and you can almost see the rolling waves of more useful and maintainable unit tests fanning out wherever those books travel.

The .NET aspects are not intrusive. This book is very useful for anyone who writes unit tests in any language, but doesn't yet have 10 years of experience to know how best to do so.
0Comment|4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on February 1, 2012
This book gives you a very good introduction for unit testing and the explanation is neat and easy to understand. However, after reading this book you still not able to create a real test simple because the sample given is for you to understand the unit test technique. In real application, you need more than that. I get stuck when I try to apply it with my application mainly because the first thing to fake out is always the database. I have no clue at all how to apply this technique as the entity framework is not mockable and the book doesn't mention how to do it. I can't even start my first real application test in this case. I have spent a couple of weeks to figure out how to create repository and unit of work from other books. In short, this is the book for you to know what unit testing is. You should look for TDD books such as "Professional Test Driven Development with C#" if you are serious about unit testing in .Net. The additional book which might help is "Programming Entity Framework" by Julie Lerman. They both provides a very clear guide and sample on how to create a testable database layer.
44 comments|3 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 26, 2010
I thoroughly enjoyed reading the Art of Unit Testing. My only knock against the book would be chapter six, which was a bit dry and perhaps not as unambiguous as it could have been. Nevertheless, the content of the book is phenomenal. Whether someone is experienced with unit testing, or is just starting, this book is invaluable.

As I type this the things that stand out about the book are as follows:

1) A clear description of what a unit test is, as well as what it's not and how it differs from integration testing. This is important because if one isn't careful, a unit test can easily turn into an integration test.

2) Why unit testing is important and useful.

3) The differences between stubs and mocks, as well as when to use them.

4) How to create trustworthy, maintainable, and readable tests. I think this is the most important section of the book, outside of perhaps the basics about unit testing and isolation frameworks. It's obvious that if unit tests become a pain point or add friction to a developer's job, then any success or benefit from them will be limited. If one invests the time and effort to create the tests, then they should be able to get the most return out of that investment.

5) A good introduction to a variety of frameworks and techniques useful for not just unit testing, but also in facilitating good design in general.

6) Addresses the political issues involved with introducing unit testing to an organization.

Roy Osherove provides many heuristics and opinions in his book. I don't necessarily agree with all his viewpoints, but the majority of them I've found very helpful and insightful. This book also contains many gems that I will remember and refer to often. One very astute gem is as follows: "There is no object-oriented problem that cannot be solved by adding a layer of indirection, except, of course, too many layers of indirection." Adding unit tests to an application can indeed result in creating additional layers of indirection. Sometimes these layers can feel awkward or unnatural.

Thus, knowing how to make best use of unit tests is as the title suggests part art. I know this book has improved my skills at unit testing, and I highly recommend it to anyone wishing to do the same.
0Comment|3 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 20, 2013
This book is a very good book for the programmer that is past the intro stage, but, before the seasoned professional with unit tests. In other words, me.

I found this book very helpful with its suggestions on how to set up tests, what kinds of tests to use in any given scenario. I didn't really know before reading it, that unit tests should not have any external dependancies (i.e. database, file system, etc, etc.).

There are many examples in this book and was very invaluable to me. Highly recommend you pick up this book.
0Comment|Was this review helpful to you?YesNoReport abuse
on June 5, 2011
This is an excellent intro to unit testing. Easy to read, clear and with very good examples. I was glad to see the author used freeware libraries (nunit, rhino mocks) for the examples so anyone can learn with them (and then apply the principles to different libraries of they chose). This was exceptionally gratifying since he worked for a company that produced a competing commercial product at the time.

After I read this I told the rest of my team to buy a copy.
0Comment|One person found this helpful. Was this review helpful to you?YesNoReport abuse
Osherove covers new ground in this brief, dense book: unit testing. Although unit testing has become something of an article of faith among the Xtremists and in many industrial settings, the only way to learn it has been under the guidance of an experienced tester. (I recently had a shocking experience with an undergraduate class. Apparently, testing had never come up in their four years, and some didn't even know that a test should distinguish correct from incorrect behavior.) This isn't really a formal program of study, but it's the best how-to I've seen to date.

The author covers the topic at many levels. For the beginner, he presents the fundamentals like what a unit test is and even why unit testing is a good thing - which, believe it or not, some people still argue against. He shows how unit testing interacts with other parts of the design cycle, such as refactoring. Among other things, testing a module in isolation requires that the code be isolated, that its dependencies be clearly identified and be amenable to replacement by test fixtures. I didn't see Osherove state this outright, but one benefit of the unit test lifestyle is that test-friendly code has fewer dependencies and more explicit ones - something that makes maintenance enormously easier, or even possible in some cases.

Large parts of this book refer to specifics of the .NET environment or of specific tools, of which dozens seem to exist. Even if you don't use those tools or that environment, there are still important lessons in these sections, since concepts are often transferable even if particulars aren't. He adds new meaning to common knowledge, too. For example, he defends some cases of redundant tests written by different people, on the grounds that they're likely to test different things. This puts new words to the "N-version programming" concept familiar in the fault-tolerance world. There, the hope is that different implementations will contain different defects; here, the observation is that different implementations often detect different defects.

Of course, I found a few things to disagree with. Osherove makes little mention of randomized testing, something that I often find useful - directed tests cover the cases I was thinking about, but randomized testing often reveals cases I wasn't thinking about. And, although I generally agree with his premise that tests themselves shouldn't contribute to the debug burden, I find that looping over data elements that specify test cases can decrease global test complexity at some cost in local complexity.

Beginners shouldn't expect to understand everything that Osherove presents. Likewise, experienced testers should be patient with the introductory material that leads up to the advanced discussion. All of this book will have value to one reader or another, but any one reader might not find all of it useful. Also, unit test tools are still maturing, so discussing the many tools available makes parts of this book seem scattered. Still, if you don't have a test guru to study with (or even if you do), I strongly recommend this book.

-- wiredweird
0Comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse