Professional Test Driven Development with C#

James Bender is Vice President of Technology for Improving Enterprises. He is a Microsoft MVP, working on everything from small, single-user applications to Enterprise-scale, multi-user systems. Jeff McWherter is a Partner and Director of Development at Gravity Works Design and Development. In 2010 Jeff was awarded with the Microsoft MVP for the third consecutive year.

INTRODUCTION xxv

PART I: GETTING STARTED

CHAPTER 1: THE ROAD TO TEST-DRIVEN DEVELOPMENT 3

The Classical Approach to Software Development 4

A Brief History of Software Engineering 4

From Waterfall to Iterative and Incremental 5

A Quick Introduction to Agile Methodologies 6

A Brief History of Agile Methodologies 6

The Principles and Practices of Test-Driven Development 7

The Concepts Behind TDD 8

TDD as a Design Methodology 8

TDD as a Development Practice 8

The Benefi ts of TDD 9

A Quick Example of the TDD Approach 10

Summary 17

CHAPTER 2: AN INTRODUCTION TO UNIT TESTING 19

What Is a Unit Test? 19

Unit Test Definition 20

What Is Not a Unit Test? 20

Other Types of Tests 22

A Brief Look at NUnit 24

What Is a Unit Test Framework? 24

The Basics of NUnit 25

Decoupling with Mock Objects 28

Why Mocking Is Important 28

Dummy, Fake, Stub, and Mock 29

Best and Worst Practices 35

A Brief Look at Moq 36

What Does a Mocking Framework Do? 36

A Bit About Moq 36

Moq Basics 36

Summary 40

CHAPTER 3: A QUICK REVIEW OF REFACTORING 41

Why Refactor? 42

A Project’s Lifecycle 42

Maintainability 43

Code Metrics 43

Clean Code Principles 45

OOP Principles 45

Encapsulation 45

Inheritance 46

Polymorphism 48

The SOLID Principles 49

The Single Responsibility Principle 50

The Open/Close Principle 50

The Liskov Substitution Principle 51

The Interface Segregation Principle 51

The Dependency Inversion Principle 52

Code Smells 52

What Is a Code Smell? 52

Duplicate Code and Similar Classes 53

Big Classes and Big Methods 54

Comments 55

Bad Names 56

Feature Envy 57

Too Much If/Switch 58

Try/Catch Bloat 59

Typical Refactoring 60

Extract Classes or Interfaces 60

Extract Methods 62

Rename Variables, Fields, Methods, and Classes 66

Encapsulate Fields 67

Replace Conditional with Polymorphism 68

Allow Type Inference 71

Summary 71

CHAPTER 4: TEST-DRIVEN DEVELOPMENT: LET THE TESTS BE YOUR GUIDE 73

It Starts with the Test 74

Red, Green, Refactor 76

The Three Phases of TDD 77

The Red Phase 77

The Green Phase 78

The Refactoring Phase 79

Starting Again 79

A Refactoring Example 79

The First Feature 80

Making the First Test Pass 83

The Second Feature 83

Refactoring the Unit Tests 85

The Third Feature 87

Refactoring the Business Code 88

Correcting Refactoring Defects 91

The Fourth Feature 93

Summary 94

CHAPTER 5: MOCKING EXTERNAL RESOURCES 97

The Dependency Injection Pattern 98

Working with a Dependency Injection Framework 99

Abstracting the Data Access Layer 108

Moving the Database Concerns Out of the Business Code 108

Isolating Data with the Repository Pattern 108

Injecting the Repository 109

Mocking the Repository 112

Summary 113

PART II: PUTTING BASICS INTO ACTION

CHAPTER 6: STARTING THE SAMPLE APPLICATION 117

Defi ning the Project 118

Developing the Project Overview 118

Defi ning the Target Environment 119

Choosing the Application Technology 120

Defi ning the User Stories 120

Collecting the Stories 120

Defi ning the Product Backlog 122

The Agile Development Process 123

Estimating 124

Working in Iterations 124

Communication Within Your Team 126

Iteration Zero: Your First Iteration 127

Testing in Iteration Zero 127

Ending an Iteration 128

Creating the Project 129

Choosing the Frameworks 129

Defi ning the Project Structure 131

Organizing Project Folders 131

Creating the Visual Studio Solution 132

Summary 134

CHAPTER 7: IMPLEMENTING THE FIRST USER STORY 137

The First Test 138

Choosing the First Test 138

Naming the Test 139

Writing the Test 140

Implementing the Functionality 148

Writing the Simplest Thing That Could Possibly Work 148

Running the Passing Test 157

Writing the Next Test 158

Improving the Code by Refactoring 165

Triangulation of Tests 166

Summary 166

CHAPTER 8: INTEGRATION TESTING 169

Integrate Early; Integrate Often 170

Writing Integration Tests 171

How to Manage the Database 171

How to Write Integration Tests 172

Reviewing the ItemTypeRepository 173

Adding Ninject for Dependency Injection 174

Creating the Fluent NHibernate Confi guration 177

Creating the Fluent NHibernate Mapping 179

Creating the Integration Test 183

End-to-End Integration Tests 191

Keeping Various Types of Tests Apart 191

When and How to Run Integration Tests 191

Summary 192

PART III: TDD SCENARIOS

CHAPTER 9: TDD ON THE WEB 197

ASP.NET Web Forms 197

Web Form Organization 198

ASPX Files 198

Code-Behind Files 198

Implementing Test-Driven Development with MVP and Web Forms 199

Working with the ASP.NET MVC 210

MVC 101 211

Microsoft ASP.NET MVC 3.0 212

Creating an ASP.NET MVC Project 212

Creating Your First Test 213

Making Your First Test Pass 215

Creating Your First View 216

Gluing Everything Together 217

Using the MVC Contrib Project 220

ASP.NET MVC Summarized 220

Working with JavaScript 220

JavaScript Testing Frameworks 221

Summary 226

CHAPTER 10: TESTING WINDOWS COMMUNICATION FOUNDATION SERVICES 227

WCF Services in Your Application 228

Services Are Code Too 228

Testing WCF Services 228

Refactoring for Testability 229

Introducing Dependency Injection to Your Service 231

Writing the Test 236

Stubbing the Dependencies 239

Verifying the Results 243

Trouble Spots to Watch 244

Summary 244

CHAPTER 11: TESTING WPF AND SILVERLIGHT APPLICATIONS 245

The Problem with Testing the User Interface 246

The MVVM Pattern 246

How MVVM Makes WPF/Silverlight Applications Testable 248

Bringing It All Together 261

Summary 263

PART IV: REQUIREMENTS AND TOOLS

CHAPTER 12: DEALING WITH DEFECTS AND NEW REQUIREMENTS 267

Handling Change 268

Change Happens 268

Adding New Features 268

Addressing Defects 269

Starting with a Test 270

Changing the Code 272

Keeping the Tests Passing 276

Summary 276

CHAPTER 13: THE GREAT TOOL DEBATE 279

Test Runners 279

TestDriven.NET 280

Developer Express Test Runner 280

Gallio 281

Unit Testing Frameworks 282

MSTest 282

MbUnit 283

xUnit 284

Mocking Frameworks 285

Rhino Mocks 285

Type Mock 287

Dependency Injection Frameworks 289

Structure Map 289

Unity 291

Windsor 293

Autofac 294

Miscellaneous Useful Tools 295

nCover 295

PEX 295

How to Introduce TDD to Your Team 296

Working in Environments That Are Resistant to Change 297

Working in Environments That Are Accepting of Change 297

Summary 297

CHAPTER 14: CONCLUSIONS 299

What You Have Learned 299

You Are the Client of Your Code 300

Find the Solutions Step by Step 300

Use the Debugger as a Surgical Instrument 300

TDD Best Practices 301

Use Signifi cant Names 301

Write at Least One Test for One Unit of Functionality 301

Keep Your Mocks Simple 302

The Benefi ts of TDD 302

How to Introduce TDD in Your Team 303

Summary 304

APPENDIX: TDD KATAS 307

Working with TDD Katas 307

Share Your Work 308

OSIM User Stories 308

INDEX 311