10099cam-a2200793zu-4500 almatuudk_9923192791802884 DE-602 20251214174417.0 m o d cr unu 160829s2007 xx o eng d 9780321504807 0321504801 9780132797467 0132797461 (CKB)1000000000298116 (SSID)ssj0000078923 (PQKBManifestationID)12015653 (PQKBTitleCode)TC0000078923 (PQKBWorkID)10066424 (PQKB)10964969 (MiAaPQ)EBC7050711 (Au-PeEL)EBL7050711 (OCoLC)154684541 (OCoLC)ocm154684541 (CaSebORM)9780131495050 (MiAaPQ)EBC31206469 (Au-PeEL)EBL31206469 (OCoLC)1531322903 (OCoLC)1337944947 (EXLCZ)991000000000298116 PQKB eng DE-83;9923192791802884 QA76.76.P37 M49 2007 005.1 DE-83;9923192791802884 almatuudk_9923192791802884 Meszaros, Gerard Author XUNIT TEST PATTERNS xUnit test patterns : refactoring test code 1st edition [Place of publication not identified] Addison Wesley 2007 1 online resource (944 pages) text txt computer c online resource cr text file Addison-Wesley signature series The Addison-Wesley signature series xUnit test patterns Bibliographic Level Mode of Issuance: Monograph Includes bibliographical references and index. Intro -- Contents -- Visual Summary of the Pattern Language -- Foreword -- Preface -- Acknowledgments -- Introduction -- Refactoring a Test -- PART I. The Narratives -- Chapter 1. A Brief Tour -- About This Chapter -- The Simplest Test Automation Strategy That Could Possibly Work -- What's Next? -- Chapter 2. Test Smells -- About This Chapter -- An Introduction to Test Smells -- A Catalog of Smells -- What's Next? -- Chapter 3. Goals of Test Automation -- About This Chapter -- Why Test? -- Goals of Test Automation -- What's Next? -- Chapter 4. Philosophy of Test Automation -- About This Chapter -- Why Is Philosophy Important? -- Some Philosophical Differences -- When Philosophies Differ -- My Philosophy -- What's Next? -- Chapter 5. Principles of Test Automation -- About This Chapter -- The Principles -- What's Next? -- Chapter 6. Test Automation Strategy -- About This Chapter -- What's Strategic? -- Which Kinds of Tests Should We Automate? -- Which Tools Do We Use to Automate Which Tests? -- Which Test Fixture Strategy Do We Use? -- How Do We Ensure Testability? -- What's Next? -- Chapter 7. xUnit Basics -- About This Chapter -- An Introduction to xUnit -- Common Features -- The Bare Minimum -- Under the xUnit Covers -- xUnit in the Procedural World -- What's Next? -- Chapter 8. Transient Fixture Management -- About This Chapter -- Test Fixture Terminology -- Building Fresh Fixtures -- Tearing Down Transient Fresh Fixtures -- What's Next? -- Chapter 9. Persistent Fixture Management -- About This Chapter -- Managing Persistent Fresh Fixtures -- Managing Shared Fixtures -- What's Next? -- Chapter 10. Result Verification -- About This Chapter -- Making Tests Self-Checking -- State Verification -- Verifying Behavior -- Reducing Test Code Duplication -- Avoiding Conditional Test Logic -- Other Techniques -- Where to Put Reusable Verification Logic?. What's Next? -- Chapter 11. Using Test Doubles -- About This Chapter -- What Are Indirect Inputs and Outputs? -- Testing with Doubles -- Other Uses of Test Doubles -- Other Considerations -- What's Next? -- Chapter 12. Organizing Our Tests -- About This Chapter -- Basic xUnit Mechanisms -- Right-Sizing Test Methods -- Test Methods and Testcase Classes -- Test Naming Conventions -- Organizing Test Suites -- Test Code Reuse -- Test File Organization -- What's Next? -- Chapter 13. Testing with Databases -- About This Chapter -- Testing with Databases -- Testing without Databases -- Testing the Database -- Testing with Databases (Again!) -- What's Next? -- Chapter 14. A Roadmap to Effective Test Automation -- About This Chapter -- Test Automation Difficulty -- Roadmap to Highly Maintainable Automated Tests -- What's Next? -- PART II. The Test Smells -- Chapter 15. Code Smells -- Obscure Test -- Conditional Test Logic -- Hard-to-Test Code -- Test Code Duplication -- Test Logic in Production -- Chapter 16. Behavior Smells -- Assertion Roulette -- Erratic Test -- Fragile Test -- Frequent Debugging -- Manual Intervention -- Slow Tests -- Chapter 17. Project Smells -- Buggy Tests -- Developers Not Writing Tests -- High Test Maintenance Cost -- Production Bugs -- PART III. The Patterns -- Chapter 18. Test Strategy Patterns -- Recorded Test -- Scripted Test -- Data-Driven Test -- Test Automation Framework -- Minimal Fixture -- Standard Fixture -- Fresh Fixture -- Shared Fixture -- Back Door Manipulation -- Layer Test -- Chapter 19. xUnit Basics Patterns -- Test Method -- Four-Phase Test -- Assertion Method -- Assertion Message -- Testcase Class -- Test Runner -- Testcase Object -- Test Suite Object -- Test Discovery -- Test Enumeration -- Test Selection -- Chapter 20. Fixture Setup Patterns -- In-line Setup -- Delegated Setup -- Creation Method. Implicit Setup -- Prebuilt Fixture -- Lazy Setup -- Suite Fixture Setup -- Setup Decorator -- Chained Tests -- Chapter 21. Result Verification Patterns -- State Verification -- Behavior Verification -- Custom Assertion -- Delta Assertion -- Guard Assertion -- Unfinished Test Assertion -- Chapter 22. Fixture Teardown Patterns -- Garbage-Collected Teardown -- Automated Teardown -- In-line Teardown -- Implicit Teardown -- Chapter 23. Test Double Patterns -- Test Double -- Test Stub -- Test Spy -- Mock Object -- Fake Object -- Configurable Test Double -- Hard-Coded Test Double -- Test-Specific Subclass -- Chapter 24. Test Organization Patterns -- Named Test Suite -- Test Utility Method -- Parameterized Test -- Testcase Class per Class -- Testcase Class per Feature -- Testcase Class per Fixture -- Testcase Superclass -- Test Helper -- Chapter 25. Database Patterns -- Database Sandbox -- Stored Procedure Test -- Table Truncation Teardown -- Transaction Rollback Teardown -- Chapter 26. Design-for-Testability Patterns -- Dependency Injection -- Dependency Lookup -- Humble Object -- Test Hook -- Chapter 27. Value Patterns -- Literal Value -- Derived Value -- Generated Value -- Dummy Object -- PART IV. Appendixes -- Appendix A. Test Refactorings -- Appendix B. xUnit Terminology -- Appendix C. xUnit Family Members -- Appendix D. Tools -- Appendix E. Goals and Principles -- Appendix F. Smells, Aliases, and Causes -- Appendix G. Patterns, Aliases, and Variations -- Glossary. Automated testing is a cornerstone of agile development. An effective testing strategy will deliver new functionality more aggressively, accelerate user feedback, and improve quality. However, for many developers, creating effective automated tests is a unique and unfamiliar challenge. xUnit Test Patterns is the definitive guide to writing automated tests using xUnit, the most popular unit testing framework in use today. Agile coach and test automation expert Gerard Meszaros describes 68 proven patterns for making tests easier to write, understand, and maintain. He then shows you how to make them more robust and repeatable--and far more cost-effective. Loaded with information, this book feels like three books in one. The first part is a detailed tutorial on test automation that covers everything from test strategy to in-depth test coding. The second part, a catalog of 18 frequently encountered "test smells," provides trouble-shooting guidelines to help you determine the root cause of problems and the most applicable patterns. The third part contains detailed descriptions of each pattern, including refactoring instructions illustrated by extensive code samples in multiple programming languages. Topics covered include Writing better tests--and writing them faster The four phases of automated tests: fixture setup, exercising the system under test, result verification, and fixture teardown Improving test coverage by isolating software from its environment using Test Stubs and Mock Objects Designing software for greater testability Using test "smells" (including code smells, behavior smells, and project smells) to spot problems and know when and how to eliminate them Refactoring tests for greater simplicity, robustness, and execution speed This book will benefit developers, managers, and testers working with any agile or conventional development process, whether doing test-driven development or writing the tests last. While the patterns and smells are especially applicable to all members of the xUnit family, they also apply to next-generation behavior-driven development frameworks such as RSpec and JBehave and to other kinds of test automation tools, including recorded test tools and data-driven test tools such as Fit and FitNesse. Visual Summary of the Pattern Language Foreword Preface Acknowledgments Introduction Refactoring a Test PART I: The Narratives Chapter 1 A Brief Tour Chapter 2 Test Smells Chapter 3 Goals of Test Automation Chapter 4 Phi... English Description based on publisher supplied metadata and other sources. Software patterns Testing. Computer software. Engineering & Applied Sciences HILCC Computer Science HILCC ISBN 9780131495050 ISBN 0131495054 Addison-Wesley Signature Series (Fowler) BOOK cr 9923192791802884 DE-83 KOBV c false