In This Course
Did you know that a recent poll revealed that 80% of QA Automation Engineers cannot run more than 100 functional tests daily, with 95% reliability? Furthermore, over 50% of these Automation Engineers struggle to run between 0 – 50 automated functional tests per day!
Functional test automation is a hard job. However, you can make your job much easier by learning a pattern known as the Page Object Pattern. The Page Object Pattern helps to resolve a lot of the problems that other automation techniques cannot. Making your test automation more stable as a result.
This course is designed to teach you how to properly code the Page Object Pattern using Selenium Webdriver with C#.
However, all of the information here is equally applicable to any other functional testing tool because the Page Object Pattern is a universal principle that makes test automation more robust. Similar to other universal concepts such as Don’t Repeat Yourself or Single Responsibility Principle.
Therefore, if you know Object Oriented programming and a different functional automation tool, you can still comfortably follow along with all of the principles and patterns that I lay out in this course.
In this course, you will learn:
– Why other methods such as Record & Replay or Keyword Driven do not work when it comes to test automation
– What the Page Object Pattern is in automation
– Advantages and disadvantages of the Page Objects
– Amazing tips and tricks on how to:
- Implement the Page Objects using Selenium Webdriver
- Improve your Page Objects to follow DRY Principle
- Improve Page Objects to follow SRP Principle
- Create amazing Page Objects for gigantic web pages
In This Lecture
In the previous video, we learned analysis of objectrepository implementation of the page objects in test automation course. In this video, we will go through the process of analyzing the new CoursesPage for the course.
Analyzing the new CoursesPage
So take a look.
With me at the Course’s page what I have done over here on the left-hand side is our old implementation of the Course page. And on the right-hand side is the new implementation of the Course page. The right-hand side of the Course’s page has removed our objects and stored them into an object repository.
Now, this has the benefit because our courses page now only deals with Page manipulation and our object repository is going to deal with object storage. If any of you are familiar with Q-tips, this is the kind of similar paradigm that they used to implement with their object repository.
They used to have all the objects live in an object repository. And then you utilized all of those objects inside of your script utilizing the object repository. So that’s the same thing that’s happening here. And thanks to the object repository we are now following the single responsibility principle.
Because our courses page is only responsible for interacting with the page and not object storage. So you can see that our class has become a little bit smaller. Because now we don’t need to store any elements like we do here on line 7. Also when we initialize the page we initialize it through a base page that gets created with a type of courses page object repository. Our constructor now creates our base page and along with the creation of the base
Finally, the other advantage that I believe this page object has is that now we have access to all of our objects related to this page using the object repository keyword.
So rather than knowing the name of something like assigning length, for example, all we have to do is type in Object repository poorish the period. And then that’s going to allow us to see all of the objects inside of the object repository related to this page. Now that maybe a little bit confusing so let’s go ahead. And step through the code so that I can better show you exactly what’s going on here