Waits/Synchronization using Selenium with Java

Introduction:

    One of the biggest challenges in Selenium automation is dealing with dynamic web elements. If elements take time to load, interaction with them too soon can result in errors like NoSuchElementException.

    To handle this, Selenium provides different types of waits: Implicit Wait, Explicit Wait, and Fluent Wait. These waits help synchronize test execution with the web page's behaviour, making tests more stable and reliable.

Understanding Selenium Waits with a Real-Life Analogy

Imagine you're at a traffic signal:

🚦Implict Wait - You decide to wait for a fixed time before crossing, regardless of whether the signal changes.

🚦Explicit Wait - You wait until the light turns green before crossing.

🚦Fluent Wait - You keep checking the light every few seconds, and as soon as it turns green, you cross.

Just like in real life, choosing the right waiting strategy in Selenium depends on the situation!

---

---

1. Implicit Wait

    Implicit Wait sets a default waiting time for all elements before throwing an exception. It applies globally to every element in the scripts.

✅ When to Use:

• When elements load in a predictable time frame.
• When you want a simple, global wait mechanism.

🚨Limitations:

• Can cause unnecessary delays if elements appear earlier.
• Doesn't handle dynamic elements effectively.

Implementation in Selenium

Before Selenium 4:

Syntax:

driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);

Example:

driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

After Selenium 4:

Syntax/Example:

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

---

---

2. Explicit Wait

    Explicit Wait waits for a specific condition to be met before proceeding with execution. Unlike implicit Wait, it applies only to a particular element.

✅ When to Use:

• When elements load dynamically at different times.
• When waiting for a specific condition (e.g., visibility clickability, presence).

🚨 Limitations:

• Requires additional code to define wait conditions.

Common Wait Conditions in Explicit Wait

Selenium provides various built-in wait conditions via ExpectedConditions Class:

Condition	Description	Example
visibilityOfElementLocated	Waits until the element is visible	wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));
elementToBeClickable	Waits until the element is clickable	wait.until(ExpectedConditions.elementToBeClickable(By.id("submit")));
presenceOfElementLocated	Waits until the element is present in the DOM	wait.until(ExpectedConditions.presenceOfElementLocated(By.id("login")));
textToBePresentInElement	Waits until a specific text appears in an element	wait.until(ExpectedConditions.textToBePresentInElement(By.id("status"), "Success"));
alertIsPresent	Waits for an alert to appear	wait.until(ExpectedConditions.alertIsPresent());

Implementation in Selenium

Before Selenium 4:

Syntax:

WebDriverWait wait = new WebDriverWait(driver, 10);

wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[@id="123"]")));

After Selenium 4:

Syntax:

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[@id="123"]")));

Example:

wait.until(ExpectedConditons.elementToBeClickable(By.id("submitButton")));

---

---

 3. Fluent Wait

Fluent Wait gives more control over waiting. It allows setting:

✔ A maximum timeout (how long to wait)

✔ A polling frequency (how often Selenium checks for the element)

✔ Exception handling (ignoring specific exceptions)

✅ When to Use:

• When elements load at unpredictable intervals.
• When elements appear after AJAX calls or animations.

🚨 Limitations:

• Requires more setup compared to other waits.

Key Features of Fluent Wait

• Timeout: Defines the maximum wait time before throwing an exception.
• Polling Frequency: Sets how often Selenium checks for the element.
• Ignoring Exceptions: Allows ignoring specific exceptions (e.g., NoSuchElementException) while waiting.

Implementation in Selenium

Before Selenium 4:

Syntax:

Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)

                    .withTimeout(40, TimeUnit.SECONDS)

                    .pollingEvery(5, TimeUnit.SECONDS)

                    .ignoring(NoSuchElementException.class);

After Selenium 4:

Syntax:

Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)

                    .withTimeout(Duration.ofSeconds(40))

                    .pollingEvery(Duration.ofSeconds(5))

                    .ignoring(NoSuchElementException.class);

Example:

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

---

---

Comparison Table: Implicit vs. Explicit vs. Fluent Wait

Wait Type	Scope	Best Use Case	Polling?	Exception Handling?	Custom Conditions?
Implicit Wait	Global	Static waits for all elements	No	No	No
Explicit Wait	Specific element	When waiting for specific conditions	No	No	Yes
Fluent Wait	Specific element	Handling dynamic/unpredictable elements	Yes	Yes	Yes

---

Best Practices for Using Selenium Waits

✔ Use Explicit wait instead of Implicit Wait when dealing with dynamic elements.

✔ Avoid mixing Implict and Explicit Waits -- It can lead to unpredictable behavior.

✔ use Fluent Wait when element appear at varying intervals.

✔ Keep wait times as short as possible to avoid increasing test execution time.

---

Conclusion

    Understanding how to use waits effectively in Selenium can significantly improve test stability and reliability. Try experimenting with different wait type in your test automation projects to see how they impact execution time.

- Next Page: Take Screen Shot