SDET- Design Patterns With Selenium [Hands-On]

SDET: Design Patterns With Selenium [Hands-On], available at $84.99, has an average rating of 4.52, with 106 lectures, 1 quizzes, based on 774 reviews, and has 6385 subscribers.

You will learn about Design Patterns In Test Automation Clean Reusable Page object design & Frameworks Single Responsibility Principle Factory Pattern Strategy Pattern Command Pattern Template Method Pattern Proxy Pattern Execute Around Method Pattern Decorator Pattern This course is ideal for individuals who are Anybody who has interests in Test Automation or Sr SDET / Lead / Principal / Architect SDET or Test Automation Framework design It is particularly useful for Anybody who has interests in Test Automation or Sr SDET / Lead / Principal / Architect SDET or Test Automation Framework design.

Enroll now: SDET: Design Patterns With Selenium [Hands-On]

Summary

Title: SDET: Design Patterns With Selenium [Hands-On]

Price: $84.99

Average Rating: 4.52

Number of Lectures: 106

Number of Quizzes: 1

Number of Published Lectures: 106

Number of Published Quizzes: 1

Number of Curriculum Items: 107

Number of Published Curriculum Objects: 107

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Design Patterns In Test Automation

Clean Reusable Page object design & Frameworks

Single Responsibility Principle

Factory Pattern

Strategy Pattern

Command Pattern

Template Method Pattern

Proxy Pattern

Execute Around Method Pattern

Decorator Pattern

Who Should Attend

Anybody who has interests in Test Automation

Sr SDET / Lead / Principal / Architect SDET

Test Automation Framework design

Target Audiences

Anybody who has interests in Test Automation

Sr SDET / Lead / Principal / Architect SDET

Test Automation Framework design

Mastering Design Patterns for Test Automation: Reusability and Maintainability

Design Patterns offer repeatable and reusable solutions to address software design challenges. In this comprehensive course, you will be introduced to frequently used Design Patterns, empowering you to leverage their potential in Test Automation. By applying these patterns to your Automation Frameworks, Page Objects, and Test classes, you will achieve enhanced reusability and maintainability, paving the way for efficient and scalable test automation solutions.

Key Learning Points:

1. Single Responsibility Principle: Gain insights into the fundamental principle of assigning specific responsibilities to modules, classes, and methods within an application. Learn how to refactor complex Page Objects into modular Page Components or Fragments, resulting in more organized and neater test steps.

2. Factory Pattern: Uncover the power of creating objects without exposing the creation logic to the test class. Explore localization testing scenarios, where multiple languages and their specific behaviors come into play. Implement an abstract class with common functionalities and language-specific subclasses, leveraging the Factory Pattern to dynamically create Page Objects based on the language being tested.

3. Strategy Pattern: Understand how to pass behavior to an object at runtime without resorting to cumbersome if-else blocks. For instance, examine a Google search page with different search strategies, such as text-based or voice-based search. By utilizing the Strategy Pattern, you can dynamically switch between these strategies, promoting flexibility in your automation code.

4. Command Pattern: Explore how to encapsulate an object with all the necessary information for later execution. This pattern is highly valuable for Pages with multiple UI components and numerous UI validations.

5. Template Method Pattern: Discover how to design high-level steps or a skeleton in a superclass while allowing subclasses to override specific steps. This pattern is particularly useful in scenarios where similar applications, such as room booking and car booking, share common workflows with varying options.

6. Proxy Pattern: Learn how to create a placeholder object for another object, facilitating seamless execution of specific steps based on the testing environment. For instance, executing certain steps in the QA environment while skipping them in the production environment is made more efficient using the Proxy Pattern.

7. Execute Around Method Pattern: This pattern addresses the need to perform specific steps consistently, regardless of the main task. For example, opening and closing files before and after reading or writing content is a common occurrence. The Execute Around Method Pattern provides a systematic approach for handling such scenarios.

8. Decorator Pattern: Delve into the world of dynamic UI components based on user roles within an application. By employing the Decorator Pattern, you can create flexible Page Objects that adapt to different user roles, such as admin or user, granting them varying levels of access.

By completing this course, you will acquire a strong foundation in essential Design Principles and Patterns for Test Automation. Empowered with this knowledge, you will significantly enhance the reusability and maintainability of your Automation Framework, Page Objects, and Test classes. Unleash the full potential of Design Patterns and elevate your test automation solutions to new heights of efficiency and scalability.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course Introduction

Lecture 2: Goals, Advantages of Design Patterns, Prerequisites

Chapter 2: Single Responsibility Principle

Lecture 1: Problems With Poor Design

Lecture 2: Good Code Vs Bad Code

Lecture 3: Single Responsibility Principle – Introduction

Lecture 4: [Optional] – Coupling & Cohesion

Lecture 5: Sample Workflow For Automation

Lecture 6: Page Components Design

Lecture 7: Source Code

Lecture 8: IDE – Setup

Lecture 9: Abstract Component

Lecture 10: Search Widget Component Implementation

Lecture 11: Search Suggestion Component Implementation

Lecture 12: Explicit Wait Using Lambda

Lecture 13: Refactoring

Lecture 14: Navigation Bar Component Implementation

Lecture 15: Result Stat Component Implementation

Lecture 16: Google Main Page Implementation

Lecture 17: Google Result Page Implementation

Lecture 18: Base Test

Lecture 19: Google Search Test – Part 1

Lecture 20: Google Search Test – Part 2

Lecture 21: Few Corrections

Lecture 22: Google Search Test Run

Lecture 23: Google Search Test Parameterize

Lecture 24: Package Refactoring

Lecture 25: Cohesion

Lecture 26: Project Structure

Lecture 27: Clarification For BDD

Lecture 28: Single Responsibility Principle – Summary

Chapter 3: Factory Pattern

Lecture 1: Design Pattern – Introduction

Lecture 2: SRP vs Design Patterns

Lecture 3: [Optional] – Design Patterns Classification

Lecture 4: Factory Introduction

Lecture 5: Factory – Exercise

Lecture 6: Factory – Abstract Google Page

Lecture 7: Factory – Google English Page Implementation

Lecture 8: Factory – Google French Page Implementation

Lecture 9: Factory – Google Arabic Page Implementation

Lecture 10: Google Factory Implementation

Lecture 11: Google Search Test With Factory

Lecture 12: Factory – Test Run Demo

Lecture 13: Accommodating New Requirements

Lecture 14: Additional Materials

Lecture 15: Factory – Summary

Chapter 4: Strategy Pattern

Lecture 1: Strategy – Introduction

Lecture 2: Strategy – Sample Application Walk-through

Lecture 3: Strategy – Sample Application – Regular Design

Lecture 4: Strategy – Payment Screen Design

Lecture 5: Strategy – Payment Option Implementation

Lecture 6: Strategy – Payment Screen Components

Lecture 7: Strategy – Payment Screen Test – Part 1

Lecture 8: Strategy – Payment Screen Test – Part 2

Lecture 9: Strategy – Payment Screen Test – Run

Lecture 10: Strategy Pattern Explanation

Lecture 11: Factory vs Strategy

Lecture 12: Combining Factory and Strategy

Lecture 13: Additional Materials

Lecture 14: Strategy – Summary

Lecture 15: Exercise

Chapter 5: Command Pattern

Lecture 1: Command – Introduction

Lecture 2: Command – Sample Application Walk-through

Lecture 3: Command – Sample Application – Regular Design

Lecture 4: Command – Notification Validator

Lecture 5: Command – Dismissal Alert Validator

Lecture 6: Command – Home Page Implementation

Lecture 7: Command – Get Element Validators Implementation

Lecture 8: Command – Home Page Test

Lecture 9: Small Correction

Lecture 10: Command – Running Test

Lecture 11: Element Validators With Data Provider

Lecture 12: Command – Summary

Chapter 6: Template Method Pattern

Lecture 1: Template Method – Introduction

Lecture 2: Template Method – Sample Application Walk-through

Lecture 3: Template Method – Shopping Template Implementation

Lecture 4: Template Method – Amazon Shopping Implementation

Lecture 5: Template Method – eBay Shopping Implementation

Lecture 6: Template Method – Shopping Test Implementation

Lecture 7: Template Method – Test Run

Lecture 8: Template Method – When To Use

Lecture 9: Template Method – Multi Pages Workflow – Refactoring

Lecture 10: Template Method – Final Test Run

Lecture 11: Additional Materials

Chapter 7: Proxy Pattern

Lecture 1: Proxy – Introduction

Lecture 2: Proxy – Sample Application Walk-through

Lecture 3: Proxy – Order Component Real – Implementation

Lecture 4: Proxy – Order Component Proxy – Implementation

Lecture 5: Proxy – Page Object Design

Lecture 6: Proxy – Test Run

Lecture 7: Additional Materials

Lecture 8: Proxy – Summary

Chapter 8: Execute Around Method Pattern

Instructors

Vinoth Selvaraj
Principal Engineer

Rating Distribution

1 stars: 9 votes

2 stars: 7 votes

3 stars: 69 votes

4 stars: 252 votes

5 stars: 437 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!