FluentWait with polling in Selenium Java

Introduction

FluentWait helps you wait for something on a web page by checking regularly until it appears or a timeout happens. It lets you control how often to check.

When a web element takes time to appear and you want to check repeatedly until it shows up.

When you want to ignore certain errors while waiting, like element not found.

When you want to set a custom time interval between checks instead of default.

When you want to wait for a condition that is not just presence but something custom.

When you want to avoid waiting too long by setting a maximum timeout.

Syntax

Selenium Java

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(5))
    .ignoring(NoSuchElementException.class);

WebElement element = wait.until(driver -> driver.findElement(By.id("elementId")));

withTimeout sets the maximum wait time.

pollingEvery sets how often to check the condition.

Examples

Waits up to 20 seconds, checking every 2 seconds for an element with class 'my-class'.

Selenium Java

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

WebElement element = wait.until(driver -> driver.findElement(By.cssSelector(".my-class")));

Waits up to 10 seconds, checking every 0.5 seconds if the button with id 'btnSubmit' is visible.

Selenium Java

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

Boolean isVisible = wait.until(driver -> driver.findElement(By.id("btnSubmit")).isDisplayed());

Sample Program

This program opens a browser, goes to example.com, and waits up to 15 seconds checking every 3 seconds for an element with id 'dynamicElement'. If found, it prints the element's text. If not found in time, it prints a message.

Selenium Java

import org.openqa.selenium.By;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;

import java.time.Duration;
import java.util.function.Function;

public class FluentWaitExample {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        WebDriver driver = new ChromeDriver();

        try {
            driver.get("https://example.com");

            Wait<WebDriver> wait = new FluentWait<>(driver)
                    .withTimeout(Duration.ofSeconds(15))
                    .pollingEvery(Duration.ofSeconds(3))
                    .ignoring(NoSuchElementException.class);

            WebElement dynamicElement = wait.until(new Function<WebDriver, WebElement>() {
                public WebElement apply(WebDriver driver) {
                    return driver.findElement(By.id("dynamicElement"));
                }
            });

            System.out.println("Element found: " + dynamicElement.getText());
        } catch (Exception e) {
            System.out.println("Element not found within timeout.");
        } finally {
            driver.quit();
        }
    }
}

Important Notes

Always set a reasonable timeout to avoid long waits.

Polling interval should balance between responsiveness and resource use.

Ignoring exceptions helps avoid test failure during waiting.

Summary

FluentWait lets you wait for elements with custom timeout and polling.

You can ignore exceptions while waiting to keep tests stable.

Use FluentWait when elements load dynamically and timing is uncertain.

Practice

1. What is the main purpose of using FluentWait in Selenium Java?

easy

A. To throw an exception as soon as an element is not found

B. To wait for an element with a custom timeout and polling interval

C. To immediately find an element without waiting

D. To perform actions on elements without any wait

Solution

1. Step 1: Understand FluentWait functionality

   FluentWait allows waiting for a condition with a custom timeout and polling frequency.

2. Step 2: Compare options with FluentWait purpose

   Only To wait for an element with a custom timeout and polling interval describes waiting with custom timeout and polling, which matches FluentWait's use.

3. Final Answer:

   To wait for an element with a custom timeout and polling interval -> Option B

4. Quick Check:

   FluentWait = custom wait with polling [OK]

Hint: FluentWait customizes wait time and checks repeatedly [OK]

Common Mistakes:

• Confusing FluentWait with immediate findElement
• Thinking FluentWait throws exception immediately
• Assuming FluentWait skips polling

2. Which of the following is the correct way to create a FluentWait object with polling every 500 milliseconds?

easy

A. new FluentWait(driver).pollingEvery(Duration.ofMillis(500))

B. new FluentWait(driver).pollingEvery(500, TimeUnit.MILLISECONDS)

C. new FluentWait(driver).pollingEvery(500)

D. new FluentWait(driver).pollingEvery(Duration.ofSeconds(500))

Solution

1. Step 1: Check correct Duration usage for pollingEvery

   pollingEvery expects a Duration object, so Duration.ofMillis(500) is correct for 500 ms.

2. Step 2: Analyze other options for syntax errors

   new FluentWait(driver).pollingEvery(Duration.ofSeconds(500)) uses seconds instead of milliseconds; B uses deprecated TimeUnit syntax; C uses int without Duration.

3. Final Answer:

   new FluentWait(driver).pollingEvery(Duration.ofMillis(500)) -> Option A

4. Quick Check:

   pollingEvery needs Duration.ofMillis for milliseconds [OK]

Hint: Use Duration.ofMillis for polling intervals in FluentWait [OK]

Common Mistakes:

• Using Duration.ofSeconds instead of ofMillis for milliseconds
• Passing int directly without Duration
• Using deprecated TimeUnit with pollingEvery

3. What will happen when the following FluentWait code runs if the element appears after 3 seconds?

Wait<WebDriver> wait = new FluentWait<>(driver)
  .withTimeout(Duration.ofSeconds(5))
  .pollingEvery(Duration.ofSeconds(1))
  .ignoring(NoSuchElementException.class);

WebElement element = wait.until(d -> d.findElement(By.id("dynamicElement")));
System.out.println(element.getText());

medium

A. The code waits full 5 seconds then throws TimeoutException

B. The code throws NoSuchElementException immediately

C. The element is found and its text is printed after about 3 seconds

D. The code prints null because element is not found

Solution

1. Step 1: Understand FluentWait behavior with polling and timeout

   The wait polls every 1 second up to 5 seconds, ignoring NoSuchElementException until element appears.

2. Step 2: Analyze timing and result

   Since element appears after 3 seconds, wait finds it before timeout and prints its text.

3. Final Answer:

   The element is found and its text is printed after about 3 seconds -> Option C

4. Quick Check:

   FluentWait polls until element found or timeout [OK]

Hint: FluentWait polls repeatedly until element found or timeout [OK]

Common Mistakes:

• Expecting immediate exception on missing element
• Assuming wait always waits full timeout
• Thinking element text prints null if not found

4. Identify the error in this FluentWait code snippet:

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

WebElement element = wait.until(d -> d.findElement(By.id("test")));

medium

A. pollingEvery should use Duration, not int

B. withTimeout should be in milliseconds, not seconds

C. Ignoring NoSuchElementException is not allowed

D. FluentWait cannot be used with WebDriver

Solution

1. Step 1: Check pollingEvery parameter type

   pollingEvery expects a Duration object, but 500 (int) is passed, causing a compile error.

2. Step 2: Verify other method usages

   withTimeout(Duration.ofSeconds(10)) is correct; ignoring NoSuchElementException is valid; FluentWait works with WebDriver.

3. Final Answer:

   pollingEvery should use Duration, not int -> Option A

4. Quick Check:

   pollingEvery requires Duration parameter [OK]

Hint: pollingEvery needs Duration, not plain int [OK]

Common Mistakes:

• Passing int directly to pollingEvery
• Confusing withTimeout units
• Thinking ignoring exceptions is invalid

5. You want to wait up to 10 seconds for an element with id "submitBtn" to appear, checking every 2 seconds, and ignoring both NoSuchElementException and ElementNotVisibleException. Which FluentWait code snippet correctly implements this?

hard

A. new FluentWait<>(driver)
.withTimeout(Duration.ofSeconds(10))
.pollingEvery(Duration.ofSeconds(2))
.ignoring(NoSuchElementException.class)
.until(d -> d.findElement(By.id("submitBtn")));

B. new FluentWait<>(driver)
.withTimeout(Duration.ofSeconds(10))
.pollingEvery(Duration.ofSeconds(2))
.ignoring(NoSuchElementException.class ElementNotVisibleException.class)
.until(d -> d.findElement(By.id("submitBtn")));

C. new FluentWait<>(driver)
.withTimeout(10)
.pollingEvery(2)
.ignoring(NoSuchElementException.class)
.ignoring(ElementNotVisibleException.class)
.until(d -> d.findElement(By.id("submitBtn")));

D. new FluentWait<>(driver)
.withTimeout(Duration.ofSeconds(10))
.pollingEvery(Duration.ofSeconds(2))
.ignoring(NoSuchElementException.class)
.ignoring(ElementNotVisibleException.class)
.until(d -> d.findElement(By.id("submitBtn")));

Solution

1. Step 1: Check timeout and polling interval syntax

   withTimeout and pollingEvery correctly use Duration.ofSeconds(10) and Duration.ofSeconds(2) in new FluentWait<>(driver) .withTimeout(Duration.ofSeconds(10)) .pollingEvery(Duration.ofSeconds(2)) .ignoring(NoSuchElementException.class) .ignoring(ElementNotVisibleException.class) .until(d -> d.findElement(By.id("submitBtn")));.

2. Step 2: Verify ignoring multiple exceptions

   new FluentWait<>(driver) .withTimeout(Duration.ofSeconds(10)) .pollingEvery(Duration.ofSeconds(2)) .ignoring(NoSuchElementException.class) .ignoring(ElementNotVisibleException.class) .until(d -> d.findElement(By.id("submitBtn"))); chains .ignoring() calls for each exception, which is valid. new FluentWait<>(driver) .withTimeout(Duration.ofSeconds(10)) .pollingEvery(Duration.ofSeconds(2)) .ignoring(NoSuchElementException.class, ElementNotVisibleException.class) .until(d -> d.findElement(By.id("submitBtn"))); tries to pass two exceptions in one call, which is invalid.

3. Step 3: Confirm other options

   new FluentWait<>(driver) .withTimeout(10) .pollingEvery(2) .ignoring(NoSuchElementException.class) .ignoring(ElementNotVisibleException.class) .until(d -> d.findElement(By.id("submitBtn"))); uses int instead of Duration, causing errors. new FluentWait<>(driver) .withTimeout(Duration.ofSeconds(10)) .pollingEvery(Duration.ofSeconds(2)) .ignoring(NoSuchElementException.class) .until(d -> d.findElement(By.id("submitBtn"))); ignores only one exception, missing ElementNotVisibleException.

4. Final Answer:

   new FluentWait<>(driver) .withTimeout(Duration.ofSeconds(10)) .pollingEvery(Duration.ofSeconds(2)) .ignoring(NoSuchElementException.class) .ignoring(ElementNotVisibleException.class) .until(d -> d.findElement(By.id("submitBtn"))); -> Option D

5. Quick Check:

   Chain ignoring() for multiple exceptions with Duration times [OK]

Hint: Chain ignoring() for each exception; use Duration for times [OK]

Common Mistakes:

• Passing multiple exceptions in one ignoring() call
• Using int instead of Duration for time values
• Ignoring only one exception when multiple needed