How do successful agile teams deliver bug-free, maintainable software—iteration after iteration? The answer is: By seamlessly combining development and testing. On such teams, the developers write testable code that enables them to verify it using various types of automated tests. This approach keeps regressions at bay and prevents “testing crunches”—which otherwise may occur near the end of an iteration—from ever happening. Writing testable code, however, is often difficult, because it requires knowledge and skills that cut across multiple disciplines.   In Developer Testing, leading test expert and mentor Alexander Tarlinder presents concise, focused guidance for making new and legacy code far more testable. Tarlinder helps you answer questions like: When have I tested this enough? How many tests do I need to write? What should my tests verify? You’ll learn how to design for testability and utilize techniques like refactoring, dependency breaking, unit testing, data-driven testing, and test-driven development to achieve the highest possible confidence in your software. Through practical examples in Java, C#, Groovy, and Ruby, you’ll discover what works—and what doesn’t.   You can quickly begin using Tarlinder’s technology-agnostic insights with most languages and toolsets while not getting buried in specialist details. The author helps you adapt your current programming style for testability, make a testing mindset “second nature,” improve your code, and enrich your day-to-day experience as a software professional. With this guide, you will Understand the discipline and vocabulary of testing from the developer’s standpoint Base developer tests on well-established testing techniques and best practices Recognize code constructs that impact testability Effectively name, organize, and execute unit tests Master the essentials of classic and “mockist-style” TDD Leverage test doubles with or without mocking frameworks Capture the benefits of programming by contract, even without runtime support for contracts Take control of dependencies between classes, components, layers, and tiers Handle combinatorial explosions of test cases, or scenarios requiring many similar tests Manage code duplication when it can’t be eliminated Actively maintain and improve your test suites Perform more advanced tests at the integration, system, and end-to-end levels Develop an understanding for how the organizational context influences quality assurance Establish well-balanced and effective testing strategies suitable for agile teams

Table of Contents:
Foreword by Jeff Langr xiii Foreword by Lisa Crispin xv Preface xvii Acknowledgments xxiii About the Author xxv   Chapter 1: Developer Testing 1 Developers Test 1 Developer Testing Activities 2 What Developers Usually Don’t Do 5 Defining Developer Testing 6 Developer Testing and the Development Process 7 Summary 8 Chapter 2: Testing Objectives, Styles, and Roles 9 Testing and Checking 9 Testing Objectives 10 Testing Styles 11 Your Quality Assurance and Developer Testing 18 Summary 19   Chapter 3: The Testing Vocabulary 21 Errors, Defects, Failures 22 White Box and Black Box Testing 22 Classifying Tests 23 The Agile Testing Quadrants 32 Some Other Types of Testing 33 Summary 36   Chapter 4: Testability from a Developer’s Perspective 37 Testable Software 37 Benefits of Testability 39 Testability Defined 43 Summary 55   Chapter 5: Programming by Contract 57 Contracts Formalize Constraints 57 Implementing Programming by Contract 60 Enforcing Contracts 62 Summary 65   Chapter 6: Drivers of Testability 67 Direct Input and Output 68 Indirect Input and Output 68 State 70 Temporal Coupling 71 Data Types and Testability 72 Domain-to-Range Ratio 77 Summary 78   Chapter 7: Unit Testing 79 Why Do It? 79 What Is a Unit Test? 81 The Life Cycle of a Unit Testing Framework 83 Naming Tests 85 Structuring Tests 88 Assertion Methods 89 Testing Exceptions 99 Behavior-driven Development–Style Frameworks 102 Summary 105   Chapter 8: Specification-based Testing Techniques 107 Equivalence Partitioning 107 Boundary Value Analysis 110 Edge Cases and Gotchas for Some Data Types 111 State Transition Testing 113 Decision Tables 115 Summary 116   Chapter 9: Dependencies 119 Relations between Objects 119 System Resource Dependencies 125 Dependencies between Layers 129 Dependencies across Tiers 132 Summary 133   Chapter 10: Data-driven and Combinatorial Testing 135 Parameterized Tests 138 Theories 139 Generative Testing 141 Combinatorial Testing 145 Summary 149   Chapter 11: Almost Unit Tests 151 Examples 152 Impact 156 Summary 157   Chapter 12: Test Doubles 159 Stubs 159 Fakes 162 Mock Objects 164 Spies 170 Dummies 171 Verify State or Behavior? 173 Summary 176   Chapter 13: Mocking Frameworks 177 Constructing Test Doubles 177 Setting Expectations 179 Verifying Interactions 183 Misuse, Overuse, and Other Pitfalls 185 Summary 189   Chapter 14: Test-driven Development—Classic Style 191 Test-driving a Simple Search Engine 192 Order of Tests 204 Red- to Green-bar Strategies 205 Challenges 206 Test First or Test Last? 209 Summary 210   Chapter 15: Test-driven Development—Mockist Style 213 A Different Approach 213 Double-loop TDD 220 Summary 223   Chapter 16: Duplication 225 Why Duplication Is Bad 225 Taking Advantage of Duplication 227 Mechanical Duplication 228 Knowledge Duplication 232 Summary 235   Chapter 17: Working with Test Code 237 Commenting Tests 237 Deleting Tests 241 Summary 243   Chapter 18: Beyond Unit Testing 245 Tests that Aren’t Unit Tests 245 Characteristics of Tests that Aren’t Unit Tests 257 Pointers and Practices 263 Deciding on a Developer Testing Strategy 267 Summary 269   Chapter 19: Test Ideas and Heuristics 271 High-level Considerations 271 Low-level Considerations 274 Summary 276   Appendix A: Tools and Libraries 277   Appendix B: Source Code 279 Test Doubles 279 Data-driven and Combinatorial Testing 279 Test-driven Development 282 Beyond Unit Testing 287   Bibliography 289 Index 295