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 this video, we will go through on Explaining the possible problems that we will run.
Selenium Tutorial – Explaining the possible problems that we will run
Now that we’ve written a few tests three tests for the complicated page. And we’ve done some deliberate practice with everything. Let’s take a look at the complicated page to see the problems that we’re going to run into and how to resolve those problems.
So if we take a look at the complicated page now, you can see that it’s beginning to get a little bulky right now. It’s definitely not so bad but we have only written three tests. And it’s already about 60 lines of code and you can see that if we continue to work. With this giant complicated page we’re going to run into a problem where our class is gigantic and harder to maintain. It is because it’s so gigantic there’s going to be so many things and you need to keep track of so many variables and methods and so on so forth that your idea each is going to become very bulky.
So in order to improve that we can actually start rapping a little sections of this page into their own classes. That’s completely OK because it’s going to make each of our classes smaller. And then it’s actually going to make it even easier to interact with our IEEE into write automated functional tests.
So for example the way I would look at this page and logically break it out into sections. I would probably break it into a section called section of Baden’s. Where I just interact with the buttons a section of social media follows where I just interact with the social media follows and then even a section of random stuff is actually itself pretty big.
So I might break it up into more sections than that so I might write a class that’s called section of random stuff. And then that section of random stuff might contain a class that’s called the left side bar the right side bar and then I don’t know what we call the center the center. Posts the center section.
Yeah the center section. So we could break it up like that. So actually let’s go through the code and let me show you what I’m going to do. Again I’m going to implement one real time. Then I’ll explain you what I did and then we’ll implement another one again after you understand what I did.