Christmas Posting Dates
Growing Object-Oriented Software, Guided by Tests

Growing Object-Oriented Software, Guided by Tests

Paperback Beck Signature

By (author) Steve Freeman, By (author) Nat Pryce

$42.69
List price $57.95
You save $15.26 26% off

Free delivery worldwide
Available
Dispatched in 3 business days
When will my order arrive?

  • Publisher: Addison-Wesley Educational Publishers Inc
  • Format: Paperback | 384 pages
  • Dimensions: 180mm x 235mm x 19mm | 601g
  • Publication date: 1 November 2009
  • Publication City/Country: New Jersey
  • ISBN 10: 0321503627
  • ISBN 13: 9780321503626
  • Edition: 1
  • Sales rank: 26,236

Product description

Foreword by Kent Beck "The authors of this book have led a revolution in the craft of programming by controlling the environment in which software grows." --Ward Cunningham "At last, a book suffused with code that exposes the deep symbiosis between TDD and OOD. This one's a keeper." --Robert C. Martin "If you want to be an expert in the state of the art in TDD, you need to understand the ideas in this book."--Michael Feathers Test-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your code before you write the code itself. However, this "simple" idea takes skill and judgment to do well. Now there's a practical guide to TDD that takes you beyond the basic concepts. Drawing on a decade of experience building real-world systems, two TDD pioneers show how to let tests guide your development and "grow" software that is coherent, reliable, and maintainable. Steve Freeman and Nat Pryce describe the processes they use, the design principles they strive to achieve, and some of the tools that help them get the job done. Through an extended worked example, you'll learn how TDD works at multiple levels, using tests to drive the features and the object-oriented structure of the code, and using Mock Objects to discover and then describe relationships between objects. Along the way, the book systematically addresses challenges that development teams encounter with TDD--from integrating TDD into your processes to testing your most difficult features. Coverage includes * Implementing TDD effectively: getting started, and maintaining your momentum throughout the project * Creating cleaner, more expressive, more sustainable code * Using tests to stay relentlessly focused on sustaining quality * Understanding how TDD, Mock Objects, and Object-Oriented Design come together in the context of a real software development project * Using Mock Objects to guide object-oriented designs * Succeeding where TDD is difficult: managing complex test data, and testing persistence and concurrency

Other people who viewed this bought:

Showing items 1 to 10 of 10

Other books in this category

Showing items 1 to 10 of 10
Categories:

Author information

Steve Freeman is an independent consultant specializing in Agile software development. A founder member of the London Extreme Tuesday Club, he was chair of the first XPDay and is a frequent organizer and presenter at international conferences. Steve has worked in a variety of organizations, from writing shrink-wrap software for IBM, to prototyping for major research laboratories. Steve has a Ph.D. from Cambridge University, and degrees in statistics and music. Steve is based in London, UK. Nat Pryce has worked as a programmer, architect, trainer, and consultant in a variety of industries, including sports reportage, marketing communications, retail, telecoms, and finance. With a Ph.D. from Imperial College London, he has also worked on research projects and does occasional university teaching. An early adopter of Extreme Programming, he has written or contributed to several open source libraries that support Test Driven Development. He was one of the founding organizers of the London XPDay and regularly presents at international conferences. Nat is based in London, UK. Freeman and Pryce were joint winners of the 2006 Agile Alliance Gordon Pask award.

Back cover copy

Foreword by Kent Beck ""The authors of this book have led a revolution in the craft of programming by controlling the environment in which software grows." "--Ward Cunningham " " ""At last, a book suffused with code that exposes the deep symbiosis between TDD and OOD. This one's a keeper." "--Robert C. Martin ""If you want to be an expert in the state of the art in TDD, you need to understand the ideas in this book."--"Michael Feathers Test-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your code before you write the code itself. However, this "simple" idea takes skill and judgment to do well. Now there's a practical guide to TDD that takes you beyond the basic concepts. Drawing on a decade of experience building real-world systems, two TDD pioneers show how to let tests guide your development and "grow" software that is coherent, reliable, and maintainable. Steve Freeman and Nat Pryce describe the processes they use, the design principles they strive to achieve, and some of the tools that help them get the job done. Through an extended worked example, you'll learn how TDD works at multiple levels, using tests to drive the features and the object-oriented structure of the code, and using Mock Objects to discover and then describe relationships between objects. Along the way, the book systematically addresses challenges that development teams encounter with TDD--from integrating TDD into your processes to testing your most difficult features. Coverage includes - Implementing TDD effectively: getting started, and maintaining your momentum throughout the project - Creating cleaner, more expressive, more sustainable code - Using tests to stay relentlessly focused on sustaining quality - Understanding how TDD, Mock Objects, and Object-Oriented Design come together in the context of a real software development project - Using Mock Objects to guide object-oriented designs - Succeeding where TDD is difficult: managing complex test data, and testing persistence and concurrency

Table of contents

Foreword xv Preface xvii Acknowledgments xxi About the Authors xxiii PART I: INTRODUCTION 1 Chapter 1: What Is the Point of Test-Driven Development? 3 Software Development as a Learning Process 3 Feedback Is the Fundamental Tool 4 Practices That Support Change 5 Test-Driven Development in a Nutshell 6 The Bigger Picture 7 Testing End-to-End 8 Levels of Testing 9 External and Internal Quality 10 Chapter 2: Test-Driven Development with Objects 13 A Web of Objects 13 Values and Objects 13 Follow the Messages 14 Tell, Don't Ask 17 But Sometimes Ask 17 Unit-Testing the Collaborating Objects 18 Support for TDD with Mock 19 Chapter 3: An Introduction to the Tools 21 Stop Me If You've Heard This One Before 21 A Minimal Introduction to JUnit 4 21 Hamcrest Matchers and assertThat() 24 jMock2: Mock Objects 25 PART II: THE PROCESS OF TEST-DRIVEN DEVELOPMENT 29 Chapter 4: Kick-Starting the Test-Driven Cycle 31 Introduction 31 First, Test a Walking Skeleton 32 Deciding the Shape of the Walking Skeleton 33 Build Sources of Feedback 35 Expose Uncertainty Early 36 Chapter 5: Maintaining the Test-Driven Cycle 39 Introduction 39 Start Each Feature with an Acceptance Test 39 Separate Tests That Measure Progress from Those That Catch Regressions 40 Start Testing with the Simplest Success Case 41 Write the Test That You'd Want to Read 42 Watch the Test Fail 42 Develop from the Inputs to the Outputs 43 Unit-Test Behavior, Not Methods 43 Listen to the Tests 44 Tuning the Cycle 45 Chapter 6: Object-Oriented Style 47 Introduction 47 Designing for Maintainability 47 Internals vs. Peers 50 No And's, Or's, or But's 51 Object Peer Stereotypes 52 Composite Simpler Than the Sum of Its Parts 53 Context Independence 54 Hiding the Right Information 55 An Opinionated View 56 Chapter 7: Achieving Object-Oriented Design 57 How Writing a Test First Helps the Design 57 Communication over Classification 58 Value Types 59 Where Do Objects Come From? 60 Identify Relationships with Interfaces 63 Refactor Interfaces Too 63 Compose Objects to Describe System Behavior 64 Building Up to Higher-Level Programming 65 And What about Classes? 67 Chapter 8: Building on Third-Party Code 69 Introduction 69 Only Mock Types That You Own 69 Mock Application Objects in Integration Tests 71 PART III: A WORKED EXAMPLE 73 Chapter 9: Commissioning an Auction Sniper 75 To Begin at the Beginning 75 Communicating with an Auction 78 Getting There Safely 79 This Isn't Real 81 Chapter 10: The Walking Skeleton 83 Get the Skeleton out of the Closet 83 Our Very First Test 84 Some Initial Choices 86 Chapter 11: Passing the First Test 89 Building the Test Rig 89 Failing and Passing the Test 95 The Necessary Minimum 102 Chapter 12: Getting Ready to Bid 105 An Introduction to the Market 105 A Test for Bidding 106 The AuctionMessageTranslator 112 Unpacking a Price Message 118 Finish the Job 121 Chapter 13: The Sniper Makes a Bid 123 Introducing AuctionSniper 123 Sending a Bid 126 Tidying Up the Implementation 131 Defer Decisions 136 Emergent Design 137 Chapter 14: The Sniper Wins the Auction 139 First, a Failing Test 139 Who Knows about Bidders? 140 The Sniper Has More to Say 143 The Sniper Acquires Some State 144 The Sniper Wins 146 Making Steady Progress 148 Chapter 15: Towards a Real User Interface 149 A More Realistic Implementation 149 Displaying Price Details 152 Simplifying Sniper Events 159 Follow Through 164 Final Polish 168 Observations 171 Chapter 16: Sniping for Multiple Items 175 Testing for Multiple Items 175 Adding Items through the User Interface 183 Observations 189 Chapter 17: Teasing Apart Main 191 Finding a Role 191 Extracting the Chat 192 Extracting the Connection 195 Extracting the SnipersTableModel 197 Observations 201 Chapter 18: Filling In the Details 205 A More Useful Application 205 Stop When We've Had Enough 205 Observations 212 Chapter 19: Handling Failure 215 What If It Doesn't Work? 215 Detecting the Failure 217 Displaying the Failure 218 Disconnecting the Sniper 219 Recording the Failure 221 Observations 225 PART IV: SUSTAINABLE TEST-DRIVEN DEVELOPMENT 227 Chapter 20: Listening to the Tests 229 Introduction 229 I Need to Mock an Object I Can't Replace (without Magic) 230 Logging Is a Feature 233 Mocking Concrete Classes 235 Don't Mock Values 237 Bloated Constructor 238 Confused Object 240 Too Many Dependencies 241 Too Many Expectations 242 What the Tests Will Tell Us (If We're Listening) 244 Chapter 21: Test Readability 247 Introduction 247 Test Names Describe Features 248 Canonical Test Structure 251 Streamline the Test Code 252 Assertions and Expectations 254 Literals and Variables 255 Chapter 22: Constructing Complex Test Data 257 Introduction 257 Test Data Builders 258 Creating Similar Objects 259 Combining Builders 261 Emphasizing the Domain Model with Factory Methods 261 Removing Duplication at the Point of Use 262 Communication First 264 Chapter 23: Test Diagnostics 267 Design to Fail 267 Small, Focused, Well-Named Tests 268 Explanatory Assertion Messages 268 Highlight Detail with Matchers 268 Self-Describing Value 269 Obviously Canned Value 270 Tracer Object 270 Explicitly Assert That Expectations Were Satisfied 271 Diagnostics Are a First-Class Feature 271 Chapter 24: Test Flexibility 273 Introduction 273 Test for Information, Not Representation 274 Precise Assertions 275 Precise Expectations 277 "Guinea Pig" Objects 284 PART V: ADVANCED TOPICS 287 Chapter 25: Testing Persistence 289 Introduction 289 Isolate Tests That Affect Persistent State 290 Make Tests Transaction Boundaries Explicit 292 Testing an Object That Performs Persistence Operations 294 Testing That Objects Can Be Persisted 297 But Database Tests Are S-l-o-w! 300 Chapter 26: Unit Testing and Threads 301 Introduction 301 Separating Functionality and Concurrency Policy 302 Unit-Testing Synchronization 306 Stress-Testing Passive Objects 311 Synchronizing the Test Thread with Background Threads 312 The Limitations of Unit Stress Tests 313 Chapter 27: Testing Asynchronous Code 315 Introduction 315 Sampling or Listening 316 Two Implementations 318 Runaway Tests 322 Lost Updates 323 Testing That an Action Has No Effect 325 Distinguish Synchronizations and Assertions 326 Externalize Event Sources 326 Afterword: A Brief History of Mock Objects 329 Appendix A: jMock2 Cheat Sheet 335 Appendix B: Writing a Hamcrest Matcher 343 Bibliography 347 Index 349