Design Patterns for High-Quality Automated Tests: High-Quality Test Attributes and Best Practices

About This Book Achieving high-quality test automation that brings value- you need to understand core programming concepts such as SOLID and the usage of design patterns. After you master them, the usual career transition is into more architecture roles, such as choosing the best possible approaches for solving particular test automation challenges. You will get an access to more than 20000+ lines of real-world code examples. Who This Book Is For The book is NOT a getting started guide! If you don't have any prior programming experience in writing automated tests through WebDriver, I suggest you to first start with some book about basic programming and basic WebDriver usage. I believe it might be invaluable for the readers that have a couple of years of experience and whose job is to create/maintain test automation frameworks, or to write high-quality reliable automated tests. The book is written in C#. However, I think that you can use the approaches and practices in every OOP language. If you have a Java background (or similar), you will get everything you need, don't worry. Even if you don't get all the concepts from the first read, try to use and incorporate some of them, later you can return and reread them. I believe with the accumulation of experience using high-quality practices- you will become a hard-core test automation ninja! What You Will Learn \* Learn how to optimize and stabilize your flaky tests. \* Learn how to handle asnynchronious web pages in your tests. Automatically deal with AJAX and jQuery. \* Improve Test Readability, Maintainability, Reusability, Extensibility by incorporating 10+ design patterns: Page Object Model, Facade, Decorator, Observer, Strategy, Singleton, Fluent Interface, Template Method, Abstract Factory, Factory Method, Repository, Lazy Load. \* Learn what are the SOLID principles and how they can improve your test code. We will also discuss other essential programming principles such as composition, DRY, KISS and others. \* Learn how to asses and choose the best possible design for your framework or library. \* Learn how the benchmarking your code can help you to speed up your tests. \* Learn how to design and build your framework to handle test data and different test environments. \* Learn about high quality code practices and naming convention so that your code get much more understandable. Credits About the Author About the Reviewers Acknowledgements Foreword Preface What this book covers Chapter 1. Defining High-Quality Test Attributes Chapter 2. Optimizing and Refactoring Legacy Flaky Tests Chapter 3. Strategies for Speeding-up the Tests Chapter 4. Test Readability Chapter 5. Enhancing the Test Maintainability and Reusability Chapter 6. API Usability Chapter 7. Building Extensibility in Your Test Library Chapter 8. Assessment System for Tests’ Architecture Design Chapter 9. Benchmarking for Assessing Automated Test Components Performance Chapter 10. Test Data Preparation and Configuring Test Environments Appendix 1. Defining the Primary Problems that Test Automation Frameworks Solve Appendix 2. Most Exhaustive CSS Selectors Cheat Sheet Appendix 3. Most Exhaustive XPath Selectors Cheat Sheet Who Is This Book For? Before You Get Started Conventions Reader feedback Errata Piracy Questions Chapter 1. Defining High-Quality Test Attributes Different Types of Tests Unit Tests Integration Tests System Tests What Is a Test Automation Framework? What Is a Software Library? What Is a Framework? Test Automation Framework Is Selenium WebDriver a Test Framework? SOLID Principles SRP – Single Responsibility Principle OCP – Open/Closed Principle LSP – Liskov Substitution Principle ISP – Interface Segregation Principle DIP – Dependency Inversion Principle High-Quality Test Attributes What Is a Design Pattern? Test Maintainability and Reusability Test Readability API Usability Extensibility Learning Curve Summary Questions Further Reading Chapter 2. Optimizing and Refactoring Legacy Flaky Tests Writing the First Real-World Automated Test First Automated Test Case Explanation Second Automated Test Case Explanation Third Automated Test Case Explanation First Automated Test Code Second Automated Test Code Third Automated Test Code Reasons for Failures Refactoring Tests Implicit VS Explicit Waits Implementing Explicit Waits in Tests DRY- Do Not Repeat Yourself Principle Decorator Design Pattern for Fixing WebDriver Unstable Actions Decorator Design Pattern Decorator Design Pattern Implementation for IWebElement Decorator Design Pattern Implementation for IWebDriver Decorator Design Pattern in Tests Test Independence- Isolation Principle Refactoring Tests to Follow Test Independence- Isolation Principle Summary Questions Further Reading Chapter 3. Strategies for Speeding-up the Tests Instrumenting the Test Code to Find Possible Points for Optimization Optimize Login How to Wait for Asynchronous Requests to Finish in Tests? Waiting for All AJAX Requests Completion Optimize Browser Initialization- Observer Design Pattern Observer Design Pattern Observer Design Pattern Implementation Configure Browser Behavior via Attribute Isolated Browser Initialization for Each Test Black Hole Proxy Approach Implementing the Black Hole Proxy Summary Questions Further Reading Chapter 4. Test Readability Page Object Model Design Pattern Create First Page Object Model New Way for Creating Page Objects Page Object Model Usage in Tests Handling Common Page Elements and Actions Defining Common Page Elements Non-DRY Page Objects First Version of Reusing Common Elements Creating Common Page Section Page Objects Page Sections Usage in Page Objects - Version One Page Sections Usage in Page Objects - Version Two Page Sections Usage in Tests High Quality Code - Use Meaningful Names General Naming Guidelines Naming Classes Naming New Versions of Existing API Naming the Methods - The Right Way General Naming Guidelines Using Meaningful Method Names Best Practices for Method Parameters Follow Coding Standards - Tools Enforcing Coding Standards Using EditorConfig Summary Questions Further Reading Chapter 5. Enhancing the Test Maintainability and Reusability Navigatable Page Objects- Template Method Design Pattern Non-refactored Version Page Objects Create Separate Base Classes for Navigatable and Non-navigatable Pages Template Method Design Pattern Template Method Design Pattern Implementation Using Composition Principle Non-refactored Version Page Objects without Composition Elements and Assertions - Composition Implementation Using Composition in Tests Reuse Test Workflows - Facade Design Pattern Test Workflows Naive Implementation Facade Design Pattern Facade Design Pattern Implementation Combining Facade with Template Method Design Pattern Purchase Facade with Template Methods Concrete Facade Implementation Summary Questions Further Reading Chapter 6. API Usability Interface Segregation principle for WebDriver Decorator WebDriver Decorator Current Implementation Splitting Driver Interface into Smaller Interfaces Smaller Interfaces Usage in Page Objects Use Page Objects Through Singleton Design Pattern Singleton Design Pattern Singleton Design Pattern Implementation Thread-safe Singleton Implementation Singleton Design Pattern Usage in Tests App Design Pattern for Creating Page Objects App Design Pattern Implementation App Usage in Tests Fluent API Page Objects Fluent API Implementation Using Fluent API in Tests Page Objects Elements Access Styles Exposing Elements Through Properties Accessing Elements Through Elements Public Property Hiding Elements in Tests Hiding Element Unnecessary Details Summary Questions Further Reading Chapter 7. Building Extensibility in Your Test Library Building Extensibility for Finding Elements through Strategy Design Pattern Vanilla WebDriver Finding of Elements Strategy Design Pattern Reviewing Current Version for Finding Elements Creating Elements Find Strategies Refactoring IElementFindService Improving Elements Find Strategies API Usability Building Extensibility for Waiting for Elements through Strategy Design Pattern Vanilla WebDriver Waiting for Elements Reviewing Current Version of Elements Waiting Creating Elements Wait Strategies Creating IElementWaitService Adding Waiting for Elements to ElementFinderService Adding Extensibility Points through EventFiringWebDriver Vanilla EventFiringWebDriver Example Integrating EventFiringWebDriver Summary Questions Further Reading Chapter 8. Assessment System for Test Architecture Design Assessment System Introduction What Problem Are We Trying to Solve? Criteria Definitions 1. Readability 2. Maintainability 3. Reusability 4. API Usability 5. Extensibility 6. Code Complexity Index 7. Learning Curve 8. KISS* Steps to Apply Assessment System Usage Examples Tests without Page Objects Assessment Architecture Design Overview 1. Readability 2. Maintainability 3. Reusability 4. API Usability 5. Extensibility 6. Code Complexity Index 7. Learning Curve Test Design Index Tests with Page Objects Assessment Architecture Design Overview 1. Readability 2. Maintainability 3. Reusability 4. API Usability 5. Extensibility 6. Code Complexity Index 7. Learning Curve Test Design Index Tests with Facades Assessment Architecture Design Overview 1. Readability 2. Maintainability 3. Reusability 4. API Usability 5. Extensibility 6. Code Complexity Index 7. Learning Curve Test Design Index Final Assessment Summary Questions 1.Can you list the seven criteria of the assessment system? 2.What aspects of the code do you evaluate for the Reusability criterion? 3.Why is the learning curve a critical evaluation point? 4.What is the Test Design Index? 5.How do you calculate code metrics in Visual Studio IDE? 6.What steps do you need to follow to apply the assessment system in your project? Further Reading Chapter 9. Benchmarking for Assessing Automated Test Components Performance What Is Benchmarking? Benchmarking Your .NET Code with BenchmarkDotNet Main Features BenchmarkDotNet Example Benchmark Button Click Solutions Button Benchmark Experiment Benchmark Reports, Profiling, Disassembly Diagnoser Benchmark HTML and CSV Reports Benchmark Disassembler Benchmark Profiling Optimized Browser Initialization Benchmark Integration Updates in Observer Classes Summary Questions Further Reading Chapter 10. Test Data Preparation and Test Environments Stop Hard-coding Input Data Problematic Test Data Configuration Transformations Creating URL Settings Creating WebDriver Timeouts Settings Creating Default Billing Info Settings Environmental Variables Introducing Test Fixtures Using AutoFixture for Generating Data Using MSTest Data Driven Tests Using an API as a Source of Fixture Data Using Data Stubs Building Test Data Reset/Creating App Use Case Creating DB Access Layer Generic Repository Design Pattern Generic Repository Design Pattern in C# Creating Users Factory Using an API or DB for Verification Summary Questions Further Reading Appendix 1. Defining the Primary Problems that Test Automation Frameworks Solve Sub Problem 1 - Repetition and People Boredom, Less Reliable Automation Solution Hypothesis Subsequent Problems Sub-Problem 2 - Engineers Are Not So Good with Numbers, Accuracy Automation Solution Hypothesis Subsequent Problems Sub-Problem 3 - Time for Feedback- Release Automation Solution Hypothesis Subsequent Problems Sub-Problem 4 - Regression Issues Prevention Automation Solution Hypothesis Subsequent Problems Sub-Problem 5 - Skipping Part of the Scope Automation Solution Hypothesis Subsequent Problems Sub-Problem 6 - Ping-pong Automation Solution Hypothesis Subsequent Problems Sub-Problem 7 - Money, Time, Effort for Maintaining Test Artifacts Automation Solution Hypothesis Subsequent Problems Sub-Problem 8 - Various App Configurations Automation Solution Hypothesis Subsequent Problems Sub-Problem 9 - Low QA Team Morale Automation Solution Hypothesis Subsequent Problems Sub-Problem 10 - Questioned Professionalism Automation Solution Hypothesis Subsequent Problems Sub-Problem 11 - Provide Evidence What You Did Automation Solution Hypothesis Subsequent Problems Sub-Problem 12 - Holidays and Sickness, 24 Hours Automation Solution Hypothesis Subsequent Problems Sub-Problem 13 - Some Things Cannot be Tested Manually Automation Solution Hypothesis Subsequent Problems Sub-Problem 14 – Consistency Automation Solution Hypothesis Subsequent Problems Sub-Problem 15 - Faster Scale-up and Scale-down Automation Solution Hypothesis Subsequent Problems Summary Further Reading Appendix 2. Most Exhaustive CSS Selectors Cheat Sheet Element Selectors Contextual Selectors Attribute Selectors Useful n Values Pseudo-class Selectors that Apply to Siblings Pseudo-class Selectors for Link and User States Further Reading Appendix 3. Most Exhaustive XPath Selectors Cheat Sheet Contextual Selectors Attribute Selectors XPath Methods Axis Navigation Math Methods String Methods Further Reading Bibliography