Wait is an important command used in test automation for handling dynamic loading of web elements on a web page (or web application). The wait command in Selenium helps to ensure that our web application is less flaky and more reliable. 

In this tutorial, I’m going to walk you through two types of Selenium waits in the WebDriver – Explicit wait and Fluent waits.

What Is Explicit Wait?

Unlike implicit wait, explicit wait in Selenium C# frameworks will wait for certain conditions to occur. The conditions could be waiting for the presence of the web element, waiting for the element to be clickable, waiting for the element to be visible, etc.

Explicit wait in Selenium is also called smart wait as the wait is not for the maximum time-out. If the condition for the explicit wait is satisfied, the wait condition is exited and the execution proceeds with the next line of code. Depending on the test scenario, you should choose the best-suited wait condition for the explicit wait.

Unlike implicit wait that applies till the time the Selenium WebDriver instance (or IWebDriver object) is alive, explicit wait in Selenium works only on the particular web element on which it is set, rather than all the elements on the page.

Explicit wait in Selenium can be used in test scenarios where synchronization is needed i.e. loading of the web page is complete and you are waiting for the element (under test) to be visible.

The figure shows what happens under the hoods when explicit wait in Selenium is triggered:

Explicit wait workflow

These steps are followed in sequence when Explicit Wait command is executed:

Features of Explicit Wait in Selenium

Apart from the explicit wait, developers also have the choice of using implicit wait command in Selenium. Explicit wait in Selenium has a number of key features (or differences) than other types of Selenium waits:

  • Unlike implicit wait, the explicit wait command in Selenium is documented and has a defined behavior.

  • Explicit wait executes on the local part of Selenium i.e. the programming language of your code, whereas implicit wait works on the remote part of Selenium i.e. the one controlling the web browser.

  • It can work with any possible condition (e.g. elementToBeClickable, alertIsPresent, invisibilityOfElementWithText, stalenessOf, etc.) unlike implicit wait that only works on findelement methods.

  • Explicit wait in Selenium can also be used in case you are checking for the absence of a web element on the page.

  • The delay between retries can be customized using adjusting the .pollingInterval property which is by default set to 250 ms. On the other hand, delay in implicit waits can only be customized through the global timeout.

WebDriverWait and Expected Condition

Explicit wait in Selenium is facilitated by WebDriverWait and ExpectedCondition classes. WebDriverWait is present in the OpenQA.Selenium.Support.UI namespace in C#.  ExpectedCondition provides a set of conditions on which wait can be performed.

When a search process for a particular web element is performed, the Selenium WebDriver polls the browser for the presence of the element in the DOM (Document Object Model). Below are some of the exceptional situations:

  • NoSuchElementException – The element is not present in the DOM when the search operation is performed.

  • StaleElementReferenceException – The web element is present in the DOM when the search is initiated but the element might have become stale (or its state in the DOM could have changed) when the search call is made.

  • ElementNotVisibleException – The web element is present in the DOM but it is not yet visible when the search process is initiated.

  • ElementNotSelectableException – The element is present on the page but it cannot be selected.

  • NoSuchFrameException – The WebDriver tries switching to a frame which is not a valid one.

  • NoAlertPresentException – The WebDriver attempts switching to an alert window which is not yet available.

  • NoSuchWindowException – The WebDriver attempts switching to a window that is not a valid one.

For avoiding these exceptions, the description of the exception should be passed to the IgnoreExceptionTypes() method:

ExpectedConditions class in Selenium supplies a set of conditions that can be waited for using WebDriverWait. ExpectedConditions is present in the OpenQA.Selenium.Support.UI.ExpectedConditions namespace.

Some of the common methods exposed by the ExpectedConditions class:

  • AlertIsPresent()

  • ElementIsVisible()

  • ElementExists()

  • ElementToBeClickable(By)

  • ElementToBeClickable(IWebElement)

  • ElementToBeSelected(By)

  • ElementToBeSelected(IWebElement)

  • ElementToBeSelected(IWebElement, Boolean)

  • TitleContains()

  • UrlContains()

  • UrlMatches()

  • VisibilityOfAllElementsLocatedBy(By)

  • VisibilityOfAllElementsLocatedBy(ReadOnlyCollection<IWebElement>)

  • StalenessOf(IWebElement)

  • TextToBePresentInElement()

  • TextToBePresentInElementValue(IWebElement, String)

More details about the ExpectedConditions class can be found here

Demonstration of Explicit Wait in Selenium 

To demonstrate the usage of explicit wait in Selenium, we perform a search for LambdaTest on Google. For the examples demonstrated in this Selenium C# tutorial, we use the NUnit test framework.

The OpenQA.Selenium.Support.UI & SeleniumExtras.WaitHelpers namespaces are included to use WebDriverWait and ExpectedConditions respectively.

An explicit wait in Selenium with a timeout of 10 seconds is set using the WebDriverWait class.

The ExpectedCondition used is ElementExists. An explicit wait in Selenium is performed till the time the required web element is not found (via XPath) or a timeout occurs i.e. the web element does not exist on the DOM.

As shown in the VS-2019 screenshot, the target web page opens up after search and the test result is Success.

Test result

Now that we’ve covered what is explicit wait in Selenium test Automation and what are its features in this tutorial. We’ll now move onto the fluent wait in Selenium and discuss it in further detail.

What Is Fluent Wait?

Fluent Wait is another Wait variant in Selenium that lets you control the maximum amount of time the Selenium WebDriver needs to wait for the defined condition to appear. Fluent Wait in Selenium can be achieved by defining the frequency at which the WebDriver checks for the element before it throws ElementNotVisibleException.

One major difference between fluent wait and explicit wait in Selenium test automation is that the polling frequency (.pollingInterval) at which the presence for the web element is checked is controllable in fluent wait in Selenium, whereas it is 250 ms in explicit wait.

If the polling frequency in fluent wait is not set, it defaults to 250 ms. The user also has the flexibility to ignore exceptions that may occur during the polling period using the IgnoreExceptionTypes command. The DefaultWait class in C# is used to configure the timeout and polling interval on the fly.

Syntax of Fluent Wait command in Selenium 

Demonstration of Fluent Wait in Selenium

To demonstrate fluent wait in Selenium test automation, the same test scenario which we used for the explicit wait in Selenium, i.e. searching for LambdaTest on Google and clicking on the matching result.

The polling frequency is set to 250 ms and timeout for locating the web element is set to 5 seconds. NoSuchElementException is ignored in case if the web element is not found on the DOM.

The .until() method is used to search for the intended web element. The element is searched until the timeout (of 5 seconds) happens or until the element is found.

As seen in the execution snapshot; the element is found, the target page is opened, and the WebDriver session is terminated.

Execution snapshot

Wrapping it Up

In this tutorial, we had a detailed look at explicit and fluent wait in Selenium. Both explicit and fluent wait in Selenium is ideal for performing waits on web elements in modern-day websites as the wait can be used alongside ExpectedConditions.

Explicit and Fluent Wait in Selenium looks for the presence of the web element at regular intervals till the element is found or there is a timeout occurrence. By using Fluent wait in Selenium test automation, you can control the polling frequency (which is set the default to 250 ms) and also configure exceptions that have to be ignored during the polling period. That’s all for now. Happy Testing!!!

Source link

Write A Comment