Selenium Wait Mechanisms

In Selenium, the wait mechanism is key to ensuring that page elements are loaded before performing operations.

Since webpage loading speed is affected by factors such as network and server performance, directly operating on elements that have not finished loading can cause script failures.

Selenium provides multiple wait mechanisms to solve this problem.

1. Implicit Wait (implicitly_wait)

1.1 What is Implicit Wait?

Implicit wait is a global wait mechanism that waits a certain amount of time when looking up elements. If the element is found within the specified time, Selenium will immediately continue with subsequent operations; if the element is still not found after the timeout, it will throwNoSuchElementExceptionan exception.

1.2 How to Use Implicit Wait?

Implicit wait is set through theimplicitly_wait()method. This method only needs to be called once, and all subsequent element lookup operations will follow this wait time.

Example

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService

# Set the correct driver path
service = ChromeService(executable_path="./chromedriver-mac-arm64/chromedriver")
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(service=service, options=options)

# Set implicit wait time to 10 seconds
driver.implicitly_wait(10)

# Open the webpage
driver.get("https://example.com")

# Find element
element = driver.find_element_by_id("element_id")

# Close the browser
driver.quit()

1.3 Pros and Cons of Implicit Wait

Advantages:

  • Simple and easy to use; set it once and it applies to all element lookup operations.
  • Suitable for most simple scenarios.

Disadvantages:

  • Global waiting may lead to unnecessary wait times.
  • Cannot handle certain complex wait conditions, such as waiting for an element to become clickable.

2. Explicit Wait (WebDriverWait and expected_conditions)

2.1 What is Explicit Wait?

Explicit wait is a more flexible wait mechanism that allows you to set wait conditions for specific operations. Explicit wait is usually used together with theWebDriverWaitclass andexpected_conditionsmodule.

2.2 How to Use Explicit Wait?

The basic usage of explicit wait is as follows:

Example

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Set the correct driver path
service = ChromeService(executable_path="./chromedriver-mac-arm64/chromedriver")
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(service=service, options=options)

# Open the webpage
driver.get("https://example.com")

# Set explicit wait, wait up to 10 seconds until the element appears
element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "element_id"))
)

# Close the browser
driver.quit()

2.3 Common expected_conditions

expected_conditionsThe module provides a variety of predefined wait conditions. Here are some commonly used ones:

  • presence_of_element_located: Wait for the element to appear in the DOM.
  • visibility_of_element_located: Wait for the element to appear in the DOM and be visible.
  • element_to_be_clickable: Wait for the element to be clickable.
  • text_to_be_present_in_element: Wait for the element's text to contain the specified text.

2.4 Pros and Cons of Explicit Wait

Advantages:

  • Highly flexible; you can set different wait conditions for different operations.
  • Can handle complex wait scenarios.

Disadvantages:

  • The code is relatively complex and requires more code.
  • Wait conditions need to be set separately for each operation.

3. Fixed Wait (time.sleep)

3.1 What is Fixed Wait?

Fixed wait is the simplest wait mechanism. It pauses script execution for a specified time via thetime.sleep()method. Regardless of whether the page has finished loading, the script waits for the specified time before continuing.

3.2 How to Use Fixed Wait?

Example

import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService

# Set the correct driver path
service = ChromeService(executable_path="./chromedriver-mac-arm64/chromedriver")
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(service=service, options=options)

# Open the webpage
driver.get("https://example.com")

# Fixed wait for 5 seconds
time.sleep(5)

# Find element
element = driver.find_element_by_id("element_id")

# Close the browser
driver.quit()

3.3 Pros and Cons of Fixed Wait

Advantages:

  • Simple and easy to use; suitable for simple test scenarios.

Disadvantages:

  • Inefficient and may lead to unnecessary wait times.
  • Cannot dynamically adjust the wait time based on page loading conditions.

4. Fluent Wait

Purpose:Dynamically set wait conditions, customize polling frequency, and ignore specific exceptions.

Method:WebDriverWait combined with polling_every and ignoring

Features:More flexible, suitable for scenarios that require dynamically adjusting wait times.

Example

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException

# Set the correct driver path
service = ChromeService(executable_path="./chromedriver-mac-arm64/chromedriver")
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(service=service, options=options)

driver.get("https://www.example.com")

# Set Fluent Wait
wait = WebDriverWait(driver, timeout=10, poll_frequency=1, ignored_exceptions=[NoSuchElementException])
element = wait.until(EC.presence_of_element_located((By.ID, "username")))

5. Summary

  • Implicit wait: Suitable for simple scenarios, global wait, but may lead to unnecessary wait times.
  • Explicit wait: Suitable for complex scenarios, highly flexible, but the code is relatively complex.
  • Fixed wait: Simple and easy to use, but inefficient; not recommended for complex test scenarios.
  • Fluent Wait：: Suitable for scenarios that require dynamically adjusting wait times.

In actual automated testing, it is recommended to choose an appropriate wait mechanism based on specific test requirements. Generally, explicit wait is the most recommended approach because it offers better flexibility and efficiency.

6. Comprehensive Example

The following is a complete example demonstrating how to use implicit wait and explicit wait:

Example

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Set the correct driver path
service = ChromeService(executable_path="./chromedriver-mac-arm64/chromedriver")
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(service=service, options=options)

# Set implicit wait
driver.implicitly_wait(5)

# Open the webpage
driver.get("https://www.example.com")

# Use explicit wait for element visibility
username = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.ID, "username"))
)
username.send_keys("testuser")

# Use explicit wait for element clickable
submit_button = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "submit-btn"))
)
submit_button.click()

# Close the browser
driver.quit()
Other Extensions