Why alert handling prevents test failures in Selenium Python - Automation Benefits in Action

Handle unexpected alert on form submission

Preconditions (2)

Step 1: Enter 'testuser' in the username input field

Step 2: Click the submit button

Step 3: If an alert appears, accept the alert

Step 4: Verify the page URL changes to 'https://example.com/form-success'

✅ Expected Result: The alert is accepted without causing test failure and the page navigates to the success URL

Automation Requirements - Selenium with Python

Assertions Needed:

Verify alert is present and accepted

Verify current URL is 'https://example.com/form-success'

Best Practices:

Use explicit waits to detect alert presence

Use try-except block to handle NoAlertPresentException

Avoid hardcoded sleeps

Use By.ID locator strategy for 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
from selenium.common.exceptions import NoAlertPresentException, TimeoutException

# Setup WebDriver (assumes chromedriver is in PATH)
driver = webdriver.Chrome()

try:
    driver.get('https://example.com/form')

    # Enter username
    username_input = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, 'username'))
    )
    username_input.send_keys('testuser')

    # Click submit button
    submit_button = driver.find_element(By.ID, 'submit-btn')
    submit_button.click()

    # Wait for alert and accept it if present
    try:
        WebDriverWait(driver, 5).until(EC.alert_is_present())
        alert = driver.switch_to.alert
        alert.accept()
    except TimeoutException:
        # No alert appeared, continue
        pass

    # Verify URL changed to success page
    WebDriverWait(driver, 10).until(
        EC.url_to_be('https://example.com/form-success')
    )
    assert driver.current_url == 'https://example.com/form-success', f"Expected URL to be 'https://example.com/form-success' but got {driver.current_url}"

finally:
    driver.quit()

This script opens the form page and waits for the username input to appear before typing 'testuser'. It then clicks the submit button. After clicking, it waits up to 5 seconds for an alert to appear. If the alert appears, it accepts it to prevent the test from failing due to unhandled alert. If no alert appears, it continues without error. Finally, it waits for the URL to change to the success page and asserts this change. The use of explicit waits ensures the script waits only as long as needed, avoiding fixed delays. The try-except block for alert handling prevents test failure if no alert is present.

Common Mistakes - 3 Pitfalls

Not handling alerts causing test to fail

Using time.sleep instead of explicit waits

Hardcoding XPath locators for common elements

Bonus Challenge

Now add data-driven testing with 3 different usernames to verify alert handling for each input

Show Hint

Practice

1. Why is it important to handle alerts in Selenium tests to prevent test failures?

easy

A. Because unhandled alerts block further test execution causing failures

B. Because alerts improve the speed of test execution

C. Because alerts automatically close after some time

D. Because alerts do not affect test execution

Solution

1. Step 1: Understand alert behavior in Selenium

   Alerts are popup messages that require user interaction before continuing. If not handled, Selenium cannot proceed.

2. Step 2: Effect of unhandled alerts on tests

   When an alert is present and not handled, Selenium throws an exception and stops the test, causing failure.

3. Final Answer:

   Because unhandled alerts block further test execution causing failures -> Option A

4. Quick Check:

   Unhandled alert = test failure [OK]

Hint: Unhandled alerts stop tests; always accept or dismiss them [OK]

Common Mistakes:

• Thinking alerts close automatically
• Assuming alerts don't affect test flow
• Ignoring alert presence in tests

2. Which of the following is the correct Selenium Python code to accept an alert and prevent test failure?

easy

A. driver.accept_alert()

B. driver.switch_to.alert.accept()

C. driver.switch_to.alert.dismiss()

D. driver.alert.accept()

Solution

1. Step 1: Identify correct alert handling syntax

   In Selenium Python, alerts are handled via driver.switch_to.alert object.

2. Step 2: Accepting an alert

   To accept (click OK) on an alert, use the accept() method on the alert object.

3. Final Answer:

   driver.switch_to.alert.accept() -> Option B

4. Quick Check:

   Correct syntax = driver.switch_to.alert.accept() [OK]

Hint: Use driver.switch_to.alert.accept() to accept alerts [OK]

Common Mistakes:

• Using driver.alert.accept() which is invalid
• Confusing dismiss() with accept()
• Calling non-existent methods like driver.accept_alert()

3. What will happen when the following Selenium Python code runs if an alert is present?

driver.find_element(By.ID, 'submit').click()
driver.switch_to.alert.accept()
driver.find_element(By.ID, 'result').text

medium

A. The test throws NoAlertPresentException at alert.accept()

B. The test fails because alert.accept() is called before clicking submit

C. The alert is accepted and the result text is retrieved successfully

D. The test ignores the alert and retrieves result text

Solution

1. Step 1: Analyze the code sequence

   The code clicks a button that triggers an alert, then accepts the alert, then reads result text.

2. Step 2: Effect of alert handling on test flow

   Accepting the alert allows the test to continue and retrieve the result text without failure.

3. Final Answer:

   The alert is accepted and the result text is retrieved successfully -> Option C

4. Quick Check:

   Alert accepted = test continues [OK]

Hint: Accept alerts after triggering them to continue tests [OK]

Common Mistakes:

• Calling accept() before alert appears
• Ignoring alert causing test to fail
• Assuming alert.dismiss() is same as accept()

4. Identify the error in this Selenium Python snippet that causes test failure due to alert handling:

driver.find_element(By.ID, 'delete').click()
# Missing alert handling here
driver.find_element(By.ID, 'status').text

medium

A. Alert is not accepted or dismissed after clicking delete

B. The locator 'By.ID' is incorrect

C. The status element is not present on the page

D. The click() method is used incorrectly

Solution

1. Step 1: Understand alert presence after click

   Clicking 'delete' triggers an alert that must be handled to continue.

2. Step 2: Missing alert handling causes failure

   Since alert is not accepted or dismissed, Selenium throws an exception and test fails.

3. Final Answer:

   Alert is not accepted or dismissed after clicking delete -> Option A

4. Quick Check:

   Missing alert handling = test failure [OK]

Hint: Always handle alerts immediately after actions triggering them [OK]

Common Mistakes:

• Assuming alert closes automatically
• Ignoring alert presence in test flow
• Blaming locator or click method instead

5. You have a test that intermittently fails due to unexpected alerts appearing. Which approach best prevents these failures while keeping the test stable?

hard

A. Disable alerts in the browser settings

B. Ignore alerts and let the test fail to find bugs

C. Add long sleep delays to wait for alerts to disappear

D. Use try-except to catch alert, accept it if present, else continue

Solution

1. Step 1: Understand intermittent alert issues

   Unexpected alerts cause random test failures if not handled properly.

2. Step 2: Implement robust alert handling

   Using try-except to detect and accept alerts only if present avoids failures and keeps tests stable.

3. Step 3: Evaluate other options

   Ignoring alerts causes failures, sleeps waste time, disabling alerts may break app behavior.

4. Final Answer:

   Use try-except to catch alert, accept it if present, else continue -> Option D

5. Quick Check:

   Try-except alert handling = stable tests [OK]

Hint: Catch and accept alerts only if they appear using try-except [OK]

Common Mistakes:

• Ignoring alerts causing flaky tests
• Using fixed sleeps wasting test time
• Disabling alerts breaking app logic