How To Use 'expected Conditions' To Check For An Element In Python-selenium?

March 19, 2024 Post a Comment

I have trouble understanding how to use an 'expected conditions' to check for the presence of an element. Given this documentation it is not clear at all how to use this. I have tr

Solution 1:

To summarize in a more organized manner:

Expected Condition is a callable (could be a function or a class with __call__() magic method defined)
Expected Condition is supposed to be used inside the until() method of a WebDriverWait() instance:
```
wait = WebDriverWait(driver, 10)
wait.until(<Expected_condition_here>)
```
the result of an Expected Condition does not have to be just True/False. The result would be tested on truthiness by the WebDriverWait. Note: a WebElement instance is "truthy". Read more about truthiness in Python here
it is quite convenient that when an Expected Condition returns a WebElement instance. It allows to have a link to an element right away without the need to find it again:
```
button = wait.until(EC.element_to_be_clickable((By.ID, "my_id")))
button.click()
```
you can write your own custom Expected Conditions

Solution 2:

Seems you were almost there.

The Documentation clearly says the following:

classselenium.webdriver.support.expected_conditions.visibility_of_element_located(locator)

Which is defined as :

An expectation for checking that an element is present on the DOM of a page and visible. Visibility means that the element is not only displayed but also has a height and width that is greater than 0. locator - used to find the element returns the WebElement once it is located and visible

Hence, when you mention:

return EC.visibility_of_element_located((By.XPATH, '//*[@id="kernel_indicator_icon" and @title="Kernel Idle"]'))

The found out WebElement is being returned as follows :

<selenium.webdriver.support.expected_conditions.visibility_of_element_located object at 0x110321b90>

Even the Source Code says the same as :

try:
    return _element_if_visible(_find_element(driver, self.locator))

When the search is unsuccessfull :

except StaleElementReferenceException:
    returnFalse

Solution 3:

The way expected conditions work is by defining a WebDriverWait. You create this with an instance of your WebDriver and a timeout. The WebDriverWait has an until() method which will take an expected condition and will wait until it has been met or until the timeout has passed. So instead of just EC.visibility_of_element_located((By.XPATH, '//*[@id="kernel_indicator_icon" and @title="Kernel Idle"]')) you should use:

WebDriverWait(yourdriver, timeout).until(EC.visibility_of_element_located((By.XPATH, '//*[@id="kernel_indicator_icon" and @title="Kernel Idle"]')))

Edit I should note that this doesn't return True or False. This will return the WebElement if it has been found and is visible. Otherwise it will raise a TimeOutException. Source

Solution 4:

You're almost success! What you want could be:

def_kernel_is_idle(self):
    return EC.visibility_of_element_located(
        (By.XPATH, '//*[@id="kernel_indicator_icon" and @title="Kernel Idle"]')
    )(driver)

Here, you should pass the webdriver object as an argument.

Solution 5:

First you need to import expected_conditions module from selenium.webdriver.support. With this module you can check several conditions of the element with giving expected time as well

from selenium import webdriver
from selenium.webdriver.common.by import Byfrom selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("http://domain/element")
try:
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "idxxx"))
    )
finally:
    driver.quit()

Python Playground