What will you learn in this course?

Are you struggling with working with HTML using Selenium WebDriver? Do you know how to easily identify and manipulate an element using Selenium WebDriver? How about performing a drag n’ drop on an element? If not, then these are just a few of the questions that will be answered in this course.

This course is a complete guide on working with web elements in Selenium WebDriver! Once you are finished with this course, you will know how to work with any web elements, anytime, on any web application.

In this course from Ultimate QA, you will learn:

– Basics of HTML

– All the different locator strategies for Selenium WebDriver

– How to identify web elements using Selenium WebDriver

– Master XPath

– Navigation with Selenium WebDriver

– Web element manipulation

– Web element interrogation

– Mouse and keyboard actions with Selenium WebDriver

– Performing actions such as drag n’ drop, drawing, hovering

– Implicit and Explicit waits

– How to properly handle element identification so that your tests are not flaky

– Expected Conditions in Selenium WebDriver

Take This Entire Course for Free

What will you learn in this lecture?

In this video, we will go through the what kinds of problems can arise as a result of improper sync Implicit and Explicit Waits course.

Selenium Tutorial – Implicit and Explicit Waits What kinds of problems can arise as a result of improper sync

So I synchronizations so important with automated functional software testing. Well the reason is because we are writing code that actually has the code so our code needs to literally mimic the functionality of the application and so forth doesn’t do a good job of mimicking the functionality of the application. This can lead to a lot of weird situations that occur with your code.

Some of these situations are so problems with your synchronization through other tests can lead to three problems intermittent test failures.

False positives and negatives and slow test execution. So did you guys see how when we were debugging our code locally on our computer and we were stepping through it. Everything worked all right. But then when we ran it in the C environment it did not work and it failed because the test was too fast for the application. And so what it can do when your synchronization is not up to par. You can have these intimate and test failures where the developer takes the code and says oh, by the way, this works on my VM, therefore, I don’t know why it’s failing in CIA environment right.

You’ve seen a lot of bugs like that and you can have the same type of bugs with your automated functional testing code where you can be like I don’t understand why this test is failing when I step through it on my VM. It completely works all the time so I’m completely clueless as to why it’s not working. Well if it’s not working in the CIA it’s working on your VM.

One of the reasons is that your synchronization may be off. The other thing that improper synchronization does is it leads to false positives and negatives. Right talking about the test failures you get false positive results saying that all the tests failed. Right but the test is not really failing because the functionality is broken. The test is failing because your test is either too fast or too slow for the application and the too slow part is where you may have actually negative outcomes from your test cases.

Right because your test right it fails intermittently and therefore sometimes the results of when it fails are not correct right it may fail or it may not because depending on your synchronization and sometimes the element loads faster sometimes the element a lot slower and that can lead to improper results. And so therefore you can’t trust your test whether it’s passing or failing which is actually one of the worst things that can happen is when the entire team or even you lose the trust in your tests. When you stop trusting your tests that’s when all things go really south and you need to be able to trust your test and you need to make sure that they’re extremely solid and having proper synchronization is one way to do that.

The final problem that can occur with bad synchronization strategies is slow test execution and this mainly refers to when you use improper synchronization techniques. What’s going to happen is your test is going to run way too slow. Write your application under test is going to be running much faster than you actual code and so you may not be acting like the end user with your functional test which you may be doing is just waiting too long. Every single step and wasting a lot of valuable time. Not only does this waste time in the CIA environment where all of your tests are running and it’s taking multiple hours to run your tests when they could be run much faster. It’s also costing you time when you’re trying to debug these tests and they’re running for way too long.

All of those minutes quickly add up leading to an inefficient process and may be frustration not only from you but even from all of your team mates and management because there’s a lot of time being wasted an automated functional testing so to handle all of these synchronization techniques appropriately we need to learn a few strategies.

Pin It on Pinterest

Shares
Share This