Test Driven Development in Microsoft Net: Learn How to Leverage Test-Driven Development in The...

Rating:
Summary: Average
Review: I bought this book hoping it would clarify some of the issues I have with TDD, but not so. Granted the book does a decent job explaining what TDD is, but the level of coverage and detailed explanations aren't good.

Rating:
Summary: 7/10
Review: I give this book seven out of ten

What I liked about it:
It is easily to read. The topics are well presented and clearly defined.
The book introduces the concepts behind TDD (Test Driven Development)
Some of the less trivial aspects of TDD are discussed, like testing web services or using transactions.
Refactoring is introduced very well in chapter three.
The concepts of FIT are well explained and demonstrated.

In order to get a ten:
The book needs to decide who the target audience is. The material seemed too hard for a first introduction book and too simple for advanced developers.
As the book is about TDD it should have spent more time examining the benefits of developing software using this approach.
I would have liked to have seen more real world (hard to solve) problems tackled.

Rating:
Summary: Good, but derivate and incomplete
Review: If you want to really learn about test driven development, go to the original book by Beck. If you really want to learn about refactoring, go to the original book by Fowler.

This book does try to cover virgin territory with testing apps that use databases and web interfaces - but it really falls apart at the Web GUI interface level (not to be confused with the Web services interface level, which the book covers well). The techniques recommended in the book essentially try to simulate a web GUI interface with nUnit versus actually using an existing web GUI interface. With one Web form, maybe this isn't too much duplication, but with a large Web app, this is just silly - plus it never tests the actual Web client, so the test results are obviously incomplete. The authors neglect how easy it is to truly test a Web GUI interface - with java based tools (JWebUnit & HttpUnit) which build on top of xUnit, and which work fine on any web app (including asp.net) dot net programmers will need a little understanding of java syntax to use these tools, but java and c# and so nearly identical syntactically for the subset needed, that this is not much of an issue. I hope native ports of these tools to the dot net world are coming soon, but you can live without them and still test Web GUIs easily enough with a little java knowledge, and the authors are remiss in neglecting this.

Plus the blurb on Amazon about the book promised a Windows Form based example - and this is NOT in the book at all!

Rating:
Summary: Good, but derivate and incomplete
Review: If you want to really learn about test driven development, go to the original book by Beck. If you really want to learn about refactoring, go to the original book by Fowler.

This book does try to cover virgin territory with testing apps that use databases and web interfaces - but it really falls apart at the Web GUI interface level (not to be confused with the Web services interface level, which the book covers well). The techniques recommended in the book essentially try to simulate a web GUI interface with nUnit versus actually using an existing web GUI interface. With one Web form, maybe this isn't too much duplication, but with a large Web app, this is just silly - plus it never tests the actual Web client, so the test results are obviously incomplete. The authors neglect how easy it is to truly test a Web GUI interface - with java based tools (JWebUnit & HttpUnit) which build on top of xUnit, and which work fine on any web app (including asp.net) dot net programmers will need a little understanding of java syntax to use these tools, but java and c# and so nearly identical syntactically for the subset needed, that this is not much of an issue. I hope native ports of these tools to the dot net world are coming soon, but you can live without them and still test Web GUIs easily enough with a little java knowledge, and the authors are remiss in neglecting this.

Plus the blurb on Amazon about the book promised a Windows Form based example - and this is NOT in the book at all!

Rating:
Summary: Changes Your View
Review: Many people think that Test-Driven Development (TDD) is all about testing software. In fact, test-driven development's main goal is not testing software, but aiding the programmer and customer during the development process with unambiguous requirements. The requirements are in the form of tests that the software must pass along the development process.

This procedure helps to insure that problems are found early and corrected while they are still small.

This book first discusses TDD from a conceptual point of view then gives a TDD example using a realistic application.


Rating:
Summary: Great introduction to TDD on .NET
Review: Obviously, the best way to learn TDD is by doing it, but a short tutorial like this helps immensely. I bought this book to fill in TDD and NUnit gaps after learning the ropes at work from an experienced TDD Java developer. The book covers the basic principals of TDD and provides a thorough NUnit tutorial. Other reviewers nitpicked the web unit testing section and the depth of coverage, but all neglected to mention that the book is mercifully short. What sort of depth do you want on a very complex and subjective topic like TDD in ~250 pages? In my opinion:

1) A good xUnit tutorial
2) Coverage of the principals of TDD
3) Basic examples of TDD principals and xUnit applied in the target language/platform

This book provides all three. After reading through just a few chapters, I embarked on a TDD-based project at work that now has several hundred tests. The info in the book directly contributed to a solid design for my tests, which has proven to be quite scalable across dozens of classes and an extreme amount of refactoring due to new requirements and bug fixing. I can't ask for more than that from such a short book.

In my opinion, it's not the author's responsibility to dictate the best tools to use for every single TDD situation--NUnit coverage is good enough to get any experienced programmer started, and it's really up to you to experience and discover the right tools for the job. TDD is a fairly new concept for .NETers (so new that MS won't have any tools of their own for TDD until Visual Studio 2005 is released), and tools are popping up almost monthly on SourceForge for testing ASP.NET, WinForms, and for integrating NUnit into Visual Studio.

Cheers to James and Alexei for putting forth such a great, short introduction to TDD for everyone on .NET.

Rating:
Summary: Too shallow
Review: The book provides only shallow explanation of how TDD is supposed to work. Oversimplification may lead to bad code. For example, Red/Green/Refactor principle is only good if your first test is comrehensice enough. Imagine you are writing a parser for a complex language (HTML, C++, whatever). You simply can't write it piece by piece, i.e. write test for parsing a simple construct and then add more code to parse more complex constructs. What you end up with is a bunch of spagetti ifs. Your first test should be large enough to force you to use lex/yacc approach. The grammar does not have to be complete, but the framework has to be there from the beginning. Stack example is way too simple. C'mon, decent developer should be able to implement it correctly on whiteboard in 30 minutes. NUnit software is mentioned too many times, the book begins to look like a commercial.

Rating:
Summary: Great intro to TDD and more
Review: This books fits in fine with our recent search of .net enterprise devlopment material and we have out it to good use. Some of the chapters seem out of place.

Rating:
Summary: eXtreme Programming reaches .NET
Review: This is the first XP related book that uses .NET I know.

If you have tried to create an Architecture using ADO.NET for data access, and ASP.NET WebServices. You will see a very good one using the patterns described in Fowler's PEAA, but the best thing is that you don't see the whole picture until page 151 !! that's TDD.

And if you are trying to use TDD and automated tools to drive your development efforts this book will be unvaluable. The design of NUNit Tests it's great, and the introduction of different tools like fit.c2 to drive customer tests it's the definitive feature to involve customers in XP management.

Hope everyone enjoy it as me

Rating:
Summary: You can't judge a book by its cover
Review: When picking up this book for the first time, I expected to be submersed in the concepts of test driven development with some specific Microsoft .Net principles here and there.

Instead, the book presented a brief conceptual look at TDD, which was a good start. Then, the authors dove into how to develop a very extensive music system using SQLServer and .Net data access objects, sporadically sprinkled with unit tests.

If the reader wanted to learn how to build a complicated database driven system, the reader would buy a SQLServer book. The concepts needed to demonstrate the principles of TDD with .NET could have been much more clearly demonstrated with a much simpler example. Perhaps, fewer tables in the schema and more tests.

Even more frustrating was the way that the authors violated one of the key principles of TDD outlined in the first few chapters: Red, Green, Refactor. Consistently, the authors would implement a piece of functionality in the example and then go back and write a test for it. My colleagues and I have been using TDD for about a year and learned from experience that writing code before a test is difficult, pointless, and contradictory.

I recommend "Test-Driven Development: By Example" by Kent Beck for a more true conceptual explanation of TDD. The examples are in Java but it is simple enough to translate to C# without a problem.

After reading the Beck book, the documentation for NUnit and Fit (the technologies discussed in the book) is much more helpful if the reader wants to learn how to use the specific technology.