James Bender, Jeff Mcwherter

Professional Test Driven Development with C# (eBook, ePUB)

Developing Real World Applications with TDD

• Format: ePub

Produktbeschreibung

Hands-on guidance to creating great test-driven development practice Test-driven development (TDD) practice helps developers recognize a well-designed application, and encourages writing a test before writing the functionality that needs to be implemented. This hands-on guide provides invaluable insight for creating successful test-driven development processes. With source code and examples featured in both C# and .NET, the book walks you through the TDD methodology and shows how it is applied to a real-world application. You'll witness the application built from scratch and details each step that is involved in the development, as well as any problems that were encountered and the solutions that were applied. * Clarifies the motivation behind test-driven development (TDD), what it is, and how it works * Reviews the various steps involved in developing an application and the testing that is involved prior to implementing the functionality * Discusses unit testing and refactoring Professional Test-Driven Development with C# shows you how to create great TDD processes right away.

---

Dieser Download kann aus rechtlichen Gründen nur mit Rechnungsadresse in A, B, BG, CY, CZ, D, DK, EW, E, FIN, F, GR, HR, H, IRL, I, LT, L, LR, M, NL, PL, P, R, S, SLO, SK ausgeliefert werden.

Produktdetails

• Verlag: John Wiley & Sons
• Seitenzahl: 368
• Erscheinungstermin: 9. Mai 2011
• Englisch
• ISBN-13: 9781118102114
• Artikelnr.: 37347332

Autorenporträt

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.

Inhaltsangabe

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