Explicit waits (WebDriverWait) in Selenium Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Selenium explicit wait code?

Consider the following Selenium Python code snippet using explicit wait. What will be printed?

Selenium Python

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

class DummyElement:
    def __init__(self):
        self.text = "Loaded"

# Mock driver and wait for demonstration
class MockDriver:
    def find_element(self, by, value):
        return DummyElement()


driver = MockDriver()

try:
    element = WebDriverWait(driver, 5).until(
        EC.presence_of_element_located((By.ID, "my-element"))
    )
    print(element.text)
except Exception:
    print("Timeout")

A AttributeError

B Timeout

C Loaded

D NoSuchElementException

💡 Hint

Think about what the mock driver returns and how WebDriverWait uses it.

The mock driver returns a DummyElement with text 'Loaded'. The explicit wait condition presence_of_element_located returns this element immediately, so 'Loaded' is printed.

❓ assertion

intermediate

Which assertion correctly verifies element visibility after explicit wait?

You want to assert that an element with ID 'submit-btn' is visible after waiting explicitly. Which assertion is correct?

Selenium Python

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

wait = WebDriverWait(driver, 10)
element = wait.until(EC.visibility_of_element_located((By.ID, 'submit-btn')))

A assert element is None

B assert element.is_displayed() is False

C assert element.text == 'submit-btn'

D assert element.is_displayed() == True

💡 Hint

Visibility means the element is displayed on the page.

The explicit wait returns a visible element, so asserting is_displayed() == True confirms visibility.

❓ locator

advanced

Which locator is best for waiting for a button with text 'Submit' to be clickable?

You want to wait explicitly until a button with visible text 'Submit' is clickable. Which locator and condition combo is best?

A By.XPATH, "//button[text()='Submit']" with EC.element_to_be_clickable

B By.ID, "submit" with EC.presence_of_element_located

C By.CSS_SELECTOR, "button:contains('Submit')" with EC.element_to_be_clickable

D By.CLASS_NAME, "submit-btn" with EC.visibility_of_element_located

💡 Hint

Consider which locator matches exact button text and which condition ensures clickability.

Option A uses XPath to match button text exactly and waits for the button to be clickable, which is the best approach.

🔧 Debug

advanced

Why does this explicit wait code raise TimeoutException?

This code raises TimeoutException even though the element is present. Why?

Selenium Python

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

wait = WebDriverWait(driver, 5)
wait.until(EC.visibility_of_element_located((By.ID, 'loading-spinner')))

A The locator By.ID is invalid and causes the wait to fail

B The element is present but not visible, so visibility_of_element_located times out

C The wait timeout is too long causing an exception

D The driver is not initialized before the wait

💡 Hint

Presence and visibility are different conditions.

The element exists in the DOM but is hidden, so visibility_of_element_located never returns true before timeout.

❓ framework

expert

How to implement a custom explicit wait condition for element attribute value?

You want to wait until an element with ID 'status' has attribute 'data-state' equal to 'ready'. Which custom expected condition implementation is correct?

A

class attribute_value_is:
    def __init__(self, locator, attribute, value):
        self.locator = locator
        self.attribute = attribute
        self.value = value
    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        return element.get_attribute(self.attribute) == self.value

B

class attribute_value_is:
    def __init__(self, locator, attribute, value):
        self.locator = locator
        self.attribute = attribute
        self.value = value
    def __call__(self, driver):
        element = driver.find_element(locator)
        return element.get_attribute(attribute) == value

C

def attribute_value_is(locator, attribute, value):
    element = driver.find_element(*locator)
    return element.get_attribute(attribute) == value

D

def attribute_value_is(locator, attribute, value):
    element = driver.find_element(locator)
    return element.get_attribute(attribute) == value

💡 Hint

Custom expected conditions must be callable classes with __call__ and use *self.locator.

Option A correctly defines a callable class with __init__ and __call__, uses *self.locator to unpack, and returns the attribute check.