Expected conditions in Selenium Python - Build an Automation Script

Wait for login button to be clickable and verify navigation

Preconditions (1)

Step 1: Wait until the login button with id 'login-btn' is clickable

Step 2: Click the login button

Step 3: Wait until the URL changes to 'https://example.com/dashboard'

Step 4: Verify that the dashboard page is displayed by checking the URL

✅ Expected Result: The login button is clicked only after it becomes clickable, and the user is navigated to the dashboard page with URL 'https://example.com/dashboard'

Automation Requirements - Selenium with Python

Assertions Needed:

Assert that the login button is clickable before clicking

Assert that the current URL is 'https://example.com/dashboard' after clicking

Best Practices:

Use WebDriverWait with expected_conditions for waiting

Avoid using time.sleep() for waiting

Use By.ID locator for the login button

Use explicit waits to handle dynamic page elements

Automated Solution

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

# Initialize the Chrome driver
with webdriver.Chrome() as driver:
    driver.get('https://example.com/login')

    wait = WebDriverWait(driver, 10)  # wait up to 10 seconds

    # Wait until the login button is clickable
    login_button = wait.until(EC.element_to_be_clickable((By.ID, 'login-btn')))

    # Click the login button
    login_button.click()

    # Wait until the URL changes to dashboard
    wait.until(EC.url_to_be('https://example.com/dashboard'))

    # Assert the URL is correct
    assert driver.current_url == 'https://example.com/dashboard', f"Expected URL to be 'https://example.com/dashboard' but got {driver.current_url}"

This script uses Selenium WebDriver with Python to automate the manual test case.

First, it opens the login page URL.

Then, it uses WebDriverWait with the expected condition element_to_be_clickable to wait until the login button is ready to be clicked. This avoids errors from clicking too early.

After the button is clickable, it clicks the button.

Next, it waits until the URL changes to the dashboard page using url_to_be expected condition.

Finally, it asserts that the current URL matches the expected dashboard URL to confirm navigation succeeded.

This approach uses explicit waits instead of fixed delays, making the test more reliable and faster.

Common Mistakes - 3 Pitfalls

Using time.sleep() instead of explicit waits

Clicking the login button without waiting for it to be clickable

Using incorrect locator strategies like XPath with absolute paths

Bonus Challenge

Now add data-driven testing with 3 different login button IDs to verify the expected conditions work for each.

Show Hint

Practice

1. What is the main purpose of using ExpectedConditions in Selenium WebDriver?

easy

A. To wait for certain conditions before interacting with elements

B. To speed up the test execution by skipping waits

C. To generate random test data automatically

D. To take screenshots during test execution

Solution

1. Step 1: Understand ExpectedConditions role

   ExpectedConditions help Selenium wait for specific states like element visibility or clickability before proceeding.

2. Step 2: Identify the main purpose

   This waiting avoids errors caused by trying to interact with elements not yet ready on the page.

3. Final Answer:

   To wait for certain conditions before interacting with elements -> Option A

4. Quick Check:

   ExpectedConditions = Wait for conditions [OK]

Hint: ExpectedConditions = smart waits before actions [OK]

Common Mistakes:

• Thinking ExpectedConditions speed up tests by skipping waits
• Confusing ExpectedConditions with data generation
• Assuming ExpectedConditions take screenshots

2. Which of the following is the correct syntax to wait until an element located by ID 'submit' is clickable using Selenium's ExpectedConditions in Python?

easy

A. WebDriverWait(driver, 10).until(EC.visibility_of_element_located('submit'))

B. WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, 'submit')))

C. WebDriverWait(driver, 10).until(EC.element_to_be_clickable('submit'))

D. WebDriverWait(driver, 10).until(EC.presence_of_element_located(By.ID, 'submit'))

Solution

1. Step 1: Check correct ExpectedCondition usage

   element_to_be_clickable requires a locator tuple like (By.ID, 'submit').

2. Step 2: Verify syntax correctness

   WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, 'submit'))) correctly uses a tuple inside the condition and waits properly.

3. Final Answer:

   WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, 'submit'))) -> Option B

4. Quick Check:

   Use tuple locator with element_to_be_clickable [OK]

Hint: Use (By.ID, 'id') tuple inside ExpectedConditions [OK]

Common Mistakes:

• Passing string instead of locator tuple
• Using visibility_of_element_located instead of clickable
• Missing parentheses around locator tuple

3. What will be the output of the following code snippet if the element with ID 'login' becomes visible after 5 seconds?

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, 'login')))
print(element.is_displayed())

medium

A. TimeoutException

B. False

C. True

D. NoSuchElementException

Solution

1. Step 1: Analyze wait duration and element visibility

   The wait is 10 seconds, and the element appears after 5 seconds, so wait.until succeeds.

2. Step 2: Understand is_displayed() output

   Since the element is visible, element.is_displayed() returns True, which is printed.

3. Final Answer:

   True -> Option C

4. Quick Check:

   Element visible within wait = True output [OK]

Hint: If element appears before timeout, is_displayed() is True [OK]

Common Mistakes:

• Expecting TimeoutException though element appears in time
• Confusing is_displayed() with presence only
• Assuming False if element appears late but within wait

4. Identify the error in the following code that waits for an element with class name 'btn' to be clickable:

wait = WebDriverWait(driver, 5)
wait.until(EC.element_to_be_clickable(By.CLASS_NAME, 'btn'))

medium

A. Timeout value too low

B. Incorrect import of WebDriverWait

C. Using CLASS_NAME instead of CSS_SELECTOR

D. Missing tuple around locator in element_to_be_clickable

Solution

1. Step 1: Check element_to_be_clickable parameter

   It requires a single locator tuple like (By.CLASS_NAME, 'btn'), not two separate arguments.

2. Step 2: Identify syntax error

   Code passes two arguments instead of one tuple, causing a TypeError.

3. Final Answer:

   Missing tuple around locator in element_to_be_clickable -> Option D

4. Quick Check:

   Locator must be a tuple inside ExpectedConditions [OK]

Hint: Always wrap locator in a tuple for ExpectedConditions [OK]

Common Mistakes:

• Passing locator arguments separately instead of tuple
• Assuming timeout value causes error here
• Confusing locator types (CLASS_NAME vs CSS_SELECTOR)

5. You want to wait until the URL contains the word 'dashboard' before proceeding. Which code snippet correctly uses ExpectedConditions to achieve this in Python Selenium?

hard

A. WebDriverWait(driver, 15).until(EC.url_contains('dashboard'))

B. WebDriverWait(driver, 15).until(EC.url_to_be('dashboard'))

C. WebDriverWait(driver, 15).until(EC.url_matches('dashboard'))

D. WebDriverWait(driver, 15).until(EC.url_is('dashboard'))

Solution

1. Step 1: Identify correct ExpectedCondition for URL substring

   EC.url_contains waits until the URL contains the given substring.

2. Step 2: Verify other options

   url_matches requires a regex pattern to match the entire URL, url_to_be checks for exact URL equality, and url_is is not a valid ExpectedCondition.

3. Final Answer:

   WebDriverWait(driver, 15).until(EC.url_contains('dashboard')) -> Option A

4. Quick Check:

   Use url_contains for substring in URL [OK]

Hint: Use EC.url_contains for partial URL waits [OK]

Common Mistakes:

• Using non-existent ExpectedConditions like url_is
• Confusing url_contains with exact match conditions like url_to_be
• Using url_matches without proper regex for substring