The practice of Test-Driven Development (TDD) has helped thousands of software developers improve quality, agility, productivity, and speed. In Test-Driven Database Development, Max Guernsey, III shows how to adapt TDD to achieve the same powerful benefits in database design and development. Guernsey first explains why TDD offers so much potential to database practitioners, and how to overcome obstacles such as the lack of conventional “testable classes.” You’ll learn how to use “classes of databases” to manage change more effectively; how to define testable database behaviors; how to maximize long-term maintainability by limiting a database’s current scope; and how to use “emergent design” to simplify future expansion. Building on this foundation, the author guides you through implementing modern TDD processes and database refactoring. He presents practical techniques for improving legacy databases; for deviating from strict TDD when necessary; and for adapting TDD to applications that persist data in file systems, XML, or serialized objects. Guernsey shows how to •  Build a simple infrastructure to track and standardize scripts and databases •  Define a sustainable TDD process for database design •  Safely change a design without losing data •  Design new databases that are lighter, leaner, simpler, more testable, and easier to change •  Reduce design costs by eliminating duplication •  Gradually bring the benefits of TDD, agility, and modern design to legacy databases •  Remediate errors that find their way into database designs •  Isolate behaviors and avoid unwanted dependencies that cause tests to fail With this book as a guide, you will learn how to apply the proven practice of TDD to your database needs, and organize and optimize your organization’s data for a significant competitive advantage.   Test-Driven Database Development is the newest title in the highly respected NetObjectives Lean-Agile Series.

Table of Contents:
Foreword      xvii Preface      xix Acknowledgments      xxv About the Authors      xxvii Chapter 1  Why, Who, and What      1 Why      1    Agility Progressively Invades Domains Every Day     2    Agility Cannot Work Without TDD     2    TDD in the Database World Is a Challenge     3 Who     3    TDD and OOP     4    Applications and Databases     4 What     4    Databases Are Objects     5    TDD Works on Classes, Not Objects     5    We Need Classes of Databases     6 Summary     7 Chapter 2  Establishing a Class of Databases     9 The Class’s Role in TDD     9    A Reliable Instantiation Process     10    Tests Check Objects     10 Classes in Object-Oriented Programming Languages     11    Making Classes Is Easy: Just Make New Objects     11    One Path: Destroy If Necessary     11 Classes of Databases     12    Two Paths: Create or Change     12    The Hard Part: Unifying the Two Paths     13    Real Database Growth     13    How About Making Every Database Build Like Production Databases?     14    All DBs Would Follow the Exact Same Path     15 Incremental Build     15    Document Each Database Change     15    Identify Current Version     16    Apply Changes in Order as Needed     16 Implementation     16    Requirements     16    Pseudocode Database Instantiation Mechanism     17    Pseudocode Input     17 Summary     18 Chapter 3  A Little TDD     19 The Test-First Technique     19    Write the Test     20    Stub Out Enough to See a Failure     22    See the Test Pass     22    Repeat     23 Tests as Specifications     24    “Tests Aren’t Tests, They Are Specifications”     24    “Tests Aren’t Specifications, They Are Tests”     25    Tests Are Executable Specifications     26    Incremental Design     27 Building Good Specifications     28    Specify Behavior, Not Structure     28    Drive Design In from Without, Not the Other Way Around     29    Defining the Design Inside Out     30    Defining the Design Outside In     32 Summary     34 Chapter 4  Safely Changing Design     37 What Is Safe?     38    Breaking a Contract Is a Little Bad     38    Losing Data Will Probably Get You Fired     39    Not Changing Design Is Also Dangerous     40 Solution: Transition Testing     44    Test-Driving Instantiation     44    Transition Testing Creation     44    Transition Testing Addition     47    Transition Testing Metamorphosis     51    Why Not Use the Public Interface?     56 Transition Safeguards     56    Read/Read Transition Tests     56    Run by the Class of Databases on Every Upgrade     60    Backup and Rollback on Fail     60    Making Transition Tests Leverage Transition Safeguards     60 Summary     61 Chapter 5  Enforcing Interface     63 Interface Strength     64    Stronger Coupling Languages     64    Weaker Coupling Languages     65    The Common Thread     66    Coupling to Database Classes     66    The Problem Is Duplication     66 Client-Object-Like Enforcement     67    Creating Demand for a DatabaseDesign Class     67 Specifying the DatabaseDesign Class     68    Getting Rid of Duplication with Multiple Client Platforms     70    What Happens When Coupling Goes Bad?     71    Eliminating Duplication Between Database Build and Client Code    71    Decoupling Implementation from Design     72 Sticking Point: Change    73    Designs Change Over Time     74    Document All Versions of Design     75    Couple to the Correct Version of the Design     77 Sticking Point: Coupling     78    Various Clients Couple to Various Versions     78    Having to Change Everything All the Time Is Duplication, Too     79    Introducing the Lens Concept     83    Virtual Lenses     85    The “Current” Lens     89    The “New” Lens     89 Summary     93 Chapter 6  Defining Behaviors     95 A New Group of Problems     96    No Encapsulation     96    Hide Everything     97    Business Logic in the Database     97 Knowledge, Information, and Behavior     98    Information     99    Knowledge     102    Behavior     102 Outside-In Development     106    Defining the Test     106    Growing Interface     108    Growing Behavior and Structures     109 Justification by Specification     111    Work Against Present Requirements, Not Future     111    Build in Increments     112    Limit Access to What Is Specified     112 Summary     113 Chapter 7  Building for Maintainability     115 Never Worry About the Future     116    Look for Opportunities in the Now     116    Design to Information     117    Translate Info and Knowledge with Behavior     121 Guard Knowledge with Fervor and Zeal     124    Not Changing Is the Most Dangerous Choice     124    Keep Your Design Natural     126 Deal with the Future When It Happens     127    Define New Design     128    Introduce Minimal Changes     129    Get Tests Passing     131    Stop, Think, Refactor     133 Summary     136 Chapter 8  Error and Remediation     137 Kinds of Errors     137    Axis: Is the Error Good or Bad?     138    Axis: Is the Error Released or Not?     140 Dealing with Good Errors     142    Just Fix It     142    Document Behavior Now     143    Trace Feature Back to Its Genesis     145 Dealing with Bad Errors     146    Unreleased Errors     147    Released Errors     150    Catastrophic Errors     156 Summary     157 Chapter 9  Design     159 Structures Versus Design     160    Structures: Execution Details     160    Tests and Class Information     162 What Is Design?     163    Buckets of Concepts     163    Mandatory Part of True TDD     166 Composition and Aggregation     167    Composition: One Thing with Multiple Parts     168    Aggregation: Connecting Distinct Things     172 Reuse     175    Avoid Developing the Same Thing Twice     175    Reuse by Composition or Aggregation     177 Abstraction     178    Identifying Opportunities for Abstraction     178    Encapsulating Behaviors     179    Finding Ways to Allow Variation in Dependencies     185    Dealing with the Time Problem     186 Summary     190 Chapter 10  Mocking     191 Testing Individual Behaviors     191    Why Encapsulate     192    Tests Test Everything Not Under Their Control     193    Controlling Irrelevant Behaviors from Tests     194    Mocking Controls Behaviors     194 Mocking in Object-Oriented Programming     195    Setup     195    Decoupling     199    Isolation     202    Integration     202 Mocking in Database Design     203    Example Problem     204    Example Solution     205    Composition     208    Aggregation     210    Designing for Testability     210 Summary     210 Chapter 11  Refactoring     213 What Refactoring Is     214    Changing Design Without Changing Behavior     214    In the Context of Passing Tests     215 Lower and Higher Risk Design Changes     222    Lower Risk: Changing Class-Level Design     222    Medium Risk: Rearranging Behavior Logic     223    Higher Risk: Altering Knowledge Containers     225    This Is Not an Invitation to Skip Testing     226 Summary     226 Chapter 12  Legacy Databases     227 Promoting to a Class     228    Deducing Initial Version     228    Pinning the Transition Behavior with Tests     231 Controlling Coupling     231    Identifying and Locking Down to Existing Uses     232    Encapsulating on Demand     234 Controlling Change     235    Test-Driving New Behaviors     235    Pinning Construction on Demand     237    Pinning Behavior on Demand     238    Implementing New Behavior     239 Finding Seams and Components     240    Finding Seams     240    Encapsulating Components     243 Summary     247 Chapter 13  The Façade Pattern     249 Encapsulation with a Façade     249    Explanation of Façade Pattern     250    New Test-Driven Façade Database     254    Compositional Alternative     261    To Encapsulate or Not    261 Strangling the Old Interface     262    Transferring Changing Behaviors to Façade     262    Removing Access and Features When No Longer Needed     263 Test-Driving Behaviors in the Façade Database     264    Exposing Legacy Behaviors     265    Another Way to Do It     265    New Behaviors     266 Summary     266 Chapter 14  Variations     269 Having a Class Is Important—Implementation Is Not     270 Scenario: Skipping Steps     270    Problem     271    Solution     272    The Right Amount of Work     273 Scenario: Deviations     274    Problem     274    Solution     275    Solution Applied     277 Common Solution     281 Summary     281 Chapter 15  Other Applications     283 XML     284    Encapsulation     284    XSD Schemas     284    XSLT Transitions     286    Transition Test XSLT Changes     287 File Systems and Other Object Directories      288    Transition Test File System Manipulations     289    Shell Script Transitions     291 Data Objects     292    Class Definitions Are Schemas     292    Transition Test the Ugrader Class     294    Code Transitions     296 Summary and Send Off     300 Index     301