Developer Testing
Building Quality into Software
1st Edition
Published on 7. September 2016
352 pages
978-0-13-429111-6 (ISBN)
Description
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
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
All prices
More details
Series
Edition
1. Auflage
Language
English
Place of publication
Boston
United States
Publishing group
Pearson Education (US)
Target group
Professional and scholarly
File size
4,14 MB
ISBN-13
978-0-13-429111-6 (9780134291116)
Copyright in bibliographic data and cover images is held by Nielsen Book Services Limited or by the publishers or by their respective licensors: all rights reserved.
Schweitzer Classification
Other editions
Additional editions
Book
09/2016
Addison Wesley
€36.50
Shipment within 15-20 days
Person
Alexander Tarlinder wrote his first computer program around the age of ten, sometime in the early nineties. It was a simple, text-based role playing game for the Commodore 64. It had lots of GOTO statements and an abundance of duplicated code. Still, to him, this was the most fantastic piece of software ever conceived, and an entry point to his future career.
Twenty-five years later, Alexander still writes code and remains a developer at heart. Today, his professional career stretches over 15 years, a time during which he has shouldered a variety of roles: developer, architect, project manager, ScrumMaster, tester, and agile coach. In all these roles, he has gravitated towards sustainable pace, craftsmanship, and attention to quality, and he eventually got test infected around 2005. In a way, this was inevitable, since many of his projects involved programming money somehow (in the banking and gaming industry), and he always felt that he could do more to ensure the quality of his code before handing it over to someone else.
Presently, Alexander seeks roles that allow him to influence the implementation process on a larger scale. He combines development projects with training and coaching, and he shares technical and nontechnical aspects of developer testing and quality assurance in conferences and local user groups meetings.
Twenty-five years later, Alexander still writes code and remains a developer at heart. Today, his professional career stretches over 15 years, a time during which he has shouldered a variety of roles: developer, architect, project manager, ScrumMaster, tester, and agile coach. In all these roles, he has gravitated towards sustainable pace, craftsmanship, and attention to quality, and he eventually got test infected around 2005. In a way, this was inevitable, since many of his projects involved programming money somehow (in the banking and gaming industry), and he always felt that he could do more to ensure the quality of his code before handing it over to someone else.
Presently, Alexander seeks roles that allow him to influence the implementation process on a larger scale. He combines development projects with training and coaching, and he shares technical and nontechnical aspects of developer testing and quality assurance in conferences and local user groups meetings.
Content
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
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
