Selenium Wait Commands: Implicit, Explicit & Fluent Waits

In today’s world of automation testing, timing is everything. Imagine running a test script that goes through a web application, just to have it fail because the page didn’t load fast enough or an element wasn’t visible right at that moment when the script tried to work with it. This could be because of several reasons, like network speed, server response time, and client-side rendering. These are the types of timing issues that can make automated tests unreliable and frustrating for maintenance and a complete waste of time. This is where the concept of “waits” in automation testing becomes crucial.

To resolve these time issues, Selenium WebDriver, one of the most widely used tools in web automation, provides support for various types of waits. These wait commands ensure that your test script waits until certain conditions are met, for instance, an element is present in the DOM, or a page load is completed. Understanding and effectively using these waits is key to designing robust and stable automated tests, especially for handling dynamic content or unpredictable loading times.

In this blog, we will explain three types of waits available in Selenium: implicit, explicit, and fluent wait. We will explain precisely how each of them works, what problem each can solve, and the best practices for their implementation within your test automation framework. Whether you are an experienced tester or just starting, once mastered, these waits will take your test scripts to a whole new level in terms of stability and efficiency.

What Are Selenium Waits?

Selenium Wait is a mechanism in Selenium WebDriver that makes it wait until certain conditions are met before executing further commands of the test script. These typically contain a wait for one of the web page elements to either be loaded or interactable. Without waits, test scripts will fail in trying to perform activities with elements that have not appeared yet, or their loading is not complete; this makes tests unreliable and inconsistent.

The waits in Selenium ensure that your test script will wait (instead of pausing it with thread.sleep()) until the condition you name is satisfied, for instance, the presence of an element in the DOM or completing a page load. The concept and usage of these waits are pretty important in correctly designing automated tests of good quality.

Types of Waits in Selenium

Selenium provides three different types of wait commands that efficiently handle various timing scenarios and enhance the reliability of automated tests as follows:

1. Implicit Wait:  It sets a default time for WebDriver to wait for an element to appear before throwing an exception, applying to all elements by default. It’s used as a global wait for all elements in your test script and does not wait for specific conditions. Once set, it remains accessible and active throughout the driver’s session.
2. Explicit Wait: This wait is more targeted; you can set it for the condition you want to continue with the execution. In explicit waits, you can wait for an element or on conditions, for instance, till an element is visible or it’s clickable.
3. Fluent Wait: This is an advanced version of the explicit wait. Fluent Wait enables you to define the maximum amount of time to wait for a condition, as well as the frequency with which the WebDriver checks whether the condition is met. It also allows ignoring specific exceptions while waiting, such as NoSuchElementException.

Selenium waits are the best way to ensure your test scripts will interact with web elements only when those are ready for interaction, hence making the automation of tests much more stable and reliable.

Implicit Wait in Selenium

Implicit Wait is one of the simple yet very useful features available in Selenium, which will instruct the WebDriver to wait for a certain period of time before throwing a no such element exception (NoSuchElementException) if it cannot find an element on the page. Once set, it applies globally to all element searches performed by WebDriver for the duration of that WebDriver instance.

How Implicit Wait Works

Whenever there is a defined implicit wait, it will automatically wait for the defined time every time it attempts to locate an element. If it shows up before the time, then it goes ahead with the script without delay. In case it doesn’t show up within this given time, Selenium stops the script and throws an exception indicating that the element was not found.

Syntax for Implicit Wait in Selenium

Here’s how you can implement Implicit Wait in Selenium:

// Setting the implicit wait for 10 seconds
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

In this Selenium Java example, the WebDriver will wait up to 10 seconds for any element to appear before moving on to the next step in the script.

When to Use Implicit Wait

Implicit Wait is extremely useful in cases where you are testing a pretty simple web application because most of the elements load within a predictable time range. While it can help minimize failed test scripts due to small loading delays, over-reliance on Implicit Wait may lead to longer test execution times if used improperly.

However, it is critical to notice that since the setting of Implicit Wait is global, in complex cases where different elements may require different wait times, it may not be perfect. In such cases, Explicit Wait or Fluent Wait, which offer greater control over specific conditions and timeouts, are more appropriate.

Explicit Wait in Selenium

Explicit Wait is an advanced and flexible way of applying a waiting mechanism, using which a user can define the specific conditions for the WebDriver to wait, unlike Implicit Waits, which apply a timeout globally to all elements. Explicit Waits provide the flexibility to specify the wait conditions on certain elements or the occurrence of specific conditions that enhance its usability.

How Explicit Wait Works

Explicit wait works by combining a nominated maximum wait time with one or more expected conditions. The WebDriver will check the condition at regular intervals, typically every 500 milliseconds by default, during that time. If the condition is met within the timeout, the WebDriver continues with the next step; otherwise, it raises a TimeoutException.

Explicit Wait Syntax in Selenium

To implement Explicit Wait in Selenium, you use the WebDriverWait class along with ExpectedConditions. Here’s the basic syntax:

// Import the necessary packages
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.By;

// Create a WebDriverWait instance
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

// Use Explicit Wait to wait for a specific condition
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("element_id")));

In this example, the WebDriver waits up to 10 seconds for the element with the Selenium locator (id=”element_id”) to become visible. If the element is visible before 10 seconds, the script continues; if not, an exception is thrown.

When to Use Explicit Wait

Explicit Wait is ideal for scenarios where fine-grained control over waiting on a particular element or condition is necessary, and you can even adjust the polling interval for checking conditions. In particular, it is very useful when:

• Dynamic Content: Pages that load elements dynamically, usually driven by technologies like AJAX.
• Specialized Conditions: When you have to wait for specific states of elements, for instance, visibility, clickability, and text presence.
• Unpredictable Load Times: In applications where the load times of elements can’t be predicted or vary a lot.

Types of Expected Conditions in Explicit Wait

Explicit waits allow for waiting until certain conditions are met before the test script is executed, or throwing exceptions when they cannot be satisfied. This is facilitated with the help of Selenium’s ExpectedCondition class. Many conditions can be used with waits as follows:

• Visibility of Element: Waits until an element is visible using ExpectedConditions.visibilityOf(element).
• Element Clickable: Waits until an element is visible and enabled with ExpectedConditions.elementToBeClickable(element).
• Presence of Element: Waits until an element is present in the DOM using ExpectedConditions.presenceOfElementLocated(by).
• Text in Element: Waits until specific text appears in an element with ExpectedConditions.textToBePresentInElement(element, text).
• Alert is Present: Waits until an alert is displayed using ExpectedConditions.alertIsPresent().
• Element Selection State: Waits until an element’s selection state matches the condition with ExpectedConditions.elementToBeSelected(element).
• Frame Available: Waits until a frame is available, then switches to it using ExpectedConditions.frameToBeAvailableAndSwitchToIt(by).
• Element Invisibility: Waits until an element is no longer visible with ExpectedConditions.invisibilityOf(element).
• URL Contains: Waits until the URL contains a specific substring using ExpectedConditions.urlContains(substring).
• Title is: Waits until the page title matches a specific value with ExpectedConditions.titleIs(title).

Fluent Wait In Selenium

Fluent Wait is an advanced version of explicit wait, offering more flexibility in dealing with dynamic web elements. Unlike the standard explicit wait, Fluent Wait allows you to specify:

• Polling Frequency: How often should the condition be checked? For example, every 500 milliseconds.
• Timeout: Maximum time to wait for the condition to be met.
• Ignoring Exceptions: You can configure Fluent Wait to ignore specific exceptions, like NoSuchElementException, and continue checking the condition without failing immediately.

How Fluent Wait Works

Fluent Wait will continuously poll the DOM until the condition is met or the timeout expires. In case the condition is met, it then proceeds with the execution of the script; if not, it throws an exception.

Fluent Wait Syntax in Selenium

Here’s the basic syntax for Fluent Wait in Selenium:

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))  // Maximum time to wait
    .pollingEvery(Duration.ofMillis(500)) // Interval between each poll
    .ignoring(NoSuchElementException.class); // Exceptions to ignore

WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("elementID")));

• withTimeout(Duration.ofSeconds(30)): This sets the maximum amount of time Selenium will wait for the condition to be met (in this case, 30 seconds).
• pollingEvery(Duration.ofMillis(500)): This defines the polling interval, meaning Selenium will check the condition every 500 milliseconds.
• ignoring(NoSuchElementException.class): This tells Selenium to ignore NoSuchElementException during the wait period, allowing it to continue polling instead of throwing an exception immediately.

When to Use Fluent Wait

Fluent Wait proves pretty useful when used with the best Selenium practices in the following cases:

• Dynamic Loading of Content: In cases when elements loaded dynamically on the page may not pop up at once after an action has been performed. Such examples include waiting for a loading spinner to disappear or content becoming visible after performing an AJAX call.
• Unpredictable Delays: Fluent Wait allows you to handle such cases when there are unpredictable delays in the appearance of an element or a change in its state, through polling frequency and timeout.
• Custom Waiting Logic: Fluent Wait can be used to wait for an element to change color or for a specific value in an element’s attribute. This makes it ideal for waiting for custom conditions. Fluent Wait can be customized to wait for any condition to be checked by a function; hence, it is ideal for complicated scenarios.

Selenium Waits vs Thread.sleep(): Key Differences

Thread.sleep() is a Java method that pauses the execution of a test script for a specified time in milliseconds. While it can introduce delays in automation scripts, it differs significantly from Selenium waits in terms of flexibility, efficiency, and functionality. Let’s understand the differences between Selenium waits and Thread.sleep() across various scenarios.

Dynamic Waiting vs. Static Waiting

• Selenium Wait: Selenium Wait introduces dynamic waiting by pausing execution until a specified condition is met or the maximum timeout is reached. If the condition is satisfied earlier, the test proceeds immediately, improving execution efficiency.

• Thread.sleep(): Thread.sleep() uses static waiting, where the test pauses for a fixed duration regardless of whether the required condition is met, leading to inefficient test execution.

Conditional Logic vs. Blind Waiting

• Selenium Wait: Selenium Wait actively checks for conditions such as element visibility, clickability, or presence before proceeding with execution.

• Thread.sleep(): Since Thread.sleep() does not support conditional logic, it pauses execution for a predefined duration, which may be longer or shorter than required and can affect test reliability.

Test Execution Speed and Efficiency

• Selenium Wait: Enhances test performance by avoiding unnecessary wait time. Since the test resumes immediately after the condition is met, it helps improve overall execution speed and performance.

• Thread.sleep(): This can slow down test execution significantly. It always waits for the predefined duration, even when the application is ready earlier. This could lead to a longer time in test execution.

Error Handling and Test Stability

• Selenium Wait: Selenium Wait is more robust because it can handle exceptions such as NoSuchElementException, improving test stability and reducing flaky test behavior.

• Thread.sleep(): Thread.sleep() does not provide built-in condition handling during the wait period, making tests more fragile if elements fail to load within the expected time.

When to Use Selenium Waits and Thread.sleep()

• Selenium Wait: It is best used for handling asynchronous events, dynamic content, and when the timing of element availability is not certain.

• Thread.sleep(): Thread.sleep() should be used only in limited scenarios where a fixed delay is necessary, such as debugging or handling external system delays outside browser control.

In most modern Selenium automation testing scenarios, Explicit Wait and Fluent Wait are preferred over Thread.sleep() because they improve test stability, execution speed, and reliability.

Conclusion

Effectively managing wait time is a very important aspect of test automation, and fortunately, Selenium has a very solid set of waiting mechanisms to deal with complexities brought in by dynamic web content, API calls, client-side rendering, etc. From Implicit Wait and Explicit Wait to Fluent Wait, testers can solve a wide variety of timing problems with precision and flexibility. It ensures adaptability against constantly changing conditions for efficiency, yet resilient tests in their nature for modern web applications.

Implicit Wait is a very simple, global solution to the problem of element availability, while Explicit Wait gives the ability to control explicitly what you are waiting for as a tester. Further to that, Fluent Wait makes it even more customizable with intervals and conditions that can be easily met under more complicated circumstances. All together, they form a nice balance that can deal with dynamic content, make tests less prone to flakiness, and are much more robust.

Frequently Asked Questions