Differences between impilicit, explicit and fluent

Question

What are the exact differences between implicitwait(), explicitwait() and fluentwait()? Could you explain with examples?

Answer 1

ImplicitWait

ImplicitWait is an implementation to configure the WebDriver instance i.e. the driver to poll the HTML DOM for a certain amount of time (interms of NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS or DAYS) when trying to find an element or elements if they are not immediately available. The default setting is 0 which means the driver when finds an instruction to find an element or elements, the search starts and results are available on immediate basis.

In this case, after a fresh loading of a Webpage an element or elements may be / may not be found on an immediate search. So your Automation Script may be facing any of these exceptions:

• NoSuchElementException
• TimeoutException
• ElementNotVisibleException
• ElementNotSelectableException

Hence we introduce ImplicitWait. By introducing ImplicitWait the driver will poll the HTML DOM for the configured amount of time looking out for the element or elements. By that time the element or elements for which you had been looking for may be available in the HTML DOM. As in your code you have already set ImplicitWait to a value of 10 seconds, the driver will poll the HTML DOM for 10 seconds.

• Python:

  driver.implicitly_wait(10)
  

• Java:

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

Finally, once you set the ImplicitWait, the WebDriver instance i.e. the driver is able to carry this configuration till its lifetime. But if you need to change the coarse of time for the WebDriver instance i.e. the driver to wait then you can reconfigure it as follows:

• Python:

  driver.implicitly_wait(5)
  

• Java:

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

If at any point of time you want to nullify the ImplicitWait you can reconfigure it as follows:

• Python:

  driver.implicitly_wait(0)
  

• Java:

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

---

Fluent Wait

Fluent Wait is the implementation of the Wait interface through which we can configure the timeout and polling interval on the fly. An instance of FluentWait can be defined to configure the maximum amount of time to wait for a condition as well as the frequency at which the condition must be checked. User can also configure the wait to ignore specific types of exceptions while waiting for an element, such as NoSuchElementExceptions on the page.

• Usage

     // Waiting 30 seconds for an element to be present on the page, checking
     // for its presence once every 5 seconds.
     Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)
         .withTimeout(30, SECONDS)
         .pollingEvery(5, SECONDS)
         .ignoring(NoSuchElementException.class);
  
     WebElement foo = wait.until(new Function<WebDriver, WebElement>() {
       public WebElement apply(WebDriver driver) {
         return driver.findElement(By.id("foo"));
       }
     });
  

---

ExplicitWait

ExplicitWait commonly known as WebDriverWait is a specialized implementation of FluentWait through which user can define, configure and implement for the WebDriver instance to wait for a certain condition to be met before proceeding for the next line of code. There are some methods that helps us to implement ExplicitWait that will wait only as long as required. WebDriverWait in combination with ExpectedCondition is one of the way ExplicitWait can be achieved.

An Example:

import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
.
.
.
WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("element_xpath")));
element.click();

Explanation:

This implementation of ExplicitWait waits up to 10 seconds before throwing a TimeoutException or if it finds the element then it will return within 0 to 10 seconds. WebDriverWait by default calls the ExpectedCondition every 500 milliseconds until it returns successfully. A successful return value for the ExpectedCondition function type is a Boolean value of true or a not-null object.

Expected Conditions:

There are some frequently encountered conditions when automating Web Browsers for Testing Web/Mobile Applications. The Java, C# and Python bindings include those convenient methods so we don’t have to write-up an ExpectedCondition class ourselves or create our own utility package for them. Some of the Expected Conditions are:

• alertIsPresent()
• elementToBeClickable(locator)
• elementToBeSelected(WebElement)
• frameToBeAvailableAndSwitchToIt(locator)
• invisibilityOf(element)

You can find about the all the methods supported by Expected Conditions here.

Answer 2

I don't see much difference here between ExplicitWait (WebDriverWait) and FluentWait. Because WebDriverWait is subclass of FluentWait so everything what FluentWait can do is possible by WebDriverWait as well.

WebDriverWait also can set polling time, max wait time and ignoring any exception.

Answer 3

An explicit waits is code you define to wait for a certain condition to occur before proceeding further in the code. The worst case of this is Thread.sleep(), which sets the condition to an exact time period to wait. There are some convenience methods provided that help you write code that will wait only as long as required. WebDriverWait in combination with ExpectedCondition is one way this can be accomplished.Example is as follows:

WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("someid")));

However, depending on the language implementation varies a little bit. See here more about ExpectedCondition interface

An implicit wait is to tell WebDriver to poll the DOM for a certain amount of time when trying to find an element or elements if they are not immediately available. The default setting is 0. Once set, the implicit wait is set for the life of the WebDriver object instance. Below is an implementation of implicit wait:

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

Both of these definitions are from seleniumhq and most perfect definitions out there.

Fluent Wait Just another mechanism to wait for element. It provides some distinct mechanisms for polling the DOM to find the element. One of the greatest features it provides is to wait for the element ignoring certain exceptions. See this

Answer 4

Implicit wait: Implicit wait tells web driver to wait on every instance when try to find element. It is like global wait for all driver.findelement instance. It will force web driver to wait until element is appeared on page or defined time whatever is earliest. Drawback is it throws exception when element is not loaded on page even in defined time span.

Explicit wait: Explicit wait is of two types:

1. WebDriverWait
2. FluentWait

both are classes and implements Wait interface.

WebDriverWait is applied on certain element with defined expected condition and time. This wait is only applied to the specified element. This wait can also throw exception when element is not found.

WebDriverWait wait = new WebDriverWait (driver, 20);
wait.until(ExpectedConditions.VisibilityofElementLocated(By.xpath(""//button[@value='Save Changes']"")));

Fluent wait: Fluent wait is another type of Explicit wait and you can define polling and ignore the exception to continue with script execution in case element is not found.

new FluentWait<WebDriver>(driver).withTimeout(30, TimeUnit.SECONDS).pollingevery(10, TimeUnit.SECONDS).ignoring(NoSuchElementException.class);

Answer 5

Implicit Waits:

An implicit wait is to tell WebDriver to poll the DOM for a certain amount of time when trying to find an element if they are not immediately available.WebDriver will wait for mentioned time and it will not try to find the element again during the specified time period. Once the specified time is over, it will try to search the element once again the last time before throwing exception.The major disadvantage is time is lot as driver waits for the specified time before proceeding

Explicit wait

There can be a situation when a particular element takes more than a minute to load in this situation you can you can simply put a separate time on the required element only. By following this your browser implicit wait time would be short for every element and it would be large for specific element.The default polling period is 500 milliseconds ie)it will check for the element for every 500 milliseconds interval.

Fluent wait If you have an element which sometime appears in just 1 second and some time it takes minutes to appear. In that case it is better to use fluent wait, as this will try to find element again and again until it find it or until the final timer runs out.you can set the polling time in fluent wait The user can also configure the wait to ignore specific types of exceptions such as NosuchElementException

 // Waiting 30 seconds for an element to be present on the page, checking
   // for its presence once every 5 seconds.
   Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)
       .withTimeout(30, SECONDS)
       .pollingEvery(5, SECONDS)
       .ignoring(NoSuchElementException.class);

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

Answer 6

I posted a blog article about this, and I think I provide a few very details that these other answers missed.

Implicit Wait: During an Implicit wait, if the Web Driver cannot find it immediately because of its availability, the WebDriver will periodically poll the DOM (at an interval of 0.5 seconds or depending on the driver-browser implementation) until the default implicit max wait time is reached. Once the specified implicit wait max time is over, it will try to search the element once again the last time before throwing a WebDriverException such as NoSuchElementException. With the default setting of 0, meaning that a call to driver.findElement will not need to poll the DOM and it will immediately return in 0–999 milliseconds if the element actually does exist or it will throw a NoSuchElementException if it doesn’t exist in the same time period. To override the default max time, do it like this:

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

Explicit Wait: There can be instances when a particular element takes more than a second to load, or longer. In that case you definitely do not want to set a huge implicit wait time, because if you do, then your browser is going to wait up to the same max time for every driver call to find an element. Because of this you would likely notice a minor decline in test performance.

To avoid that situation you can simply define a separate wait time on the required element only. By following this rule, your browser implicit wait time would be short for every driver call to find an element and it could be large for one specific element on a case by case basis.

An explicit wait always first defines a FluentWait, such as a WebDriverWait object and then usually uses an expected condition to resolve the wait.

WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id(“aId”)));

Fluent Wait: Let’s say you have an element which sometime appears in just 1 second and some times it takes minutes to appear. In that case it is better to define a explicit wait using FluentWait, as this will try to find element again and again until it find it or until the final timer runs out. A WebDriverWait is a type of FluentWait since WebDriverWait extends FluentWait and has all the capabilities of the FluentWait class, such as being able to adjust the DOM polling interval, ignore exceptions.

FluentWait<WebDriver> wait = new FluentWait<WebDriver>(driver)
            .withTimeout(timeoutSeconds, TimeUnit.SECONDS)
            .pollingEvery(500, TimeUnit.MILLISECONDS)
            .ignoring(NoSuchElementException.class);