Custom expected conditions in Selenium Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this custom expected condition?

Consider the following Selenium custom expected condition class. What will be the output of the test assertion if the element with id 'status' has text 'Ready'?

Selenium Python

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

class element_text_is_ready:
    def __init__(self, locator):
        self.locator = locator

    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        return element.text == 'Ready'

# Usage example:
# wait = WebDriverWait(driver, 10)
# result = wait.until(element_text_is_ready((By.ID, 'status')))
# print(result)

A TimeoutException

B False

C True

D AttributeError

💡 Hint

Think about what the __call__ method returns when the element text matches 'Ready'.

The custom expected condition returns True when the element's text is exactly 'Ready'. The WebDriverWait.until method returns this True value, so the assertion prints True.

❓ assertion

intermediate

Which assertion correctly verifies a custom expected condition?

You have a custom expected condition that returns the element if visible, else False. Which assertion correctly checks that the element is found and visible?

Selenium Python

class element_is_visible:
    def __init__(self, locator):
        self.locator = locator

    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        return element if element.is_displayed() else False

# wait = WebDriverWait(driver, 10)
# result = wait.until(element_is_visible((By.CSS_SELECTOR, '.btn')))

A assert result == False

B assert result is not False

C assert result is None

D assert result == True

💡 Hint

Remember the custom condition returns the element or False, not a boolean True.

The custom condition returns the element object if visible, otherwise False. So the assertion must check that result is not False to confirm visibility.

🔧 Debug

advanced

Why does this custom expected condition cause a TimeoutException?

This custom expected condition is intended to wait until an element's attribute 'data-status' equals 'complete'. Why does it always cause a TimeoutException?

Selenium Python

class attribute_value_is_complete:
    def __init__(self, locator):
        self.locator = locator

    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        return element.get_attribute('data-status') == 'complete'

# wait = WebDriverWait(driver, 5)
# wait.until(attribute_value_is_complete((By.ID, 'task')))

A Attribute 'data-status' does not exist on element

B Timeout is too short to wait for condition

C The __call__ method returns None instead of boolean

D Incorrect unpacking of locator tuple in find_element

💡 Hint

Check how the locator tuple is used in find_element.

The find_element method requires unpacking the locator tuple with *self.locator. Without unpacking, it treats the tuple as a single argument, causing NoSuchElementException and timeout.

❓ framework

advanced

Which custom expected condition class correctly waits for an element's CSS class to include 'active'?

Select the class that correctly implements a custom expected condition to wait until the element's class attribute contains the word 'active'.

A

class element_has_active_class:
    def __init__(self, locator):
        self.locator = locator
    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        return 'active' in element.get_attribute('class')

B

class element_has_active_class:
    def __init__(self, locator):
        self.locator = locator
    def __call__(self, driver):
        element = driver.find_element(self.locator)
        return element.get_attribute('class') == 'active'

C

class element_has_active_class:
    def __init__(self, locator):
        self.locator = locator
    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        return element.get_attribute('class').contains('active')

D

class element_has_active_class:
    def __init__(self, locator):
        self.locator = locator
    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        return element.get_attribute('class') == ['active']

💡 Hint

Check correct locator unpacking and string containment syntax in Python.

Option A correctly unpacks the locator tuple and uses Python's 'in' operator to check if 'active' is in the class attribute string. Other options have syntax errors or incorrect comparisons.

🧠 Conceptual

expert

What is the main advantage of using custom expected conditions in Selenium tests?

Why should testers create custom expected conditions instead of only using built-in ones?

A They allow waiting for complex or specific conditions not covered by built-in ones

B They reduce test execution time by skipping waits

C They automatically fix flaky tests without code changes

D They replace the need for assertions in tests

💡 Hint

Think about flexibility and test reliability.

Custom expected conditions let testers wait for very specific states or behaviors in the application that built-in conditions do not cover, improving test accuracy and reliability.