Home > Store > Software Development & Management > Testing

Developer Testing: Building Quality into Software

Register your product to gain access to bonus material or receive a coupon.

Developer Testing: Building Quality into Software

Best Value Purchase

Book + eBook Bundle

  • Your Price: $43.19
  • List Price: $71.98
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

More Purchase Options

Book

  • Your Price: $31.99
  • List Price: $39.99
  • Usually ships in 24 hours.

eBook (Watermarked)

  • Your Price: $25.59
  • List Price: $31.99
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

About

Features

  • Answers crucial developer questions such as: When have I tested this enough? How many unit tests do I need to write? What should my test verify?
  • Helps developers start thinking about testability without getting buried in specialist details
  • Offers practical guidance on transforming suboptimal legacy code into manageable, testable pieces
  • Reflects the author's extensive consulting, training, and mentoring experience, and his deep understanding of development teams' QA learning curves

Description

  • Copyright 2017
  • Dimensions: 7 X 9-1/8
  • Pages: 352
  • Edition: 1st
  • Book
  • ISBN-10: 0-13-429106-9
  • ISBN-13: 978-0-13-429106-2

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

Extras

Author's Site

Please visit the author's site at developertesting.rocks.

Sample Content

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

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership