| Description |
1 online resource (1 volume) : illustrations |
| Series |
Community experience distilled |
|
Community experience distilled.
|
| Note |
Includes index. |
| Contents |
Cover; Copyright; Credits; About the Author; About the Reviewers; www.PacktPub.com; Table of Contents; Preface; Chapter 1: Getting Started; Why you should busy yourself with unit tests; Reducing the defect rate; Improving the code quality; Increasing the development pace; Enhancing the specification density; Boosting confidence and courage; Setting the table; Choosing the ingredients; Organizing your code; Serving the starter; Introducing the example app; Understanding the nature of a unit test; Writing the first test; Evaluating test results; Writing tests first; Summary. |
|
Chapter 2: Writing Well-structured TestsThe four phases of a unit test; Using a common test structure; Setting up the fixture; What goes up must come down; Verification; Choosing the next functionality to test; Start with the happy path; Conclude with corner cases; After the war; Getting the test names right; Test prefix; Behavior expressing patterns; Reducing names to the essentials; Summary; Chapter 3: Developing Independently Testable Units; Decomposing requirements; Separating concerns; Component dependencies; Understanding isolation; Delegating responsibilities to DOCs. |
|
Indirect input and outputUnit isolation with test doubles; Working with test doubles; Placeholder dummies; Fake it till you make it; Providing indirect input with stubs; Recording interactions with spies; Verifying behavior with mocks; Increasing efficiency with mock frameworks; The promised land?; Basic stubbing; Indirect output verification; Using test helpers; Motivation; The test helper class; The test helper object; Summary; Chapter 4: Testing Exceptional Flow; Testing patterns; Using the fail statement; Annotated expectations; Verification with the ExpectedException rule. |
|
Capturing exceptions with closuresTreating collaborators; Fail fast; The stubbing of exceptional behavior; Summary; Chapter 5: Using Runners for Particular Testing Purposes; Understanding the architecture; What are runners good for?; Looking at the big picture; Writing your own extension; Using custom runners; Furnishing a suite with test cases; Structuring suites into categories; Populating suites automatically; How about creating test doubles with annotations?; Writing dataset tests; Using parameterized tests; Reduce glue code with JUnitParams. |
|
Increase the expressiveness of test descriptions with BurstSummary; Chapter 6: Reducing Boilerplate with JUnit Rules; Understanding rules; What are JUnit rules?; Writing your own rule; Configuring the fixture with annotations; Working with advanced concepts; Using ClassRules; The Ordering of rule execution; Employing custom solutions; Working with system settings; Ignoring tests conditionally; Summary; Chapter 7: Improving Readability with Custom Assertions; Working with the JUnit built-in assert approach; Understanding the basics; Reviewing the file session storage. |
| Bibliography |
Includes bibliographical references and index. |
| Summary |
Master high quality software development driven by unit tests About This Book Design and implement robust system components by means of the de facto unit testing standard in Java Reduce defect rate and maintenance effort, plus simultaneously increase code quality and development pace Follow a step-by-step tutorial imparting the essential techniques based on real-world scenarios and code walkthroughs Who This Book Is For No matter what your specific background as a Java developer, whether you're simply interested in building up a safety net to reduce regressions of your desktop application or in improving your server-side reliability based on robust and reusable components, unit testing is the way to go. This book provides you with a comprehensive but concise entrance advancing your knowledge step-wise to a professional level. What You Will Learn Organize your test infrastructure and resources reasonably Understand and write well structured tests Decompose your requirements into small and independently testable units Increase your testing efficiency with on-the-fly generated stand-in components and deal with the particularities of exceptional flow Employ runners to adjust to specific test demands Use rules to increase testing safety and reduce boilerplate Use third party supplements to improve the expressiveness of your verification statements In Detail JUnit has matured to become the most important tool when it comes to automated developer tests in Java. Supported by all IDEs and build systems, it empowers programmers to deliver software features reliably and efficiently. However, writing good unit tests is a skill that needs to be learned; otherwise it's all too easy to end up in gridlocked development due to messed up production and testing code. Acquiring the best practices for unit testing will help you to prevent such problems and lead your projects to success with respect to quality and costs. This book explains JUnit concepts and best practices applied to the test first approach, a foundation for high quality Java components delivered in time and budget. From the beginning you'll be guided continuously through a practically relevant example and pick up background knowledge and development techniques step by step. Starting with the basics of tests organization you'll soon comprehend the necessity of well structured tests and delve into the relationship of requirement decomposition and the many-faceted world of test double usage. In conju ... |
| Subject |
Computer software -- Testing.
|
|
Computer software -- Development.
|
|
Computer software -- Development |
|
Computer software -- Testing |
| Added Title |
Master high-quality software development driven by unit tests |
| Other Form: |
Print version: Appel, Frank. Testing with JUnit. Olton Birmingham : Packt Publishing Ltd, ©2015 9781782166603 |
| ISBN |
9781782166610 (electronic bk.) |
|
1782166610 (electronic bk.) |
|
More Resources