Understanding Waits in Selenium 4

In this post, we’ll explore the different types of waits in Selenium 4, including new improvements and best practices for their usage.

Types of Waits in Selenium 4
Selenium 4 provides three main types of waits:

1. Implicit Waits
2. Explicit Waits
3. Fluent Waits

Let’s dive into each one!

1. Implicit Waits Implicit Waits are the simplest type of wait. They tell the WebDriver to wait for a certain amount of time when trying to find an element if it is not immediately available. Once the time is set, it applies globally to all elements in the test. Code Example:

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

In this example, Selenium will wait for up to 10 seconds for an element to appear before throwing a NoSuchElementException. The wait applies to every element lookup during the entire session.

Pros:

Easy to implement.
Suitable for simple projects.
Cons:

Can slow down the test execution as it applies the wait globally, even if it isn’t needed.
Can lead to unpredictable test behavior when used with other wait types.

1. Explicit Waits Explicit Waits allow you to set conditions for certain elements. You can tell WebDriver to wait until a specific condition is met before proceeding. This wait is more granular and gives you greater control over waiting times.

Code Example:

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("example")));

In this example, WebDriver will wait up to 15 seconds until the element becomes visible. If the element appears before the 15 seconds, the wait ends early.

Common Explicit Wait Conditions:

visibilityOfElementLocated()
elementToBeClickable()
presenceOfElementLocated()
alertIsPresent()
Pros:

Highly customizable and more efficient than implicit waits.
Only waits when specific conditions are needed.
Cons:

Requires more code, which can increase complexity.
Managing multiple explicit waits can become tricky in large projects.

1. Fluent Waits Fluent Waits are an advanced version of explicit waits. They allow you to define the maximum time to wait, the polling interval, and handle exceptions. Fluent waits are useful when dealing with dynamic content that requires frequent checks.

Wait<WebDriver> fluentWait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(20))
    .pollingEvery(Duration.ofMillis(500))
    .ignoring(NoSuchElementException.class);

WebElement element = fluentWait.until(driver -> driver.findElement(By.id("example")));

Here, WebDriver will check for the element every 500 milliseconds and wait up to 20 seconds before timing out. It will also ignore NoSuchElementException during this time.

Pros:

Provides more flexibility and control over how waiting is handled.
Allows customization of polling intervals and exception handling.
Cons:

Can be more complex to set up and understand.
Over-customization can lead to confusing and hard-to-maintain code.
Improvements in Selenium 4 Waits
Selenium 4 introduces some improvements, especially in how you manage waits:

Better Syntax: Selenium 4 uses Duration instead of the previous TimeUnit, making it more intuitive and readable.
Relative Locators: You can now wait for elements in relation to other elements (e.g., to the left of, near, etc.).
Enhanced WebDriverWait: The WebDriverWait class in Selenium 4 is more streamlined and easier to use with modern syntax.

Best Practices for Using Waits in Selenium 4
Use Explicit Waits Instead of Implicit Waits: For better control and performance, prefer explicit waits, especially in complex scenarios.
Avoid Mixing Implicit and Explicit Waits: Using both can cause unpredictable behavior and increased wait times.

Set Reasonable Timeout Values: Avoid setting unnecessarily long waits. Analyze your application’s behavior to determine appropriate wait times.

Use Fluent Waits for Dynamic Elements: If elements are highly dynamic, consider using fluent waits with polling intervals to reduce unnecessary waiting.

Conclusion
Handling waits effectively in Selenium 4 is crucial to writing stable and reliable automated tests. Understanding when and how to use implicit, explicit, and fluent waits can greatly improve the robustness of your test suite. With the improvements in Selenium 4, you have even more powerful tools to manage synchronization issues.