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

Free Video Course

In This Lecture

In this video, we will go through Conclusions.

Selenium Tutorial – Conclusions

Well congratulations you have had a fantastic journey on learning the advanced techniques of utilizing page objects to drastically stabilize your automated functional tests. Really. You have been fantastic.

Let’s quickly go through everything that we’ve covered just to kind of get a recap on what you’ve learned. We began our journey by learning that GUI automation is hard. Many of you struggle with test automation and a majority of us can only execute between 0 to 50 daily tests and actually have those tests 95 percent reliable.

I bet those numbers are actually even lower one side digging into the 0 to 15 split it out into more categories. I bet it’s probably between zero to ten tests per day that most people can actually execute successfully. And it’s hard simply because the web is becoming more and more dynamic more user friendly making functional test automation harder.

So what you need to do is start using Page object page objects are a fantastic step towards drastic. Test stability don’t utilize any other method don’t use record and replay don’t use keyword driven frameworks. They are not conducive to helping you to have stable functional test automation.

Furthermore page objects even make your tests more readable so that anybody who is reading or tests can actually understand what’s going on inside of them. Then you learn that you need to remove duplication.

Duplication is the enemy. And that’s why page objects are so efficient in what they do because they allow us to remove a lot of duplication abstracted out into a page object and then utilize that page object all throughout our tests.

Also you learn that you need to follow the Single Responsibility Principle. Make sure that your classes only do a single thing. That’s where we learn how to utilize the object repository in our page objects.

We separated the object and identify management and storage from actual interaction with the page. And it also made all of our page classes much smaller and easier to maintain again.

Afterwards we learned that you need to separate large page objects separating large page objects that have a lot of HVM elements on it is going to make your tests more readable and your class is smaller when your classes are smaller they’re easier to maintain.

And when your tests are more readable that’s just great for everybody because it’s easier to understand all of your tests. Also separating large classes into much smaller classes allows you to use composition to create your classes which is one of the patterns that people want us to follow.

Use composition over inheritance and with all of that our journey comes to an end. You have reached fantastic automation success by learning all of these skills and going through all of their exercises. Your page objects are now going to be phenomenal.

They’re going to be at an extremely high level where you’re not going to run into much problems. The main problem is that you’re going to start running into now. How many automated functional test can you write and maintain it because you’re going to have a lot and you’re going to need to maintain all of them.

But all of these tools that I’ve given you here will help you to maintain those automated functional tests in a fantastic state.

You just have to make sure that you take the time to do your automated functional tests right.

Pin It on Pinterest

Shares
Share This