Understanding Explicit Wait in Selenium with Python

💡 Problem Formulation: Automated web testing with Selenium often involves scenarios where you need to wait for elements to become available or in a specific state before taking action. The “explicit wait” strategy in Selenium with the Python language binding enables a more efficient and reliable testing process by waiting for a certain condition to be met. For instance, you may want your script to wait explicitly for a ‘Submit’ button to become clickable after entering data in a form, ensuring the button exists and actions can be performed on it.

Method 1: Using WebDriverWait with expected_conditions

This method utilizes Selenium’s WebDriverWait in conjunction with expected_conditions to make the driver wait for a specific condition. The WebDriverWait object takes two main arguments: the WebDriver instance and a timeout in seconds. The expected_conditions provides a set of predefined conditions for common use cases such as the presence, visibility, or clickability of elements.

Here’s an example:

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

driver = webdriver.Chrome()
driver.get('https://example.com')

try:
  element = WebDriverWait(driver, 10).until(
      EC.presence_of_element_located((By.ID, "submit-button"))
  )
  element.click()
finally:
  driver.quit()

Output: The button with the id ‘submit-button’ is clicked if it becomes present within 10 seconds.

In this example, WebDriverWait instructs Selenium to poll the DOM for up to 10 seconds until the ‘submit-button’ element is located. The presence_of_element_located condition ensures that the element is present in the DOM, which is helpful for interacting with it in later code.

Method 2: Custom Expected Conditions

When predefined expected conditions do not suit your needs, you can define custom expected conditions. A custom expected condition can be any callable that takes a WebDriver instance as its argument and returns True if the condition is met, or False otherwise.

Here’s an example:

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

driver = webdriver.Chrome()
driver.get('https://example.com')

def element_has_css_class(driver):
  element = driver.find_element_by_id('my-element')
  return 'my-class' in element.get_attribute('class').split()

try:
  WebDriverWait(driver, 10).until(element_has_css_class)
  # Proceed with additional actions here
finally:
  driver.quit()

Output: The script waits for the element with ID ‘my-element’ to have the ‘my-class’ CSS class.

This code defines a custom condition element_has_css_class, which checks if an element with a specific ID also has a particular CSS class. The WebDriver will wait up to 10 seconds for this condition to become true before proceeding.

Method 3: Explicitly waiting for AJAX calls to complete

Sometimes you need to wait for AJAX calls to complete after triggering an action on the page. By combining JavaScript execution with explicit waits, you can make your tests wait until all AJAX requests have been completed.

Here’s an example:

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

driver = webdriver.Chrome()
driver.get('https://example.com')

try:
  driver.execute_script("return jQuery.active == 0")
  WebDriverWait(driver, 10).until(lambda driver: driver.execute_script("return jQuery.active == 0"))
  # Proceed with additional actions here
finally:
  driver.quit()

Output: The WebDriver waits until there are no active jQuery AJAX calls before proceeding.

This snippet uses JavaScript execution within the WebDriver to assess if there are any active jQuery AJAX calls. The WebDriverWait utility will keep polling the JavaScript condition for up to 10 seconds or until it returns True.

Method 4: Waiting for an Element to Be Clickable

Interacting with the web elements sometimes requires them to not only be present but also be in a clickable state. Using EC.element_to_be_clickable, you can wait until an element is both visible and enabled.

Here’s an example:

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

driver = webdriver.Chrome()
driver.get('https://example.com')

try:
  element = WebDriverWait(driver, 10).until(
      EC.element_to_be_clickable((By.ID, 'submit-button'))
  )
  element.click()
finally:
  driver.quit()

Output: The ‘submit-button’ element is clicked if it becomes clickable within 10 seconds.

This code snippet makes use of the element_to_be_clickable condition that waits until the specified element is both visible in the web page and enabled, i.e., not disabled, before performing a click action on it.

Bonus One-Liner Method 5: Inline Waiting with Timeouts and Conditions

This one-liner demonstrates how to use Python’s lambda functions to wait for a simple condition in a very compact form.

Here’s an example:

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

driver = webdriver.Chrome()
driver.get('https://example.com')

try:
  WebDriverWait(driver, 10).until(lambda d: d.find_element_by_id('my-element').is_displayed())
  # Proceed with additional actions here
finally:
  driver.quit()

Output: The script waits for the element with ID ‘my-element’ to be displayed.

This efficient one-liner uses a lambda function passed directly to WebDriverWait. It waits up to 10 seconds for the element with specified ID ‘my-element’ to be displayed on the page.

Summary/Discussion

• Method 1: WebDriverWait with expected_conditions. Highly reliable for predefined conditions. Can be verbose for complex conditions.
• Method 2: Custom Expected Conditions. Offers flexibility. More complex to implement than using predefined conditions.
• Method 3: Waiting for AJAX. Ensures that dynamic page content is fully loaded. May be tricky to implement if not using jQuery.
• Method 4: Waiting for an Element to Be Clickable. Guarantees the interaction with elements. Assumes the element will not be obstructed or disabled beyond the wait time.
• Method 5: Inline Waiting with Timeouts and Conditions. Concise and good for simple conditions. Not as readable for other team members or complex conditions.