CF

Selenium WebDriver and Design Patterns

7h 42m 56s
English
Paid

Design Patterns are repeatable and reusable solutions for software design related issues. This course helps you to get introduced to the some of the frequently used Design Patterns in the software development community and demo how we can use them in Test Automation to achieve better re-usability and maintainability in the Test Automation Frameworks, Page Objects, Test classes design!

We will learn these design patterns along with Single Responsibility Principle.

  • Factory Pattern

  • Strategy Pattern

  • Command Pattern

  • Template Method Pattern

  • Proxy Pattern

  • Execute Around Method Pattern

  • Decorator Pattern

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 97 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 97 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Course Introduction
All Course Lessons (97)
#Lesson TitleDurationAccess
1
Course Introduction Demo
02:21
2
Goals, Advantages of Design Patterns, Prerequisites
03:38
3
Problems With Poor Design
10:53
4
Good Code Vs Bad Code
02:47
5
Single Responsibility Principle - Introduction
05:55
6
[Optional] - Coupling & Cohesion
03:54
7
Sample Workflow For Automation
02:21
8
Page Components Design
02:15
9
IDE - Setup
03:15
10
Abstract Component
03:46
11
Search Widget Component Implementation
08:19
12
Search Suggestion Component Implementation
04:49
13
Explicit Wait Using Lambda
04:34
14
Refactoring
04:40
15
Navigation Bar Component Implementation
03:45
16
Result Stat Component Implementation
01:51
17
Google Main Page Implementation
04:18
18
Google Result Page Implementation
05:21
19
Base Test
03:54
20
Google Search Test - Part 1
04:24
21
Google Search Test - Part 2
04:13
22
Few Corrections
04:29
23
Google Search Test Run
00:51
24
Google Search Test Parameterize
02:01
25
Package Refactoring
04:18
26
Cohesion
02:02
27
Project Structure
05:45
28
Clarification For BDD
01:21
29
Single Responsibility Principle - Summary
05:24
30
Design Pattern - Introduction
03:03
31
SRP vs Design Patterns
02:46
32
Factory Introduction
05:22
33
Factory - Exercise
05:24
34
Factory - Abstract Google Page
02:05
35
Factory - Google English Page Implementation
07:29
36
Factory - Google French Page Implementation
07:45
37
Factory - Google Arabic Page Implementation
07:31
38
Google Factory Implementation
12:20
39
Google Search Test With Factory
09:40
40
Factory - Test Run Demo
02:34
41
Accommodating New Requirements
05:28
42
Factory - Summary
01:46
43
Strategy - Introduction
02:46
44
Strategy - Sample Application Walk-through
03:17
45
Strategy - Sample Application - Regular Design
02:35
46
Strategy - Payment Screen Design
08:19
47
Strategy - Payment Option Implementation
08:40
48
Strategy - Payment Screen Components
03:53
49
Strategy - Payment Screen Test - Part 1
08:25
50
Strategy - Payment Screen Test - Part 2
04:14
51
Strategy - Payment Screen Test - Run
01:32
52
Strategy Pattern Explanation
02:53
53
Factory vs Strategy
04:56
54
Combining Factory and Strategy
08:09
55
Strategy - Summary
04:15
56
Command - Introduction
02:32
57
Command - Sample Application Walk-through
01:58
58
Command - Sample Application - Regular Design
02:57
59
Command - Notification Validator
08:30
60
Command - Dismissal Alert Validator
05:47
61
Command - Home Page Implementation
10:42
62
Command - Get Element Validators Implementation
06:14
63
Command - Home Page Test
04:37
64
Small Correction
02:45
65
Command - Running Test
05:11
66
Command - Summary
02:30
67
Template Method - Introduction
03:12
68
Template Method - Sample Application Walk-through
02:19
69
Template Method - Shopping Template Implementation
03:34
70
Template Method - Amazon Shopping Implementation
06:41
71
Template Method - eBay Shopping Implementation
06:21
72
Template Method - Shopping Test Implementation
02:12
73
Template Method - Test Run
01:46
74
Template Method - When To Use
03:52
75
Template Method - Multi Pages Workflow - Refactoring
11:34
76
Template Method - Final Test Run
03:32
77
Proxy - Introduction
04:16
78
Proxy - Sample Application Walk-through
02:12
79
Proxy - Order Component Real - Implementation
04:53
80
Proxy - Order Component Proxy - Implementation
06:28
81
Proxy - Page Object Design
02:21
82
Proxy - Test Run
05:09
83
Proxy - Summary
02:26
84
Execute Around Method - Introduction
02:39
85
Execute Around Method - Sample Application Walk-through
01:57
86
Execute Around Method - Main Page Implementation
05:01
87
Java 8 Consumer - Refresh
07:09
88
Execute Around Method - Main Page Problems With Frames
06:52
89
Execute Around Method - Implementation & Demo
09:32
90
Decorator - Introduction
02:03
91
Decorator - Sample Application Walk-through
02:51
92
Decorator - Page Object
05:36
93
Decorators Implementation
16:42
94
Decorator - Test Run
08:40
95
Decorator - Assignment
05:33
96
Decorator - Assignment Solution
05:50
97
Dependency Injection Pattern - Intro
01:29
Unlock unlimited learning

Get instant access to all 96 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
The course assumes a basic understanding of software design principles and familiarity with test automation frameworks. It is helpful to have prior experience with tools like Selenium WebDriver and an understanding of design patterns, as the course covers their application in test automation extensively.
What will I build during the course?
Throughout the course, you will work on developing components for an automated testing framework. This includes implementing various design patterns in test classes, such as Page Objects, and building components like the Search Widget, Navigation Bar, and Result Stat for testing a Google search application using Selenium WebDriver.
Who is the target audience for this course?
This course is designed for software developers and test automation engineers looking to enhance their skills in using design patterns within automated testing frameworks. It is particularly useful for those who aim to improve the reusability and maintainability of their test automation projects.
How does this course differ from other Selenium WebDriver courses?
Unlike many Selenium WebDriver courses that focus solely on tool usage, this course integrates the concept of design patterns. It provides practical demonstrations on how patterns like Factory, Strategy, and Command can be used to create more efficient test frameworks, thus bridging a gap between general software design principles and test automation.
What specific tools or platforms are covered in the course?
The course specifically focuses on Selenium WebDriver for implementing test automation. Additionally, it covers the setup of Integrated Development Environments (IDEs) for test automation projects, though it doesn't specify which IDE is used.
Are there any topics not covered in this course that I should be aware of?
While the course covers several design patterns and their application in test automation, it does not delve into other aspects of software development such as database testing, performance testing, or the use of other test automation tools beyond Selenium WebDriver.
How much time should I expect to commit to this course?
The course comprises 97 lessons. Even though the runtime isn't specified, given the depth of topics like Factory and Strategy patterns, as well as practical exercises, you should plan to spend several hours a week for a thorough understanding, especially if you engage with optional lessons and exercises.